TCP/IP协议栈

开发平台：
Visual C++

bootpd.c：源码内容
							/*
 * 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
 */
/*
 * BOOTP (bootstrap protocol) server daemon.
 *
 */
#include <stdio.h>
#include <systypes.h>
#include <sysstat.h>
#include <ctype.h>
#include <time.h>
#include "global.h"
#include "config.h"
#include "bootp.h"
#include "cmdparse.h"
#include "iface.h"
#include "mbuf.h"
#include "proc.h"
#include "socket.h"
#include "bootpd.h"
#include "udp.h"
#include "ip.h"
#include "arp.h"
#include "netuser.h"
void bootpd(struct iface *iface, struct udp_cb *sock, int cnt); 
struct udp_cb *Bootpd_cb = NULL;
char homedir[64] = "";      		/* bootfile homedirectory */
char defaultboot[64] = "";  		/* default file to boot */
struct host hosts[MHOSTS+1];
int Nhosts = 0;  	 /* current number of hosts */
int32 bp_DefaultDomainNS[BP_MAXDNS] =  {0};
struct bootpd_stat Bootpd_stat;
char *ArpNames[] = {
	"Netrom",
	"Ethernet",
	"AX25",
	"Pronet",
	"Chaos",
	"IEEE 802",
	"ArcNet",
	"AppleTalk" 
};
/* Routine declarations */
static int bootpd_recv(struct udp_cb *sock,struct bootp *bootp);
static void sendreply(struct bootp *bp,struct iface *iface);
static void vend_fill(uint8 *vend,struct iface *iface,struct host *hp);
static void vend_print(uint8 *vend);
static void bootpd_request(struct bootp *rq,struct iface *iface);
/* The bootp server. */
void 
bootpd(iface,sock,cnt)
struct iface *iface;
struct udp_cb *sock;
int cnt;
{
	struct bootp bp_packet;
	while(bootpd_recv(sock, &bp_packet) != -1) {
       		if(readtab() == -1) /* maybe re-read bootptab */
			return;
		switch(bp_packet.op) {
	    	case BOOTREQUEST:
			bootpd_request(&bp_packet, iface); 
			break;
		case BOOTREPLY: 
			/* Replies are not forwarded, left to the gateway */ 
			break;
		}
	}
}
/* A packet has been received, read it into a bootp structure. */
static int
bootpd_recv(sock, bootp)
struct udp_cb *sock;
struct bootp *bootp;
{
	struct socket fsock;
	struct mbuf *bp;
	int len;
	/* increment the rcvd cnt */
	Bootpd_stat.rcvd++;
	/* receive the packet */
	len = recv_udp(sock,&fsock,&bp);
	if(len == -1)
		return -1;
	/* check length of packet */
	if(len < sizeof(struct bootp)) {
		Bootpd_stat.bad_size++;
		bootp->op = 0;
		free_p(&bp);
		return -1;
	}
		
	/* parse the packet */
	pullup (&bp, bootp, sizeof (struct bootp));
	free_p(&bp);	
	if(bootp->op != BOOTREPLY  &&  bootp->op != BOOTREQUEST) {
		Bootpd_stat.bad_op++;
		bootp->op = 0;
		return -1;
	}
	bootp->ciaddr.s_addr = (unsigned long) get32 ((uint8 *)&(bootp->ciaddr));
	bootp->giaddr.s_addr = (unsigned long) get32 ((uint8 *)&(bootp->giaddr));
	return 0;
};
/*
 * Process BOOTREQUEST packet.
 *
 * (Note, this version of the bootp.c server never forwards 
 * the request to another server.  In our environment the 
 * stand-alone gateways perform that function.)
 *
 * (Also this version does not interpret the hostname field of
 * the request packet;  it COULD do a name->address lookup and
 * forward the request there.)
 */
static void
bootpd_request (rq, iface)
struct bootp *rq;
struct iface *iface;
{
	struct bootp *rp;
	char path[64], file[64];
	struct host *hp;
	int n;
	time_t tloc;
	int32 ipaddr;
	struct arp_type *at;
	time(&tloc);
	bp_log ("nBootpd request packet received %s", ctime(&tloc));
	/* Forwarding not done here. */
	if(rq->giaddr.s_addr)  {
		bp_log ("     Dropped, giaddr specifies to be forwarded;n");
		return;
	}
	/* Is a specific host requested? */
	if((strlen(rq->sname) != 0) && (strcmp (Hostname, rq->sname) != 0)) {
		bp_log ("     Dropped, sname specifies server '%s'n", rq->sname);  
		return;
	}
	/* allocate the reply */
	rp = (struct bootp *) calloc (1, sizeof (struct bootp));
	/* copy for construction */
	memcpy (rp, rq, sizeof (struct bootp) - sizeof (rp->vend));
	rp->op = BOOTREPLY;
	hp = NULL;
	/* If the client doesn't know it's ip address, find one. */
	if(rq->ciaddr.s_addr == 0) { 
		/*
		 * client doesn't know his IP address, 
		 * search by hardware address.
		 */
		at = &Arp_type[rq->htype];
		bp_log ("     Resolved by %s addr %sn", ArpNames[rq->htype], 
			(*at->format)(bp_ascii, rq->chaddr));
		for(hp = &hosts[0], n = 0 ; n < Nhosts ; n++,hp++)
			if((rq->htype == hp->htype)
			   && (memcmp(rq->chaddr, hp->haddr, rq->hlen) == 0))
				break;
		/* If the client wasn't found, assign an IP address */
		if(n == Nhosts) {
			hp = NULL;
			if(da_assign(iface, rq->chaddr, &ipaddr) != 0) {
				free (rp);
				bp_log ("     No dynamic addresses available.n");
				return;
			} else {		
				put32 ((uint8 *) &(rp->yiaddr), ipaddr);
				bp_log ("     Dynamic address assigned: %sn", 
					inet_ntoa (ipaddr));
			}
		} else {
			bp_log ("     Static address assigned: %sn", 
				inet_ntoa (hp->iaddr.s_addr));
			put32 ((uint8 *) &(rp->yiaddr), hp->iaddr.s_addr);
		}
	} else {
		/* search by IP address */
		bp_log ("     Resolve by IP addr %sn", inet_ntoa (rq->ciaddr.s_addr));
		for(hp = &hosts[0], n = 0 ; n < Nhosts ; n++,hp++)
			if(rq->ciaddr.s_addr == hp->iaddr.s_addr)
				break;
		if(n == Nhosts) {
			hp = NULL;
			bp_log ("     Host not found, default values used.n");
		} else
			bp_log ("     Lookup successful.n");
		put32 ((uint8 *) &(rp->ciaddr), rq->ciaddr.s_addr);
	}
	put32 ((uint8 *) &(rp->siaddr), iface->addr);
	/* Determine the bootp file */
	file[0] = 0;
	if(rq->file[0] == 0) { 		/* if client didn't specify file */
		/* Use the host record file, else the default file */
		if((hp == NULL) || (hp->bootfile[0] == 0))
			strcpy(file, defaultboot);
		else
			strcpy(file, hp->bootfile);
	} else {
		/* use client specified file */
		strcpy(file, rq->file);
	}
	/* If a file is specified, specify the path to the bootp file */
	path[0] = 0;
	if((*homedir != 0) && (*file != 0)) {
		strcpy(path, homedir);
		strcat(path, "/");
	}
	if(file[0] == '/')     /* if absolute pathname */
		strcpy(path, file);
	else
		strcat(path, file);
	/* No files are provided here, just return a path. */
	strcpy(rp->file, path);
	/* Fill in the vendor information */
	vend_fill (rp->vend, iface, hp);
	sendreply (rp, iface);
	free (rp); 
};
/* Print the bootp structure. */
void
bootp_print_packet  (bp)
struct bootp *bp;
{
	bp_log ("Packet op code........................%dn", bp->op);
	bp_log ("hardware address type.................%dn", bp->htype);
	bp_log ("hardware address length...............%dn", bp->hlen);
	bp_log ("client sets to zero...................%dn", bp->hops);
	bp_log ("transaction ID........................%ldn", bp->xid);
	bp_log ("seconds elapsed since client booted...%dn", bp->secs);
	bp_log ("unused................................%dn", bp->unused);
	bp_log ("Client IP address, if known...........%sn",
			inet_ntoa ((int32)bp->ciaddr.s_addr));
	bp_log ("Server supplied IP address............%sn", 
			inet_ntoa ((int32)bp->yiaddr.s_addr));
	bp_log ("Server IP address.....................%sn", 
			inet_ntoa ((int32)bp->siaddr.s_addr));
	bp_log ("Gateway IP address....................%sn", 
			inet_ntoa ((int32)bp->giaddr.s_addr));
	bp_log ("Client hardware address...............%x:%x:%x:%x:%x:%xn",
		bp->chaddr[0], bp->chaddr[1], bp->chaddr[2],
		bp->chaddr[3], bp->chaddr[4], bp->chaddr[5]);
	bp_log ("Server host name......................'%s'n", bp->sname);
	bp_log ("Boot file name........................'%s'n", bp->file);
	
	vend_print (bp->vend);	
}
static void
vend_print (vend)
uint8 *vend; 
{
	uint8 ch;
	int size;
	uint8 *start;
	int32 *ipaddr;
	int i;
	start = vend;
	bp_log ("Magic Cookie..........................x%02x%02x%02x%02xn", 
		(int) vend[0], (int) vend[1], (int) vend[2], (int) vend[3]);
	vend = vend + 4;
	while(((ch = *vend++) != BOOTP_END) && (vend - start <= 64)) 
		switch(ch) {
		case BOOTP_PAD:	 /* They're just padding */
			continue;
		case BOOTP_SUBNET:      /* fixed length, 4 octets */
			size = (int) *vend++;
			ipaddr = (int32 *) vend;
			bp_log ("Vend Subnet...........................%sn", inet_ntoa
(*ipaddr));
			vend += size;
			break;
		case BOOTP_HOSTNAME:
			size = (int) *vend++;
			bp_log ("Vend Hostname.........................%sn", vend);
			vend += size;
			break;
		case BOOTP_DNS:
			size = (int) *vend++;
			for(i = 0; i < (size / 4); i++) {
				ipaddr = (int32 *) vend;
				bp_log ("Vend DomainNS.........................%sn", 
					inet_ntoa (*ipaddr));
				vend += 4;
			}
			break;
		case BOOTP_GATEWAY:
			size = (int) *vend++;
			for(i = 0; i < (size / 4); i++) {
				ipaddr = (int32 *) vend;
				bp_log ("Vend Gateway..........................%sn", 
					inet_ntoa (*ipaddr));
				vend += 4;
			}
			break;
			
			
		default:		/* variable field we don't know about */
			size = *vend++;
			vend += size;
			break;
	}
}
static void
vend_fill (vend, iface, hp)
uint8 *vend;
struct iface *iface;
struct host *hp;
{
	uint8 	cookie[5] = {99, 130, 83, 99, 0};
	int 	len;
	int	mod;
	int	i;
	uint8	*sizep;
	/* Magic cookie */
	memcpy(vend,cookie,4);
	vend += 4;
	/* Send the iface subnet */
	/* Pad so number falls on word boundry */
	
	vend++;
	vend++;
	*vend = BOOTP_SUBNET;
	vend++;
	*vend = 4;
	vend++;
	put32 (vend, iface->netmask);
	vend += 4;
	
	/* Send the DNS */
	if(bp_DefaultDomainNS[0] != 0) {
		/* Pad for allignment */
		vend++;
		vend++;
		*vend = BOOTP_DNS;
		vend++;
		sizep = vend;
		vend++;
		for(i = 0; (i < BP_MAXDNS) && (bp_DefaultDomainNS[i] != 0); i++) {
			put32 (vend, bp_DefaultDomainNS[i]);
			*sizep = *sizep + 4;
			vend += 4;
		}
	}
	/* Send the default gateway */
	if(R_default.iface == iface) {
		vend++;
		vend++;
		*vend = BOOTP_GATEWAY; 
		vend++;	
		*vend = 4;	
		vend++;
		put32 (vend, R_default.gateway);
		vend +=  4;
	}
	
	/* Send the hostname */
	if(hp != NULL) {
		/* Pad so name begins on a word boundry */
		vend++;
		vend++;
		*vend = BOOTP_HOSTNAME;
		vend++;
		*vend = len = strlen (hp->name) + 1;
		vend++;
		strcpy ((char *)vend, hp->name);
		vend += len;
		/* Pad to a word. */
		mod = 4 - (len % 4);
		for(i = 0; i < mod; i++) {
			*vend = BOOTP_PAD;
			vend++;
		}
	}
	/* Mark the end of the data */
	*vend = BOOTP_END;
}
/*
 * Send a reply packet to the client.  'forward' flag is set if we are
 * not the originator of this reply packet.
 */
static void
sendreply(bp, iface)
struct bootp *bp;
struct iface *iface;
{
	struct mbuf *buf;
	int32 faddr;
	uint16 length;
	uint8 *cp;
	/*
	 * If the client IP address is specified, use that
	 * else if gateway IP address is specified, use that
	 * else make a temporary arp cache entry for the client's NEW 
	 * IP/hardware address and use that.
	 */
	if(bp->ciaddr.s_addr) {
		faddr = get32 ((uint8 *) &(bp->ciaddr));
	} else {
		faddr = get32 ((uint8 *) &(bp->yiaddr));
		arp_add (faddr, (uint16) bp->htype, bp->chaddr, 0);
	}
	if((buf = qdata (bp, sizeof (struct bootp))) == NULL)
		return;
	pushdown (&buf, NULL,UDPHDR);
	length = sizeof (struct bootp) + UDPHDR;
	cp = buf->data;
	cp = put16 (cp, IPPORT_BOOTPS);		/* Source */
	cp = put16 (cp, IPPORT_BOOTPC);		/* Dest */
	cp = put16 (cp, length);
	*cp++ = 0;
	*cp = 0;
	ip_send (iface->addr, faddr, UDP_PTCL, 0, 0, &buf, length, 0, 0);
};

						