Subversion Repositories openrisc

/*
 **************************************************************************
 *
 *  Component:	RDBG
 *  Module:	servtsp.c
 *
 *  Synopsis:	Transport management for remote debug server.
 *
 * $Id: servtsp.c,v 1.2 2001-09-27 12:02:01 chris Exp $
 *
 **************************************************************************
 */
 
#include <sys/errno.h>
#include <rdbg/rdbg.h>	
#include <rdbg/servrpc.h>
#include <signal.h>		
#include <rpc/rpc.h>		
#include <rpc/svc.h>		
#include <netinet/in.h>		
#include <sys/socket.h>		
 
static int	out_sock;	
static int	warm_test;	
 
static void TimeTestHandler();	
 
    /*
     *  TspInit - Initialize the transport system.
     *
     */
 
    void
TspInit (int id)
{
    struct sigaction sa;
 
	/* setup a socket to send event messages back through */
    out_sock = socket (PF_INET, SOCK_DGRAM, 0);
    if (out_sock < 0) {
	DPRINTF (("TspInit: socket() failed %d errno %d\n",
		out_sock, getErrno()));
	return;		/* failed to open socket, let caller deal with */
    }
    {
	struct sockaddr_in addr;
 
	bzero ((void *)(&addr), sizeof addr);
	addr.sin_family = AF_INET;
	addr.sin_port = htons (BackPort);
	if (bind (out_sock, (struct sockaddr*) &addr, sizeof addr) < 0) {
	    DPRINTF (("TspInit: bind() failed\n"));
	}
    }
    /* setup alarm timer for warm testing */
    memset (&sa, 0, sizeof (sa));
    sa.sa_handler = TimeTestHandler;
    sigaction (SIGALRM, &sa, 0);
}
 
    /*
     *  TspTranslateRpcAddr - translate from an RPC handle to an
     *                        opaque address.
     *
     *  Converts the sender's address into the opaque data structure
     *  used for network addresses. This is used to look up the sender
     *  on each call.
     */
 
    Boolean
TspTranslateRpcAddr (struct svc_req* rqstp, NET_OPAQUE* opaque)
{
    struct sockaddr_in*	addr;	/* used as template to extract net info */
    unsigned char*	up;
 
    memset (opaque, 0, sizeof (NET_OPAQUE));
	/*
	 *  We interpret the remote address as a standard netbuf name.
	 *  The format is 2 bytes of address family (normally AF_INET)
	 *  and then a length (5) and then the IP address.
	 */
    if (rqstp->rq_xprt->xp_addrlen != 16)
    {
	DPRINTF (("TspTranslateRpcAddr: Unknown remote address!!!\n"));
	setErrno (EPROTONOSUPPORT);
	return False;		/* invalid, so fails */
    }
	/* addr = &rqstp->rq_xprt->xp_raddr; */
    addr = svc_getcaller (rqstp->rq_xprt);
	/* verify it is AF_INET */
    if (addr->sin_family != AF_INET) {		/* no, error */
	DPRINTF (("TspTranslateRpcAddr: Not an internet address!!\n"));
	setErrno (EAFNOSUPPORT);/* invalid addr family */
	return False;
    }
	/* good address type */
    up = (unsigned char *) &addr->sin_addr.s_addr;
    DPRINTF (("TspTranslateRpcAddr: Sent by %u.%u.%u.%u port #%u\n",
	up[0], up[1], up[2], up[3], htons (addr->sin_port)));
    memcpy (opaque, addr, sizeof (struct sockaddr_in));
    return True;
}
 
    /*
     *  TspValidateAddr - validate a passed in opaque address.
     *
     *  Checks that the passed in address is in the format
     *  expected.
     */
 
    Boolean
TspValidateAddr (NET_OPAQUE* opaque, NET_OPAQUE* sender)
{
    struct sockaddr_in*	addr;	/* used as template to extract net info */
 
    addr = (struct sockaddr_in*) opaque;
	/* Verify it is AF_INET. Should check against sender IP address too */
    if (addr->sin_family != AF_INET) {
	DPRINTF (("TspValidateAddr: Back port invalid: %d\n",
	    htons (addr->sin_port)));
	return False;		/* not valid */
    }
	/* otherwise, we copy in the IP address, since client may not know it */
    addr->sin_addr.s_addr = ((struct sockaddr_in*) sender)->sin_addr.s_addr;
    DPRINTF (("TspValidateAddr: Back port is %d\n", htons (addr->sin_port)));
    return True;
}
 
    /*
     *  TspConnGetIndex - lookup an rpc caller's address as a connection entry.
     *
     *  Looks up an ip address of a caller to locate the
     *  connection index in our connection array.
     */
 
    int
TspConnGetIndex (struct svc_req* rqstp)
{
    int		conn;
	/* &rqstp->rq_xprt->xp_raddr; */
    struct sockaddr_in *addr = svc_getcaller (rqstp->rq_xprt);
 
    for (conn = 0; conn < conn_list_cnt; conn++) {
	if (!conn_list[conn].in_use)
	    continue;			/* not used */
 
	if (addr->sin_addr.s_addr == ((struct sockaddr_in *)
		&conn_list [conn].sender)->sin_addr.s_addr
		&&  addr->sin_port == ((struct sockaddr_in *)
		&conn_list[conn].sender)->sin_port) {
	    return conn;
	}
    }
    return -1;
}
 
 
    /*
     *  TspSendWaitChange - send wait-change message to clients to
     *                      notify change.
     */
 
    void
TspSendWaitChange(
    int		conn,		/* connection to send to */
    BACK_MSG	msg,		/* BMSG type */
    UINT16	spec,		/* special information */
    PID		pid,		/* pid it refers to */
    UINT32	context,	/* additional context for message */
    Boolean	force)		/* force into being only message */
{
    int			idx;
    struct SEND_LIST*	snd_ptr;
 
    if (force) {
	    /* force to top, which means others gone */
	idx = 0;
	conn_list [conn].send_idx = 1;
	conn_list[conn].retry = 0;
    } else {
	for (idx = 0; idx < (int) conn_list[conn].send_idx; idx++) {
	    if (conn_list[conn].send_list[idx].send_type == msg
		&&  conn_list[conn].send_list[idx].pid == pid)
	    return;			/* already pended for this pid */
	}
	idx = conn_list[conn].send_idx;
	if (idx+1 > MAX_SEND)
	    return;			/* we lose it, what should we do??? */
	conn_list[conn].send_idx++;
    }
    snd_ptr = &conn_list[conn].send_list[idx];
    snd_ptr->send_type = msg;		/* message to send */
    snd_ptr->retry = TSP_RETRIES;	/* about 1 minute of retries */
    snd_ptr->spec = htons ((u_short) spec);
    snd_ptr->pid = htonl (pid);
    snd_ptr->context = htonl (context);
    TspSendMessage (conn, False);	/* now do the send */
}
 
    /*
     *  TspSendMessage - send message at top of send list for connection.
     */
 
    void
TspSendMessage( int conn, Boolean resend)
{
    struct sockaddr_in	addr;
    struct UDP_MSG	msg;
    int			cnt;
 
    if (!resend && conn_list[conn].retry)
	return;			/* already waiting for reply */
 
	/*
	 *  Note on above: if no back port we can't remove unless
	 *  someone blows off.
	 */
    if (!resend) {
	    /* first time, setup. Set retry count: */
	conn_list[conn].retry = conn_list[conn].send_list[0].retry;
	conn_list[conn].last_msg_num++; /* new sequence number */
	if (!warm_test++) { 		/* starting, so enable timer */
	    alarm (2);			/* resend every 2 seconds as needed */
	}
    }
 
    msg.type	= conn_list[conn].send_list[0].send_type;
    msg.msg_num	= conn_list[conn].last_msg_num;
    msg.spec	= conn_list[conn].send_list[0].spec;
    msg.pid	= conn_list[conn].send_list[0].pid;
    msg.context	= conn_list[conn].send_list[0].context;
 
    memset (&addr, 0, sizeof addr);
    addr.sin_family = AF_INET;
    addr.sin_port = ((struct sockaddr_in*)&conn_list[conn].back_port)->sin_port;
    addr.sin_addr.s_addr = 
	((struct sockaddr_in*)&conn_list[conn].back_port)->sin_addr.s_addr;
 
    DPRINTF (("TspSendMessage: Sending msg %d (%s) to port %d\n",
	msg.type, BmsgNames [msg.type], HL_W (addr.sin_port)));
 
    cnt = sendto (out_sock, &msg, sizeof msg, 0, (struct sockaddr*) &addr,
		    sizeof addr);
    if (cnt != sizeof msg) {		/* failed on send */
	printf ("%s: Failed to send msg %d to conn %d (%d vs. %d)\n",
	    ActName, msg.type, conn, cnt, sizeof msg);
    }
}
 
    /*
     *  TspMessageReceive - confirmation received, now send next if any.
     *
     *  - since UDP is connectionless, we batch up the sends and use
     *    one at a time until we get a message indicating ready for
     *    next (from ack).
     */
 
    void
TspMessageReceive (int conn, PID pid)
{
	/* We remove the send list entry and use next if any */
    conn_list[conn].retry = 0;	/* reset */
    if (!warm_test || !--warm_test) {
	alarm (0);			/* reset timer if not used */
    }
#ifdef DDEBUG
    if (conn_list[conn].send_list[0].send_type == BMSG_WARM) {
	DPRINTF (("TspMessageReceive: Connection reset for conn %d\n", conn));
    }
#endif
	/* Move up by one if needed */
    if (!--conn_list[conn].send_idx)
	return;			/* no more to do */
 
    memcpy (conn_list[conn].send_list, conn_list[conn].send_list+1,
	conn_list[conn].send_idx * sizeof(struct SEND_LIST)); /* copy down */
    TspSendMessage (conn, 0);
}
 
    /*
     *  TspGetHostName - return client's host name.
     *
     *  - this routine returns the name of the client's host or the net
     *    number of unknown.
     */
 
    char*
TspGetHostName (conn_idx)
    int		conn_idx;	/* client connection number */
{
    static char		buff [30];	/* largest net num */
    unsigned char*	cp;
 
    cp = conn_list[conn_idx].sender.c+4;
    sprintf (buff, "%u.%u.%u.%u", cp[0], cp[1], cp[2], cp[3]);
    return buff;
}
 
    /*
     *  TimeTestHandler - alarm timer handler to resend warm/wait test.
     */
 
    static void
TimeTestHandler()
{
    int		conn;
 
    if (!warm_test)
	return;			/* no longer enabled */
 
    for (conn = 0; conn < conn_list_cnt; conn++) {	
	    /* locate all that are using this */
	if (!conn_list[conn].in_use)
	    continue;			/* not used */
 
	if (!conn_list[conn].retry) continue;
	    /* found one that we are testing */
	if (!--conn_list[conn].retry) {
		/*
		 *  Counted down the retries: blow off.
		 *  Need to have connection flag to indicate not blowing
		 *  off for cases where client is stopped due to being
		 *  debugged.
		 */
	    ConnDelete (conn, NULL, CLOSE_IGNORE);
	    continue;
	}
	TspSendMessage (conn, True);	/* send another message */
    }
    alarm (2);			/* setup for 2 seconds from now */
}