/* -------------------------------------------------------------------- File : dnltclnt.c Title : client loadable transport for DECnet Win - client side Description : History : 6-26-91 Jim Teague Initial version. -------------------------------------------------------------------- */ #include "dnltclnt.h" #pragma pack(1) #define DNA_SESSION_CONTROL 0x02 #define NSP_TRANSPORT 0x04 #define DNA_ROUTING 0x06 #define DNET_TOWERFLOORS 6 #define DNET_EP "#69" #define DNET_PROTSEQ "ncacn_dnet_nsp" #define DNET_FLOOR3_SIZE 8 /* LHSbc = 2, LHSd = 1, RHSbc = 2, RHSd = 3 */ #define DNET_FLOOR4_SIZE 5 /* LHSbc = 2, LHSd = 1, RHSbc = 2, RHSd = 0 */ #define DNET_FLOOR5_SIZE 9 /* LHSbc = 2, LHSd = 1, RHSbc = 2, RHSd = 4 */ typedef struct _FLOOR { unsigned short LHSByteCount; unsigned char LHSData; unsigned short RHSByteCount; unsigned char RHSData[2]; } FLOOR, PAPI * PFLOOR; #define NEXTFLOOR(t,x) (t)((unsigned char PAPI *)x \ + ((t)x)->LHSByteCount \ + ((t)x)->RHSByteCount \ + sizeof(((t)x)->LHSByteCount) \ + sizeof(((t)x)->RHSByteCount)) #pragma pack() RPC_CLIENT_RUNTIME_INFO PAPI * RpcRuntimeInfo; RPC_TRANS_STATUS RPC_ENTRY ClientOpen ( IN PCONNECTION pConn, IN unsigned char _far * NetworkAddress, IN unsigned char _far * Endpoint, IN unsigned char _far * NetworkOptions, IN unsigned char _far * TransportAddress, IN unsigned char _far * RpcProtocolSequence, IN unsigned int Timeout ) // Open a client connection { struct sockaddr_dn server; struct nodeent _far *hostentry; struct dn_naddr _far *dotaddress; int i; // // See if node address is in numeric format... // if ((i = strcspn(NetworkAddress,".0123456789")) == 0) { dotaddress = dnet_addr(NetworkAddress); hostentry = getnodebyaddr (dotaddress->a_addr, sizeof(short),AF_DECnet); } else hostentry = getnodebyname (NetworkAddress); if (hostentry == (struct nodeent _far *) 0) return (RPC_S_SERVER_UNAVAILABLE); server.sdn_family = AF_DECnet; server.sdn_objnum = 0; server.sdn_objnamel = 0; server.sdn_objname[0] = 0; // // Look at the port string: if the first character is '#', // then interpret it as an object number... // if (*Endpoint == '#') server.sdn_objnum = atoi(Endpoint+1); // // ...otherwise, it is an object name... // else { server.sdn_objnamel = strlen(Endpoint); strcpy (server.sdn_objname,Endpoint); } server.sdn_add.a_len = hostentry->n_length; memcpy ((char _far *) &server.sdn_add.a_addr, (char _far *) hostentry->n_addr, hostentry->n_length); // // Get a socket // if ((pConn->Socket = socket(AF_DECnet, SOCK_STREAM, 0)) < 0) return (RPC_S_SERVER_UNAVAILABLE); // // Try to connect... // if (connect(pConn->Socket, (struct sockaddr_dn _far *) &server, sizeof (server)) < 0) return (RPC_S_SERVER_UNAVAILABLE); return (RPC_S_OK); } RPC_TRANS_STATUS RPC_ENTRY ClientClose ( IN PCONNECTION pConn ) // Close a client connection { // Don't close a connection that is already closed... sclose(pConn->Socket); return (RPC_S_OK); } RPC_TRANS_STATUS RPC_ENTRY ClientWrite ( IN PCONNECTION pConn, IN void _far * Buffer, IN unsigned int BufferLength ) // Write a message to a connection. This operation is retried in case // the server is "busy". { int bytes; // // Send a message on the socket // bytes = send(pConn->Socket, (char _far *) Buffer, (int) BufferLength, 0); if (bytes != (int) BufferLength) { ClientClose(pConn); return(RPC_P_SEND_FAILED); } return(RPC_S_OK); } RPC_TRANS_STATUS RPC_ENTRY ClientRead ( IN PCONNECTION pConn, IN OUT void _far * _far * Buffer, IN OUT unsigned int _far * BufferLength ) // Read a message from a connection. { unsigned short bytes; unsigned short total_bytes; message_header header; unsigned short native_length; fd_set ClientConnMask; unsigned short got_data; RPC_STATUS status; FD_ZERO(&ClientConnMask); FD_SET(pConn->Socket, &ClientConnMask); got_data = select(MAX_SOCKETS,&ClientConnMask,(fd_set _far *) 0, (fd_set _far *) 0, NULL); // // If there's data, deal with it. // if (got_data <= 0) { ClientClose(pConn); return (RPC_P_RECEIVE_FAILED); } // // Read protocol header to see how big // the record is... // bytes = recv ( pConn->Socket, (char _far *) &header, sizeof (message_header), 0); if (bytes == 0) { ClientClose(pConn); return(RPC_P_CONNECTION_CLOSED); } if (bytes != sizeof(message_header)) { ClientClose(pConn); return (RPC_P_RECEIVE_FAILED); } // // Look at the header: if this packet comes from a big endian // machine, we'll have to byte swap the frag_length field... // if ( (header.drep[0] & ENDIAN_MASK) == 0 ) { // Big endian...swap bytes // ((unsigned char _far *) &native_length)[0] = ((unsigned char _far *) &header.frag_length)[1]; ((unsigned char _far *) &native_length)[1] = ((unsigned char _far *) &header.frag_length)[0]; } else // Little endian, just like us // native_length = header.frag_length; // // Make sure buffer is big enough. If it isn't, then go back // to the runtime to reallocate it. // if (native_length > *BufferLength) { status = (*(RpcRuntimeInfo->ReallocBuffer)) (pConn, Buffer, 0, native_length); if (status) { ClientClose(pConn); return (RPC_S_OUT_OF_MEMORY); } } *BufferLength = native_length; // // Read message segments until we get what we expect... // memcpy (*Buffer, &header, sizeof(message_header)); total_bytes = sizeof(message_header); while (total_bytes < native_length) { if((bytes = recv( pConn->Socket, (unsigned char _far *) *Buffer + total_bytes, (int) (*BufferLength - total_bytes), 0)) == -1) { ClientClose(pConn); return (RPC_P_RECEIVE_FAILED); } else total_bytes += bytes; } return(RPC_S_OK); } #pragma pack(1) RPC_STATUS RPC_ENTRY ClientTowerConstruct( IN char PAPI * Endpoint, IN char PAPI * NetworkAddress, OUT unsigned short PAPI * Floors, OUT unsigned long PAPI * ByteCount, OUT unsigned char PAPI * PAPI * Tower, IN char PAPI * Protseq ) /*++ Routine Description: This function constructs upper floors of DCE tower from the supplied endpoint and network address. It returns #of floors [lower+upper] for this protocol/transport, bytes in upper floors and the tower [floors 4,5] Arguments: Endpoint- A pointer to string representation of Endpoint NetworkAddress - A pointer to string representation of NW Address Floors - A pointer to #of floors in the tower ByteCount - Size of upper floors of tower. Tower - The constructed tower returmed - The memory is allocated by the routine and caller will have to free it. Return Value: RPC_S_OK RPC_S_OUT_OF_MEMORY - There is no memory to return the constructed Tower. --*/ { unsigned long TowerSize; struct dn_naddr _far * dotaddress; struct nodeent _far * hostentry; PFLOOR Floor; int i; unsigned char * Port; *Floors = DNET_TOWERFLOORS; if(Protseq); TowerSize = 0; TowerSize = DNET_FLOOR3_SIZE + DNET_FLOOR4_SIZE + DNET_FLOOR5_SIZE; if ((*Tower = (unsigned char PAPI*)(*(RpcRuntimeInfo->Allocate))((unsigned int) (*ByteCount = TowerSize))) == NULL) { return (RPC_S_OUT_OF_MEMORY); } Floor = (PFLOOR) *Tower; Floor->LHSByteCount = 1; Floor->LHSData = (unsigned char)(DNA_SESSION_CONTROL & 0xFF); Floor->RHSByteCount = 3; Port = (unsigned char *) &Floor->RHSData[0]; if (Endpoint == NULL || *Endpoint == '\0') { Endpoint = DNET_EP; } memcpy ( Port, Endpoint, strlen(Endpoint)); /* * Onto the next floor... */ Floor = NEXTFLOOR(PFLOOR, Floor) ; Floor->LHSByteCount = 1; Floor->LHSData = (unsigned char)(NSP_TRANSPORT & 0xFF); Floor->RHSByteCount = 0; /* * Next floor... */ Floor = NEXTFLOOR(PFLOOR, Floor); Floor->LHSByteCount = 1; Floor->LHSData = (unsigned char)(DNA_ROUTING & 0xFF); Floor->RHSByteCount = 4; //dotaddress = (struct dn_naddr *)&Floor->RHSData[0]; if ((NetworkAddress) && (*NetworkAddress)) { // if (i = strcspn(NetworkAddress,".0123456789")) // { // dotaddress = dnet_addr((unsigned char *) NetworkAddress); // hostentry = getnodebyaddr (dotaddress->a_addr,sizeof(short), // AF_DECnet); // } // else // hostentry = getnodebyname (NetworkAddress); // // memcpy (&Floor->RHSData[0],&hostentry->n_length,Floor->RHSByteCount); Floor->RHSData[0] = 0; Floor->RHSData[1] = 1; Floor->RHSData[2] = 2; Floor->RHSData[3] = 3; } else { dotaddress = 0; } return(RPC_S_OK); } RPC_STATUS RPC_ENTRY ClientTowerExplode( IN unsigned char PAPI * Tower, OUT char PAPI * PAPI * Protseq, OUT char PAPI * PAPI * Endpoint, OUT char PAPI * PAPI * NetworkAddress ) { /*++ Routine Description: This function takes the protocol/transport specific floors and returns Protseq, Endpoint and NwAddress Note: Since ther is no need to return NW Address, currently nothing is done for NW Address. Arguments: Tower - The DCE tower, upper floors Protseq - Protocol Sequence returned- memory is allocated by the routine and caller will have to free using I_RpcFree Endpoitn- Endpoint returned- memory is allocated by the routine and caller will have to free using I_RpcFree NWAddress- Nothing is done here - just incase we need it later Return Value: RPC_S_OK RPC_S_OUT_OF_MEMORY - There is no memory to return the constructed Tower. --*/ PFLOOR Floor = (PFLOOR) Tower; RPC_STATUS Status = RPC_S_OK; if (Protseq != NULL) { *Protseq = (*(RpcRuntimeInfo->Allocate))(strlen(DNET_PROTSEQ) + 1); if (*Protseq == NULL) Status = RPC_S_OUT_OF_MEMORY; else memcpy(*Protseq, DNET_PROTSEQ, strlen(DNET_PROTSEQ) + 1); } if ((Endpoint == NULL) || (Status != RPC_S_OK)) { return (Status); } *Endpoint = (*(RpcRuntimeInfo->Allocate))(Floor->RHSByteCount + 1); if (*Endpoint == NULL) { Status = RPC_S_OUT_OF_MEMORY; if(Protseq != NULL) { (*(RpcRuntimeInfo->Free))(*Protseq); } } else { memcpy ( *Endpoint, &Floor->RHSData[3], Floor->RHSByteCount-3); *(*Endpoint + (Floor->RHSByteCount-3)) = (unsigned char) 0; } return(Status); } #pragma pack() RPC_CLIENT_TRANSPORT_INFO TransInfo = { RPC_TRANSPORT_INTERFACE_VERSION, DNA_SESSION_CONTROL, ClientTowerConstruct, ClientTowerExplode, DNET_MAXIMUM_SEND, sizeof (CONNECTION), ClientOpen, ClientClose, ClientWrite, ClientRead, NULL, 0, 0, 0 }; RPC_CLIENT_TRANSPORT_INFO _far * RPC_ENTRY TransPortLoad ( IN RPC_CHAR _far * RpcProtocolSequence, IN RPC_CLIENT_RUNTIME_INFO PAPI * RpcClientRuntimeInfo ) // Loadable transport initialization function { RpcRuntimeInfo = RpcClientRuntimeInfo; return(&TransInfo); }