clnt_ttysvr.c

vxworks源码源码解读是学习vxworks的最佳途径

clntttysvr_geterr(cl, errp)
	CLIENT *cl;
	struct rpc_err *errp;
{
	register struct cu_data *cu = (struct cu_data *)cl->cl_private;

	*errp = cu->cu_error;
}


static bool_t
clntttysvr_freeres(cl, xdr_res, res_ptr)
	CLIENT *cl;
	xdrproc_t xdr_res;
	caddr_t res_ptr;
{
	register struct cu_data *cu = (struct cu_data *)cl->cl_private;
	register XDR *xdrs = &(cu->cu_outxdrs);

	xdrs->x_op = XDR_FREE;
	return ((*xdr_res)(xdrs, res_ptr));
}

static void
clntttysvr_abort(/*h*/)
	/*CLIENT *h;*/
{
}

static bool_t
clntttysvr_control (cl, request, info)
    CLIENT *cl;
    int request;
    char *info;
{
    register struct cu_data *cu = (struct cu_data *) cl->cl_private;

    switch (request)
	{
	case CLSET_TIMEOUT:
		cu->cu_total = *(struct timeval *) info;
		break;
	case CLGET_TIMEOUT:
		*(struct timeval *) info = cu->cu_total;
		break;
	case CLSET_RETRY_TIMEOUT:
		cu->cu_wait = *(struct timeval *)info;
		break;
	case CLGET_RETRY_TIMEOUT:
		*(struct timeval *) info = cu->cu_wait;
		break;
	default:
		return (FALSE);
	}
    return (TRUE);
}

static void
clntttysvr_destroy(cl)
	CLIENT *cl;
{
	register struct cu_data *cu = (struct cu_data *)cl->cl_private;
	char strgInit[100];
	char * pWindBase;

	close (cu->cu_fd);

	XDR_DESTROY(&(cu->cu_outxdrs));
	mem_free((caddr_t)cu, (sizeof(*cu) + cu->cu_sendsz + cu->cu_recvsz));
	mem_free((caddr_t)cl, sizeof(CLIENT));

	/* Restore portServer configuration after a wdb communication */

	pWindBase = getenv ("WIND_BASE");

#ifndef	WIN32
        sprintf(strgInit, "wtxtcl %s/host/resource/wdb/wdbportsvr/portSvrConfig.tcl on %d %d %s", pWindBase, CONSOLE_BAUD, port ,pPortSvrAddr);
#else	/* WIN32 */
	sprintf(strgInit, "wtxtcl %s\\host\\resource\\wdb\\wdbportsvr\\portSvrConfig.tcl on %d %d %s", pWindBase, CONSOLE_BAUD, port ,pPortSvrAddr);
#endif	/* WIN32 */

	system(strgInit);
}



/* TTY specific stuff */


/* SLIP protocol characters */

#define FRAME_END          (char)0300   /* Frame End */
#define FRAME_ESCAPE       (char)0333   /* Frame Esc */
#define TRANS_FRAME_END    (char)0334   /* transposed frame end */
#define TRANS_FRAME_ESCAPE (char)0335   /* transposed frame esc */

/* dummy UDP/IP header info (in 16-bit words) */

#define UDP_IP_HDR_SIZE	28

#define IP_VERS_LEN	0	/* IP version + IP header length */
#define IP_PROT		9	/* protocol to use */
#define IP_DEST_ADDR	12	/* destination address */
#define IP_SRC_ADDR	16	/* source address */
#define UDP_SRC_PORT	20	/* source port */
#define UDP_DEST_PORT	22	/* destination port */
#define UDP_LEN		24	/* length */
#define UDP_CKSUM	26	/* checksum */

#define IN_BUF(offset)	((offset) < UDP_IP_HDR_SIZE ?			\
					pUdpIpHdr [offset] :		\
					inBuf [offset - UDP_IP_HDR_SIZE])

#define BUF_PUT(ch) if (bytesRead >= UDP_IP_HDR_SIZE) 			\
			buf[bytesRead - UDP_IP_HDR_SIZE] = ch

#ifdef  IPPROTO_UDP
#undef 	IPPROTO_UDP
#endif
#define IPPROTO_UDP	0x11

/******************************************************************************
*
* clntttysvr_send - write data after encoding it with SLIP escape sequences.
*/ 

LOCAL int clntttysvr_send
    (
    int		fd,
    char *	inBuf,
    int		nBytes
    )
    {
    int		inputIx;
    int		outputIx;
    char *	outBuf;
    char *	outBufCopy;
    int		bytesSent;
    int		buf[UDP_IP_HDR_SIZE/sizeof (int)];
    char *	pUdpIpHdr;
    int         loop = 8;
    int		ix;

    BACKEND_PRINT(BACKEND_DEBUG,("\n Send %d\n", nBytes));

    /* set up a dummy UDP/IP header */

    pUdpIpHdr				 = (char *) buf;

    bzero (pUdpIpHdr, UDP_IP_HDR_SIZE);

    pUdpIpHdr [IP_VERS_LEN]		= 0x45; /* XXX - little endian 0x54? */
    pUdpIpHdr [IP_PROT]			= IPPROTO_UDP;
    * (short *) &pUdpIpHdr [UDP_DEST_PORT]	= htons(WDBPORT);

    outBuf = (char *) malloc (nBytes * 2);
    outBufCopy = outBuf;

    if (outBuf == NULL)
	return (0);

    outBuf[0] = FRAME_END;

    outputIx = 1;

    for (inputIx = 0; inputIx < nBytes + UDP_IP_HDR_SIZE; inputIx ++)
	{
	switch (IN_BUF (inputIx))
	    {
	    case FRAME_END:
		outBuf [outputIx++] = FRAME_ESCAPE;
		outBuf [outputIx++]   = TRANS_FRAME_END;
		break;

	    case FRAME_ESCAPE:
		outBuf [outputIx++] = FRAME_ESCAPE;
		outBuf [outputIx++]   = TRANS_FRAME_ESCAPE;
		break;

	    default:
		outBuf [outputIx++] = IN_BUF(inputIx);
	    }
	}

    outBuf [outputIx++] = FRAME_END;

    BACKEND_PRINT(BACKEND_DEBUG,("Frame sent :\n"));

    for(ix=0; ix < outputIx; ix++)
	BACKEND_PRINT(BACKEND_DEBUG,(" %x", outBuf[ix]));

    BACKEND_PRINT(BACKEND_DEBUG,("\n"));

    /* write out the data */

#ifndef WIN32
    bytesSent = write (fd, outBuf, outputIx);
#else	/* WIN32 */
    ResetEvent (ovrlapped_s.hEvent);
    ovrlapped_s.Offset = 0;
    ovrlapped_s.OffsetHigh = 0;

    WriteFile ((HANDLE) fd, outBuf, outputIx, &bytesSent, &ovrlapped_s);
#endif	/* WIN32 */

    BACKEND_PRINT(BACKEND_DEBUG,("bytesSent = %d \n", bytesSent));
    
    if (bytesSent < 0)
      {
        wpwrLogErr ("\nclnttty_send: write failed\n");
        return (0);
      }

    /* SPR #8979 */
 
    outputIx -= bytesSent;
    outBuf += bytesSent;
    loop--;
 
    while ((outputIx > 0) && (loop > 0))
      {
 
#ifndef WIN32
        bytesSent = write (fd, outBuf, outputIx);
#else   /* WIN32 */
	WriteFile ((HANDLE) fd, outBuf, outputIx, &bytesSent, &ovrlapped_s);
#endif  /* WIN32 */
 
	BACKEND_PRINT(BACKEND_DEBUG,("2 bytesSent = %d \n", bytesSent));

        if (bytesSent < 0)
          {
            wpwrLogErr ("\nclnttty_send: write failed\n");
            return (0);
          }
 
        outputIx -= bytesSent;
        outBuf += bytesSent;
        loop--;
      }
 
    if ((loop == 0) || (outputIx > 0))
      {
        wpwrLogErr ("\nclnttty_send: didn't send all bytes\n");
        return (0);
      }
 
    free (outBufCopy);
 
    return (nBytes);
    }

/******************************************************************************
*
* clntttysvr_rcv - get input over a serial line
*
* This routine gets characters one at a time, and decodes the SLIP escape
* sequences.
* It assumes there is a UDP/IP header at the beggining, which it throws
* away.
*/ 

LOCAL int clntttysvr_rcv
    (
    int		fd,
    char *	buf,
    int		nBytes
    )
    {
    char		inChar;
    int			bytesRead;
    fd_set		readFds;
    fd_set		mask;
    struct timeval	timeval;

#ifdef WIN32
    int			numBytes;

    if (dbg_on)
	{
	dbg_ch_printed = 0;
	printf ("\nclntttysvr_rcv: receive len = %d\n", nBytes);
	}
#endif 	/* WIN32 */

    timeval.tv_sec = 1;
    timeval.tv_usec = 0;

    /*
     * Add the portServer socket file desciptor 
     * to the list of file descriptor to wait on.
     */

    FD_ZERO (&mask);
    FD_SET (fd, &mask);
 
    BACKEND_PRINT (BACKEND_DEBUG,("Frame received :\n"));
 
    readFds = mask;

    for (bytesRead = 0; bytesRead < nBytes + UDP_IP_HDR_SIZE; bytesRead++)
	{

        switch (select (FD_SETSIZE, &readFds, (fd_set *) NULL, 
					(fd_set *) NULL, &timeval))
	    {
	    case -1:
		wpwrLogErr ("cnltttysvr_rcv: - Select failed\n");
		return (-1);

	    case 0:			/* select timeout */
#ifdef WIN32
		if (dbg_on)
		    printf ("\n");
#endif	/* WIN32 */
/*		wpwrLogErr ("clntttysvr_rcv: read timed out\n");*/
		return (0);

	    default:
		{   
#ifndef WIN32
		read (fd, &inChar, 1);
#else	/* WIN32 */
                ovrlapped_s.Offset = 0;
                ovrlapped_s.OffsetHigh = 0;
                ReadFile ((HANDLE) fd, &inChar, 1, &numBytes, &ovrlapped_s);
#endif	/* WIN32 */

        	BACKEND_PRINT (BACKEND_DEBUG,("%x ", inChar));

		switch (inChar)
		    {
		    case FRAME_END:
			if (bytesRead == 0)
			    {
			    bytesRead = -1;
			    continue;
			    }

#ifdef WIN32
			if (dbg_on)
			    printf ("\n");
#endif	/* WIN32 */
                	BACKEND_PRINT (BACKEND_DEBUG, ("\n length = %d \n", 
						(bytesRead - UDP_IP_HDR_SIZE)));

			return (bytesRead > UDP_IP_HDR_SIZE ?
				bytesRead - UDP_IP_HDR_SIZE : 0);
			break;

		    case FRAME_ESCAPE:
#ifndef WIN32
			if (read (fd, &inChar, 1) < 1)
#else	/* WIN32 */
                	ovrlapped_s.Offset = 0;
                	ovrlapped_s.OffsetHigh = 0;
                	ReadFile ((HANDLE) fd, &inChar, 1, 
					&numBytes, &ovrlapped_s);
			if (numBytes < 1)
#endif	/* WIN32 */
			    {
#ifdef WIN32
			    if (dbg_on)
				printf ("\n");
#endif	/* WIN32 */
			    wpwrLogErr ("clntttysvr_rcv: read failed");

			    return (bytesRead);
			    }

			switch (inChar)
			    { 
			    case TRANS_FRAME_END:
				BUF_PUT (FRAME_END);
				break;

			    case TRANS_FRAME_ESCAPE:
				BUF_PUT (FRAME_ESCAPE);
				break;

			    default:
#ifdef WIN32
				if (dbg_on)
				    printf ("\n");
#endif	/* WIN32 */
				wpwrLogErr ("clntttysvr_rcv: bad escape sequence\n");
				BUF_PUT (inChar);
			    }
		    break;

		    default:
			BUF_PUT (inChar);
		    }
		}
	    }
	}
    wpwrLogErr ("clntttysvr_rcv: no end of frame in input\n");

#ifdef WIN32
	if (dbg_on)
		printf ("\n");
#endif	/* WIN32 */

    return (bytesRead - UDP_IP_HDR_SIZE);

    }

/******************************************************************************
*
* clntttysvr_open - open and initialize a socket.
*
* RETURNS: a file handle, or -1 on error.
*/ 

LOCAL int clntttysvr_open
    (
    struct sockaddr_in * pCli_addr
    )
    {
    int		sktAddrLen;
    u_int	wdbSocket;

#ifdef WIN32
    {
    char *      socket;
    if ((socket = getenv ("WDB_PORTSVR_SOCKET")) != NULL)
        {
        wdbSocket = atol (socket);
        closesocket (wdbSocket);
        }
    }
#endif /* WIN32 */

    sktAddrLen = sizeof (struct sockaddr_in);

    /* get portServer ip_address */

    pPortSvrAddr = inet_ntoa(pCli_addr->sin_addr);

    /* XXX RLP Waiting 2 seconds before create a socket */

    sleep(2);

    /* open a socket */
     
    wdbSocket = socket (AF_INET, SOCK_STREAM, 0);
    if (wdbSocket < 0)
	{
	wpwrLogErr("Can't open a socket\n");
        return(-1);
        }

    /* connect a socket */

    if (connect(wdbSocket,(struct sockaddr *) pCli_addr, sktAddrLen) < 0)
	{
	wpwrLogErr ("Connect failed: host %s port %d\n",
		pPortSvrAddr, ntohs(pCli_addr->sin_port));
        return(-1);
        }

#ifdef WIN32
    {
    char        socket[100];
    sprintf (socket,"WDB_PORTSVR_SOCKET=%d", wdbSocket);
    putenv (socket);
    }
#endif /* WIN32 */

    return (wdbSocket);
    }