discovery.c

PPPoE协议在Psos中的实现源代码

/***********************************************************************
*
* discovery.c
*
* Perform PPPoE discovery
*
* Copyright (C) 1999 by Roaring Penguin Software Inc.
*
* LIC: GPL
*
***********************************************************************/

#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <pna.h>
#include <tmlib/dprintf.h>
#include <ppp.h>

#include "syslog.h"
#include "pppoe.h"

#define BCOPY(p0, p1, n) memmove (p1, p0, n)

extern u_char outpacket_buf[];
extern char BroadcastAddr[6];

int parsePacket(PPPoEPacket *packet, ParseFunc *func, void *extra);
static void padi_timeout(caddr_t arg);
static void padr_timeout(caddr_t arg);

/**********************************************************************
*%FUNCTION: parsePADOTags
*%ARGUMENTS:
* type -- tag type
* len -- tag length
* data -- tag data
* extra -- extra user data.  Should point to a PacketCriteria structure
*          which gets filled in according to selected AC name and service
*          name.
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Picks interesting tags out of a PADO packet
***********************************************************************/
void
parsePADOTags(UINT16_t type, UINT16_t len, unsigned char *data,
	      void *extra)
{
    struct PacketCriteria *pc = (struct PacketCriteria *) extra;
    PPPoEConnection *conn = pc->conn;
    int i;

    switch(type) {
    case TAG_AC_NAME:
	pc->seenACName = 1;
	if (conn->printACNames) {
	    printf("Access-Concentrator: %.*s\n", (int) len, data);
	}
	syslog(LOG_DEBUG, "PADO: AC-Name: '%.*s'", (int) len, data);
	if (conn->acName && len == strlen(conn->acName) &&
	    !strncmp((char *) data, conn->acName, len)) {
	    pc->acNameOK = 1;
	}
	break;
    case TAG_SERVICE_NAME:
	pc->seenServiceName = 1;
	if (conn->printACNames && len > 0) {
	    printf("       Service-Name: %.*s\n", (int) len, data);
	}
	syslog(LOG_DEBUG, "PADO: Service-Name: '%.*s'", (int) len, data);
	if (conn->serviceName && len == strlen(conn->serviceName) &&
	    !strncmp((char *) data, conn->serviceName, len)) {
	    pc->serviceNameOK = 1;
	}
	break;
    case TAG_AC_COOKIE:
	if (conn->printACNames) {
	    printf("Got a cookie:");
	    /* Print first 20 bytes of cookie */
	    for (i=0; i<len && i < 20; i++) {
		printf(" %02x", (unsigned) data[i]);
	    }
	    if (i < len) printf("...");
	    printf("\n");
	}
	conn->cookie.type = htons(type);
	conn->cookie.length = htons(len);
	memcpy(conn->cookie.payload, data, len);
	break;
    case TAG_RELAY_SESSION_ID:
	if (conn->printACNames) {
	    printf("Got a Relay-ID:");
	    /* Print first 20 bytes of relay ID */
	    for (i=0; i<len && i < 20; i++) {
		printf(" %02x", (unsigned) data[i]);
	    }
	    if (i < len) printf("...");
	    printf("\n");
	}
	conn->relayId.type = htons(type);
	conn->relayId.length = htons(len);
	memcpy(conn->relayId.payload, data, len);
	break;
    case TAG_SERVICE_NAME_ERROR:
	if (conn->printACNames) {
	    printf("Got a Service-Name-Error tag: %.*s\n", (int) len, data);
	} else {
	    syslog(LOG_ERR, "PADO: Service-Name-Error: %.*s", (int) len, data);
	    exit(1);
	}
	break;
    case TAG_AC_SYSTEM_ERROR:
	if (conn->printACNames) {
	    printf("Got a System-Error tag: %.*s\n", (int) len, data);
	} else {
	    syslog(LOG_ERR, "PADO: System-Error: %.*s", (int) len, data);
	    exit(1);
	}
	break;
    case TAG_GENERIC_ERROR:
	if (conn->printACNames) {
	    printf("Got a Generic-Error tag: %.*s\n", (int) len, data);
	} else {
	    syslog(LOG_ERR, "PADO: Generic-Error: %.*s", (int) len, data);
	    exit(1);
	}
	break;
    }
}

/**********************************************************************
*%FUNCTION: parsePADSTags
*%ARGUMENTS:
* type -- tag type
* len -- tag length
* data -- tag data
* extra -- extra user data (pointer to PPPoEConnection structure)
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Picks interesting tags out of a PADS packet
***********************************************************************/
void
parsePADSTags(UINT16_t type, UINT16_t len, unsigned char *data,
	      void *extra)
{
    PPPoEConnection *conn = (PPPoEConnection *) extra;
    switch(type) {
    case TAG_SERVICE_NAME:
	syslog(LOG_DEBUG, "PADS: Service-Name: '%.*s'", (int) len, data);
	break;
    case TAG_SERVICE_NAME_ERROR:
	syslog(LOG_ERR, "PADS: Service-Name-Error: %.*s", (int) len, data);
	exit(1);
    case TAG_AC_SYSTEM_ERROR:
	syslog(LOG_ERR, "PADS: System-Error: %.*s", (int) len, data);
	exit(1);
    case TAG_GENERIC_ERROR:
	syslog(LOG_ERR, "PADS: Generic-Error: %.*s", (int) len, data);
	exit(1);
    case TAG_RELAY_SESSION_ID:
	conn->relayId.type = htons(type);
	conn->relayId.length = htons(len);
	memcpy(conn->relayId.payload, data, len);
	break;
    }
}

/*Parse PADT packet*/
void
parseLogErrs(UINT16_t type, UINT16_t len, unsigned char *data, void *extra)
{
    switch(type) {
    case TAG_SERVICE_NAME_ERROR:
	syslog(LOG_ERR, "PADT: Service-Name-Error: %.*s", (int) len, data);
	break;
    case TAG_AC_SYSTEM_ERROR:
	syslog(LOG_ERR, "PADT: System-Error: %.*s", (int) len, data);
	break;
    case TAG_GENERIC_ERROR:
	syslog(LOG_ERR, "PADT: Generic-Error: %.*s", (int) len, data);
	break;
    }
}
/***********************************************************************
*%FUNCTION: sendPADI
*%ARGUMENTS:
* conn -- PPPoEConnection structure
*%RETURNS:
* Nothing
*%DESCRIPTION:
* Sends a PADI packet
***********************************************************************/
void
sendPADI(PPPoEConnection *conn)
{
    
    UINT16_t namelen = 0;
    UINT16_t plen;
    u_char *outp = outpacket_buf;
    int tm,i;
    
    if (conn->serviceName) {
	namelen = (UINT16_t) strlen(conn->serviceName);
    }
    plen = TAG_HDR_SIZE + namelen;
    
    tm = PADI_TIMEOUT;
    for(i=0;i<conn->padi_trans;i++) tm = tm*2;
      
    PUTSHORT(ETH_PPPOE_DISCOVERY, outp);
    PUTCHAR(0x11,outp); 
    PUTCHAR(CODE_PADI, outp);
    PUTSHORT(0, outp);
    PUTSHORT(plen, outp);
    PUTSHORT(TAG_SERVICE_NAME, outp);
    PUTSHORT(namelen, outp);
    if (conn->serviceName) {
	BCOPY(conn->serviceName, outp, namelen);
    }
    output( BroadcastAddr, 0, outpacket_buf, plen+8 );

    TIMEOUT(padi_timeout, (caddr_t)(conn), tm);
    ++conn->padi_trans;
    conn->discoveryState = STATE_SENT_PADI;
    syslog(LOG_INFO, "send PADI: Sent code %d .", CODE_PADI);
    
}

/***********************************************************************
*%FUNCTION: recvPADO
*%ARGUMENTS:   *conn -- PPPoEConnection structure
*%RETURNS:      Nothing
*%DESCRIPTION:  Receive a PADO packet
***********************************************************************/
void
recvPADO(PPPoEConnection *conn, unsigned char *ptr, unsigned int num)
{
    PPPoEPacket *packet;
    struct PacketCriteria pc;
    
    pc.conn          = conn;
    pc.acNameOK      = (conn->acName)      ? 0 : 1;
    pc.serviceNameOK = (conn->serviceName) ? 0 : 1;
    pc.seenACName    = 0;
    pc.seenServiceName = 0;
    
    packet = (PPPoEPacket *)ptr;
    
    if (ntohs(packet->length) + HDR_SIZE > num) {
	    syslog(LOG_ERR, "Bogus PPPoE length field (%u)", (unsigned int) ntohs(packet->length));
	    goto error;
    }
    
    if (memcmp(packet->h_dest, conn->myEth, ETH_ALEN)) {
    	    syslog(LOG_ERR, "This packet is not for me !");
    	    goto error;
    } 
    
    if (NOT_UNICAST(packet->h_source)) {
    	    syslog(LOG_ERR, "This packet is not unicast !");
    	    goto error;	  
    }
    
    parsePacket(packet, parsePADOTags, &pc);
    
    if (!pc.seenACName) {
	    syslog(LOG_ERR, "Ignoring PADO packet with no AC-Name tag !");
    	    goto error;	  	
    }
    if (!pc.seenServiceName) {
	    syslog(LOG_ERR, "Ignoring PADO packet with no Service-Name tag !");
    	    goto error;	  		
    }
    
    conn->numPADOs++;
    if (pc.acNameOK && pc.serviceNameOK) {
	    memcpy(conn->peerEth, packet->h_source, ETH_ALEN);
	    if (conn->printACNames) {
		    printf("AC-Ethernet-Address: %02x:%02x:%02x:%02x:%02x:%02x\n",
			   (unsigned) conn->peerEth[0],
			   (unsigned) conn->peerEth[1],