/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/* Portions Copyright 2005 Juergen Keil */

#include <sys/types.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <ndbm.h>
#include <rpc/rpc.h>
#include <rpc/svc.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <syslog.h>
#include "ypxfrd.h"
#include "ypsym.h"
#include "ypdefs.h"
/*
 * Because this code hacks into DBM underneath its API it can't use the N2L
 * shim in it's normal way. It thus includes shim.h instead of shim_hooks.h
 * and has knowledge of shim internals. While copying the DBM files it does
 * not lock them. This reflects the behavior of the pre N2L code.
 */
#include "shim.h"
#include "yptol.h"

#if (defined(vax) || defined(i386))
#define DOSWAB 1
#endif

USE_YP_SECURE

/* per connection stuff */
struct mycon {
        map_ctrl *map;
        int     lblk;
        int     firstd;
        datum   key;
};

bool_t xdr_myfyl(XDR *xdrs, struct mycon *objp);
bool_t xdr_pages(XDR *xdrs, struct mycon *m);
bool_t xdr_dirs(XDR *xdrs, struct mycon *m);

int mygetdir(char *block, int *no, struct mycon *m);
int mygetpage(char *block, int *pageno, struct mycon *m);

datum mydbm_topkey(DBM *db, datum okey);
datum dbm_do_nextkey();
datum shim_dbm_do_nextkey();

extern void get_secure_nets(char *);
extern int check_secure_net_ti(struct netbuf *, char *);
extern int _main(int, char **);

int
main(int argc, char **argv)
{
        int connmaxrec = RPC_MAXDATASIZE;

        /* load up the securenet file */
        get_secure_nets(argv[0]);

        /*
         * Set non-blocking mode and maximum record size for
         * connection oriented RPC transports.
         */
        if (!rpc_control(RPC_SVC_CONNMAXREC_SET, &connmaxrec)) {
                syslog(LOG_INFO|LOG_DAEMON,
                        "unable to set maximum RPC record size");
        }

        /* Initialize file locking etc. */
        if (!init_lock_system(TRUE))
                /* An detailed error will already have been logged */
                exit(-1);

        return (_main(argc, argv));
}

/*
 * In yptol mode we may start a cache update thread within a child process.
 * It is thus important that child processes do not exit, killing any such
 * threads, before the thread has completed. They must thus call this version
 * of the exit() function.
 */
void
yptol_exit(int status)
{
        if (yptol_mode) {
                thr_join(0, NULL, NULL);
        }
        exit(status);
}

dbmfyl *
getdbm_1_svc(hosereq *argp, struct svc_req *rqstp)
{
        static dbmfyl  result;
        char path[MAXNAMLEN + 1];
        SVCXPRT *xprt;
        int pid;
        int res;
        struct mycon m;
        char *ypname = "ypxfrd";
        struct netbuf *nbuf;
        sa_family_t af;
        in_port_t port;

        xprt = rqstp->rq_xprt;

        signal(SIGPIPE, SIG_IGN);
        signal(SIGCHLD, SIG_IGN);

        /*
         * Build up path name. If we are working in N2L mode also conv
         * to the new N2L style mapname.
         *
         * Do not allow any path as a domain name or map name.
         */
        if ((strchr(argp->domain, '/') != NULL) ||
                (strchr(argp->map, '/') != NULL) ||
                (!ypmkfilename(argp->domain, argp->map, (char *)&path))) {
                res = GETDBM_ERROR;
                if (!svc_sendreply(rqstp->rq_xprt, xdr_answer,
                                        (caddr_t)&res)) {
                        svcerr_systemerr(rqstp->rq_xprt);
                }
                return (NULL);
        }

        pid = fork1();
        if (pid < 0) {
                perror("fork");

                res = GETDBM_ERROR;
                if (!svc_sendreply(rqstp->rq_xprt, xdr_answer,
                                        (caddr_t)&res)) {
                        svcerr_systemerr(rqstp->rq_xprt);
                }
                return (NULL);
        }
        if (pid != 0)
                return (NULL);

        m.map = (map_ctrl *)shim_dbm_open(path, 0, 0);
        if (m.map == NULL) {
                perror(path);
                res = GETDBM_ERROR;
                if (!svc_sendreply(rqstp->rq_xprt, xdr_answer,
                                        (caddr_t)&res)) {
                    svcerr_systemerr(rqstp->rq_xprt);
                }
                yptol_exit(0);
                return (NULL);
        }

        /* Do the security thing */
        if ((nbuf = svc_getrpccaller(xprt)) == 0) {
                res = GETDBM_ERROR;
                if (!svc_sendreply(xprt, xdr_answer, (caddr_t)&res)) {
                        svcerr_systemerr(xprt);
                }
                shim_dbm_close((DBM *)m.map);
                yptol_exit(0);
                return (NULL);
        }
        if (!check_secure_net_ti(nbuf, ypname)) {
                res = GETDBM_ERROR;
                if (!svc_sendreply(xprt, xdr_answer, (caddr_t)&res)) {
                        svcerr_systemerr(xprt);
                }
                shim_dbm_close((DBM *)m.map);
                yptol_exit(1);
                return (NULL);
        }

        af = ((struct sockaddr_storage *)nbuf->buf)->ss_family;
        port = (af == AF_INET6) ?
                ((struct sockaddr_in6 *)nbuf->buf)->sin6_port :
                ((struct sockaddr_in  *)nbuf->buf)->sin_port;

        if ((af == AF_INET || af == AF_INET6) &&
                (ntohs(port) > IPPORT_RESERVED)) {
                datum key, val;

                key.dptr = yp_secure;
                key.dsize = yp_secure_sz;
                val = shim_dbm_fetch((DBM *)m.map, key);
                if (val.dptr != NULL) {
                        res = GETDBM_ERROR;
                        if (!svc_sendreply(xprt, xdr_answer, (caddr_t)&res)) {
                                svcerr_systemerr(xprt);
                        }
                        shim_dbm_close((DBM *)m.map);
                        yptol_exit(1);
                        return (NULL);
                }
        }

        /* OK, we're through */
        m.key = shim_dbm_firstkey((DBM *)m.map);

        m.lblk = -1;
        m.firstd = 0;

        if (!svc_sendreply(rqstp->rq_xprt, xdr_myfyl, (caddr_t)&m)) {
                svcerr_systemerr(rqstp->rq_xprt);
        }
        shim_dbm_close((DBM *)m.map);
        yptol_exit(0);

        return (&result);
}

bool_t
xdr_myfyl(XDR *xdrs, struct mycon *objp)
{
        int     ans = OK;

        if (!xdr_answer(xdrs, (answer *) &ans))
                return (FALSE);
        if (!xdr_pages(xdrs, objp))
                return (FALSE);
        if (!xdr_dirs(xdrs, objp))
                return (FALSE);

        return (TRUE);
}

bool_t
xdr_pages(XDR *xdrs, struct mycon *m)
{
        static  struct pag res;
        bool_t  false = FALSE;
        bool_t  true = TRUE;
#ifdef DOSWAB
        short   *s;
        int     i;
        int     cnt;
#endif
        res.status = mygetpage(res.pag_u.ok.blkdat, &(res.pag_u.ok.blkno), m);

#ifdef DOSWAB
        if (res.status == OK) {
                s = (short *)res.pag_u.ok.blkdat;
                cnt = s[0];
                for (i = 0; i <= cnt; i++)
                        s[i] = ntohs(s[i]);
        }
#endif

        if (!xdr_pag(xdrs, &res))
                return (FALSE);

        while (res.status == OK) {
                if (!xdr_bool(xdrs, &true))
                        return (FALSE);
                res.status = mygetpage(res.pag_u.ok.blkdat,
                                        &(res.pag_u.ok.blkno), m);

#ifdef DOSWAB
                if (res.status == OK) {
                        s = (short *)res.pag_u.ok.blkdat;
                        cnt = s[0];
                        for (i = 0; i <= cnt; i++)
                                s[i] = ntohs(s[i]);
                }
#endif

                if (!xdr_pag(xdrs, &res))
                        return (FALSE);
        }

        return (xdr_bool(xdrs, &false));
}

int
mygetdir(char *block, int *no, struct mycon *m)
{
        int     status;
        int     len;

        if (m->firstd == 0) {
                lseek(m->map->entries->dbm_dirf, 0, 0);
                m->firstd = 1;
        } else
                m->firstd++;

        len = read(m->map->entries->dbm_dirf, block, DBLKSIZ);
        *no = (m->firstd) - 1;
        status = OK;

        /*
         * printf("dir block %d\n", (m->firstd) - 1);
         */

        if (len < 0) {
                perror("read directory");
                status = GETDBM_ERROR;
        } else if (len == 0) {
                status = GETDBM_EOF;
                /*
                 * printf("dir EOF\n");
                 */
        }
        return (status);
}

bool_t
xdr_dirs(XDR *xdrs, struct mycon *m)
{
        static  struct dir res;
        bool_t  false = FALSE;
        bool_t  true = TRUE;

        res.status = mygetdir(res.dir_u.ok.blkdat, &(res.dir_u.ok.blkno), m);

        if (!xdr_dir(xdrs, &res))
                return (FALSE);

        while (res.status == OK) {
                if (!xdr_bool(xdrs, &true))
                        return (FALSE);
                res.status = mygetdir(res.dir_u.ok.blkdat,
                                        &(res.dir_u.ok.blkno), m);
                if (!xdr_dir(xdrs, &res))
                        return (FALSE);
        }

        return (xdr_bool(xdrs, &false));
}

int
mygetpage(char *block, int *pageno, struct mycon *m)
{

        for (; m->key.dptr;
                        m->key = shim_dbm_do_nextkey((DBM *)m->map, m->key)) {

                if (m->map->entries->dbm_pagbno != m->lblk) {
                        /*
                         * printf("block=%d lblk=%d\n",
                         *              m->map->entries->dbm_pagbno,
                         *              m->lblk);
                         */
                        m->lblk = m->map->entries->dbm_pagbno;
                        *pageno = m->lblk;
                        memmove(block, m->map->entries->dbm_pagbuf, PBLKSIZ);
                        /* advance key on first  try    */
                        m->key = mydbm_topkey(m->map->entries, m->key);
                        m->key = shim_dbm_do_nextkey((DBM *)m->map, m->key);
                        return (OK);
                }
        }
        /*
         * printf("EOF\n");
         */
        return (GETDBM_EOF);
}

datum
mydbm_topkey(DBM *db, datum okey)
{
        datum           ans;
        datum           tmp;
        register char   *buf;
        int             n;
        register short  *sp;
        register short  t;
        datum           item;
#if defined(_XPG4_2)
        register size_t m;
#else
        register long   m;
#endif
        register char   *p1, *p2;

        buf = db->dbm_pagbuf;
        sp = (short *)buf;
        /* find the maximum key in cmpdatum order */

        if ((unsigned)0 >= sp[0]) {
                return (okey);
        } else {
                ans.dptr = buf + sp[1];
                ans.dsize = PBLKSIZ - sp[1];
        }
        for (n = 2; ; n += 2) {
                if ((unsigned)n >= sp[0]) {
                        if (ans.dptr == NULL) {
                                return (okey);
                        } else {
                                return (ans);
                        }
                } else {
                        t = PBLKSIZ;
                        if (n > 0)
                                t = sp[n];
                        tmp.dptr = buf + sp[n + 1];
                        tmp.dsize = t - sp[n + 1];
                }

                m = tmp.dsize;
                if (m != ans.dsize) {
                        if ((m - ans.dsize) < 0)
                                ans = tmp;
                } else if (m == 0) {
                } else {
                        p1 = tmp.dptr;
                        p2 = ans.dptr;
                        do
                                if (*p1++ != *p2++) {
                                        if ((*--p1 - *--p2) < 0)
                                                ans = tmp;
                                break;
                                }
                        while (--m);
                }
        }
}