Subversion Repositories or1k

/*

 **************************************************************************

 *

 *  Component:  RDBG

 *  Module:     servtsp.c

 *

 *  Synopsis:   Transport management for remote debug server.

 *

 * servtsp.c,v 1.3 2002/02/01 17:00:01 joel 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;

  struct sockaddr_in addr;

  /*

   * 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 */

  }

  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",

            taskName, 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 */

}