/*++ Copyright (C) Microsoft Corporation, 1996 - 1999 Module Name: dgtrans.cxx Abstract: Common code for winsock-based datagram transports. Author: Dave Steckler (davidst) 15-Mar-1993 Jeff Roberts (jroberts) 02-Dec-1994 Mario Goertzel (mariogo) 10-Apr-1996 Michael Burton (t-mburt) 05-Sep-1997 Charlie Wickham (charlwi) 01-Oct-1997 Revision History: Dave wrote a version. Connie changed it but forgot to add her name. Jeff made it work. Mario rewrote most of it for NT and io completion ports. MarioGo 12/10/1996 Changes for async support, added client t-mburt 09/05/1997 Added prelim support for clusters charlwi 10/01/1997 Finished cluster work --*/ #include #include #include #include #ifdef NCADG_MQ_ON #include "mqtrans.hxx" #endif // // If a datagram send doesn't complete within 5 seconds, abort it. // #define DG_SEND_TIMEOUT (5000) // Cluster SOCKADDR_CLUSTER initialization routine inline void CDP_InitLocalAddress( SOCKADDR_CLUSTER *Address, unsigned short Endpoint ) { Address->sac_family = AF_CLUSTER; Address->sac_node = CLUSADDR_ANY; Address->sac_port = Endpoint; Address->sac_zero = 0; } extern RPC_STATUS CDP_InitializeSockAddr(char *Endpoint, WS_SOCKADDR *); extern RPC_STATUS UDP_InitializeSockAddr(char *Endpoint, WS_SOCKADDR *); #ifdef IPX_ON extern RPC_STATUS IPX_InitializeSockAddr(char *Endpoint, WS_SOCKADDR *); #endif const DG_TRANS_INFO DgTransportTable[] = { // UDP { AF_INET, SOCK_DGRAM, IPPROTO_UDP, 0x40000, 0x10000, UDP_InitializeSockAddr }, #ifdef IPX_ON // IPX { AF_IPX, SOCK_DGRAM, NSPROTO_IPX, 0x40000, 0x10000, IPX_InitializeSockAddr }, #else // IPX { 0, 0, 0, 0, 0, 0 }, #endif // CDP { AF_CLUSTER, SOCK_DGRAM, CLUSPROTO_CDP, 0x40000, 0x10000, CDP_InitializeSockAddr } }; inline const DG_TRANS_INFO *GetDgTransportInfo(PROTOCOL_ID id) { #ifdef IPX_ON ASSERT(id == UDP || id == IPX || id == CDP); #else ASSERT(id == UDP || id == CDP); #endif return &DgTransportTable[id - UDP]; } typedef const DG_TRANS_INFO *PDG_TRANS_INFO; // may be TRUE only for rpcss. For all others it's FALSE BOOL fWSARecvMsgFnPtrInitialized = FALSE; const UUID WSARecvMsgFnPtrUuid = WSAID_WSARECVMSG; //////////////////////////////////////////////////////////////////////// // // Generic datagram (winsock and NT based) routines. // RPC_STATUS DG_SubmitReceive(IN PWS_DATAGRAM_ENDPOINT pEndpoint, IN PWS_DATAGRAM pDatagram) /*++ Arguments: pEndpoint - The endpoint on which the receive should be posted. pDatagram - The datagram object to manage the receive. Return Value: RPC_P_IO_PENDING - OK RPC_S_OUT_OF_MEMORY RPC_S_OUT_OF_RESOURCES --*/ { RPC_STATUS status; NTSTATUS NtStatus; DWORD bytes, flags; int err; if (pDatagram->Packet.buf == 0) { status = I_RpcTransDatagramAllocate(pEndpoint, (BUFFER *)&pDatagram->Packet.buf, (PUINT) &pDatagram->Packet.len, &pDatagram->AddressPair); if (status != RPC_S_OK) { return(RPC_S_OUT_OF_MEMORY); } pDatagram->AddressPair->LocalAddress = WSA_CMSG_DATA(&pDatagram->MessageAncillaryData) + FIELD_OFFSET(in_pktinfo, ipi_addr); ASSERT( pDatagram->Packet.buf ); } ASSERT(*(PDWORD)pDatagram->Packet.buf = 0xDEADF00D); bytes = flags = 0; if (!fWSARecvMsgFnPtrInitialized) { pDatagram->cRecvAddr = sizeof(WS_SOCKADDR); err = WSARecvFrom(((WS_DATAGRAM_ENDPOINT*)(pDatagram->pEndpoint))->Socket, &pDatagram->Packet, 1, &bytes, &flags, &((WS_SOCKADDR *)pDatagram->AddressPair->RemoteAddress)->generic, &pDatagram->cRecvAddr, &pDatagram->Read.ol, 0); } else { pDatagram->Msg.lpBuffers = &pDatagram->Packet; pDatagram->Msg.name = &((WS_SOCKADDR *)pDatagram->AddressPair->RemoteAddress)->generic; pDatagram->Msg.namelen = sizeof(WS_SOCKADDR); pDatagram->Msg.dwBufferCount = 1; pDatagram->Msg.Control.buf = (char *)pDatagram->MessageAncillaryData; pDatagram->Msg.Control.len = sizeof(pDatagram->MessageAncillaryData); pDatagram->Msg.dwFlags = 0; err = WSARecvMsg(((WS_DATAGRAM_ENDPOINT*)(pDatagram->pEndpoint))->Socket, &pDatagram->Msg, &bytes, &pDatagram->Read.ol, 0); } #if 0 TransDbgPrint((DPFLTR_RPCPROXY_ID, DPFLTR_WARNING_LEVEL, RPCTRANS "ERROR: RecvFrom: %p buf %p (%d bytes) status %d\n", pDatagram, pDatagram->Packet.buf, pDatagram->Packet.len, err == 0 ? 0 : GetLastError())); #endif if (err == NO_ERROR) { return(RPC_P_IO_PENDING); } status = GetLastError(); if ( status == ERROR_IO_PENDING || status == WSAEMSGSIZE ) { // WSAEMSGSIZE will be handled in complete.cxx. This is like "NO_ERROR" return(RPC_P_IO_PENDING); } RpcpErrorAddRecord( EEInfoGCWinsock, status, EEInfoDLWinsockDatagramSubmitReceive10, ((WS_DATAGRAM_ENDPOINT*)(pDatagram->pEndpoint))->Socket ); if (WSAECONNRESET == status) { return RPC_P_PORT_DOWN; } TransDbgPrint((DPFLTR_RPCPROXY_ID, DPFLTR_WARNING_LEVEL, RPCTRANS "WSARecvFrom failed %p\n", GetLastError())); return(RPC_S_OUT_OF_RESOURCES); } void DG_SubmitReceives( BASE_ADDRESS *ThisEndpoint ) /*++ Routine Description: Helper function called when the pending IO count on an address is too low. Arguments: ThisEndpoint - The address to submit IOs on. Return Value: None --*/ { PWS_DATAGRAM pDg; PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; if (pEndpoint->Socket == 0) { // // The address is currently deactivated, don't submit more I/O // return; } do { BOOL fIoSubmitted; fIoSubmitted = FALSE; // Only one thread should be trying to submit IOs at a time. // This saves locking each DATAGRAM object. // Simple lock - but requires a loop. See the comment at the end // of the loop. if (pEndpoint->fSubmittingIos != 0) break; if (InterlockedIncrement(&pEndpoint->fSubmittingIos) != 1) break; // Submit new IOs on all the idle datagram objects for (int i = 0; i < pEndpoint->cMaximumIos; i++) { pDg = &pEndpoint->aDatagrams[i]; if (pDg->Busy) { continue; } // Must be all set for the IO to complete before trying // to submit the IO. InterlockedIncrement(&pEndpoint->cPendingIos); pDg->Busy = TRUE; if (DG_SubmitReceive(pEndpoint, pDg) == RPC_P_IO_PENDING) { fIoSubmitted = TRUE; } else { pDg->Busy = FALSE; InterlockedDecrement(&pEndpoint->cPendingIos); break; } } // Release the "lock" on the endpoint object. pEndpoint->fSubmittingIos = 0; if (!fIoSubmitted && pEndpoint->cPendingIos == 0) { // It appears that no IO is pending on the endpoint. COMMON_AddressManager(pEndpoint); return; } // Even if we submitted new IOs, they may all have completed // already. Which means we may need to loop and submit more // IOs. This is needed since the thread which completed the // last IO may have run into our lock and returned. } while (pEndpoint->cPendingIos == 0); return; } RPC_STATUS RPC_ENTRY DG_SendPacket( IN DG_TRANSPORT_ENDPOINT ThisEndpoint, IN DG_TRANSPORT_ADDRESS pAddress, IN BUFFER pHeader, IN unsigned cHeader, IN BUFFER pBody, IN unsigned cBody, IN BUFFER pTrailer, IN unsigned cTrailer ) /*++ Routine Description: Sends a packet to an address. The routine will send a packet built out of the three buffers supplied. All the buffers are optional, the actual packet sent will be built from all the buffers actually supplied. In each call at least buffer should NOT be null. Arguments: ThisEndpoint - Endpoint to send from. pAddress - Address to send to. pHeader - First data buffer cHeader - Size of the first data buffer or 0. pBody - Second data buffer cBody - Size of the second data buffer or 0. pTrailer - Third data buffer. cTrailer - Size of the first data buffer or 0. Return Value: RPC_S_OK RPC_S_OUT_OF_RESOURCES RPC_P_SEND_FAILED --*/ { PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; WS_SOCKADDR* pSockAddr = (WS_SOCKADDR *)pAddress; WSABUF buffers[3]; int cBuffers; HANDLE hIoEvent; DWORD Status = 0; if (pHeader) { CallTestHook( TH_X_DG_SEND, pHeader, &Status ); } else { CallTestHook( TH_X_DG_SEND, pBody, &Status ); } if (Status) { return Status; } hIoEvent = I_RpcTransGetThreadEvent(); cBuffers = 0; if (cHeader) { buffers[cBuffers].len = cHeader; buffers[cBuffers].buf = (PCHAR) pHeader; cBuffers++; } if (cBody) { buffers[cBuffers].len = cBody; buffers[cBuffers].buf = (PCHAR) pBody; cBuffers++; } if (cTrailer) { buffers[cBuffers].len = cTrailer; buffers[cBuffers].buf = (PCHAR) pTrailer; cBuffers++; } ASSERT(cBuffers); // All RPC packets have version 4. // ASSERT( buffers[0].buf[0] == 4 ); OVERLAPPED ol; ol.hEvent = (HANDLE)(ULONG_PTR(hIoEvent) | 1); DWORD bytes; if ( WSASendTo(pEndpoint->Socket, buffers, cBuffers, &bytes, 0, &pSockAddr->generic, WsTransportTable[pEndpoint->id].SockAddrSize, &ol, 0) != 0) { DWORD Status = GetLastError(); RpcpErrorAddRecord( EEInfoGCWinsock, Status, EEInfoDLWinsockDatagramSend10, PULONG(&pSockAddr->generic)[0], PULONG(&pSockAddr->generic)[1] ); if (WSAENETUNREACH == Status) { TransDbgDetail((DPFLTR_RPCPROXY_ID, DPFLTR_INFO_LEVEL, RPCTRANS "WSASendTo failed with net unreachable\n", GetLastError())); return RPC_P_PORT_DOWN; } if (WSAEHOSTDOWN == Status) { TransDbgDetail((DPFLTR_RPCPROXY_ID, DPFLTR_INFO_LEVEL, RPCTRANS "WSASendTo failed with host down\n", GetLastError())); return RPC_P_HOST_DOWN; } if (Status != WSA_IO_PENDING) { TransDbgDetail((DPFLTR_RPCPROXY_ID, DPFLTR_INFO_LEVEL, RPCTRANS "WSASendTo failed %d\n", GetLastError())); return(RPC_P_SEND_FAILED); } if (WAIT_OBJECT_0 != WaitForSingleObject( hIoEvent, DG_SEND_TIMEOUT )) { TransDbgDetail((DPFLTR_RPCPROXY_ID, DPFLTR_INFO_LEVEL, RPCTRANS "Dg Send timed out\n")); // // Cancel the send and wait for it to complete. // CancelIo( (HANDLE)pEndpoint->Socket ); GetOverlappedResult((HANDLE)pEndpoint->Socket, &ol, &bytes, TRUE); return(RPC_P_SEND_FAILED); } BOOL b = GetOverlappedResult((HANDLE)pEndpoint->Socket, &ol, &bytes, TRUE); if (!b) { TransDbgDetail((DPFLTR_RPCPROXY_ID, DPFLTR_INFO_LEVEL, RPCTRANS "Dg Send wait failed %d\n", GetLastError())); return(RPC_P_SEND_FAILED); } } ASSERT(bytes == cHeader + cBody + cTrailer); if (pEndpoint->cMinimumIos && pEndpoint->cPendingIos <= pEndpoint->cMinimumIos) { // It's ok if this fails, this is just a performance optimization. // Right after a send there often "idle" time waiting for the response // so this is a good time to submit receives. DG_SubmitReceives(pEndpoint); } return(RPC_S_OK); } RPC_STATUS RPC_ENTRY DG_ForwardPacket( IN DG_TRANSPORT_ENDPOINT ThisEndpoint, IN BUFFER pHeader, IN unsigned cHeader, IN BUFFER pBody, IN unsigned cBody, IN BUFFER pTrailer, IN unsigned cTrailer, IN CHAR * pszPort ) /*++ Routine Description: Sends a packet to the server it was originally destined for (that is, the client had a dynamic endpoint it wished the enpoint mapper to resolve and forward the packet to). Arguments: ThisEndpoint - The endpoint to forward the packet from. // Buffer like DG_SendPacket pszPort - Pointer to the server port num to forward to. This is in an Ansi string. Return Value: RPC_S_CANT_CREATE_ENDPOINT - pEndpoint invalid. results of SendPacket(). --*/ { PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; WS_SOCKADDR SockAddr; PDG_TRANS_INFO pInfo = GetDgTransportInfo(pEndpoint->id); ASSERT(pEndpoint->type | SERVER); if (pInfo->EndpointToAddr(pszPort, &SockAddr) != RPC_S_OK) { return RPC_S_CANT_CREATE_ENDPOINT; } return ( DG_SendPacket(ThisEndpoint, (PVOID)&SockAddr, pHeader, cHeader, pBody, cBody, pTrailer, cTrailer) ); } RPC_STATUS RPC_ENTRY DG_ReceivePacket( IN DG_TRANSPORT_ENDPOINT ThisEndpoint, OUT DG_TRANSPORT_ADDRESS *pReplyAddress, OUT PUINT pBufferLength, OUT BUFFER *pBuffer, IN LONG Timeout ) /*++ Routine Description: Used to wait for a datagram from a server. Returns the data returned and the address of the machine which replied. This is a blocking API. It should only be called during sync client RPC threads. Arguments: Endpoint - The endpoint to receive from. ReplyAddress - Contain the source address of the datagram if successful. BufferLength - The size of Buffer on input, the size of the datagram received on output. Timeout - Milliseconds to wait for a datagram. Return Value: RPC_S_OK RPC_P_OVERSIZE_PACKET - Datagram > BufferLength arrived, first BufferLength bytes of Buffer contain the partial datagram. RPC_P_RECEIVE_FAILED RPC_P_TIMEOUT --*/ { RPC_STATUS status; BOOL b; PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; PWS_DATAGRAM pDatagram = &pEndpoint->aDatagrams[0]; DWORD bytes; DWORD flags; int err; ASSERT((pEndpoint->type & TYPE_MASK) == CLIENT); ASSERT(pEndpoint->aDatagrams[0].Read.ol.hEvent); DWORD Status = 0; CallTestHook( TH_X_DG_SYNC_RECV, ThisEndpoint, &Status ); if (Status) { return Status; } if (pDatagram->Busy == 0) { if (pEndpoint->aDatagrams[0].Packet.buf == 0) { status = I_RpcTransDatagramAllocate(pEndpoint, (BUFFER *)&pDatagram->Packet.buf, (PUINT) &pDatagram->Packet.len, &pDatagram->AddressPair); if (status != RPC_S_OK) { return(RPC_S_OUT_OF_MEMORY); } pDatagram->cRecvAddr = sizeof(WS_SOCKADDR); pDatagram->AddressPair->LocalAddress = WSA_CMSG_DATA(&pDatagram->MessageAncillaryData) + FIELD_OFFSET(in_pktinfo, ipi_addr); ASSERT( pDatagram->Packet.buf ); } bytes = flags = 0; if (!fWSARecvMsgFnPtrInitialized) { err = WSARecvFrom(pEndpoint->Socket, &pDatagram->Packet, 1, &bytes, &flags, &((WS_SOCKADDR *)pDatagram->AddressPair->RemoteAddress)->generic, &pDatagram->cRecvAddr, &pDatagram->Read.ol, 0); } else { pDatagram->Msg.lpBuffers = &pDatagram->Packet; pDatagram->Msg.name = &((WS_SOCKADDR *)pDatagram->AddressPair->RemoteAddress)->generic; pDatagram->Msg.namelen = sizeof(WS_SOCKADDR); pDatagram->Msg.dwBufferCount = 1; pDatagram->Msg.Control.buf = (char *)&pDatagram->MessageAncillaryData; pDatagram->Msg.Control.len = sizeof(pDatagram->MessageAncillaryData); pDatagram->Msg.dwFlags = 0; err = WSARecvMsg(((WS_DATAGRAM_ENDPOINT*)(pDatagram->pEndpoint))->Socket, &pDatagram->Msg, &bytes, &pDatagram->Read.ol, 0); } if ( err != 0) { status = GetLastError(); if (status != WSA_IO_PENDING) { RpcpErrorAddRecord( EEInfoGCWinsock, status, EEInfoDLWinsockDatagramReceive10, pEndpoint->Socket ); if (status == WSAEMSGSIZE) { status = RPC_P_OVERSIZE_PACKET; } else if (status == WSAECONNRESET) { return RPC_P_PORT_DOWN; } else { // No need to free the packet now. TransDbgDetail((DPFLTR_RPCPROXY_ID, DPFLTR_INFO_LEVEL, RPCTRANS "WSARecvFrom failed %d\n", status)); ASSERT(pDatagram->Busy == 0); return(RPC_P_RECEIVE_FAILED); } } else { status = RPC_P_IO_PENDING; } } else { status = RPC_S_OK; } pDatagram->Busy = TRUE; } else { ASSERT(pDatagram->Busy); ASSERT(pDatagram->Packet.buf); status = RPC_P_IO_PENDING; } // Wait for IO to complete or timeout if (status == RPC_P_IO_PENDING) { status = WaitForSingleObjectEx(pDatagram->Read.ol.hEvent, Timeout, TRUE); if (status != STATUS_WAIT_0) { // In the timeout case we just want to return and // leave. We'll finish the receive on the next call. if (status == WAIT_IO_COMPLETION) { TransDbgPrint((DPFLTR_RPCPROXY_ID, DPFLTR_WARNING_LEVEL, RPCTRANS "DG received cancelled (%p)\n", pDatagram)); } else { ASSERT(status == STATUS_TIMEOUT); } ASSERT(pDatagram->Busy); return(RPC_P_TIMEOUT); } BOOL b = GetOverlappedResult((HANDLE)pEndpoint->Socket, &pDatagram->Read.ol, &bytes, FALSE); if (!b) { RpcpErrorAddRecord( EEInfoGCWinsock, GetLastError(), EEInfoDLWinsockDatagramSend20, pEndpoint->Socket ); switch (GetLastError()) { case WSAEMSGSIZE: case ERROR_MORE_DATA: ASSERT(bytes == pDatagram->Packet.len); status = RPC_P_OVERSIZE_PACKET; break; case ERROR_PORT_UNREACHABLE: pDatagram->Busy = 0; return RPC_P_PORT_DOWN; break; case STATUS_TIMEOUT: ASSERT(0); case ERROR_OPERATION_ABORTED: // ERROR_OPERATION_ABORTED can occur if one thread // tried to make a call and failed, leaving a pending // receive. That thread dies. Then the endpoint is // reused by a different thread and the IO is aborted. // Returning receive failed will cause the runtime to // retransmit which will do the right thing. default: TransDbgDetail((DPFLTR_RPCPROXY_ID, DPFLTR_INFO_LEVEL, RPCTRANS "DG sync recv failed %d\n", GetLastError())); pDatagram->Busy = 0; return(RPC_P_RECEIVE_FAILED); break; } } else { status = RPC_S_OK; } } ASSERT( status == RPC_S_OK || status == RPC_P_OVERSIZE_PACKET); ASSERT(pDatagram->Busy); ASSERT(pDatagram->Packet.buf); ASSERT(bytes <= pDatagram->Packet.len); *pBuffer = (BUFFER)pDatagram->Packet.buf; *pBufferLength = bytes; *pReplyAddress = pDatagram->AddressPair->RemoteAddress; pDatagram->Packet.buf = 0; pDatagram->Busy = 0; return(status); } RPC_STATUS DG_CreateEndpoint( OUT WS_DATAGRAM_ENDPOINT *pEndpoint ) /*++ Routine Description: Creates a new endpoint. Arguments: pEndpoint - The runtime allocated endpoint structure to filled in. pSockAddr - An initialized sockaddr with the correct (or no) endpoint. id - The id of the protocol to use in creating the address. fClient - If TRUE this is a client endpoint fAsync - If TRUE this endpoint is "async" which means that a) It should be added to the IO completion port and b) that the transport should pend a number of receives on the endpoint automatically. EndpointFlags - used in allocation IP ports. Return Value: RPC_S_OK RPC_S_OUT_OF_MEMORY RPC_S_OUT_OF_RESOURCES RPC_S_CANT_CREATE_ENDPOINT RPC_S_DUPLICATE_ENDPOINT --*/ { PWS_DATAGRAM pDatagram; int i, err; int length; RPC_STATUS status = RPC_S_OK; SOCKET sock = 0; PDG_TRANS_INFO pInfo = GetDgTransportInfo(pEndpoint->id); BOOL fClient = pEndpoint->fClient; BOOL fAsync = pEndpoint->fAsync; LPFN_WSARECVMSG WSARecvMsgFnPtr; DWORD dwBytesReturned; // Common stuff pEndpoint->type = DATAGRAM | ADDRESS; pEndpoint->Socket = 0; pEndpoint->Endpoint = 0; pEndpoint->pAddressVector = 0; pEndpoint->SubmitListen = DG_SubmitReceives; pEndpoint->InAddressList = NotInList; pEndpoint->pNext = 0; pEndpoint->fSubmittingIos = 0; pEndpoint->cPendingIos = 0; pEndpoint->cMinimumIos = 0; pEndpoint->cMaximumIos = 0; pEndpoint->aDatagrams = 0; pEndpoint->pFirstAddress = pEndpoint; pEndpoint->pNextAddress = 0; pEndpoint->fAborted = 0; if (fClient) { pEndpoint->type |= CLIENT; } else { pEndpoint->type |= SERVER; } // // Check if we can use a wrapper around the AFD send/recv // IOCTLs instead WSASendTo. // TryUsingAfd(); // // Create the socket. // sock = WSASocketT(pInfo->AddressFamily, pInfo->SocketType, pInfo->Protocol, 0, 0, WSA_FLAG_OVERLAPPED); if (sock == INVALID_SOCKET) { RpcpErrorAddRecord( EEInfoGCWinsock, GetLastError(), EEInfoDLWinsockDatagramCreate10, (ULONG) pInfo->AddressFamily, (ULONG) pInfo->Protocol ); switch(GetLastError()) { case WSAEAFNOSUPPORT: case WSAEPROTONOSUPPORT: case WSAENETDOWN: case WSAESOCKTNOSUPPORT: status = RPC_S_PROTSEQ_NOT_SUPPORTED; break; case WSAENOBUFS: case WSAEMFILE: case WSA_NOT_ENOUGH_MEMORY: status = RPC_S_OUT_OF_MEMORY; break; default: TransDbgPrint((DPFLTR_RPCPROXY_ID, DPFLTR_WARNING_LEVEL, RPCTRANS "DG socket() returned 0x%lx\n", GetLastError())); ASSERT(0); // no break case WSAEPROVIDERFAILEDINIT: status = RPC_S_OUT_OF_RESOURCES; break; } return(status); } if (fWSARecvMsgFnPtrInitialized == FALSE) { // if the AddressChangeFn is non-default (i.e. we are in RPCSS), // use WSARecvMsg so that we can retrieve the local address as // well if (AddressChangeFn && (AddressChangeFn != NullAddressChangeFn)) { // retrieve the WSARecvMsg function pointer err = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER, (void *) &WSARecvMsgFnPtrUuid, sizeof(UUID), (void *) &WSARecvMsgFnPtr, sizeof(void *), &dwBytesReturned, NULL, NULL); if (err == SOCKET_ERROR) { closesocket(sock); return RPC_S_PROTSEQ_NOT_SUPPORTED; } WFT.pWSARecvMsg = WSARecvMsgFnPtr; fWSARecvMsgFnPtrInitialized = TRUE; } } // // Make the handle non-inheritable so it goes away when we close it. // if (FALSE == SetHandleInformation( (HANDLE) sock, HANDLE_FLAG_INHERIT, 0)) { closesocket(sock); return RPC_S_OUT_OF_RESOURCES; } // // Protect the socket to prevent another server from using our port. // WS_ProtectListeningSocket(sock, TRUE); // // Bind the socket to the endpoint (or to a dynamic endpoint) // status = WS_Bind(sock, &pEndpoint->ListenAddr, (pEndpoint->id == UDP), pEndpoint->EndpointFlags); if (status != RPC_S_OK) { closesocket(sock); return(status); } pEndpoint->Socket = sock; // // Turn on ring buffering for server- and client-side async endpoints. // Any error is ignored. // if (fAsync || !fClient) { DWORD BytesReturned; if (0 != WSAIoctl( sock, SIO_ENABLE_CIRCULAR_QUEUEING, 0, 0, 0, 0, &BytesReturned, 0, 0 )) { TransDbgPrint((DPFLTR_RPCPROXY_ID, DPFLTR_WARNING_LEVEL, RPCTRANS "DG couldn't enable circular queueing 0x%lx\n", GetLastError())); } } if (!fClient) { // // Set server socket recv buffer size.. // int size; int PacketInfoOn = TRUE; if (gfServerPlatform == TRUE && gPhysicalMemorySize >= 40) { size = pInfo->ServerBufferSize; } else { size = pInfo->WorkstationBufferSize; } if (fWSARecvMsgFnPtrInitialized) { err = setsockopt(sock, IPPROTO_IP, IP_PKTINFO, (char *)&PacketInfoOn, sizeof(PacketInfoOn) ); if (err != 0) { TransDbgPrint((DPFLTR_RPCPROXY_ID, DPFLTR_WARNING_LEVEL, RPCTRANS "DG couldn't set packet info %d\n", GetLastError())); closesocket(sock); return(RPC_S_OUT_OF_MEMORY); } } err = setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *) &size, sizeof(size) ); #if DBG if (err != 0) TransDbgPrint((DPFLTR_RPCPROXY_ID, DPFLTR_WARNING_LEVEL, RPCTRANS "DG couldn't set buffer size %d\n", GetLastError())); #endif } else { // Enable broadcast send on the client DWORD option = TRUE; err = setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (PCHAR)&option, sizeof(option)); ASSERT(err == 0); } // // If the endpoint is going to async initialize async part // and add the socket to the IO completion port. // if (status == RPC_S_OK) { int cMaxIos; int cMinIos; ASSERT(fAsync || fClient); // Step one, figure out the high and low mark for ios. if (fAsync) { cMinIos = 1; cMaxIos = 2; if (gPhysicalMemorySize >= 40) // megabytes { cMaxIos = 2 + (gfServerPlatform == TRUE) * 2 + (fClient == FALSE) * gNumberOfProcessors; // This should be larger than zero so that we'll generally submit new // recvs during idle time rather then just after receiving a datagram. cMinIos = 1 + (fClient == FALSE ) * (gNumberOfProcessors/2); } } else { // For sync endpoints we need to allocate a single datagram // object for the receive. cMinIos = 0; cMaxIos = 1; } ASSERT(cMinIos < cMaxIos); pEndpoint->cMinimumIos = cMinIos; pEndpoint->cMaximumIos = cMaxIos; // Allocate a chunk on memory to hold the array of datagrams // PERF: For clients, allocate larger array but don't submit all // the IOs unless we determine that the port is "really" active. pEndpoint->aDatagrams = new WS_DATAGRAM[cMaxIos]; if (pEndpoint->aDatagrams) { UINT type; type = DATAGRAM | RECEIVE; type |= (fClient) ? CLIENT : SERVER; for (i = 0; i < cMaxIos; i++) { pDatagram = &pEndpoint->aDatagrams[i]; pDatagram->id = pEndpoint->id; pDatagram->type = type; pDatagram->pEndpoint = pEndpoint; pDatagram->Busy = 0; pDatagram->Packet.buf = 0; memset(&pDatagram->Read, 0, sizeof(pDatagram->Read)); pDatagram->Read.pAsyncObject = pDatagram; } if (fAsync) { status = COMMON_PrepareNewHandle((HANDLE)sock); } else { // The receive operation on sync endpoints will may span // several receives. This means it can't use the thread // event, so allocate an event for the receive. HANDLE hEvent = CreateEventW(0, TRUE, FALSE, 0); if (!hEvent) { status = RPC_S_OUT_OF_RESOURCES; } else { ASSERT(pDatagram == &pEndpoint->aDatagrams[0]); pDatagram->Read.ol.hEvent = hEvent; } } } else { status = RPC_S_OUT_OF_MEMORY; } } // If adding a new failure case here, add code to close the sync receive event. if (status != RPC_S_OK) { closesocket(sock); delete pEndpoint->aDatagrams; return(status); } TransportProtocol::AddObjectToProtocolList((BASE_ASYNC_OBJECT *) pEndpoint); if (!fClient) { TransportProtocol::FunctionalProtocolDetected(pEndpoint->id); } return(RPC_S_OK); } VOID DG_DeactivateAddress ( IN WS_DATAGRAM_ENDPOINT *pEndpoint ) /*++ Function Name:DG_DeactivateAddress Parameters: Description: Returns: --*/ { if (InterlockedIncrement(&pEndpoint->fAborted) != 1) { return; } if (pEndpoint->Socket) { closesocket(pEndpoint->Socket); pEndpoint->Socket = 0; } } RPC_STATUS DG_ReactivateAddress ( IN WS_DATAGRAM_ENDPOINT *pEndpoint ) /*++ Function Name:DG_DeactivateAddress Parameters: Description: Returns: --*/ { RPC_STATUS Status; WS_SOCKADDR *addr = &pEndpoint->ListenAddr; // // If the endpoint is dynamic, clear out the endpoint // if (pEndpoint->fDynamicEndpoint) { // // Clear out the listenaddr // switch (pEndpoint->id) { #ifdef IPX_ON case IPX: addr->ipxaddr.sa_socket = 0; break; #endif case CDP: CDP_InitLocalAddress(&addr->clusaddr, 0); break; case UDP: addr->inetaddr.sin_port = 0; break; default: ASSERT(0); } } Status = DG_CreateEndpoint(pEndpoint); if (Status == RPC_S_OK) { pEndpoint->fAborted = 0; DG_SubmitReceives(pEndpoint); } return Status; } void RPC_ENTRY DG_ServerAbortListen( IN DG_TRANSPORT_ENDPOINT ThisEndpoint ) /*++ Routine Description: Callback after DG_CreateEndpoint has completed successfully but the runtime for some reason is not going to be able to listen on the endpoint. --*/ { PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; ASSERT(pEndpoint->cPendingIos == 0); ASSERT(pEndpoint->Socket); ASSERT(pEndpoint->pNext == 0); ASSERT(pEndpoint->type & SERVER); delete pEndpoint->pAddressVector; delete pEndpoint->aDatagrams; closesocket(pEndpoint->Socket); return; } RPC_STATUS RPC_ENTRY DG_ClientCloseEndpoint( IN DG_TRANSPORT_ENDPOINT ThisEndpoint ) /*++ Routine Description: Called on sync client endpoints when they are no longer needed. Arguments: ThisEndpoint Return Value: RPC_S_OK --*/ { BOOL b; PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; PWS_DATAGRAM pDatagram = &pEndpoint->aDatagrams[0]; ASSERT((pEndpoint->type & TYPE_MASK) == CLIENT); ASSERT(pEndpoint->Socket); // Open must have worked ASSERT(pEndpoint->cMinimumIos == 0); ASSERT(pEndpoint->cMaximumIos == 1); // Must not be async! ASSERT(pEndpoint->aDatagrams); ASSERT(pEndpoint->aDatagrams[0].Read.ol.hEvent); ASSERT(pEndpoint->Endpoint == 0); ASSERT(pEndpoint->pAddressVector == 0); ASSERT(pEndpoint->pNext == 0); // If there is a pending receive, closing the socket will cancel the IO. closesocket(pEndpoint->Socket); // Wait for the pending receive to actually complete. if (pDatagram->Busy) { DWORD bytes; ASSERT(pDatagram->Busy); ASSERT(pDatagram->Packet.buf); GetOverlappedResult((HANDLE)pEndpoint->Socket, &pDatagram->Read.ol, &bytes, TRUE); if (GetLastError() != ERROR_OPERATION_ABORTED) { // Overactive output, the receive may have completed normally.. TransDbgPrint((DPFLTR_RPCPROXY_ID, DPFLTR_WARNING_LEVEL, RPCTRANS "DG receive completed %d on %p after closed\n", GetLastError(), pDatagram)); } } b = CloseHandle(pEndpoint->aDatagrams[0].Read.ol.hEvent); ASSERT(b); TransportProtocol::RemoveObjectFromProtocolList(pEndpoint); // Free the receive buffer if allocated if (pDatagram->Packet.buf) { I_RpcTransDatagramFree(pEndpoint, (BUFFER)pDatagram->Packet.buf ); } delete pDatagram; return(RPC_S_OK); } RPC_STATUS RPC_ENTRY DG_GetEndpointStats( IN DG_TRANSPORT_ENDPOINT ThisEndpoint, OUT DG_ENDPOINT_STATS * pStats ) { DWORD Status; DWORD Data; int Length; BOOL Ok; PWS_DATAGRAM_ENDPOINT Endpoint = (PWS_DATAGRAM_ENDPOINT) ThisEndpoint; Length = sizeof(DWORD); Status = getsockopt(Endpoint->Socket, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *) &Data, &Length); if (Status) { return GetLastError(); } // // jroberts, 10-Jan-2001 : I believe that getsockopt is returning 0xffffffff occasionally. // This is an attempt to catch it. // if (Endpoint->id == UDP) { ASSERT( Data < 0x10000 ); } Data &= ~7UL; pStats->MaxPduSize = Data; Length = sizeof(DWORD); Status = getsockopt(Endpoint->Socket, SOL_SOCKET, SO_RCVBUF, (char *) &Data, &Length); if (Status) { return GetLastError(); } Data &= ~7UL; pStats->ReceiveBufferSize = Data; return RPC_S_OK; } //////////////////////////////////////////////////////////////////////// // // CDP/IP specific functions. // RPC_STATUS RPC_ENTRY CDP_ServerListen( IN OUT DG_TRANSPORT_ENDPOINT ThisEndpoint, IN RPC_CHAR *NetworkAddress, IN OUT RPC_CHAR **pPort, IN void *pSecurityDescriptor, IN ULONG EndpointFlags, IN ULONG NICFlags, OUT NETWORK_ADDRESS_VECTOR **ppNetworkAddressVector ) /*++ Routine Description: Creates a server endpoint object to receive packets. New packets won't actually arrive until CompleteListen is called. Arguments: ThisEndpoint - Storage for the server endpoint object. pPort - The endpoint to listen on or a pointer to 0 if the transport should choose the address. Contains the endpoint listened to on output. The caller should free this. pSecurityDiscriptor - Security to attach to this endpoint (not used by this transport). EndpointFlags - Application flags passed into RPC via RpcServerUseProtseq*Ex. NICFlags - Application flags passed into RPC via RpcServerUseProtseq*Ex. pNetworkAddresses - A vector of the network addresses listened on by this call. This vector does not need to be freed. Return Value: RPC_S_OK RPC_S_OUT_OF_MEMORY RPC_S_OUT_OF_RESOURCES RPC_S_CANT_CREATE_ENDPOINT RPC_S_INVALID_ENDPOINT_FORMAT RPC_S_DUPLICATE_ENDPOINT --*/ { RPC_STATUS status; NTSTATUS NtStatus; USHORT port; UNICODE_STRING UnicodeString; ANSI_STRING AsciiString; PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; WS_SOCKADDR *addr = &pEndpoint->ListenAddr; NETWORK_ADDRESS_VECTOR * ServerAddress; // Figure out the port to listen on. if (*pPort) { status = EndpointToPortNumber(*pPort, port); if (status != RPC_S_OK) { return(status); } pEndpoint->fDynamicEndpoint = 0; CDP_InitLocalAddress( &addr->clusaddr, port ); } else { return RPC_S_INVALID_ENDPOINT_FORMAT; } pEndpoint->id = CDP; pEndpoint->fClient = FALSE; pEndpoint->fAsync = TRUE; pEndpoint->EndpointFlags = 0; // // Actually create the endpoint // status = DG_CreateEndpoint(pEndpoint); if (status != RPC_S_OK) { return(status); } // Figure out the network addresses. // The only way we can determine our cluster // address is to read it out of the registry status = CDP_BuildAddressVector(&pEndpoint->pAddressVector); if (status != RPC_S_OK) { DG_ServerAbortListen(ThisEndpoint); return(status); } *ppNetworkAddressVector = pEndpoint->pAddressVector; return RPC_S_OK; } RPC_STATUS CDP_QueryEndpoint ( IN void * pOriginalEndpoint, OUT RPC_CHAR * pClientEndpoint ) { WS_SOCKADDR * pSockAddr = (WS_SOCKADDR *)pOriginalEndpoint; unsigned NativeSocket = pSockAddr->clusaddr.sac_port; char AnsiBuffer[CDP_MAXIMUM_ENDPOINT]; char * pAnsi = AnsiBuffer; RPC_CHAR * pUni = pClientEndpoint; // // Convert endpoint to an ASCII string, and thence to Unicode. // _ultoa(NativeSocket, AnsiBuffer, 10); while ( *pUni++ = *pAnsi++ ); return RPC_S_OK; } RPC_STATUS CDP_QueryAddress ( IN void * pOriginalEndpoint, OUT RPC_CHAR * pClientAddress ) { PSOCKADDR_CLUSTER pSockAddr = (PSOCKADDR_CLUSTER) pOriginalEndpoint; _ultow(pSockAddr->sac_node, pClientAddress, 10); return(RPC_S_OK); } RPC_STATUS RPC_ENTRY CDP_ClientInitializeAddress ( OUT DG_TRANSPORT_ADDRESS Address, IN RPC_CHAR *NetworkAddress, IN RPC_CHAR *pPort, IN BOOL fUseCache, IN BOOL fBroadcast ) /*++ Routine Description: Initializes a address object for sending to a server. Arguments: Address - Storage for the address NetworkAddress - The address of the server or 0 if local Endpoint - The endpoint of the server fUseCache - If TRUE then the transport may use a cached value from a previous call on the same NetworkAddress. fBroadcast - If TRUE, NetworkAddress is ignored and a broadcast address is used. Return Value: RPC_S_OK - Success, name resolved and, optionally, added to cache. RPC_P_FOUND_IN_CACHE - Success, returned only if fUseCache is TRUE and the was name found in local cache. RPC_P_MATCHED_CACHE - Partial success, fUseCache is FALSE and the result of the lookup was the same as the value previously in the cache. RPC_S_OUT_OF_MEMORY RPC_S_OUT_OF_RESOURCES RPC_S_INVALID_ENDPOINT_FORMAT RPC_S_SERVER_UNAVAILABLE --*/ { WS_SOCKADDR *pAddr = (WS_SOCKADDR *)Address; ULONG HostAddr; ULONG Endpoint; int i; USHORT port; RPC_STATUS status; // Figure out the destination port status = EndpointToPortNumber(pPort, port); if (RPC_S_OK != status) { ASSERT( 0 ); return(status); } CDP_InitLocalAddress( &pAddr->clusaddr, port ); // Resolve the network address - CDP addresses are // numbers representing a member ID in the cluster. pAddr->clusaddr.sac_node = _wtol( NetworkAddress ); return(status); } RPC_STATUS RPC_ENTRY CDP_ClientOpenEndpoint( OUT DG_TRANSPORT_ENDPOINT ThisEndpoint, IN BOOL fAsync, DWORD Flags ) { RPC_STATUS Status; PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; // We don't care what port we bind to, we also don't care what // port we bind to. // I think he's trying to say that we don't care what port // we bind to. CDP_InitLocalAddress(&pEndpoint->ListenAddr.clusaddr, 0); pEndpoint->id = CDP; pEndpoint->fClient = TRUE; pEndpoint->fAsync = fAsync; pEndpoint->EndpointFlags = 0; pEndpoint->fDynamicEndpoint = 1; Status = DG_CreateEndpoint(pEndpoint); return Status; } RPC_STATUS CDP_InitializeSockAddr( IN char *Endpoint, OUT WS_SOCKADDR *pSockAddr ) /*++ Routine Description: Initialized the sockaddr to be a loopback address to the endpoint specified. Used to forward packets locally. Arguments: Endpoint - The string value of the servers endpoint. pSockAddr - The sockaddr to fill in. Return Value: RPC_S_INVALID_ENDPOINT_FORMAT RPC_S_OK --*/ { long port; port = atol(Endpoint); if (port <= 0 || port > 0xFFFF) { ASSERT( 0 ); return(RPC_S_INVALID_ENDPOINT_FORMAT); } CDP_InitLocalAddress(&pSockAddr->clusaddr, (unsigned short) port); return(RPC_S_OK); } RPC_STATUS RPC_ENTRY CDP_GetEndpointStats( IN DG_TRANSPORT_ENDPOINT ThisEndpoint, OUT DG_ENDPOINT_STATS * pStats ) { RPC_STATUS Status; Status = DG_GetEndpointStats(ThisEndpoint, pStats); if (Status) { pStats->MaxPduSize = 1452; pStats->MaxPacketSize = 1452; pStats->PreferredPduSize = 1452; pStats->ReceiveBufferSize= 8192; return Status; } // // ethernet frame (1500) - UDP/IP headers (28) - CNP/CDP headers (20) // pStats->MaxPacketSize = 1452; pStats->PreferredPduSize = 4096; if (pStats->PreferredPduSize > pStats->MaxPduSize) { pStats->PreferredPduSize = pStats->MaxPduSize; } return RPC_S_OK; } //////////////////////////////////////////////////////////////////////// // // UDP/IP specific functions. // RPC_STATUS RPC_ENTRY UDP_ServerListen( IN OUT DG_TRANSPORT_ENDPOINT ThisEndpoint, IN RPC_CHAR *NetworkAddress, IN OUT RPC_CHAR **pPort, IN void *pSecurityDescriptor, IN ULONG EndpointFlags, IN ULONG NICFlags, OUT NETWORK_ADDRESS_VECTOR **ppNetworkAddressVector ) /*++ Routine Description: Creates a server endpoint object to receive packets. New packets won't actually arrive until CompleteListen is called. Arguments: ThisEndpoint - Storage for the server endpoint object. pPort - The endpoint to listen on or a pointer to 0 if the transport should choose the address. Contains the endpoint listened to on output. The caller should free this. pSecurityDiscriptor - Security to attach to this endpoint (not used by UDP). EndpointFlags - Application flags passed into RPC via RpcServerUseProtseq*Ex. NICFlags - Application flags passed into RPC via RpcServerUseProtseq*Ex. pNetworkAddresses - A vector of the network addresses listened on by this call. This vector does not need to be freed. Return Value: RPC_S_OK RPC_S_OUT_OF_MEMORY RPC_S_OUT_OF_RESOURCES RPC_S_CANT_CREATE_ENDPOINT RPC_S_INVALID_ENDPOINT_FORMAT RPC_S_DUPLICATE_ENDPOINT --*/ { RPC_STATUS status; NTSTATUS NtStatus; USHORT port; UNICODE_STRING UnicodeString; ANSI_STRING AsciiString; PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; WS_SOCKADDR *addr = &pEndpoint->ListenAddr; addr->inetaddr.sin_family = AF_INET; if (NetworkAddress) { IP_ADDRESS_RESOLVER resolver(NetworkAddress, cosServer, ipvtuIPv4 // IP version to use ); // Loop until success, fatal failure or we run out of addresses. status = resolver.NextAddress(&addr->inetaddr); if (status != RPC_S_OK) { return RPC_S_INVALID_NET_ADDR; } } else { addr->inetaddr.sin_addr.s_addr = INADDR_ANY; } // Figure out the port to listen on. if (*pPort) { status = EndpointToPortNumber(*pPort, port); if (status != RPC_S_OK) { return(status); } pEndpoint->fDynamicEndpoint = 0; addr->inetaddr.sin_port = htons(port); } else { addr->inetaddr.sin_port = 0; pEndpoint->fDynamicEndpoint = 1; } pEndpoint->id = UDP; pEndpoint->fClient = FALSE; pEndpoint->fAsync = TRUE; pEndpoint->EndpointFlags = EndpointFlags; // // Actually create the endpoint // status = DG_CreateEndpoint(pEndpoint); if (status != RPC_S_OK) { return(status); } // If needed, figure out the dynamically allocated endpoint. if (!*pPort) { *pPort = new RPC_CHAR[IP_MAXIMUM_ENDPOINT]; if (!*pPort) { DG_ServerAbortListen(ThisEndpoint); return(RPC_S_OUT_OF_MEMORY); } port = ntohs(addr->inetaddr.sin_port); PortNumberToEndpoint(port, *pPort); } // Figure out the network addresses status = IP_BuildAddressVector(&pEndpoint->pAddressVector, RPC_C_BIND_TO_ALL_NICS, NULL, NULL); if (status != RPC_S_OK) { DG_ServerAbortListen(ThisEndpoint); return(status); } *ppNetworkAddressVector = pEndpoint->pAddressVector; return RPC_S_OK; } RPC_STATUS UDP_QueryEndpoint ( IN void * pOriginalEndpoint, OUT RPC_CHAR * pClientEndpoint ) { WS_SOCKADDR * pSockAddr = (WS_SOCKADDR *)pOriginalEndpoint; unsigned NativeSocket = ntohs(pSockAddr->inetaddr.sin_port); char AnsiBuffer[IP_MAXIMUM_ENDPOINT]; char * pAnsi = AnsiBuffer; RPC_CHAR * pUni = pClientEndpoint; // // Convert endpoint to an ASCII string, and thence to Unicode. // _ultoa(NativeSocket, AnsiBuffer, 10); while ( *pUni++ = *pAnsi++ ); return RPC_S_OK; } RPC_STATUS UDP_QueryAddress ( IN void * pOriginalEndpoint, OUT RPC_CHAR * pClientAddress ) { UNICODE_STRING UnicodeString; ANSI_STRING AsciiString; WS_SOCKADDR *pSockAddr = (WS_SOCKADDR *)pOriginalEndpoint; NTSTATUS NtStatus; UnicodeString.Buffer = pClientAddress; UnicodeString.Length = 0; UnicodeString.MaximumLength = IP_MAXIMUM_RAW_NAME * sizeof(RPC_CHAR); char *t = inet_ntoa(pSockAddr->inetaddr.sin_addr); ASSERT(t); RtlInitAnsiString(&AsciiString, t); ASSERT(AsciiString.Length < IP_MAXIMUM_RAW_NAME); NtStatus = RtlAnsiStringToUnicodeString(&UnicodeString, &AsciiString, FALSE); if (!NT_SUCCESS(NtStatus)) { ASSERT(0); return(RPC_S_OUT_OF_RESOURCES); } return(RPC_S_OK); } RPC_STATUS RPC_ENTRY UDP_ClientInitializeAddress ( OUT DG_TRANSPORT_ADDRESS Address, IN RPC_CHAR *NetworkAddress, IN RPC_CHAR *pPort, IN BOOL fUseCache, IN BOOL fBroadcast ) /*++ Routine Description: Initializes a address object for sending to a server. Arguments: Address - Storage for the address NetworkAddress - The address of the server or 0 if local Endpoint - The endpoint of the server fUseCache - If TRUE then the transport may use a cached value from a previous call on the same NetworkAddress. fBroadcast - If TRUE, NetworkAddress is ignored and a broadcast address is used. Return Value: RPC_S_OK - Success, name resolved and, optionally, added to cache. RPC_P_FOUND_IN_CACHE - Success, returned only if fUseCache is TRUE and the was name found in local cache. RPC_P_MATCHED_CACHE - Partial success, fUseCache is FALSE and the result of the lookup was the same as the value previously in the cache. RPC_S_OUT_OF_MEMORY RPC_S_OUT_OF_RESOURCES RPC_S_INVALID_ENDPOINT_FORMAT RPC_S_SERVER_UNAVAILABLE --*/ { WS_SOCKADDR *pAddr = (WS_SOCKADDR *)Address; ULONG HostAddr; ULONG Endpoint; int i; USHORT port; RPC_STATUS status; // Contant part of address memset(pAddr->inetaddr.sin_zero, 0, 8); pAddr->inetaddr.sin_family = AF_INET; // Figure out the destination port status = EndpointToPortNumber(pPort, port); if (RPC_S_OK != status) { return(status); } pAddr->inetaddr.sin_port = htons(port); // Resolve the network address if (fBroadcast) { pAddr->inetaddr.sin_addr.s_addr = INADDR_BROADCAST; return(RPC_S_OK); } // Multiple server address support for UDP/IP is not available. IP_ADDRESS_RESOLVER resolver(NetworkAddress, cosClient, ipvtuIPv4 // IP version to use ); status = resolver.NextAddress(&pAddr->inetaddr); if (status) { RpcpErrorAddRecord( EEInfoGCWinsock, status, EEInfoDLWinsockDatagramResolve10, NetworkAddress ); } return(status); } RPC_STATUS RPC_ENTRY UDP_ClientOpenEndpoint( OUT DG_TRANSPORT_ENDPOINT ThisEndpoint, IN BOOL fAsync, DWORD EndpointFlags ) { PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; WS_SOCKADDR *addr = &pEndpoint->ListenAddr; // We don't care what port we bind to, we also don't care what // port we bind to. memset(addr, 0, sizeof(*addr)); addr->inetaddr.sin_family = AF_INET; pEndpoint->id = UDP; pEndpoint->fClient = TRUE; pEndpoint->fAsync = fAsync; pEndpoint->EndpointFlags = EndpointFlags; pEndpoint->fDynamicEndpoint = 1; return(DG_CreateEndpoint(pEndpoint)); } RPC_STATUS UDP_InitializeSockAddr( IN char *Endpoint, OUT WS_SOCKADDR *pSockAddr ) /*++ Routine Description: Initialized the sockaddr to be a loopback address to the endpoint specified. Used to forward packets locally. Arguments: Endpoint - The string value of the servers endpoint. pSockAddr - The sockaddr to fill in. Return Value: RPC_S_INVALID_ENDPOINT_FORMAT RPC_S_OK --*/ { int len; long port; pSockAddr->generic.sa_family = AF_INET; pSockAddr->inetaddr.sin_addr.s_addr = 0x0100007F; // byte swapped, 127.0.0.1 port = atol(Endpoint); if (port <= 0 || port > 0xFFFF) { return(RPC_S_INVALID_ENDPOINT_FORMAT); } pSockAddr->inetaddr.sin_port = htons((USHORT) port); return(RPC_S_OK); } RPC_STATUS RPC_ENTRY UDP_GetEndpointStats( IN DG_TRANSPORT_ENDPOINT ThisEndpoint, OUT DG_ENDPOINT_STATS * pStats ) { RPC_STATUS Status; Status = DG_GetEndpointStats(ThisEndpoint, pStats); if (Status) { pStats->MaxPduSize = 1472; pStats->MaxPacketSize = 1472; pStats->PreferredPduSize = 1472; pStats->ReceiveBufferSize= 8192; return Status; } pStats->MaxPacketSize = 1472; pStats->PreferredPduSize = 4096; if (pStats->PreferredPduSize > pStats->MaxPduSize) { pStats->PreferredPduSize = pStats->MaxPduSize; } return RPC_S_OK; } #ifdef IPX_ON //////////////////////////////////////////////////////////////////////// // // IPX specific functions. // RPC_STATUS RPC_ENTRY IPX_ServerListen( IN OUT DG_TRANSPORT_ENDPOINT ThisEndpoint, IN RPC_CHAR *NetworkAddress, IN OUT RPC_CHAR **pPort, IN void *pSecurityDescriptor, IN ULONG EndpointFlags, IN ULONG NICFlags, OUT NETWORK_ADDRESS_VECTOR **ppNetworkAddressVector ) /*++ Routine Description: Creates a server endpoint object to receive packets. New packets won't actually arrive until CompleteListen is called. Arguments: ThisEndpoint - Storage for the server endpoint object. pPort - The endpoint to listen on or a pointer to 0 if the transport should choose the address. Contains the endpoint listened to on output. The caller should free this. pSecurityDiscriptor - Security to attach to this endpoint (not used by the IPX transport). EndpointFlags - Application flags passed into RPC via RpcServerUseProtseq*Ex. NICFlags - Application flags passed into RPC via RpcServerUseProtseq*Ex. pNetworkAddresses - A vector of the network addresses listened on by this call. This vector does not need to be freed. Return Value: RPC_S_OK RPC_S_OUT_OF_MEMORY RPC_S_OUT_OF_RESOURCES RPC_S_CANT_CREATE_ENDPOINT RPC_S_INVALID_ENDPOINT_FORMAT RPC_S_DUPLICATE_ENDPOINT --*/ { RPC_STATUS status; NTSTATUS NtStatus; USHORT port; UNICODE_STRING UnicodeString; ANSI_STRING AsciiString; PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; WS_SOCKADDR *addr = &pEndpoint->ListenAddr; // // Figure out what port to listen on. // if (*pPort) { status = EndpointToPortNumber(*pPort, port); if (status != RPC_S_OK) { return(status); } pEndpoint->fDynamicEndpoint = 0; } else { port = 0; pEndpoint->fDynamicEndpoint = 1; } addr->generic.sa_family = AF_IPX; addr->ipxaddr.sa_socket = htons(port); pEndpoint->id = IPX; pEndpoint->fClient = FALSE; pEndpoint->fAsync = TRUE; pEndpoint->EndpointFlags = 0; // // Actually create the endpoint // status = DG_CreateEndpoint(pEndpoint); if (status != RPC_S_OK) { return(status); } // If needed, figure out the dynamically allocated endpoint. if (!*pPort) { *pPort = new RPC_CHAR[IP_MAXIMUM_ENDPOINT]; if (!*pPort) { DG_ServerAbortListen(ThisEndpoint); return(RPC_S_OUT_OF_MEMORY); } port = ntohs(addr->ipxaddr.sa_socket); PortNumberToEndpoint(port, *pPort); } // Update the local address cache // // Since there is only one addess no lock is required. // memcpy(IpxAddr.sa_netnum, addr->ipxaddr.sa_netnum, sizeof(IpxAddr.sa_netnum)); memcpy(IpxAddr.sa_nodenum, addr->ipxaddr.sa_nodenum, sizeof(IpxAddr.sa_nodenum)); fIpxAddrValid = TRUE; // // Figure out our server's raw IPX address. // status = IPX_BuildAddressVector(ppNetworkAddressVector); if (status != RPC_S_OK) { DG_ServerAbortListen(ThisEndpoint); delete *pPort; return(status); } pEndpoint->pAddressVector = *ppNetworkAddressVector; return RPC_S_OK; } RPC_STATUS IPX_QueryEndpoint ( IN void * pOriginalEndpoint, OUT RPC_CHAR * pClientEndpoint ) { WS_SOCKADDR * pSockAddr = (WS_SOCKADDR *)pOriginalEndpoint; unsigned NativeSocket = ntohs(pSockAddr->ipxaddr.sa_socket); char AnsiBuffer[IPX_MAXIMUM_ENDPOINT]; char * pAnsi = AnsiBuffer; RPC_CHAR * pUni = pClientEndpoint; // // Convert endpoint to an ASCII string, and thence to Unicode. // _ultoa(NativeSocket, AnsiBuffer, 10); while ( *pUni++ = *pAnsi++ ); return RPC_S_OK; } RPC_STATUS IPX_QueryAddress ( IN void * pOriginalEndpoint, OUT RPC_CHAR * pString ) { WS_SOCKADDR *pSockAddr = (WS_SOCKADDR *) pOriginalEndpoint; IPX_AddressToName(&pSockAddr->ipxaddr, pString); return RPC_S_OK; } RPC_STATUS RPC_ENTRY IPX_ClientInitializeAddress ( OUT DG_TRANSPORT_ADDRESS Address, IN RPC_CHAR *NetworkAddress, IN RPC_CHAR *pPort, IN BOOL fUseCache, IN BOOL fBroadcast ) /*++ Routine Description: Initializes a address object for sending to a server. Arguments: Address - Storage for the address NetworkAddress - The address of the server or 0 if local pPort - The endpoint of the server fUseCache - If TRUE then the transport may use a cached value from a previous call on the same NetworkAddress. fBroadcast - If TRUE, NetworkAddress is ignored and a broadcast address is used. Return Value: RPC_S_OK - Success, name resolved and, optionally, added to cache. RPC_P_FOUND_IN_CACHE - Success, returned only if fUseCache is TRUE and the was name found in local cache. RPC_P_MATCHED_CACHE - Partial success, fUseCache is FALSE and the result of the lookup was the same as the value previously in the cache. RPC_S_OUT_OF_MEMORY RPC_S_OUT_OF_RESOURCES RPC_S_INVALID_ENDPOINT_FORMAT RPC_S_SERVER_UNAVAILABLE --*/ { WS_SOCKADDR *pAddr = (WS_SOCKADDR *)Address; RPC_STATUS status = RPC_S_OK; USHORT port = 0; pAddr->ipxaddr.sa_family = AF_IPX; pAddr->ipxaddr.sa_socket = 0; // Convert unicode endpoint to port number status = EndpointToPortNumber(pPort, port); if (status != RPC_S_OK) { return(status); } // // Convert unicode network address to ipx address // if (FALSE == fBroadcast) { status = IPX_NameToAddress(NetworkAddress, fUseCache, &pAddr->ipxaddr ); } else { memset(pAddr->ipxaddr.sa_netnum, 0, sizeof(pAddr->ipxaddr.sa_netnum)); memset(pAddr->ipxaddr.sa_nodenum, 0xFF, sizeof(pAddr->ipxaddr.sa_nodenum)); } pAddr->ipxaddr.sa_socket = htons(port); return(status); } RPC_STATUS RPC_ENTRY IPX_ClientOpenEndpoint( OUT DG_TRANSPORT_ENDPOINT ThisEndpoint, IN BOOL fAsync, DWORD Flags ) { RPC_STATUS status; PWS_DATAGRAM_ENDPOINT pEndpoint = (PWS_DATAGRAM_ENDPOINT)ThisEndpoint; WS_SOCKADDR *addr = &pEndpoint->ListenAddr; // We don't care what port we bind to, we also don't care what // port we bind to. memset(addr, 0, sizeof(*addr)); addr->ipxaddr.sa_family = AF_IPX; pEndpoint->id = IPX; pEndpoint->fClient = TRUE ; pEndpoint->fAsync = fAsync; pEndpoint->EndpointFlags = 0; pEndpoint->fDynamicEndpoint = 1; status = DG_CreateEndpoint(pEndpoint); if (status == RPC_S_OK) { // Update cache memcpy(IpxAddr.sa_netnum, addr->ipxaddr.sa_netnum, sizeof(IpxAddr.sa_netnum)); memcpy(IpxAddr.sa_nodenum, addr->ipxaddr.sa_nodenum, sizeof(IpxAddr.sa_nodenum)); fIpxAddrValid = TRUE; } return(status); } RPC_STATUS IPX_InitializeSockAddr( IN char *Endpoint, OUT WS_SOCKADDR *pSockAddr ) /*++ Routine Description: Initialized the sockaddr to be a loopback address to the endpoint specified. Used to forward packets locally. Arguments: Endpoint - The string value of the servers endpoint. pSockAddr - The sockaddr to fill in. Return Value: RPC_S_INVALID_ENDPOINT_FORMAT RPC_S_OK --*/ { int len; long port; pSockAddr->generic.sa_family = AF_IPX; port = atol(Endpoint); if (port <= 0 || port > 0xFFFF) { return(RPC_S_INVALID_ENDPOINT_FORMAT); } pSockAddr->ipxaddr.sa_socket = htons((USHORT)port); // // In order to get this far this server must have // alrady listened to IPX. // ASSERT(fIpxAddrValid); memcpy(pSockAddr->ipxaddr.sa_netnum, IpxAddr.sa_netnum, sizeof(pSockAddr->ipxaddr.sa_netnum)); memcpy(pSockAddr->ipxaddr.sa_nodenum, IpxAddr.sa_nodenum, sizeof(pSockAddr->ipxaddr.sa_nodenum)); return(RPC_S_OK); } RPC_STATUS RPC_ENTRY IPX_GetEndpointStats( IN DG_TRANSPORT_ENDPOINT ThisEndpoint, OUT DG_ENDPOINT_STATS * pStats ) { RPC_STATUS Status; Status = DG_GetEndpointStats(ThisEndpoint, pStats); if (Status) { pStats->MaxPduSize = 1478; pStats->MaxPacketSize = 1478; pStats->PreferredPduSize = 1478; pStats->ReceiveBufferSize= 8192; return Status; } pStats->MaxPacketSize = 1478; pStats->PreferredPduSize = pStats->MaxPduSize; pStats->MaxPacketSize = pStats->MaxPduSize; return RPC_S_OK; } #endif //////////////////////////////////////////////////////////////////////// // // Transport interface structures and loader // const RPC_DATAGRAM_TRANSPORT UDP_TransportInterface = { RPC_TRANSPORT_INTERFACE_VERSION, UDP_TOWER_ID, IP_ADDRESS_ID, RPC_STRING_LITERAL("ncadg_ip_udp"), "135", COMMON_ProcessCalls, COMMON_StartPnpNotifications, COMMON_ListenForPNPNotifications, COMMON_TowerConstruct, COMMON_TowerExplode, COMMON_PostRuntimeEvent, TRUE, sizeof(WS_DATAGRAM_ENDPOINT), sizeof(WS_DATAGRAM_ENDPOINT), sizeof(WS_SOCKADDR), IP_MAXIMUM_ENDPOINT, IP_MAXIMUM_PRETTY_NAME, 1024, 1472, DG_SendPacket, UDP_ClientOpenEndpoint, UDP_ClientInitializeAddress, DG_ClientCloseEndpoint, DG_ReceivePacket, UDP_ServerListen, DG_ServerAbortListen, COMMON_ServerCompleteListen, DG_ForwardPacket, UDP_QueryAddress, UDP_QueryEndpoint, UDP_GetEndpointStats, FALSE, // fIsMessageTransport (TRUE/FALSE). 0, // OptionSize 0, // InitOptions() 0, // SetOption() 0, // InqOption() 0, // ImplementOptions() 0, // AllowReceives() 0 // InquireAuthClient() }; const RPC_DATAGRAM_TRANSPORT CDP_TransportInterface = { RPC_TRANSPORT_INTERFACE_VERSION, CDP_TOWER_ID, IP_ADDRESS_ID, RPC_STRING_LITERAL("ncadg_cluster"), NULL, COMMON_ProcessCalls, COMMON_StartPnpNotifications, COMMON_ListenForPNPNotifications, COMMON_TowerConstruct, COMMON_TowerExplode, COMMON_PostRuntimeEvent, TRUE, sizeof(WS_DATAGRAM_ENDPOINT), sizeof(WS_DATAGRAM_ENDPOINT), sizeof(WS_SOCKADDR), IP_MAXIMUM_ENDPOINT, IP_MAXIMUM_PRETTY_NAME, 1024, 1452, DG_SendPacket, CDP_ClientOpenEndpoint, CDP_ClientInitializeAddress, DG_ClientCloseEndpoint, DG_ReceivePacket, CDP_ServerListen, DG_ServerAbortListen, COMMON_ServerCompleteListen, DG_ForwardPacket, CDP_QueryAddress, CDP_QueryEndpoint, CDP_GetEndpointStats, FALSE, // fIsMessageTransport (TRUE/FALSE). 0, // OptionSize 0, // InitOptions() 0, // SetOption() 0, // InqOption() 0, // ImplementOptions() 0, // AllowReceives() 0 // InquireAuthClient() }; #ifdef IPX_ON const RPC_DATAGRAM_TRANSPORT IPX_TransportInterface = { RPC_TRANSPORT_INTERFACE_VERSION, IPX_TOWER_ID, IPX_ADDRESS_ID, RPC_STRING_LITERAL("ncadg_ipx"), "34280", COMMON_ProcessCalls, COMMON_StartPnpNotifications, COMMON_ListenForPNPNotifications, COMMON_TowerConstruct, COMMON_TowerExplode, COMMON_PostRuntimeEvent, TRUE, sizeof(WS_DATAGRAM_ENDPOINT), sizeof(WS_DATAGRAM_ENDPOINT), sizeof(WS_SOCKADDR), IPX_MAXIMUM_ENDPOINT, IPX_MAXIMUM_PRETTY_NAME, 1024, 1464, DG_SendPacket, IPX_ClientOpenEndpoint, IPX_ClientInitializeAddress, DG_ClientCloseEndpoint, DG_ReceivePacket, IPX_ServerListen, DG_ServerAbortListen, COMMON_ServerCompleteListen, DG_ForwardPacket, IPX_QueryAddress, IPX_QueryEndpoint, IPX_GetEndpointStats, FALSE, // fIsMessageTransport (TRUE/FALSE). 0, // OptionSize 0, // InitOptions() 0, // SetOption() 0, // InqOption() 0, // ImplementOptions() 0, // AllowReceives() 0 // InquireAuthClient() }; #endif #ifdef NCADG_MQ_ON const RPC_DATAGRAM_TRANSPORT MQ_TransportInterface = { RPC_TRANSPORT_INTERFACE_VERSION, MQ_TOWER_ID, MQ_ADDRESS_ID, RPC_STRING_LITERAL("ncadg_mq"), "EpMapper", COMMON_ProcessCalls, COMMON_StartPnpNotifications, COMMON_ListenForPNPNotifications, COMMON_TowerConstruct, COMMON_TowerExplode, COMMON_PostRuntimeEvent, TRUE, sizeof(MQ_DATAGRAM_ENDPOINT), sizeof(MQ_DATAGRAM_ENDPOINT), sizeof(MQ_ADDRESS), MQ_MAXIMUM_ENDPOINT, MQ_MAXIMUM_PRETTY_NAME, MQ_MAX_PDU_SIZE, MQ_PREFERRED_PDU_SIZE, MQ_SendPacket, MQ_ClientOpenEndpoint, MQ_ClientInitializeAddress, MQ_ClientCloseEndpoint, MQ_ReceivePacket, MQ_ServerListen, MQ_ServerAbortListen, COMMON_ServerCompleteListen, MQ_ForwardPacket, MQ_QueryAddress, MQ_QueryEndpoint, MQ_GetEndpointStats, TRUE, // fIsMessageTransport (TRUE/FALSE). sizeof(MQ_OPTIONS), // OptionSize MQ_InitOptions, // InitOptions() MQ_SetOption, // SetOption() MQ_InqOption, // InqOption() MQ_ImplementOptions, // ImplementOptions() MQ_AllowReceives, // AllowReceives() MQ_InquireAuthClient }; #endif // NCADG_MQ_ON const RPC_DATAGRAM_TRANSPORT * DG_TransportLoad ( IN PROTOCOL_ID index ) /*++ Routine Description: Loads a datagram protocol and returns the transport interface information for the protocol. Arguments: index - the PROTOCOL_ID value of the protocol to load. Return Value: 0 - failure !0 - success --*/ { const RPC_DATAGRAM_TRANSPORT *pInfo; if (fWinsockLoaded == FALSE) { if (RPC_WSAStartup() == FALSE) { return(0); } fWinsockLoaded = TRUE; } switch(index) { case UDP: pInfo = &UDP_TransportInterface; break; #ifdef IPX_ON case IPX: if (InitializeIpxNameCache() != RPC_S_OK) { pInfo = 0; } else { pInfo = &IPX_TransportInterface; } break; #endif #ifdef NCADG_MQ_ON case MSMQ: if (!MQ_Initialize()) { return(0); } else { pInfo = &MQ_TransportInterface; } break; #endif // NCADG_MQ_ON case CDP: pInfo = &CDP_TransportInterface; break; default: TransDbgPrint((DPFLTR_RPCPROXY_ID, DPFLTR_WARNING_LEVEL, RPCTRANS "DG_TransportLoad called with index: %d\n", index)); ASSERT(0); pInfo = 0; break; } // PERFBUG: Add code to lookup real PDU sizes return(pInfo); }