/*++ Copyright (c) 1992 Microsoft Corporation Module Name: dgudpc.cxx Abstract: This is the UDP datagram client dll. Author: Dave Steckler (davidst) 15-Mar-1993 Revision History: --*/ #include #define FD_SETSIZE 1 #include #include #include #ifdef IPX #include #include #include #endif #include #include #include #ifdef ENABLE_FACK_BODIES #define MAX_PDU (1514) #else #define MAX_PDU 1024 #endif #define ENDPOINT_LEN 6 #ifdef IPX #define NETADDR_LEN 22 #define MAX_HOSTNAME_LEN 22 #define ADDRESS_FAMILY AF_IPX #define PROTOCOL NSPROTO_IPX #else #define ADDRESS_FAMILY AF_INET #define PROTOCOL 0 #define MAX_HOSTNAME_LEN 32 // // Host name won't be bigger than 15, i.e., // nnn.nnn.nnn.nnn // #define NETADDR_LEN 15 #endif #ifdef IPX /* For some reason, getsockname wants to return more then sizeof(SOCKADDR_IPX) bytes. bugbug. */ typedef union SOCKADDR_FIX { SOCKADDR_IPX s; struct sockaddr unused; } SOCKADDR_FIX; typedef struct { CSADDR_INFO info; SOCKADDR_FIX addr1; SOCKADDR_FIX addr2; } CSADDR_BUFFER; #endif /* These are Transport Specific ENDPOINTS and ADDRESS Runtime has allocated a chuck of memory and as far as runtime is concerned this is opaque data that transport uses in transport specific way! */ typedef struct { int Socket; fd_set Set; } DG_UDP_ENDPOINT; unsigned long LargestPacketSize = MAX_PDU; typedef DG_UDP_ENDPOINT * PDG_UDP_ENDPOINT; typedef struct { #ifdef IPX SOCKADDR_FIX ServerAddress; #else struct sockaddr_in ServerAddress; #endif BOOL ServerLookupFailed; } DG_UDP_ADDRESS; typedef DG_UDP_ADDRESS * PDG_UDP_ADDRESS; #define DG_UDP_TRANSPORT_VERSION 1 #pragma pack(1) #ifdef IPX #define TRANSPORTID 0x0e #define TRANSPORTHOSTID 0x0d #define TOWERFLOORS 5 /*Endpoint = 2 bytes, HostId = 10 bytes*/ #define TOWEREPSIZE 10 #define TOWERSIZE (TOWEREPSIZE+2) #define PROTSEQ "ncadg_ipx" #define ENDPOINT_MAPPER_EP "34280" #define MAX_ENDPOINT_SIZE 8 #else #define TRANSPORTID 0x08 #define TRANSPORTHOSTID 0x09 #define TOWERFLOORS 5 /*Endpoint = 2 bytes, HostId = 4 bytes*/ #define TOWEREPSIZE 4 #define TOWERSIZE (TOWEREPSIZE+2) #define PROTSEQ "ncadg_ip_udp" #define ENDPOINT_MAPPER_EP "135" #define MAX_ENDPOINT_SIZE 6 #endif typedef struct _FLOOR_234 { unsigned short ProtocolIdByteCount; unsigned char FloorId; unsigned short AddressByteCount; unsigned char Data[2]; } FLOOR_234; typedef FLOOR_234 PAPI UNALIGNED * PFLOOR_234; #define NEXTFLOOR(t,x) (t)((unsigned char PAPI *)x +((t)x)->ProtocolIdByteCount\ + ((t)x)->AddressByteCount\ + sizeof(((t)x)->ProtocolIdByteCount)\ + sizeof(((t)x)->AddressByteCount)) #define ByteSwapLong(Value) \ Value = ( (((unsigned long) (Value) & 0xFF000000) >> 24) \ | (((unsigned long) (Value) & 0x00FF0000) >> 8) \ | (((unsigned long) (Value) & 0x0000FF00) << 8) \ | (((unsigned long) (Value) & 0x000000FF) << 24)) #define ByteSwapShort(Value) \ Value = ( (((unsigned short) (Value) & 0x00FF) << 8) \ | (((unsigned short) (Value) & 0xFF00) >> 8)) /* End of Tower Stuff! */ #pragma pack() #define LOOPBACK (htonl(INADDR_LOOPBACK)) #ifdef IPX GUID SERVICE_TYPE = { 0x000b0640, 0, 0, { 0xC0,0,0,0,0,0,0,0x46 } }; #endif #ifdef IPX unsigned char chtob( unsigned char c1, unsigned char c2 ) /* Convert two hex digits (stored as ascii) into one byte. */ { unsigned char out; if (c1 >= '0' && c1 <= '9') out = (c1 - '0') << 4; else { if (c1 >= 'a' && c1 <= 'f') out = (c1 - 'a' + 10) << 4; else if (c1 >= 'A' && c1 <= 'F') out = (c1 - 'A' + 10) << 4; else out = 0; } if (c2 >= '0' && c2 <= '9') out |= c2 -'0'; else { if (c2 >= 'a' && c2 <= 'f') out |= c2 - 'a' + 10; else if (c2 >= 'A' && c2 <= 'F') out |= c2 - 'A' + 10; else out = 0; } return out; } // This routine takes a host name or address as a string and returns it // as a SOCKADDR_IPX structure. It accepts a NULL string for the local // host address. This routine works for IPX addresses. int my_get_host_by_name( SOCKET socket, void *netaddr, char *host ) { // Allocate extra some extra space. CSADDR_BUFFER csaddr[2]; int num; int length; DWORD protocol_list[2]; DWORD csaddr_size = sizeof(csaddr); SOCKADDR_FIX *ipx = netaddr; int i; // Verify the length of the host name. length = strlen(host); // If no address was specified, look up the local address. if (length == 0) { length = sizeof ( SOCKADDR_FIX ); if (getsockname ( socket, (struct sockaddr *) netaddr, &length )) return ( RPC_S_SERVER_UNAVAILABLE ); } // If the name starts with ~, convert it directly to a network address. else if (host[0] == '~') { if (length != 21) return RPC_S_SERVER_UNAVAILABLE; for (i = 0; i < 4; i++) ipx->s.sa_netnum[i] = chtob( host[2*i + 1], host[2*i + 2] ); for (i = 0; i < 6; i++) ipx->s.sa_nodenum[i] = chtob( host[2*i + 9], host[2*i + 10] ); } // Quit if the name is too long. else if (length > MAX_HOSTNAME_LEN) return RPC_S_SERVER_UNAVAILABLE; // If a name was passed, look it up in the SAP service. else { // Get address. protocol_list[0] = PROTOCOL; protocol_list[1] = 0; num = GetAddressByName( NS_SAP, &SERVICE_TYPE, host, protocol_list, 0, FALSE, &csaddr, &csaddr_size, NULL, 0 ); if (num <= 0) { // PrintToDebugger( "GetAddressByName failed 0x%x\n", WSAGetLastError() ); return RPC_S_SERVER_UNAVAILABLE; } // Copy the address. memcpy( netaddr, csaddr[0].info.RemoteAddr.lpSockaddr, sizeof(SOCKADDR_FIX) ); } return RPC_S_OK; } #endif RPC_STATUS MapStatusCode( int SocketError, RPC_STATUS Default ) /*++ Routine Description: Maps a winsock return value into a RPC_STATUS. Arguments: ErrorCode - Input error code. Return Value: mapped status code --*/ { RPC_STATUS Status; switch (SocketError) { case 0: { Status = RPC_S_OK; break; } case WSAETIMEDOUT: { Status = RPC_P_TIMEOUT; break; } case WSAENOBUFS: { Status = RPC_S_OUT_OF_MEMORY; break; } case WSAEMSGSIZE: { Status = RPC_P_OVERSIZE_PACKET; break; } default: { #ifdef DEBUGRPC PrintToDebugger("RPC DG: Winsock error %d\n", SocketError); #endif Status = Default; } } return Status; } RPC_STATUS AssignLocalEndpoint( IN void * Endpoint ) /*++ Routine Description: Ask transport for a new endpoint. Arguments: Return Value: RPC_S_OK --*/ { BOOL SetSocketOptions; int PacketType; // // Create a socket. // PDG_UDP_ENDPOINT TransportEndpoint = (PDG_UDP_ENDPOINT) Endpoint; TransportEndpoint->Socket = socket(ADDRESS_FAMILY, SOCK_DGRAM, PROTOCOL); if (TransportEndpoint->Socket == INVALID_SOCKET) { return (MapStatusCode(WSAGetLastError(), RPC_S_CALL_FAILED_DNE) ); } #ifdef IPX // Use packet type 4. PacketType = 4; if (setsockopt( TransportEndpoint->Socket, NSPROTO_IPX, IPX_PTYPE, (char *) &PacketType, sizeof(PacketType)) != 0) { closesocket(TransportEndpoint->Socket); return(RPC_S_CALL_FAILED_DNE); } #endif //Enable broadcasts by default .. on this socket //We may change this later - to do broadcasts by demand SetSocketOptions = TRUE; if (setsockopt( TransportEndpoint->Socket, SOL_SOCKET, SO_BROADCAST, (char *)&SetSocketOptions, sizeof(SetSocketOptions)) != 0) { closesocket(TransportEndpoint->Socket); return(RPC_S_CALL_FAILED_DNE); } SetSocketOptions = 1000L; //1 sec if (setsockopt( TransportEndpoint->Socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&SetSocketOptions, sizeof(SetSocketOptions)) != 0) { closesocket(TransportEndpoint->Socket); return(RPC_S_CALL_FAILED_DNE); } FD_ZERO(&(TransportEndpoint->Set)); FD_SET(TransportEndpoint->Socket, &(TransportEndpoint->Set)); return(RPC_S_OK); } RPC_STATUS FreeLocalEndpoint( IN void * Endpoint ) /*++ Routine Description: Frees an endpoint Arguments: Return Value: RPC_S_OK --*/ { //We wont free the memory as the runtime will do that //We just do the transport related stuff PDG_UDP_ENDPOINT TransportEndpoint = (PDG_UDP_ENDPOINT)Endpoint; closesocket(TransportEndpoint->Socket); return(RPC_S_OK); } RPC_STATUS ReceivePacket( IN void * TransportEndpoint, IN void * Buffer, IN unsigned long * BufferLength, IN unsigned long Timeout, IN void * SenderAddress ) /*++ Routine Description: Receives a packet from the network. Arguments: pPack - Packet to receive into. Timeout - Timeout in seconds. Return Value: RPC_S_OK RPC_P_TIMEOUT --*/ { PDG_UDP_ENDPOINT Endpoint = (PDG_UDP_ENDPOINT)TransportEndpoint; int SockStatus; int BytesReceived; struct timeval TimeoutVal; int DummyLen = sizeof(struct sockaddr); // // Receive something on our socket. // // // By default the socket we have setup will wait // for 1 sec [default timeout] for a packet. // If timeout is greater than 1 sec we need to force a select // In the common case we just go and do a recvfrom and avoid the // hit of doing a select followed by a recv if (Timeout > 1) { TimeoutVal.tv_sec = Timeout; TimeoutVal.tv_usec = 0; // // Wait for our socket to be receivable. // SockStatus = select( 1, &(Endpoint->Set), 0, 0, &TimeoutVal ); if (SockStatus == 0) { FD_SET(Endpoint->Socket, &(Endpoint->Set)); return RPC_P_TIMEOUT; } #if DBG if (SockStatus < 0) { PrintToDebugger("select returned %d \n", SockStatus); } #endif ASSERT(FD_ISSET(Endpoint->Socket, &(Endpoint->Set))); } BytesReceived = recvfrom( Endpoint->Socket, (char *)Buffer, (int)LargestPacketSize, 0, SenderAddress, &DummyLen ); // // Did we get something? // if ((BytesReceived == SOCKET_ERROR) || (BytesReceived == 0)) { return MapStatusCode(WSAGetLastError(), RPC_P_RECEIVE_FAILED); } *BufferLength = BytesReceived; return RPC_S_OK; } RPC_CHAR MaxEndpoint[] = { '6', '5', '5', '3', '5', '\0' }; #ifdef IPX RPC_STATUS RegisterServerAddress( IN void * pClientCall, IN RPC_CHAR * pServer, IN RPC_CHAR * pEndpoint, OUT void PAPI * PAPI * ppTransAddress ) /*++ Routine Description: Registers a new call with the transport. This informs the transport that data is about to be sent and received on this address to and from the server/endpoint. This routine returns a 'transport address' through which the sending and receiving will be accomplished. This routine serves mainly as a psuedo-constructor for a DG_UDP_CLIENT_TRANSPORT object, where all the real work occurs. Arguments: pClientCall - A pointer to the protocol's DG_CCALL object for this call. This is defined as a 'void *' instead of a PDG_CCALL because we don't want to have to include (and link in) all the stuff associated with DG_CCALL (including DCE_BINDING, BINDING_HANDLE, MESSAGE_OBJECT, etc.) pServer - Name of the server we are talking with. pEndpoint - Endpoint on that server. ppTransAddress - Where to place a pointer to a new transport address which the protocol will use to identify the socket we are using. Return Value: RPC_S_OK RPC_S_OUT_OF_MEMORY --*/ { int Endpoint; int EndpointLength; int i; int length; SOCKET dummy; SOCKADDR_FIX dummy_address; PDG_UDP_ADDRESS pdgAddress = (PDG_UDP_ADDRESS) *ppTransAddress ; RPC_STATUS status; UNICODE_STRING UServer; UNICODE_STRING UEndpoint; ANSI_STRING AServer; ANSI_STRING AEndpoint; NTSTATUS NtStatus; if (*ppTransAddress == NULL) { return RPC_S_OUT_OF_MEMORY; } pdgAddress->ServerLookupFailed = TRUE; // // convert the endpoint to a number. // EndpointLength = RpcpStringLength(pEndpoint); if (EndpointLength > 5 || (EndpointLength == 5 && RpcpStringCompare(pEndpoint, MaxEndpoint) > 0)) { return RPC_S_INVALID_ENDPOINT_FORMAT; } for (i=0, Endpoint=0 ; i< EndpointLength ; i++) { if ( ((char)pEndpoint[i] >= '0') && ((char)pEndpoint[i] <= '9')) { Endpoint *= 10; Endpoint += (char)pEndpoint[i]-'0'; } else { return RPC_S_INVALID_ENDPOINT_FORMAT; } } // Get a socket in case my_get_address_by_name needs to look up the local // address. memset( &dummy_address, 0, sizeof(dummy_address) ); dummy_address.s.sa_family = ADDRESS_FAMILY; dummy = socket( ADDRESS_FAMILY, SOCK_DGRAM, PROTOCOL ); if (dummy == INVALID_SOCKET) return RPC_S_OK; length = sizeof ( pdgAddress->ServerAddress ); if (bind( dummy, &dummy_address.unused, length ) != 0) return RPC_S_OK; // Find the address. RtlInitUnicodeString(&UServer,pServer); RtlInitUnicodeString(&UEndpoint,pEndpoint); AServer.Buffer = NULL; AEndpoint.Buffer = NULL; NtStatus = RtlUnicodeStringToAnsiString(&AServer,&UServer,TRUE); if (NT_SUCCESS(NtStatus)) { NtStatus = RtlUnicodeStringToAnsiString(&AEndpoint,&UEndpoint,TRUE); if (NT_SUCCESS(NtStatus)) { status = my_get_host_by_name(dummy, &pdgAddress->ServerAddress, AServer.Buffer ); if (status == RPC_S_OK) pdgAddress->ServerLookupFailed = FALSE; } } RtlFreeAnsiString(&AServer); RtlFreeAnsiString(&AEndpoint); closesocket( dummy ); pdgAddress->ServerAddress.s.sa_family = ADDRESS_FAMILY; pdgAddress->ServerAddress.s.sa_socket = htons((unsigned short) Endpoint); return RPC_S_OK; } #else RPC_STATUS RegisterServerAddress( IN void * pClientCall, IN RPC_CHAR * pServer, IN RPC_CHAR * pEndpoint, OUT void PAPI * PAPI * ppTransAddress ) /*++ Routine Description: Registers a new call with the transport. This informs the transport that data is about to be sent and received on this address to and from the server/endpoint. This routine returns a 'transport address' through which the sending and receiving will be accomplished. This routine serves mainly as a psuedo-constructor for a DG_UDP_CLIENT_TRANSPORT object, where all the real work occurs. Arguments: pClientCall - A pointer to the protocol's DG_CCALL object for this call. This is defined as a 'void *' instead of a PDG_CCALL because we don't want to have to include (and link in) all the stuff associated with DG_CCALL (including DCE_BINDING, BINDING_HANDLE, MESSAGE_OBJECT, etc.) pServer - Name of the server we are talking with. pEndpoint - Endpoint on that server. ppTransAddress - Where to place a pointer to a new transport address which the protocol will use to identify the socket we are using. Return Value: RPC_S_OK RPC_S_OUT_OF_MEMORY --*/ { RPC_STATUS Status; int EndpointLength; int ServerLength; int i; char * pCharServerName; struct hostent *pHostEntry; int Endpoint; PDG_UDP_ADDRESS pdgAddress = (PDG_UDP_ADDRESS) *ppTransAddress ; unsigned long HostAddr; if (*ppTransAddress == NULL) { return RPC_S_OUT_OF_MEMORY; } pdgAddress->ServerLookupFailed = FALSE; // // convert the endpoint to a number. // EndpointLength = RpcpStringLength(pEndpoint); if (EndpointLength > 5 || (EndpointLength == 5 && RpcpStringCompare(pEndpoint, MaxEndpoint) > 0)) { return RPC_S_INVALID_ENDPOINT_FORMAT; } for (i=0, Endpoint=0 ; i< EndpointLength ; i++) { if ( ((char)pEndpoint[i] >= '0') && ((char)pEndpoint[i] <= '9')) { Endpoint *= 10; Endpoint += (char)pEndpoint[i]-'0'; } else { return RPC_S_INVALID_ENDPOINT_FORMAT; } } // // Put our server name in a character array (instead of wchar) // if ((pServer == NULL) || (*pServer == '\0')) { HostAddr = LOOPBACK; } else { ServerLength = RpcpStringLength((char *)pServer); if ( (pCharServerName = (char *) I_RpcAllocate(ServerLength+1)) == 0 ) return (RPC_S_OUT_OF_MEMORY); for (i=0 ; iServerLookupFailed = TRUE; } else { HostAddr = *(unsigned long *)pHostEntry->h_addr; } } I_RpcFree(pCharServerName); } pdgAddress->ServerAddress.sin_family = ADDRESS_FAMILY; pdgAddress->ServerAddress.sin_port = htons((unsigned short) Endpoint); if (pdgAddress->ServerLookupFailed == FALSE) { RpcpMemoryCopy((char *) &(pdgAddress->ServerAddress.sin_addr.s_addr), (char *) &HostAddr, sizeof(unsigned long)); } return RPC_S_OK; } #endif RPC_STATUS DeregisterServerAddress( IN void * pTransAddress ) /*++ Routine Description: This routine serves as a psuedo-destructor for a DG_UDP_CLIENT_TRANSPORT object. It frees up a socket. Arguments: pTransAddress - Address to deregister. Return Value: RPC_S_OK --*/ { return RPC_S_OK; } RPC_STATUS SendToServer( IN void * TransportEndpoint, IN void * Buffer, IN unsigned long BufferLength, IN BOOL Broadcast, IN void * TransportAddress ) /*++ Routine Description: Sends a packet on the network through the transport address associated with the passed packet. Arguments: pPack - Packet to send. Broadcast - Whether to broadcast or not. Return Value: RPC_S_OK --*/ { PDG_UDP_ADDRESS pTransAddress = (PDG_UDP_ADDRESS)TransportAddress; int SockStatus; SOCKET Socket = ((PDG_UDP_ENDPOINT)TransportEndpoint)->Socket; // // Send the data on the net. // if ((Broadcast == FALSE) && (pTransAddress->ServerLookupFailed == TRUE)) { return(RPC_S_SERVER_UNAVAILABLE); } ASSERT(BufferLength <= MAX_PDU); if (Broadcast) { #ifdef IPX SOCKADDR_FIX ServerAddress; int i; RpcpMemoryCopy( (char *) &ServerAddress, (char *) &pTransAddress->ServerAddress, sizeof( ServerAddress ) ); for (i = 0; i < 6; i++) ServerAddress.s.sa_nodenum[i] = (char) 0xff; #else struct sockaddr_in ServerAddress; ServerAddress.sin_family = ADDRESS_FAMILY; ServerAddress.sin_port = pTransAddress->ServerAddress.sin_port; *((long *) &ServerAddress.sin_addr.s_addr) = INADDR_BROADCAST; #endif SockStatus = sendto( Socket, (char *)Buffer, BufferLength, 0, (struct sockaddr *)&ServerAddress, sizeof(ServerAddress) ); } else { SockStatus = sendto( Socket, (char *)Buffer, BufferLength, 0, (struct sockaddr *)&(pTransAddress->ServerAddress), sizeof(pTransAddress->ServerAddress) ); } if (SockStatus == (int) BufferLength) { return RPC_S_OK; } else { return MapStatusCode(WSAGetLastError(), RPC_P_SEND_FAILED); } } #pragma pack(1) RPC_STATUS RPC_ENTRY ClientTowerConstruct( IN char PAPI * Endpoint, IN char PAPI * NetworkAddress, OUT UNALIGNED unsigned short PAPI * Floors, OUT UNALIGNED unsigned long PAPI * ByteCount, OUT unsigned char PAPI * UNALIGNED PAPI * Tower, IN char PAPI * Protseq ) { unsigned long TowerSize; unsigned short portnum; UNALIGNED PFLOOR_234 Floor; #ifdef IPX SOCKADDR_IPX netaddr; #else unsigned long hostval; #endif /* Compute the memory size of the tower. */ *Floors = TOWERFLOORS; TowerSize = TOWERSIZE; TowerSize += 2*sizeof(FLOOR_234) - 4; /* Allocate memory for the tower. */ *ByteCount = TowerSize; if ((*Tower = (unsigned char PAPI*)I_RpcAllocate(TowerSize)) == NULL) { return (RPC_S_OUT_OF_MEMORY); } /* Put the endpoint address and transport protocol id in the first floor. */ Floor = (PFLOOR_234) *Tower; Floor->ProtocolIdByteCount = 1; Floor->FloorId = (unsigned char)(TRANSPORTID & 0xFF); Floor->AddressByteCount = 2; if (Endpoint == NULL || *Endpoint == '\0') { Endpoint = ENDPOINT_MAPPER_EP; } portnum = (unsigned short) htons ( (unsigned short) atoi (Endpoint)); memcpy((char PAPI *)&Floor->Data[0], &portnum, sizeof(portnum)); /* Put the network address and the transport host protocol id in the second floor. */ Floor = NEXTFLOOR(PFLOOR_234, Floor); Floor->ProtocolIdByteCount = 1; Floor->FloorId = (unsigned char)(TRANSPORTHOSTID & 0xFF); Floor->AddressByteCount = TOWEREPSIZE; Floor->Data[0] = '\0'; Floor->Data[1] = '\0'; if ((NetworkAddress) && (*NetworkAddress)) { #ifdef IPX my_get_host_by_name( 0, &netaddr, NetworkAddress ); memcpy(&Floor->Data[0], netaddr.sa_netnum, sizeof(netaddr.sa_netnum)); memcpy(&Floor->Data[4], netaddr.sa_nodenum, sizeof(netaddr.sa_nodenum)); #else hostval = inet_addr((char *) NetworkAddress); memcpy((char PAPI *)&Floor->Data[0], &hostval, sizeof(hostval)); #endif } return(RPC_S_OK); } RPC_STATUS RPC_ENTRY ClientTowerExplode( IN unsigned char PAPI * Tower, OUT char PAPI * UNALIGNED PAPI * Protseq, OUT char PAPI * UNALIGNED PAPI * Endpoint, OUT char PAPI * UNALIGNED PAPI * NetworkAddress ) { UNALIGNED PFLOOR_234 Floor = (PFLOOR_234) Tower; RPC_STATUS Status = RPC_S_OK; unsigned short portnum; UNALIGNED unsigned short *Port; if (Protseq != NULL) { *Protseq = I_RpcAllocate(strlen(PROTSEQ) + 1); if (*Protseq == NULL) Status = RPC_S_OUT_OF_MEMORY; else memcpy(*Protseq, PROTSEQ, strlen(PROTSEQ) + 1); } if ((Endpoint == NULL) || (Status != RPC_S_OK)) { return (Status); } *Endpoint = I_RpcAllocate(6); //Ports are all <64K [5 decimal dig +1] if (*Endpoint == NULL) { Status = RPC_S_OUT_OF_MEMORY; if (Protseq != NULL) { I_RpcFree(*Protseq); } } else { #if defined(MIPS) || defined(_ALPHA_) memcpy(&portnum, (char PAPI *)&Floor->Data[0], sizeof(portnum)); #else Port = (unsigned short *)&Floor->Data[0]; portnum = *Port; #endif _itoa(ByteSwapShort(portnum), *Endpoint, 10); } return(Status); } #pragma pack() #ifdef IPX RPC_STATUS QueryClientEndpoint ( IN void * pOriginalEndpoint, OUT RPC_CHAR * pClientEndpoint ) { SOCKADDR_IPX * pSockAddr = (SOCKADDR_IPX *) pOriginalEndpoint; unsigned NativeSocket = ntohs(pSockAddr->sa_socket); char AnsiBuffer[6]; char * pAnsi = AnsiBuffer; RPC_CHAR * pUni = pClientEndpoint; // // Convert endpoint to an ASCII string, and thence to Unicode. // _ultoa(NativeSocket, AnsiBuffer, 10); do { *pUni++ = *pAnsi; } while ( *pAnsi++ ); return RPC_S_OK; } #else RPC_STATUS RPC_ENTRY QueryClientEndpoint ( IN void * pOriginalEndpoint, OUT RPC_CHAR * pClientEndpoint ) { struct sockaddr_in * pSockAddr = (struct sockaddr_in *) pOriginalEndpoint; unsigned NativeSocket = ntohs(pSockAddr->sin_port); char AnsiBuffer[6]; char * pAnsi = AnsiBuffer; RPC_CHAR * pUni = pClientEndpoint; // // Convert endpoint to an ASCII string, and thence to Unicode. // _ultoa(NativeSocket, AnsiBuffer, 10); do { *pUni++ = *pAnsi; } while ( *pAnsi++ ); return RPC_S_OK; } #endif RPC_STATUS RPC_ENTRY SetBufferLength( IN void PAPI * Endpoint, IN unsigned Length ) { DG_UDP_ENDPOINT * pInfo = (DG_UDP_ENDPOINT *) Endpoint; int SockStatus; SockStatus = setsockopt(pInfo->Socket, SOL_SOCKET, SO_RCVBUF, (char *) &Length, sizeof(Length) ); if (SockStatus == SOCKET_ERROR) { return RPC_S_OUT_OF_MEMORY; } return RPC_S_OK; } DG_RPC_CLIENT_TRANSPORT_INFO TransInfo = { 2, MAX_PDU, sizeof(DG_UDP_ADDRESS), sizeof(DG_UDP_ENDPOINT), 0, 0, ReceivePacket, SendToServer, MAX_ENDPOINT_SIZE, (TRANS_CLIENT_TOWERCONSTRUCT) ClientTowerConstruct, (TRANS_CLIENT_TOWEREXPLODE) ClientTowerExplode, TRANSPORTID, RegisterServerAddress, DeregisterServerAddress, AssignLocalEndpoint, FreeLocalEndpoint, QueryClientEndpoint, SetBufferLength }; PDG_RPC_CLIENT_TRANSPORT_INFO TransportLoad( RPC_CHAR * pProtocolSequence ) /*++ Routine Description: This routine is the "psuedo constructor" for the client transport object. This is the exported entry point into this dll. Arguments: pProtocolSequence - The protocol sequence we're running on. Return Value: Pointer to a DG_UDP_CLIENT_TRANSPORT if successful, otherwise NULL. --*/ { RPC_STATUS Status; WSADATA Data; #ifdef IPX SOCKET Socket; #endif // // Initialize our network. // Status = WSAStartup( 0x0101, // version required &Data ); if (Status != 0) { return 0; } #ifdef IPX Socket = socket(ADDRESS_FAMILY, SOCK_DGRAM, PROTOCOL); if (Socket == INVALID_SOCKET) { return (0); } closesocket(Socket); #endif return (&TransInfo); }