xtransam.c

远程桌面连接工具

	ciptr->addrlen = strlen("XXXXTODO");
	break;
    case ACDT_VIRTCIRC:
	/* For Amoeba connections the adress is not really used,
	 * so just fake something
	 */
	ciptr->family = AF_AMOEBA;
	ciptr->addr = strdup("Amoeba");
	ciptr->addrlen = strlen(ciptr->addr);
	break;
    }
}

#ifdef TRANS_SERVER

static XtransConnInfo
TRANS(AMOpenCOTSServer)(thistrans, protocol, given_host, port)
Xtransport	*thistrans;
char		*protocol;
char		*given_host;
char		*port;
{
    XAmChanDesc    *chandesc;
    XtransConnInfo  ciptr;

    PRMSG(2,"AMOpenCOTSServer(%s,%s,%s)\n", protocol, given_host, port);

    ciptr = (XtransConnInfo) xcalloc (1, sizeof(struct _XtransConnInfo));
    if (ciptr == NULL) {
        PRMSG (1, "AMOpenCotsClient: malloc failed\n", 0, 0, 0);
        return NULL;
    }

    chandesc = XAmAllocChanDesc();
    if (chandesc == NULL) {
	return NULL;
    }

#ifdef XSERV_t
    AmStartXserverThreads(chandesc);
#endif

    chandesc->conninfo = ciptr;
    ciptr->fd = XAmChanDescToFd(chandesc);

    TRANS(AmSetAddr)(ciptr, chandesc);
    TRANS(AMGetPeerAddr)(ciptr);

    return ciptr;
}

#endif /* TRANS_SERVER */


#ifdef TRANS_CLIENT

static XtransConnInfo
TRANS(AMOpenCLTSClient)(thistrans, protocol, host, port)
Xtransport	*thistrans;
char		*protocol;
char		*host;
char		*port;
{
    XtransConnInfo	ciptr;
    int 		i;
    
    PRMSG(1,"AMOpenCLTSClient(%d,%s,%s)\n", protocol, host, port );
    /* TODO */
    return NULL;
}			

#endif /* TRANS_CLIENT */


#ifdef TRANS_SERVER

static XtransConnInfo
TRANS(AMOpenCLTSServer)(thistrans, protocol, host, port)
Xtransport	*thistrans;
char		*protocol;
char		*host;
char		*port;
{
    XtransConnInfo	ciptr;
    int 		i;
    
    PRMSG(1,"AMOpenCLTSServer(%d,%s,%s)\n", protocol, host, port );
    /* TODO */
    return NULL;
}			

static int
TRANS(AMResetListener)(ciptr)
XtransConnInfo	ciptr;
{
    PRMSG(2,"AMResetListener()\n", 0, 0, 0 );

    /* nothing to do? */
    return 0;
}

#endif /* TRANS_SERVER */

static
TRANS(AMSetOption)(ciptr, option, arg)
XtransConnInfo	ciptr;
int		option;
int		arg;
{
    PRMSG(1,"AMSetOption(%d,%d,%d)\n", ciptr->fd, option, arg );
    /* TODO */
    return -1;
}


#ifdef TRANS_SERVER

static
TRANS(AMCreateListener)(ciptr, req)
XtransConnInfo	ciptr;
char	       *req;
{
    PRMSG(2,"AMCreateListener(%x->%d,%x)\n", ciptr, ciptr->fd, req );

    /* Listener threads are already created at this point */
    return 0;
}


static XtransConnInfo
TRANS(AMAccept)(ciptr)
XtransConnInfo	ciptr;
{
    XAmChanDesc    *chandesc;
    XtransConnInfo  newciptr;

    PRMSG(2,"AMAccept(%x->%d)\n", ciptr, ciptr->fd, 0 );

#if defined(XSERV_t) || defined(FS_t)
    chandesc = XAmFetchConnectingClient();
    if (chandesc == NULL) {
        PRMSG (1, "AMAccept: no client waiting?\n", 0, 0, 0);
        return NULL;
    }
    nNewConns--;

    newciptr = (XtransConnInfo) xcalloc (1, sizeof(struct _XtransConnInfo));
    if (newciptr == NULL)
    {
        PRMSG (1, "AMAccept: malloc failed\n", 0, 0, 0);
        return NULL;
    }

    newciptr->fd = XAmChanDescToFd(chandesc);
    chandesc->conninfo = newciptr;
    chandesc->status |= CONN_ALIVE;

    PRMSG(2,"AMAccept: OK: (%x->%d)\n", newciptr, newciptr->fd, 0 );

    TRANS(AmSetAddr)(newciptr, chandesc);
    TRANS(AMGetPeerAddr)(newciptr);
    
    return newciptr;
#else
    return NULL;
#endif
}

#endif /* TRANS_SERVER */


#ifdef TRANS_CLIENT

static
TRANS(AMConnect)(ciptr, host, port)
XtransConnInfo	ciptr;
char		*host;
char		*port;
{
    /* If this function is called, we are already connected */
    PRMSG(2, "AMConnect(%d,%s)\n", ciptr->fd, host, 0);
    return 0;
}

#endif /* TRANS_CLIENT */


int
TRANS(AmFdBytesReadable)(fd, count)
int fd;
BytesReadable_t	*count;
{
    register XAmChanDesc *chandesc;

    PRMSG(2, "AmFdBytesReadable(%d,%x): ", fd, count, 0 );

#ifndef XSERV_t
    /* give reader threads a chance: */
    threadswitch();
#endif

    errno = 0;
    chandesc = XAmFdToChanDesc(fd);
    if (chandesc == NULL || chandesc->state != ACDS_USED) {
	errno = EBADF;
	*count = 0;
	return -1;
    }

    switch (chandesc->type) {
    case ACDT_TCPIP:
	*count = cb_full(chandesc->circbuf);
	break;
    case ACDT_VIRTCIRC:
	*count = vc_avail(chandesc->virtcirc, VC_IN);
	break;
    }

    if (*count < 0) {
	errno = (chandesc->state == ACDS_CLOSED) ? EINTR : EPIPE;
	*count = 0;
	return -1;
    }

    PRMSG(2, "AMFdBytesReadable: %d\n", *count, 0, 0 );

    return 0;
}

static
TRANS(AMBytesReadable)(ciptr, count)
XtransConnInfo	ciptr;
BytesReadable_t	*count;
{
    return TRANS(AmFdBytesReadable)(ciptr->fd, count);
}


static
TRANS(AMRead)(ciptr, buf, count)
XtransConnInfo	ciptr;
char		*buf;
int		count;
{
    int fdi;
    register XAmChanDesc *chandesc;
    register int rv;
    BytesReadable_t avail;

    fdi = ciptr->fd;
    PRMSG(2, "AMRead(%d,%x,%d)\n", ciptr->fd, buf, count );

    errno = 0;
    chandesc = XAmFdToChanDesc(fdi);
    if (chandesc == NULL || chandesc->state != ACDS_USED) {
	errno = EBADF;
	return -1;
    }

    /* do a non-blocking read (maybe only conditionally?) */
    if ((TRANS(AMBytesReadable)(ciptr, &avail)) == 0) {
	if (avail <= 0) {
	    PRMSG(2, "AMRead: nothing available yet\n", 0, 0, 0);
	    errno = EAGAIN;
	    return 0;
	} else if (count > avail) {
	    PRMSG(2, "AMRead(%d): only %d of %d available\n",
		  ciptr->fd, avail, count);
	    count = avail; /* just read amount available */
	}
    } else {
	PRMSG(1, "AMRead: ...BytesReadable failed\n", 0, 0, 0);
	return -1;
    }

    switch (chandesc->type) {
    case ACDT_TCPIP:
	rv = cb_gets(chandesc->circbuf, buf, count, count);
	if (rv != count) {
	    if (rv == 0) {
		fprintf(stderr, "Xlib: Cannot read circbuf\n");
		errno = EPIPE;
		rv = -1;
	    } else {
		fprintf(stderr, "Xlib: Cannot read circbuf (%d)\n", rv);
	    }
	}
	break;

    case ACDT_VIRTCIRC:
	rv = vc_readall(chandesc->virtcirc, buf, count);
	if (rv < 0) {
	    fprintf(stderr, "Xlib: Cannot read virtual circuit\n");
	    errno = EPIPE;
	    rv = -1;
	}
	break;
    }

    /* The circular buffer writer will only UP the semaphore when
     * characters are available; we have to down it ourselfs.
     */
    if (chandesc->sema && rv > 0)
	sema_mdown(chandesc->sema, rv);

    PRMSG(2, "AMRead: %d bytes\n", rv, 0, 0);

    return rv;
}


static
TRANS(AMWrite)(ciptr, buf, count)
XtransConnInfo	ciptr;
char		*buf;
int		count;
{
    register XAmChanDesc *chandesc;
    register int written;
    
    PRMSG(2, "AMWrite(%d,%x,%d)\n", ciptr->fd, buf, count );

    errno = 0;
    written = 0;

    chandesc = XAmFdToChanDesc(ciptr->fd);
    if (chandesc == NULL || chandesc->state != ACDS_USED) {
	errno = EBADF;
	return -1;
    }

    switch (chandesc->type) {
    case ACDT_TCPIP:
	while (count > 0) {
	    bufsize bsize;
	    int wrcnt;

	    wrcnt = count > TCPIP_BUFSIZE ? TCPIP_BUFSIZE : count;
	    bsize = tcpip_write(&chandesc->chancap, buf, wrcnt);
	    if (ERR_STATUS(bsize)) {
		fprintf(stderr, "Xlib: TCP/IP write failed (%s)\n",
			tcpip_why(ERR_CONVERT(bsize)));
		errno = EPIPE;
		return -1;
	    }
	    if (bsize != wrcnt) {
		fprintf(stderr,
			"Xlib: TCP/IP write failed (expected %d, wrote %d)\n",
			(int)bsize, wrcnt);
		errno = EPIPE;
		return -1;
	    }
	    buf += bsize;
	    count -= (int) bsize;
	    written += (int) bsize;
	}
	break;

    case ACDT_VIRTCIRC:
	if ((written = vc_write(chandesc->virtcirc, buf, count)) < 0) {
	    fprintf(stderr, "Xlib: virtual circuit write failed\n");
	    errno = EPIPE;
	    return -1;
	}
	break;
    }

    return written;
}


static
TRANS(AMReadv)(ciptr, iov, n)
XtransConnInfo	ciptr;
struct iovec   *iov;
int		n;
{
    int i;
    int count = 0, thiscount;

    PRMSG(2, "AMReadv(%d,%x,%d)\n", ciptr->fd, ciptr, n );

    for (i = 0; i < n; i++, iov++) {
	if (iov->iov_len) {
	    thiscount = TRANS(AMRead)(ciptr, iov->iov_base, iov->iov_len);
	    if (thiscount < 0) return thiscount;
	    count += thiscount;
	    if (thiscount < iov->iov_len) break;
	}
    }

    return count;
}


static
TRANS(AMWritev)(ciptr, iov, n)
XtransConnInfo	ciptr;
struct iovec	*iov;
int		n;
{
    int i;
    int count = 0, thiscount;

    PRMSG(2, "AMWritev(%d,%x,%d)\n", ciptr->fd, iov, n );

    for (i = 0; i < n; i++, iov++) {
	if (iov->iov_len) {
	    thiscount = TRANS(AMWrite)(ciptr, iov->iov_base, iov->iov_len);
	    if (thiscount < 0)
		return thiscount;
	    count += thiscount;
	    if (thiscount < iov->iov_len) break;
	}
    }

    return count;
}


static
TRANS(AMDisconnect)(ciptr)
XtransConnInfo	ciptr;
{
    register XAmChanDesc *chandesc;

    PRMSG(2, "AMDisconnect(%x->%d)\n", ciptr, ciptr->fd, 0 );

    chandesc = XAmFdToChanDesc(ciptr->fd);
    if (chandesc != NULL) {
	switch (chandesc->type) {
	case ACDT_TCPIP:
	    if (chandesc->signal != -1) {
		sig_raise(chandesc->signal);
		chandesc->signal = -1;
	    }
	    std_destroy(&chandesc->chancap);
	    break;

	case ACDT_VIRTCIRC:
	    vc_close(chandesc->virtcirc, VC_BOTH | VC_ASYNC);
	    break;
	}
#ifdef XSERV_t
	if (ciptr->fd == maxClient - 1) {
	    maxClient--;
	    /* we could look if maxClient can be reduced even more */
	}
#endif
	XAmFreeChanDesc(chandesc);
    }

    return 0;
}


static
TRANS(AMClose)(ciptr)
XtransConnInfo	ciptr;
{
    PRMSG(2, "AMClose(%x->%d)\n", ciptr, ciptr->fd, 0 );

    return TRANS(AMDisconnect)(ciptr);
}


Xtransport	TRANS(AmConnFuncs) = {
	/* Combined AMOEBA RPC/TCP Interface; maybe we should split this  */
	"amcon",
	0,
#ifdef TRANS_CLIENT
	TRANS(AMOpenCOTSClient),
#endif /* TRANS_CLIENT */
#ifdef TRANS_SERVER
	TRANS(AMOpenCOTSServer),
#endif /* TRANS_SERVER */
#ifdef TRANS_CLIENT
	TRANS(AMOpenCLTSClient),
#endif /* TRANS_CLIENT */
#ifdef TRANS_SERVER
	TRANS(AMOpenCLTSServer),
#endif /* TRANS_SERVER */
	TRANS(AMSetOption),
#ifdef TRANS_SERVER
	TRANS(AMCreateListener),
	TRANS(AMResetListener),
	TRANS(AMAccept),
#endif /* TRANS_SERVER */
#ifdef TRANS_CLIENT
	TRANS(AMConnect),
#endif /* TRANS_CLIENT */
	TRANS(AMBytesReadable),
	TRANS(AMRead),
	TRANS(AMWrite),
	TRANS(AMReadv),
	TRANS(AMWritev),
	TRANS(AMDisconnect),
	TRANS(AMClose),
};