archie/prospero/lib/ardp/ardp_send.c

/*
 * Copyright (c) 1991-1993 by the University of Southern California
 *
 * Written  by bcn 1989-92  as dirsend.c in the Prospero distribution
 * Modified by bcn 1/93     separate library and add support for asynchrony 
 *
 * For copying and distribution information, please see the file
 * <usc-license.h>.
 */

#include <usc-license.h>

#include <stdio.h>
#include <errno.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>

#include <ardp.h>
#include <perrno.h>
#include <pmachine.h>

#define OLD_GETHOSTBYNAME       /* do it the old way, since we're on the client
                                   */ 
#ifdef PROSPERO
#include <pcompat.h>
#else /* not PROSPERO */
#define DISABLE_PFS_START()
#define DISABLE_PFS_END()
#endif /* not PROSPERO */

RREQ		       ardp_activeQ = NOREQ;  /* Info about active requests */
RREQ		       ardp_completeQ = NOREQ;/* Completed requests         */
static unsigned short  ardp_def_port_no = 0;  /* Default UDP port to use    */
int		       ardp_port = -1;	      /* Opened UDP port	    */

extern int	       pfs_debug;             /* Debug level                */

static ardp_init();
static short ardp_next_cid();

/*
 * ardp_send - send a request and possibly wait for response
 *
 *   ardp_send takes a pointer to a structure of type RREQ, an optional 
 *   hostname, an optional pointer to the desination address, and the time to
 *   wait before returning in microseconds.
 *
 *   If a destination address was specified, the address is inserted
 *   into the RREQ structure.  If not, but a hostname was specified, the
 *   hostname is resolved, and its address inserted into the RREQ
 *   structure.  The hostname may be followed by a port number in
 *   parentheses in which case the port field is filled in.  If not
 *   specified, the Prospero directory server port is used as the default. 
 *   If the host address is a non-null pointer to an empty address, then
 *   the address is also filled in.
 *
 *   ardp_send then sends the packets specified by the request structure 
 *   to the address in the request structure.  If the time to wait is
 *   -1, it waits until the complete response has been received and
 *   returns PSUCCESS or PFAILURE depending on the outcome.  Any
 *   returned packets are left in the RREQ strucure.  If the time to
 *   wait is 0, ardp_send returns immediately.  The prereq strucure will
 *   be filled in as the response is received if calls are made to
 *   ardp_check_messages (which may be called by an interrupt, or
 *   explicitly at appropriate points in the application.  If the time
 *   to wait is positive, then ardp_send waits the specified lenght of
 *   time before returning.
 *
 *   If ardp_send returns before the complete response has been
 *   received, it returns ARDP_PENDING (-1).  This means that only
 *   the status field in the RREQ structure may be used until the status
 *   field indicates ARDP_STATUS_COMPLETE.  In no event shall it be legal 
 *   for the application to modify fields in the RREQ structure while a
 *   request is pending.  If the request completes during the call to
 *   ardp_send, it returns ARDP_SUCCESS (0).  On error, a positive
 *   return or status value indicates the error that occured.
 *
 *   In attempting to obtain the response, the ARDP library will wait
 *   for a response and retry an appropriate number of times as defined
 *   by timeout and retries (both static variables).  It will collect
 *   however many packets form the reply, and return them in the
 *   request structue.
 *
 *   ARGS:      req        Request structure holding packets to send 
 *			   and to receive the response
 *              hname      Hostname including optional port in parentheses
 *              dest       Pointer to destination address
 *              ttwait     Time to wait in microseconds
 *
 *   MODIFIES:  dest	   If pointer to empty address
 *              req	   Fills in ->recv and frees ->trns
 *
 *   NOTE:      In preparing packets for transmission, the packets
 *              are modified.  Once the full response has been received,
 *              the packets that were sent are freed.
 */
int
ardp_send(RREQ		req,	/* Request structure to use (in, out) */
	  char		*dname,	/* Hostname (and port) of destination */
	  struct sockaddr_in *dest, /* Pointer to destination address */
	  int		ttwait) /* Time to wait in microseconds       */
{
    char	hostnoport[400];/* Hostname without port              */
    char	*openparen;	/* Start of port in dname             */
    int		req_udp_port;	/* UDP port from hostname             */
#ifdef OLD_GETHOSTBYNAME        /* unused */
    struct hostent *host;	/* Host info from gethostbyname	      */
#endif

    PTEXT	ptmp;		/* Temporary packet pointer	      */
    int		DpfStmp;        /* Used when disabling prospero       */
    int		tmp;		/* To temporarily hold return values  */

    p_clear_errors();

    if((ardp_port < 0) && (tmp = ardp_init())) return(tmp);

    if(req->status == ARDP_STATUS_FREE) {
	fprintf(stderr,"Attempt to send free RREQ\n");
	abort();
	return(perrno = ARDP_BAD_REQ);
    }

    while(req->outpkt) {
        req->outpkt->seq = ++(req->trns_tot);
        ptmp = req->outpkt;
        EXTRACT_ITEM(ptmp,req->outpkt);
        APPEND_ITEM(ptmp,req->trns);
    }

    if(pfs_debug >= 9) {
	fprintf(stderr, "In ardp_send - sending to %s\n", dname);
        ptmp = req->trns;
        while(ptmp) {
            fprintf(stderr,"Packet %d:\n",ptmp->seq);
            ardp_showbuf(ptmp->text, ptmp->length, stderr);
            putc('\n', stderr);
            ptmp = ptmp->next;
        }
    }

    /* Assign connection ID */
    req->cid = ardp_next_cid();

    /* Resolve the host name, address, and port arguments          */
    
    /* If we were given the host address, then use it.  Otherwise  */
    /* lookup the hostname.  If we were passed a host address of   */
    /* 0, we must lookup the host name, then replace the old value */
    if(!dest || (dest->sin_addr.s_addr == 0)) {
        /* I we have a null host name, return an error */
        if((dname == NULL) || (*dname == '\0')) {
            if (pfs_debug >= 1)
                fprintf(stderr, "ardp_send: Null hostname specified\n");
            return(perrno = ARDP_BAD_HOSTNAME);
        }
        /* If a port is included, save it away */
	if(openparen = strchr(dname,'(')) {
            sscanf(openparen+1,"%d",&req_udp_port);
            if(req_udp_port) req->peer_port = htons(req_udp_port);
            strncpy(hostnoport,dname,399);
            if((openparen - dname) < 400) {
                *(hostnoport + (openparen - dname)) = '\0';
                dname = hostnoport;
            }
        }
#ifdef OLD_GETHOSTBYNAME
        DISABLE_PFS_START();
	assert(P_IS_THIS_THREAD_MASTER());
        if((host = gethostbyname(dname)) == NULL) {
            DISABLE_PFS_END();
            /* Check if a numeric address */
            req->peer.sin_family = AF_INET;
            req->peer_addr.s_addr = inet_addr(dname);
            if(req->peer_addr.s_addr == -1) {
                if (pfs_debug >= 1)
                    fprintf(stderr, "ardp: Can't resolve host %s\n", dname);
                return(perrno = ARDP_BAD_HOSTNAME);
            }
        }
        else {
            DISABLE_PFS_END();
            req->peer.sin_family = host->h_addrtype;
            bcopy(host->h_addr, (char *)&(req->peer_addr), 
                  host->h_length);
        }
#else
        /* New way of doing things */
        if (ardp_hostname2addr(dname, &req->peer_addr))
            return perrno = ARDP_BAD_HOSTNAME;
        
#endif
    }
    else bcopy(dest, &(req->peer), S_AD_SZ);

    /* If no port set, use default port */
    if(req->peer_port == 0) req->peer_port = ardp_def_port_no;

    /* If dest was set, but zero, fill it in */
    if(dest && (dest->sin_addr.s_addr == 0)) 
	bcopy(&(req->peer), dest, S_AD_SZ);

    if(tmp = ardp_headers(req)) return(tmp);

    req->status = ARDP_STATUS_ACTIVE;
    APPEND_ITEM(req,ardp_activeQ);
    req->wait_till.tv_sec = time(NULL) + req->timeout_adj.tv_sec;
    ardp_xmit(req, req->pwindow_sz);
    return(ardp_retrieve(req,ttwait));
}

/*
 * ardp_init - Open socket and bind port for network operations
 *
 *    ardp_init attempts to determine the default destination port.
 *    It then opens a socket for network operations and attempts
 *    to bind it to an available privleged port.  It tries to bind to a
 *    privileged port so that its peer can tell it is communicating with
 *    a "trusted" program.  If it can not bind a priveleged port, then
 *    it also returns successfully since the system will automatically 
 *    assign a non-priveleged port later, in which case the peer will
 *    assume that it is communicating with a non-trusted program.  It
 *    is expected that in the normal case, we will fail to bind the
 *    port since most applications calling this routine should NOT
 *    be setuid.
 */
static int
ardp_init()
{
    struct servent 	*sp;	/* Entry from services file           */
    struct sockaddr_in  us;	/* Our address                        */
    int			DpfStmp;/* Used when disabling prospero       */
    int			tmp;	/* For stepping through ports 	      */

    /* Determine default udp port to use */
    DISABLE_PFS_START();
    assert(P_IS_THIS_THREAD_MASTER()); /*SOLARIS: getservbyname MT-Unsafe */
    if ((sp = getservbyname(ARDP_DEFAULT_PEER,"udp")) == 0) {
	if (pfs_debug >= 10)
	    fprintf(stderr, "ardp: udp/%s unknown service - using %d\n", 
		    ARDP_DEFAULT_PEER, ARDP_DEFAULT_PORT);
	ardp_def_port_no = htons((u_short) ARDP_DEFAULT_PORT);
    }
    else ardp_def_port_no = sp->s_port;
    DISABLE_PFS_END();
    if (pfs_debug >= 10)
	fprintf(stderr,"default udp port is %d\n", ntohs(ardp_def_port_no));


    /* Open the local socket from which packets will be sent */
    errno=0;
    if((ardp_port = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
        if (pfs_debug >= 1)
            fprintf(stderr,"ardp: Can't open socket - %s\n",
                    unixerrstr());
        return(perrno = ARDP_UDP_CANT);
    }

#ifndef ARDP_NONPRIVED
    /* Try to bind it to a privileged port - loop through candidate   */
    /* ports trying to bind.  If failed, that's OK, we will let the   */
    /* system assign a non-privileged port later                      */
    bzero((char *)&us, sizeof(us));
    us.sin_family = AF_INET;
    for(tmp = ARDP_FIRST_PRIVP; tmp < ARDP_FIRST_PRIVP+ARDP_NUM_PRIVP;tmp++) {
	us.sin_port = htons((u_short) tmp);
	if(bind(ardp_port, (struct sockaddr *)&us, sizeof(us)) == 0)
	    return(ARDP_SUCCESS);
	if(errno != EADDRINUSE) return(ARDP_SUCCESS);
    }
#endif /* ARDP_NONPRIVED */
    return(ARDP_SUCCESS);
}

/*
 * ardp_next_cid - return next connection ID in network byte order
 *
 *    ardp_next_cid returns the next connection ID to be used
 *    after first converting it to network byte order.
 */
static short ardp_next_cid()
{
    static unsigned short	next_conn_id = 0; /* Next conn id to use  */
    static int			last_pid = 0;     /* Reset after forks    */
    int				pid = getpid();
    
    /* If we did a fork, reinitialize */
    if(last_pid != pid) {
	if(ardp_port >= 0) close(ardp_port);
	ardp_port = -1;
	next_conn_id = 0;
	ardp_init();
    }
    /* Find first connection ID */
    assert(P_IS_THIS_THREAD_MASTER()); /* rand and srand are unsafe */
    if(next_conn_id == 0) {
	srand(pid+time(0));
	next_conn_id = rand();
	last_pid = pid;
    }
    if(++next_conn_id == 0) ++next_conn_id;
    return(htons(next_conn_id));
}