---

/opentcp/bootp/bootp.c

Go to the documentation of this file.

/*
 *Copyright (c) 2000-2002 Viola Systems Ltd.
 *All rights reserved.
 *
 *Redistribution and use in source and binary forms, with or without 
 *modification, are permitted provided that the following conditions 
 *are met:
 *
 *1. Redistributions of source code must retain the above copyright 
 *notice, this list of conditions and the following disclaimer.
 *
 *2. Redistributions in binary form must reproduce the above copyright 
 *notice, this list of conditions and the following disclaimer in the 
 *documentation and/or other materials provided with the distribution.
 *
 *3. The end-user documentation included with the redistribution, if 
 *any, must include the following acknowledgment:
 *      "This product includes software developed by Viola 
 *      Systems (http://www.violasystems.com/)."
 *
 *Alternately, this acknowledgment may appear in the software itself, 
 *if and wherever such third-party acknowledgments normally appear.
 *
 *4. The names "OpenTCP" and "Viola Systems" must not be used to 
 *endorse or promote products derived from this software without prior 
 *written permission. For written permission, please contact 
 *opentcp@opentcp.org.
 *
 *5. Products derived from this software may not be called "OpenTCP", 
 *nor may "OpenTCP" appear in their name, without prior written 
 *permission of the Viola Systems Ltd.
 *
 *THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED 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 VIOLA SYSTEMS LTD. OR ITS 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.
 *====================================================================
 *
 *OpenTCP is the unified open source TCP/IP stack available on a series 
 *of 8/16-bit microcontrollers, please see <http://www.opentcp.org>.
 *
 *For more information on how to network-enable your devices, or how to 
 *obtain commercial technical support for OpenTCP, please see 
 *<http://www.violasystems.com/>.
 */
 
#include<inet/datatypes.h>
#include<inet/system.h>
#include<inet/timers.h>
#include<inet/tcp_ip.h>
#include<inet/bootp/bootp.h>
#include<inet/globalvariables.h>

UINT8 bootp_app_init = 0; 
struct
{
        UINT8   state;  
        UINT8   mode;
        INT8    sochandle;      
        UINT16  tmrhandle;
        UINT16  bootsecs;

} bootp;


INT8 bootpc_init (UINT8 mode)
{
        /* Already initialized? */
        
        if(bootp_app_init)
                return(1);
        
        /* Get socket handle            */
        
        bootp.sochandle = udp_getsocket(0, bootpc_eventlistener, UDP_OPT_SEND_CS | UDP_OPT_CHECK_CS);
        
        if(bootp.sochandle < 0)
                return(-1);
        
        /* Put it to listening mode     */
                
        if( udp_open(bootp.sochandle, BOOTP_CLIENTPORT) < 0 )
                return(-1);
        
        /* Get timer handle                     */
        
        bootp.tmrhandle = get_timer();
        bootp.bootsecs = 0;
        bootp.mode = mode;
        
        bootp.state = BOOTPC_STATE_DISABLED;
        
        
        bootp_app_init = 1;
        
        return(1);              
        
}

void bootpc_stop (void){
        if(bootp_app_init == 0)
                return;

        bootp.state = BOOTPC_STATE_DISABLED;
}

INT8 bootpc_enable (void){
        if(bootp_app_init == 0)
                return(-1);
        
        bootp.state = BOOTPC_STATE_ENABLED;
        
        return(1);      

}


void bootpc_run (void)
{
        INT16 i;
        UINT8 buf[4];

        /* State machine        */
        
        if(bootp_app_init == 0)
                return;
        
        switch(bootp.state) {
                case BOOTPC_STATE_ENABLED:
                
                        /* Check the IP address of the device and start BOOTP procedure for getting     */
                        /* one if zero or 255.255.255.255                                                                                       */
                        
                        if( (localmachine.localip == 0) || (localmachine.localip == 0xFFFFFFFF) ) {
                                /* We need to start BOOTP request procedure     */
                                /* Firstly wait random time                                     */
                                
                                localmachine.localip = 0;
                                localmachine.defgw = 0;
                                localmachine.netmask = 0;                       

                                init_timer(bootp.tmrhandle, ((UINT32)(localmachine.localHW[0]) << 2) + localmachine.localHW[1]);
                                bootp.state = BOOTPC_STATE_REQUEST_NEEDED;
                        }
                
                        return;
                        
                case BOOTPC_STATE_REQUEST_NEEDED:
                
                        if( check_timer(bootp.tmrhandle) != 0 )
                                return;
                        
                        /* Send request */
                        
                        if(localmachine.localip != 0){
                                bootp.state = BOOTPC_STATE_ENABLED;
                                return;
                        
                        }
                        
                        i = 0;
                        
                        net_buf[UDP_APP_OFFSET + i++] = 0x01;
                        net_buf[UDP_APP_OFFSET + i++] = 0x01;
                        net_buf[UDP_APP_OFFSET + i++] = 0x06;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0xCA;
                        net_buf[UDP_APP_OFFSET + i++] = 0x03;
                        net_buf[UDP_APP_OFFSET + i++] = 0x32;
                        net_buf[UDP_APP_OFFSET + i++] = 0xF1;
                        
                        net_buf[UDP_APP_OFFSET + i++] = (UINT8)(bootp.bootsecs >> 8);
                        net_buf[UDP_APP_OFFSET + i++] = (UINT8)bootp.bootsecs;
                        
                        net_buf[UDP_APP_OFFSET + i++] = 0x80;
                        
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;   
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        net_buf[UDP_APP_OFFSET + i++] = 0x00;
                        
                        net_buf[UDP_APP_OFFSET + i++] = localmachine.localHW[5];        
                        net_buf[UDP_APP_OFFSET + i++] = localmachine.localHW[4];
                        net_buf[UDP_APP_OFFSET + i++] = localmachine.localHW[3];
                        net_buf[UDP_APP_OFFSET + i++] = localmachine.localHW[2];
                        net_buf[UDP_APP_OFFSET + i++] = localmachine.localHW[1];
                        net_buf[UDP_APP_OFFSET + i++] = localmachine.localHW[0];
                        
                        net_buf[UDP_APP_OFFSET + i++] = 99;
                        net_buf[UDP_APP_OFFSET + i++] = 130;    
                        net_buf[UDP_APP_OFFSET + i++] = 83;
                        net_buf[UDP_APP_OFFSET + i++] = 99;
                        net_buf[UDP_APP_OFFSET + i++] = 255;
                        
                        for(i;i<300;i++)
                                net_buf[UDP_APP_OFFSET + i] = 0;
                        
                        /* Send it      */
                        
                        udp_send(bootp.sochandle, IP_BROADCAST_ADDRESS, BOOTP_SERVERPORT, &net_buf[UDP_APP_OFFSET], NETWORK_TX_BUFFER_SIZE - UDP_APP_OFFSET, 300);
                        
                        init_timer(bootp.tmrhandle, BOOTP_RETRY_TOUT*TIMERTIC);
                        
                        bootp.bootsecs += BOOTP_RETRY_TOUT*TIMERTIC;
                        
                        bootp.state = BOOTPC_STATE_WAITING_REPLY;       
                                        
                        return;
                        
                case BOOTPC_STATE_WAITING_REPLY:
                
                        /* Wait untill timeout elapsed and try again    */
                        
                        if( check_timer(bootp.tmrhandle) != 0 )
                                return;
                        
                        bootp.state = BOOTPC_STATE_REQUEST_NEEDED;
                                
                        return;                 
                                
                case BOOTPC_STATE_REPLY_GET:
                        /* parameters configured. Inspect state of bootp.mode
                         * and do something (if needed). Also turn BOOTP client
                         * on/off.
                         */
                        
                        return;
                        
        
                default:
                
                        return;
        }

}

INT32 bootpc_eventlistener (INT8 cbhandle, UINT8 event, UINT32 remip, UINT16 remport, UINT16 bufindex, UINT16 dlen) {
        INT16 i,j,k;
        UINT32 ip = 0;
        UINT32 nm = 0;
        UINT32 dgw = 0;
        UINT8 ch;
        

        /* This function is called by UDP stack to inform about events  */
        
        if(bootp_app_init == 0)
                return(-1);
        
        if( cbhandle != bootp.sochandle)                /* Not our handle       */
                return(-1);
                        
        /* The only event is data       */
        
        if(bootp.state != BOOTPC_STATE_WAITING_REPLY)
                return(-1);     
        
        /* Process reply        */

        NETWORK_RECEIVE_INITIALIZE(bufindex);
                                
        if(dlen < 300)
                return(-1);
        
        if(     RECEIVE_NETWORK_B() != BOOTP_REPLY)
                return(-1);
                
        if(     RECEIVE_NETWORK_B() != BOOTP_HTYPE_ETHERNET)
                return(-1);
        
        if(     RECEIVE_NETWORK_B() != BOOTP_HWLEN_ETHERNET)
                return(-1);
        
        RECEIVE_NETWORK_B();            /* Skip hops    */
        
        /* Check transaction ID */
                
        if(     RECEIVE_NETWORK_B() != 0xCA)
                return(-1);             
                
        if(     RECEIVE_NETWORK_B() != 0x03)
                return(-1);     

        if(     RECEIVE_NETWORK_B() != 0x32)
                return(-1);                                                     

        if(     RECEIVE_NETWORK_B() != 0xF1)
                return(-1);             
        
        /* Skip elapsed, unused, client address */
        
        for(i=0; i<8; i++)
                RECEIVE_NETWORK_B();
        
        /* Get IP       */
        
        ip = RECEIVE_NETWORK_B();
        ip <<= 8;
        ip |= RECEIVE_NETWORK_B();
        ip <<= 8;
        ip |= RECEIVE_NETWORK_B();              
        ip <<= 8;
        ip |= RECEIVE_NETWORK_B();
        
        /* Skip server ip & bootp router address        */
        
        for(i=0; i<8; i++)
                RECEIVE_NETWORK_B();
                
        /* Check MAC                                                            */
        
        if(     RECEIVE_NETWORK_B() != localmachine.localHW[5])
                return(-1);     
                
        if(     RECEIVE_NETWORK_B() != localmachine.localHW[4])
                return(-1);

        if(     RECEIVE_NETWORK_B() != localmachine.localHW[3])
                return(-1);                                             

        if(     RECEIVE_NETWORK_B() != localmachine.localHW[2])
                return(-1);     
        
        if(     RECEIVE_NETWORK_B() != localmachine.localHW[1])
                return(-1);

        if(     RECEIVE_NETWORK_B() != localmachine.localHW[0])
                return(-1);
                
        RECEIVE_NETWORK_B();
        RECEIVE_NETWORK_B();
        
        for(i=0; i<200; i++)
                RECEIVE_NETWORK_B();
        
        /* Check options        */
        
        dlen -= 236;
        
        i = 0;
        
        while(i<dlen) {
                ch = RECEIVE_NETWORK_B();
                i++;
                
                if( (ch != BOOTP_OPTION_SUBNETMASK) && (ch != BOOTP_OPTION_DEFGW) )     {
                        /* Not supported option, skip it        */
                        
                        j = RECEIVE_NETWORK_B();
                        i++;
                
                        if(j >= 2) {
                                j -= 2;
        
                                while(j--) {
                                        RECEIVE_NETWORK_B();
                                        i++;                    
                                }       
                        }
                                        
                        continue;                       
                        
                } 
                
                if( ch == BOOTP_OPTION_SUBNETMASK) {
                        RECEIVE_NETWORK_B();                    /* Skip totlen  */
                        nm = RECEIVE_NETWORK_B();
                        nm <<= 8;
                        nm |= RECEIVE_NETWORK_B();
                        nm <<= 8;
                        nm |= RECEIVE_NETWORK_B();              
                        nm <<= 8;
                        nm |= RECEIVE_NETWORK_B();
                        
                        i += 5;
                        
                }
                
                if( ch == BOOTP_OPTION_DEFGW) {
                        j = RECEIVE_NETWORK_B();                /* Get totlen   */                      
                        dgw = RECEIVE_NETWORK_B();
                        dgw <<= 8;
                        dgw |= RECEIVE_NETWORK_B();
                        dgw <<= 8;
                        dgw |= RECEIVE_NETWORK_B();             
                        dgw <<= 8;
                        dgw |= RECEIVE_NETWORK_B();
                        
                        i += 5;
                        
                        /* Skip others  */
                        
                        if( j>5 ) {
                                j -= 5;
                                
                                while(j--) {
                                        RECEIVE_NETWORK_B();
                                        i++;                    
                                }                               
                                
                        }
                        
                }               
                
        }
        
        /* Store parameters             */
        
        localmachine.localip = ip;
        localmachine.defgw = dgw;
        localmachine.netmask = nm;      
        
        /* Change state */
        
        bootp.state = BOOTPC_STATE_REPLY_GET;
        
        return(1);
        
}

---