/*****************************************************************************
* netbootp.c - 
*
* portions Copyright (c) 2001 by Cognizant Pty Ltd.
*
* The authors hereby grant permission to use, copy, modify, distribute,
* and license this software and its documentation for any purpose, provided
* that existing copyright notices are retained in all copies and that this
* notice and the following disclaimer are included verbatim in any 
* distributions. No written agreement, license, or royalty fee is required
* for any of the authorized uses.
*
* THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
* IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
* REVISION HISTORY (please don't use tabs!)
*
*(yyyy-mm-dd)
* 2001-06-01 Robert Dickenson <odin@pnc.com.au>, Cognizant Pty Ltd.
*            Original file.
*
******************************************************************************
*/
#include "netconf.h"
#include "netbuf.h"
#include "netos.h"

#include <stdio.h>
#include "netdebug.h"

#include "net.h" // for struct in_addr
#include "netbootp.h"

#if 0
/*
 * Center for Information Technology Integration
 *           The University of Michigan
 *                    Ann Arbor
 *
 * Dedicated to the public domain.
 * Send questions to info@citi.umich.edu
 *
 * BOOTP is documented in RFC 951 and RFC 1048
 * Delinted, ANSIfied and reformatted - 5/30/91 P. Karn
 */

#include <time.h>
#include "global.h"
#include "mbuf.h"
#include "socket.h"
#include "netuser.h"
#include "udp.h"
#include "iface.h"
#include "ip.h"
#include "internet.h"
#include "domain.h"
#include "rip.h"
#include "cmdparse.h"
#include "bootp.h"

static int bootp_rx(struct iface *ifp,struct mbuf *bp);
static void ntoh_bootp(struct mbuf **bpp,struct bootp *bootpp);
static int mask2width(int32 mask);

#define BOOTP_TIMEOUT   30      /* Time limit for booting       */
#define BOOTP_RETRANS   5       /* The inteval between sendings */

int WantBootp = 0;
static int SilentStartup = 0;

int dobootp(int argc, char *argv[], void *p)
{
    struct iface *ifp = NULL;
    struct socket lsock, fsock;
    struct mbuf *bp;
    struct udp_cb *bootp_cb;
    register uint8 *cp;
    time_t    now,          /* The current time (seconds)   */
              starttime,    /* The start time of sending BOOTP */
              lastsendtime; /* The last time of sending BOOTP  */
    int i;

    if(argc < 2)            /* default to the first interface */
        ifp = Ifaces;
    else {
        for(i = 1; i != argc; ++i){
            
            if((ifp = if_lookup(argv[i])) != NULL) 
                continue;
            else if(strncmp(argv[i], "silent", strlen(argv[i])) == 0)
                SilentStartup = 1;
            else if(strncmp(argv[i], "noisy", strlen(argv[i])) == 0)
                SilentStartup = 0;
            else {
                printf("bootp [net_name] [silent] [noisy]\n");
                return 1;
            }
        }
    }

    if(ifp == NULL)
        return 0;
    
    lsock.address = ifp->addr;
    lsock.port = IPPORT_BOOTPC;

    bootp_cb = open_udp(&lsock,NULL);

    fsock.address = ifp->broadcast;
    fsock.port = IPPORT_BOOTPS;

    /* Get boot starting time */
    time(&starttime);
    lastsendtime = 0;

    /* Send the bootp request packet until a response is received or time
       out */
    for(;;){

        /* Allow bootp packets should be passed through iproute. */
        WantBootp = 1;

        /* Get the current time */
        time(&now);

        /* Stop, if time out */
        if(now - starttime >= BOOTP_TIMEOUT){
            printf("bootp: timed out, values not set\n");
            break;
        }

        /* Don't flood the network, send in intervals */
        if(now - lastsendtime > BOOTP_RETRANS){
            if(!SilentStartup) printf("Requesting...\n");

            /* Allocate BOOTP packet and fill it in */
            if((bp = alloc_mbuf(sizeof(struct bootp))) == NULL)
                break;

            cp = bp->data;      /* names per the RFC: */
            *cp++ = BOOTREQUEST;        /* op */
            *cp++ = ifp->iftype->type;  /* htype */
            *cp++ = ifp->iftype->hwalen;    /* hlen */
            *cp++ = 0;          /* hops */
            cp = put32(cp,(int32) now); /* xid */
            cp = put16(cp, now - starttime);/* secs */
            cp = put16(cp, 0);      /* unused */
            cp = put32(cp, ifp->addr);  /* ciaddr */
            cp = put32(cp, 0L);     /* yiaddr */
            cp = put32(cp, 0L);     /* siaddr */
            cp = put32(cp, 0L);     /* giaddr */
            memcpy(cp, ifp->hwaddr, ifp->iftype->hwalen);
            cp += 16;           /* chaddr */
            memset(cp, 0, 64);      /* sname */
            cp += 64;
            memset(cp, 0, 128);     /* file */
            cp += 128;
            memset(cp, 0, 64);      /* vend */
            cp += 64;
            bp->cnt = cp - bp->data;
            /* assert(bp->cnt == BOOTP_LEN) */

            /* Send out one BOOTP Request packet as a broadcast */
            send_udp(&lsock, &fsock,0,0,&bp,bp->cnt,0,0);

            lastsendtime = now;
        }

        /* Give other tasks a chance to run. */
        kwait(NULL);

        /* Test for and process any replies */
        if(recv_udp(bootp_cb, &fsock, &bp) > -1){
            if(bootp_rx(ifp,bp))
                break;
        } else if(Net_error != WOULDBLK){
            printf("bootp: Net_error %d, no values set\n",
                 Net_error);
            break;
        }
    }

    WantBootp = 0;
    del_udp(bootp_cb);
    return 0;
}

/* Process BOOTP input received from 'interface'. */
static int bootp_rx(struct iface *ifp, struct mbuf *bp)
{
    int         ch;
    int         count;
    int32       gateway = 0;
    int32       nameserver = 0;
    int32       broadcast, netmask;
    struct route    *rp;
    struct bootp    reply;
    uint8       *cp;

    if(len_p(bp) != sizeof(struct bootp)){
        free_p(&bp);
        return 0;
    }
    ntoh_bootp(&bp, &reply);
    free_p(&bp);

    if(reply.op != BOOTREPLY) 
        return 0;

    if(!SilentStartup)
        printf("Network %s configured:\n", ifp->name);

    if(ifp->addr == 0){
        Ip_addr = (int) reply.yiaddr.s_addr;    /* yiaddr */
        ifp->addr =  reply.yiaddr.s_addr;   /* yiaddr */
        if(!SilentStartup)
            printf("     IP address: %s\n",  
        inet_ntoa(ifp->addr));
    }

    /* now process the vendor-specific block, check for cookie first. */
    cp = reply.vend;
    if(get32(cp) != 0x63825363L){
        printf("Invalid magic cookie.\n");
        return(0);
    }

    cp += 4;
    while(((ch = *cp) != BOOTP_END) && (++cp < (reply.vend + 64))) 
        switch(ch){
        case BOOTP_PAD:     /* They're just padding */
            continue;
        case BOOTP_SUBNET:  /* fixed length, 4 octets */
            cp++;       /* moved past length */

            /* Set the netmask */
                /* Remove old entry if it exists */
            netmask = get32(cp);
            cp += 4;

                rp = rt_blookup(ifp->addr & ifp->netmask,mask2width(ifp->netmask));
                if(rp != NULL)
                        rt_drop(rp->target,rp->bits);
                ifp->netmask = netmask;
                rt_add(ifp->addr,mask2width(ifp->netmask),0L,ifp,0L,0L,0);

            if(!SilentStartup)
                printf("     Subnet mask: %s\n", inet_ntoa(netmask));
            
            /* Set the broadcast */
            broadcast = ifp->addr | ~(ifp->netmask);
                rp = rt_blookup(ifp->broadcast,32);
                if(rp != NULL && rp->iface == ifp)
                        rt_drop(ifp->broadcast,32);
                ifp->broadcast = broadcast;
                rt_add(ifp->broadcast,32,0L,ifp,1L,0L,1);
            
            if(!SilentStartup)
                printf("     Broadcast: %s\n", inet_ntoa(broadcast));

            break;
        case BOOTP_HOSTNAME:
            count = (int) *cp;
            cp++;

            if(Hostname != NULL)
                free(Hostname);
            Hostname = mallocw(count);
            strncpy(Hostname, (char *)cp, count);
            cp += count;

            if(!SilentStartup)
                printf("     Hostname: %s\n", Hostname);
            break;
        case BOOTP_DNS:
            count = (int) *cp;
            cp++;

            while(count){
                nameserver = get32(cp);
                add_nameserver(nameserver);
                if(!SilentStartup)
                    printf("     Nameserver: %s\n", inet_ntoa(nameserver));
                cp += 4;
                count -= 4;
            }
            break;
        case BOOTP_GATEWAY:
            count = (int) *cp;
            cp++;

            gateway = get32(cp);

            /* Add the gateway as the default */
            rt_add(0,0,gateway,ifp,1,0,0);

            if(!SilentStartup)
                printf("     Default gateway: %s\n", inet_ntoa(gateway));
            cp += count;
            break;
        default:        /* variable field we don't know about */
            count = (int) *cp;
            cp++;

            cp += count;
            break;
    }

    rt_add(ifp->addr,mask2width(ifp->netmask),0L,ifp,1,0,0);

    return(1);
}


static void ntoh_bootp(struct mbuf **bpp, struct bootp *bootpp)
{
    bootpp->op = pullchar(bpp);             /* op */
    bootpp->htype = pullchar(bpp);          /* htype */
    bootpp->hlen = pullchar(bpp);           /* hlen */
    bootpp->hops = pullchar(bpp);           /* hops */
    bootpp->xid = pull32(bpp);              /* xid */
    bootpp->secs = pull16(bpp);             /* secs */
    bootpp->unused = pull16(bpp);           /* unused */
    bootpp->ciaddr.s_addr = pull32(bpp);    /* ciaddr */
    bootpp->yiaddr.s_addr = pull32(bpp);    /* ciaddr */
    bootpp->siaddr.s_addr = pull32(bpp);    /* siaddr */
    bootpp->giaddr.s_addr = pull32(bpp);    /* giaddr */
    pullup(bpp, bootpp->chaddr, 16);        /* chaddr */
    pullup(bpp, bootpp->sname, 64);         /* sname */
    pullup(bpp, bootpp->file, 128);         /* file name */
    pullup(bpp, bootpp->vend, 64);          /* vendor */
}


int bootp_validPacket(struct ip* ip, struct mbuf* bp)
{
    struct udp udp;
    struct mbuf* bp1;

    /* Must be a udp packet */
    if (ip->protocol !=  UDP_PTCL) 
        return 0;

    /* Invalid if packet is not the right size */
    if (len_p(bp) != (sizeof(struct udp) + sizeof(struct bootp)))
        return 0;

    /* Invalid if not a udp bootp packet */
    dup_p(&bp1,bp,0,len_p(bp));
    ntohudp(&udp, &bp);
    free_p(&bp);

    return (udp.dest == IPPORT_BOOTPC) ? 1 : 0;
}
#endif

/* Given a network mask, return the number of contiguous 1-bits starting
 * from the most significant bit.
 */
static int mask2width(int32 mask)
{
    int width,i;

    width = 0;
    for (i = 31;i >= 0;i--) {
        if(!(mask & (1L << i))) break;
        width++;
    }
    return width;
}