svc_generic.c File Reference

#include <wintirpc.h>
#include <reentrant.h>
#include <sys/types.h>
#include <rpc/rpc.h>
#include <rpc/nettype.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "rpc_com.h"
#include <rpc/svc.h>

Include dependency graph for svc_generic.c:

Go to the source code of this file.

Functions
int	__svc_vc_setflag (SVCXPRT *, int)
int	svc_create (void *dispatch, rpcprog_t prognum, rpcvers_t versnum, const char *nettype)
SVCXPRT *	svc_tp_create (void *dispatch, rpcprog_t prognum, rpcvers_t versnum, const struct netconfig *nconf)
SVCXPRT *	svc_tli_create (SOCKET fd, const struct netconfig *nconf, const struct t_bind *bindaddr, u_int sendsz, u_int recvsz)

Function Documentation

__svc_vc_setflag()

int __svc_vc_setflag	(	SVCXPRT *	,
		int
	)

Referenced by svc_tli_create().

svc_create()

int svc_create	(	void *	dispatch,
		rpcprog_t	prognum,
		rpcvers_t	versnum,
		const char *	nettype
	)

Definition at line 68 of file svc_generic.c.

{
    struct xlist {
        SVCXPRT *xprt;      /* Server handle */
        struct xlist *next; /* Next item */
    } *l;
    static struct xlist *xprtlist;  /* A link list of all the handles */
    int num = 0;
    SVCXPRT *xprt;
    struct netconfig *nconf;
    void *handle;
    extern mutex_t xprtlist_lock;
 
/* VARIABLES PROTECTED BY xprtlist_lock: xprtlist */
 
    if ((handle = __rpc_setconf(nettype)) == NULL) {
        // XXX warnx("svc_create: unknown protocol");
        return (0);
    }
    while ((nconf = __rpc_getconf(handle)) != NULL) {
        mutex_lock(&xprtlist_lock);
        for (l = xprtlist; l; l = l->next) {
            if (strcmp(l->xprt->xp_netid, nconf->nc_netid) == 0) {
                /* Found an old one, use it */
                (void) rpcb_unset(prognum, versnum, nconf);
                if (svc_reg(l->xprt, prognum, versnum,
                    dispatch, nconf) == FALSE) {
                    // XXX warnx(
//      "svc_create: could not register prog %u vers %u on %s",
//                  (unsigned)prognum, (unsigned)versnum,
//                   nconf->nc_netid);
                } else {
                    num++;
                }
                break;
            }
        }
        if (l == NULL) {
            /* It was not found. Now create a new one */
            xprt = svc_tp_create(dispatch, prognum, versnum, nconf);
            if (xprt) {
                l = (struct xlist *)malloc(sizeof (*l));
                if (l == NULL) {
                    // XXX warnx("svc_create: no memory");
                    mutex_unlock(&xprtlist_lock);
                    return (0);
                }
                l->xprt = xprt;
                l->next = xprtlist;
                xprtlist = l;
                num++;
            }
        }
        mutex_unlock(&xprtlist_lock);
    }
    __rpc_endconf(handle);
    /*
     * In case of num == 0; the error messages are generated by the
     * underlying layers; and hence not needed here.
     */
    return (num);
}

svc_tli_create()

SVCXPRT * svc_tli_create	(	SOCKET	fd,
		const struct netconfig *	nconf,
		const struct t_bind *	bindaddr,
		u_int	sendsz,
		u_int	recvsz
	)

Definition at line 182 of file svc_generic.c.

{
    SVCXPRT *xprt = NULL;       /* service handle */
    bool_t madefd = FALSE;      /* whether fd opened here  */
    struct __rpc_sockinfo si;
    struct sockaddr_storage ss;
    socklen_t slen;
 
    if (fd == RPC_ANYFD) {
        if (nconf == NULL) {
            // XXX warnx("svc_tli_create: invalid netconfig");
            return (NULL);
        }
        fd = __rpc_nconf2fd(nconf);
        if (fd == -1) {
            // XXX warnx(
//              "svc_tli_create: could not open connection for %s",
//                  nconf->nc_netid);
            return (NULL);
        }
        __rpc_nconf2sockinfo(nconf, &si);
        madefd = TRUE;
    } else {
        /*
         * It is an open descriptor. Get the transport info.
         */
        if (!__rpc_fd2sockinfo(fd, &si)) {
            // XXX warnx(
//      "svc_tli_create: could not get transport information");
            return (NULL);
        }
    }
 
    /*
     * If the fd is unbound, try to bind it.
     */
    if (madefd || !__rpc_sockisbound(fd)) {
        if (bindaddr == NULL) {
            if (bindresvport(fd, NULL) < 0) {
                memset(&ss, 0, sizeof ss);
                ss.ss_family = si.si_af;
                if (bind(fd, (struct sockaddr *)(void *)&ss,
                    (socklen_t)si.si_alen) == SOCKET_ERROR) {
                    // XXX warnx(
//          "svc_tli_create: could not bind to anonymous port");
                    goto freedata;
                }
            }
            listen(fd, SOMAXCONN);
        } else {
            if (bind(fd,
                (struct sockaddr *)bindaddr->addr.buf,
                (socklen_t)si.si_alen) == SOCKET_ERROR) {
                // XXX warnx(
//      "svc_tli_create: could not bind to requested address");
                goto freedata;
            }
            listen(fd, (int)bindaddr->qlen);
        }
            
    }
    /*
     * call transport specific function.
     */
    switch (si.si_socktype) {
        case SOCK_STREAM:
            slen = sizeof ss;
            if (getpeername(fd, (struct sockaddr *)(void *)&ss, &slen)
                == 0) {
                /* accepted socket */
                xprt = svc_fd_create(fd, sendsz, recvsz);
            } else
                xprt = svc_vc_create(fd, sendsz, recvsz);
            if (!nconf || !xprt)
                break;
#if 0
            /* XXX fvdl */
            if (strcmp(nconf->nc_protofmly, "inet") == 0 ||
                strcmp(nconf->nc_protofmly, "inet6") == 0)
                (void) __svc_vc_setflag(xprt, TRUE);
#endif
            break;
        case SOCK_DGRAM:
            xprt = svc_dg_create(fd, sendsz, recvsz);
            break;
        default:
            // XXX warnx("svc_tli_create: bad service type");
            goto freedata;
    }
 
    if (xprt == NULL)
        /*
         * The error messages here are spitted out by the lower layers:
         * svc_vc_create(), svc_fd_create() and svc_dg_create().
         */
        goto freedata;
 
    /* Fill in type of service */
    xprt->xp_type = __rpc_socktype2seman(si.si_socktype);
 
    if (nconf) {
        xprt->xp_netid = strdup(nconf->nc_netid);
        xprt->xp_tp = strdup(nconf->nc_device);
    }
    return (xprt);
 
freedata:
    if (madefd)
        (void)closesocket(fd);
    if (xprt) {
        if (!madefd) /* so that svc_destroy doesnt close fd */
            xprt->xp_fd = RPC_ANYFD;
        SVC_DESTROY(xprt);
    }
    return (NULL);
}

Referenced by rpc_reg(), and svc_tp_create().

svc_tp_create()

SVCXPRT * svc_tp_create	(	void *	dispatch,
		rpcprog_t	prognum,
		rpcvers_t	versnum,
		const struct netconfig *	nconf
	)

Definition at line 141 of file svc_generic.c.

{
    SVCXPRT *xprt;
 
    if (nconf == NULL) {
        // XXX warnx(
//  "svc_tp_create: invalid netconfig structure for prog %u vers %u",
//              (unsigned)prognum, (unsigned)versnum);
        return (NULL);
    }
    xprt = svc_tli_create(RPC_ANYFD, nconf, NULL, 0, 0);
    if (xprt == NULL) {
        return (NULL);
    }
    /*LINTED const castaway*/
    (void) rpcb_unset(prognum, versnum, (struct netconfig *) nconf);
    if (svc_reg(xprt, prognum, versnum, dispatch, nconf) == FALSE) {
        // XXX warnx(
//      "svc_tp_create: Could not register prog %u vers %u on %s",
//              (unsigned)prognum, (unsigned)versnum,
//              nconf->nc_netid);
        SVC_DESTROY(xprt);
        return (NULL);
    }
    return (xprt);
}

Referenced by svc_create().