static int
TRANS(Os2Write)(XtransConnInfo ciptr, char *buf, int size)
{
int ret;
APIRET rc;
ULONG nWritten;
PRMSG(2,"Os2Write(%d,%x,%d)\n", ciptr->fd, buf, size );
rc = DosWrite(ciptr->fd, buf, size, &nWritten);
if (rc == 0){
ret = nWritten;
if(nWritten == 0) {
errno=EAGAIN;
ret = -1;
}
}
else if ((rc == 39) || (rc == 112)){
errno = EAGAIN;
ret = -1;
}
else if ((rc == 109) || (rc == 230) || (rc == 233)){
errno = EPIPE;
ret = -1;
}
else if (rc == 6){
errno=EBADF;
ret = -1;
}
else {
PRMSG(2,"(Os2Write)Unknown return code from DosWrite, fd %d rc=%d\n", ciptr->fd,rc,0 );
errno = EINVAL;
ret = -1;
}
return (ret);
}
static XtransConnInfo
TRANS(DNETOpenCOTSServer) (Xtransport *thistrans, char *protocol,
char *host, char *port)
{
XtransConnInfo ciptr;
PRMSG (2,"DNETOpenCOTSServer(%s,%s,%s)\n", protocol, host, port);
if ((ciptr = (XtransConnInfo) xcalloc (
1, sizeof(struct _XtransConnInfo))) == NULL)
{
PRMSG (1, "DNETOpenCOTSServer: malloc failed\n", 0, 0, 0);
return NULL;
}
if ((ciptr->fd = socket (AF_DECnet, SOCK_STREAM, 0)) < 0)
{
xfree ((char *) ciptr);
return NULL;
}
ciptr->index = 0; /* only one form of DECnet */
return (ciptr);
}
static int
TRANS(Os2Read)(XtransConnInfo ciptr, char *buf, int size)
{
int ret;
APIRET rc;
ULONG ulRead;
PRMSG(2,"Os2Read(%d,%x,%d)\n", ciptr->fd, buf, size );
errno = 0;
rc = DosRead(ciptr->fd, buf, size, &ulRead);
if (rc == 0){
ret = ulRead;
}
else if ((rc == 232) || (rc == 231)){
errno = EAGAIN;
ret = -1;
}
else if (rc == 6){
errno = EBADF;
ret = -1;
}
else if ((rc == 109) || (rc == 230) || (rc == 233)){
errno = EPIPE;
ret = -1;
}
else {
PRMSG(2,"Os2Read: Unknown return code from DosRead, fd %d rc=%d\n", ciptr->fd,rc,0 );
errno = EINVAL;
ret = -1;
}
return (ret);
}
int
TRANS(Connect) (XtransConnInfo ciptr, char *address)
{
char *protocol;
char *host;
char *port;
int ret;
PRMSG (2,"Connect(%d,%s)\n", ciptr->fd, address, 0);
if (TRANS(ParseAddress) (address, &protocol, &host, &port) == 0)
{
PRMSG (1,"Connect: Unable to Parse address %s\n",
address, 0, 0);
return -1;
}
if (!port || !*port)
{
PRMSG (1,"Connect: Missing port specification in %s\n",
address, 0, 0);
if (protocol) xfree (protocol);
if (host) xfree (host);
return -1;
}
ret = ciptr->transptr->Connect (ciptr, host, port);
if (protocol) xfree (protocol);
if (host) xfree (host);
if (port) xfree (port);
return ret;
}
static int
TRANS(DNETGetPeerAddr) (XtransConnInfo ciptr)
{
struct sockaddr_dn sockname;
int namelen = sizeof(sockname);
PRMSG (3,"DNETGetPeerAddr(%x)\n", ciptr, 0, 0);
if (getpeername (ciptr->fd, (struct sockaddr *) &sockname, &namelen) < 0)
{
PRMSG (1,"DNETGetPeerAddr: getpeername() failed: %d\n",
EGET(), 0, 0);
return -1;
}
/*
* Everything looks good: fill in the XtransConnInfo structure.
*/
if ((ciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
{
PRMSG (1,
"DNETGetPeerAddr: Can't allocate space for the addr\n",
0, 0, 0);
return -1;
}
ciptr->peeraddrlen = namelen;
memcpy (ciptr->peeraddr, &sockname, ciptr->peeraddrlen);
return 0;
}
static XtransConnInfo
TRANS(DNETAccept) (XtransConnInfo ciptr, int *status)
{
XtransConnInfo newciptr;
struct sockaddr_dn sockname;
int namelen = sizeof(sockname);
PRMSG (2, "DNETAccept(%x,%d)\n", ciptr, ciptr->fd, 0);
if ((newciptr = (XtransConnInfo) xcalloc(
1, sizeof (struct _XtransConnInfo))) == NULL)
{
PRMSG (1, "DNETAccept: malloc failed\n", 0, 0, 0);
*status = TRANS_ACCEPT_BAD_MALLOC;
return NULL;
}
if((newciptr->fd = accept (ciptr->fd,
(struct sockaddr *) &sockname, &namelen)) < 0)
{
PRMSG (1, "DNETAccept: accept() failed\n", 0, 0, 0);
xfree (newciptr);
*status = TRANS_ACCEPT_FAILED;
return NULL;
}
/*
* Get this address again because the transport may give a more
* specific address now that a connection is established.
*/
if (TRANS(DNETGetAddr) (newciptr) < 0)
{
PRMSG(1,
"DNETAccept: ...DNETGetAddr() failed:\n", 0, 0, 0);
close (newciptr->fd);
xfree (newciptr);
*status = TRANS_ACCEPT_MISC_ERROR;
return NULL;
}
if (TRANS(DNETGetPeerAddr) (newciptr) < 0)
{
PRMSG(1,
"DNETAccept: ...DNETGetPeerAddr() failed:\n", 0, 0, 0);
close (newciptr->fd);
if (newciptr->addr) xfree (newciptr->addr);
xfree (newciptr);
*status = TRANS_ACCEPT_MISC_ERROR;
return NULL;
}
*status = 0;
return newciptr;
}
static XtransConnInfo
TRANS(Os2OpenCLTSClient)(Xtransport *thistrans, char *protocol,
char *host, char *port)
{
PRMSG(2,"Os2OpenCLTSClient(%s,%s,%s)\n",protocol,host,port);
return TRANS(Os2OpenClient)(thistrans, protocol, host, port);
}
static int
TRANS(Os2BytesReadable)(XtransConnInfo ciptr, BytesReadable_t *pend )
{
ULONG rc, state, nread;
AVAILDATA avail;
char buffer;
PRMSG(2,"Os2BytesReadable(%x->%d,%x)\n", ciptr, ciptr->fd, pend);
rc = DosPeekNPipe (ciptr->fd, &buffer, 0, &nread, &avail, &state);
if (rc != 0)
{
errno = EPIPE;
*pend = 0;
return -1;
}
if (state == NP_STATE_CLOSING)
{
errno = EPIPE;
*pend = 0;
return -1;
}
errno = 0;
*pend = avail.cbpipe;
return 0;
}
int
TRANS(NoListen) (char * protocol)
{
Xtransport *trans;
int i = 0, ret = 0;
if ((trans = TRANS(SelectTransport)(protocol)) == NULL)
{
PRMSG (1,"TransNoListen: unable to find transport: %s\n",
protocol, 0, 0);
return -1;
}
if (trans->flags & TRANS_ALIAS) {
if (trans->nolisten)
while (trans->nolisten[i]) {
ret |= TRANS(NoListen)(trans->nolisten[i]);
i++;
}
}
trans->flags |= TRANS_NOLISTEN;
return ret;
}
static Xtransport *
TRANS(SelectTransport) (char *protocol)
{
char protobuf[PROTOBUFSIZE];
int i;
PRMSG (3,"SelectTransport(%s)\n", protocol, 0, 0);
/*
* Force Protocol to be lowercase as a way of doing
* a case insensitive match.
*/
strncpy (protobuf, protocol, PROTOBUFSIZE - 1);
for (i = 0; i < PROTOBUFSIZE && protobuf[i] != '\0'; i++)
if (isupper (protobuf[i]))
protobuf[i] = tolower (protobuf[i]);
/* Look at all of the configured protocols */
for (i = 0; i < NUMTRANS; i++)
{
if (!strcmp (protobuf, Xtransports[i].transport->TransName))
return Xtransports[i].transport;
}
return NULL;
}
XtransConnInfo
TRANS(OpenCLTSClient) (char *address)
{
PRMSG (2,"OpenCLTSClient(%s)\n", address, 0, 0);
return TRANS(Open) (XTRANS_OPEN_CLTS_CLIENT, address);
}
XtransConnInfo
TRANS(OpenCLTSServer) (char *address)
{
PRMSG (2,"OpenCLTSServer(%s)\n", address, 0, 0);
return TRANS(Open) (XTRANS_OPEN_CLTS_SERVER, address);
}
XtransConnInfo
TRANS(ReopenCLTSServer) (int trans_id, int fd, char *port)
{
PRMSG (2,"ReopenCLTSServer(%d, %d, %s)\n", trans_id, fd, port);
return TRANS(Reopen) (XTRANS_OPEN_CLTS_SERVER, trans_id, fd, port);
}
static XtransConnInfo
TRANS(Os2OpenCOTSServer)(Xtransport *thistrans, char *protocol,
char *host, char *port)
{
PRMSG(2,"Os2OpenCOTSServer(%s,%s,%s)\n",protocol,host,port);
return TRANS(Os2OpenServer)(thistrans, protocol, host, port);
}
static XtransConnInfo
TRANS(Os2ReopenCOTSServer)(Xtransport *thistrans, int fd, char *port)
{
XtransConnInfo ciptr;
char addr_name[256];
int namelen;
PRMSG(2,"Os2ReopenCOTSServer(%d,%s)\n", fd, port, 0);
if( (ciptr=(XtransConnInfo)xcalloc(1,sizeof(struct _XtransConnInfo))) == NULL )
{
PRMSG(1,"Os2ReopenCOTSServer: xcalloc(1,%d) failed\n",
sizeof(struct _XtransConnInfo),0,0 );
return NULL;
}
strcpy(addr_name,"local");
namelen=sizeof(addr_name);
if ((ciptr->addr = (char *) xalloc (namelen)) == NULL)
{
PRMSG (1, "Os2ReopenCOTSServer: Can't allocate space for the addr\n",
0, 0, 0);
xfree(ciptr);
return(NULL);
}
ciptr->addrlen = namelen;
memcpy (ciptr->addr, addr_name, ciptr->addrlen);
if ((ciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
{
PRMSG (1, "Os2ReopenCOTSServer: Can't allocate space for the addr\n",
0, 0, 0);
xfree(ciptr);
return(NULL);
}
ciptr->peeraddrlen = namelen;
memcpy (ciptr->peeraddr,addr_name, ciptr->addrlen);
ciptr->fd = fd;
ciptr->family=AF_UNIX;
ciptr->flags=1;
PRMSG(1,"Os2ReopenCOTSServer: Filled-in info for handle %d on port %s.\n", fd, port, 0);
return(ciptr);
}
static int
TRANS(DNETReadv) (XtransConnInfo ciptr, struct iovec *buf, int size)
{
PRMSG (2,"DNETReadv(%d,%x,%d)\n", ciptr->fd, buf, size);
return READV (ciptr, buf, size);
}
static int
TRANS(DNETSetOption) (XtransConnInfo ciptr, int option, int arg)
{
PRMSG (2,"DNETSetOption(%d,%d,%d)\n", ciptr->fd, option, arg);
return -1;
}
static int
TRANS(Os2Close)(XtransConnInfo ciptr)
{
int ret;
PRMSG(2,"Os2Close(%x->%d)\n", ciptr, ciptr->fd ,0);
ret=close(ciptr->fd);
return ret;
}
static int
TRANS(DNETWritev) (XtransConnInfo ciptr, struct iovec *buf, int size)
{
PRMSG (2,"DNETWritev(%d,%x,%d)\n", ciptr->fd, buf, size);
return WRITEV (ciptr, buf, size);
}
static int
TRANS(DNETDisconnect) (XtransConnInfo ciptr)
{
PRMSG (2,"DNETDisconnect(%x,%d)\n", ciptr, ciptr->fd, 0);
return shutdown (ciptr->fd, 2); /* disallow further sends and receives */
}
static int
TRANS(DNETClose) (XtransConnInfo ciptr)
{
PRMSG (2,"DNETClose(%x,%d)\n", ciptr, ciptr->fd, 0);
return close (ciptr->fd);
}
static int
TRANS(Os2Readv)(XtransConnInfo ciptr, struct iovec *buf, int size)
{
int ret;
PRMSG(2,"Os2Readv(%d,%x,%d)\n", ciptr->fd, buf, size );
ret = READV(ciptr,buf,size);
if ((ret <0) && (errno == EINVAL)) errno = EPIPE;
return (ret);
}
int
TRANS(GetPeerAddr) (XtransConnInfo ciptr, int *familyp, int *addrlenp,
Xtransaddr **addrp)
{
PRMSG (2,"GetPeerAddr(%d)\n", ciptr->fd, 0, 0);
*familyp = ciptr->family;
*addrlenp = ciptr->peeraddrlen;
if ((*addrp = (Xtransaddr *) xalloc (ciptr->peeraddrlen)) == NULL)
{
PRMSG (1,"GetPeerAddr: malloc failed\n", 0, 0, 0);
return -1;
}
memcpy(*addrp, ciptr->peeraddr, ciptr->peeraddrlen);
return 0;
}
static XtransConnInfo
TRANS(DNETOpenCLTSServer) (Xtransport *thistrans, char *protocol,
char *host, char *port)
{
/* NEED TO IMPLEMENT */
PRMSG (2,"DNETOpenCLTSServer(%s,%s,%s)\n", protocol, host, port);
return NULL;
}
static int
TRANS(Os2Writev)(XtransConnInfo ciptr, struct iovec *buf, int size)
{
int ret;
PRMSG(2,"Os2Writev(%d,%x,%d)\n", ciptr->fd, buf, size );
ret = WRITEV(ciptr,buf,size);
if ((ret <0) && (errno == EINVAL)) errno = EPIPE;
if ((ret <0) && (errno == ENOSPC)) errno = EAGAIN;
return (ret);
}
static XtransConnInfo
TRANS(DNETReopenCLTSServer) (Xtransport *thistrans, int fd, char *port)
{
XtransConnInfo ciptr;
PRMSG (2,"DNETReopenCLTSServer(%d,%s)\n", fd, port, 0);
if ((ciptr = (XtransConnInfo) xcalloc (
1, sizeof(struct _XtransConnInfo))) == NULL)
{
PRMSG (1, "DNETReopenCLTSServer: malloc failed\n", 0, 0, 0);
return NULL;
}
ciptr->fd = fd;
ciptr->index = 0; /* only one form of DECnet */
return (ciptr);
}
int
TRANS(WSAStartup) (void)
{
static WSADATA wsadata;
PRMSG (2,"WSAStartup()\n", 0, 0, 0);
if (!wsadata.wVersion && WSAStartup(0x0101, &wsadata))
return 1;
return 0;
}
static int
TRANS(DNETBytesReadable) (XtransConnInfo ciptr, BytesReadable_t *pend)
{
PRMSG (2,"DNETBytesReadable(%x,%d,%x)\n", ciptr, ciptr->fd, pend);
#ifdef WIN32
return ioctlsocket ((SOCKET) ciptr->fd, FIONREAD, (u_long *) pend);
#else
return ioctl(ciptr->fd, FIONREAD, (char *)pend);
#endif /* WIN32 */
}
static int
TRANS(DNETWrite) (XtransConnInfo ciptr, char *buf, int size)
{
PRMSG (2,"DNETWrite(%d,%x,%d)\n", ciptr->fd, buf, size);
#ifdef WIN32
return send ((SOCKET)ciptr->fd, buf, size, 0);
#else
return write (ciptr->fd, buf, size);
#endif /* WIN32 */
}
static XtransConnInfo
TRANS(DNETOpenCLTSClient) (Xtransport *thistrans, char *protocol,
char *host, char *port)
{
XtransConnInfo ciptr;
PRMSG (2,"DNETOpenCLTSClient(%s,%s,%s)\n", protocol, host, port);
if ((ciptr = (XtransConnInfo) xcalloc (
1, sizeof (struct _XtransConnInfo))) == NULL)
{
PRMSG (1, "DNETOpenCLTSClient: malloc failed\n", 0, 0, 0);
return NULL;
}
ciptr->index = 0; /* only one form of DECnet */
/* nothing else to do here */
return ciptr;
}
