netppp.c

UCOS下添加TCP/IP和PPP协议,实现TCP,UDP点到点等功能.

            st = PPPERR_PARAM;
            break;
        }
    }
    
    return st;
}

/*
 * Return the Maximum Transmission Unit for the given PPP connection.
 */
u_int pppMTU(int pd)
{
    PPPControl *pc = &pppControl[pd];
    u_int st;
    
    /* Validate parameters. */
    if (pd < 0 || pd >= NUM_PPP || !pc->openFlag)
        st = 0;
    else
        st = pc->mtu;
        
    return st;
}

/*
 * Write n characters to a ppp link.
 *  RETURN: >= 0 Number of characters written
 *           -1 Failed to write to device
 */
int pppWrite(int pd, const char *s, int n)
{
    PPPControl *pc = &pppControl[pd];
    short st = 0;
    u_char c;
    u_int fcsOut = PPP_INITFCS;
    NBuf *headMB = NULL, *tailMB;

    nGET(headMB);
    if (headMB == NULL) {
        st = PPPERR_ALLOC;
#if STATS_SUPPORT > 0
        pppStats.PPPoerrors++;
#endif
    } else {
        headMB->len = 0;
        tailMB = headMB;
        
        /* If the link has been idle, we'll send a fresh flag character to
         * flush any noise. */
        if (diffTime(pc->lastXMit) <= MAXIDLEFLAG)
            tailMB = pppMPutRaw(PPP_FLAG, tailMB);
        pc->lastXMit = mtime();
         
        /* Load output buffer. */
        while (n-- > 0) {
            c = *s++;
            
            /* Update FCS before checking for special characters. */
            fcsOut = PPP_FCS(fcsOut, c);
            
            /* Copy to output buffer escaping special characters. */
            tailMB = pppMPutC(c, &pc->outACCM, tailMB);
        }
        
        /* Add FCS and trailing flag. */
        c = ~fcsOut & 0xFF;
        tailMB = pppMPutC(c, &pc->outACCM, tailMB);
        c = (~fcsOut >> 8) & 0xFF;
        tailMB = pppMPutC(c, &pc->outACCM, tailMB);
        tailMB = pppMPutRaw(PPP_FLAG, tailMB);
        
        /* If we failed to complete the packet, throw it away.
         * Otherwise send it. */
        if (tailMB) {
            PPPDEBUG((pppControl[pd].traceOffset + LOG_INFO, TL_PPP,
//                "pppWrite[%d]: %d:%.*H", pd, headMB->len, MIN(headMB->len * 2, 40), headMB->data));
                "pppWrite[%d]: len=%d", pd, headMB->len));
            nPut(pc->fd, headMB);
#if STATS_SUPPORT > 0
            pppStats.PPPopackets++;
#endif
        }
        else {
            PPPDEBUG((pppControl[pd].traceOffset + LOG_WARNING, TL_PPP,
//                "pppWrite[%d]: Alloc err - dropping %d:%.*H", pd, headMB->len, MIN(headMB->len * 2, 40), headMB->data));
                "pppWrite[%d]: Alloc err - dropping nBuf len=%d", pd, headMB->len));
            nFreeChain(headMB);
#if STATS_SUPPORT > 0
            pppStats.PPPoerrors++;
#endif
        }
    }
    
    return st;
}

/*
 * ppp_send_config - configure the transmit characteristics of
 * the ppp interface.
 */
void ppp_send_config(
    int unit, 
    int mtu,
    u_int32_t asyncmap,
    int pcomp, 
    int accomp
)
{
    PPPControl *pc = &pppControl[unit];
    int i;
    
    pc->mtu = mtu;
    pc->pcomp = pcomp;
    pc->accomp = accomp;
    
    /* Load the ACCM bits for the 32 control codes. */
    for (i = 0; i < 32/8; i++)
        pc->outACCM[i] = (u_char)((asyncmap >> (8 * i)) & 0xFF);
    PPPDEBUG((LOG_INFO, TL_PPP, "ppp_send_config[%d]: outACCM=%X %X %X %X",
                unit,
                pc->outACCM[0], pc->outACCM[1], pc->outACCM[2], pc->outACCM[3]));
}


/*
 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
 */
void ppp_set_xaccm(int unit, ext_accm *accm)
{
    memcpy(pppControl[unit].outACCM, accm, sizeof(ext_accm));
    PPPDEBUG((LOG_INFO, TL_PPP, "ppp_set_xaccm[%d]: outACCM=%X %X %X %X",
                unit,
                pppControl[unit].outACCM[0],
                pppControl[unit].outACCM[1],
                pppControl[unit].outACCM[2],
                pppControl[unit].outACCM[3]));
}


/*
 * ppp_recv_config - configure the receive-side characteristics of
 * the ppp interface.
 */
#pragma argsused /* XXX */
void ppp_recv_config(
    int unit, 
    int mru,
    u_int32_t asyncmap,
    int pcomp, 
    int accomp
)
{
    PPPControl *pc = &pppControl[unit];
    int i;
    
    /* Load the ACCM bits for the 32 control codes. */
    for (i = 0; i < 32 / 8; i++)
        pc->inACCM[i] = (u_char)(asyncmap >> (i * 8));
    PPPDEBUG((LOG_INFO, TL_PPP, "ppp_recv_config[%d]: inACCM=%X %X %X %X",
                unit,
                pc->inACCM[0], pc->inACCM[1], pc->inACCM[2], pc->inACCM[3]));
}

/*
 * ccp_test - ask kernel whether a given compression method
 * is acceptable for use.  Returns 1 if the method and parameters
 * are OK, 0 if the method is known but the parameters are not OK
 * (e.g. code size should be reduced), or -1 if the method is unknown.
 */
#pragma argsused
int ccp_test(
    int unit, 
    int opt_len, 
    int for_transmit,
    u_char *opt_ptr
)
{
    return 0;   /* XXX Currently no compression. */
}

/*
 * ccp_flags_set - inform kernel about the current state of CCP.
 */
#pragma argsused
void ccp_flags_set(int unit, int isopen, int isup)
{
    /* XXX */
}

/*
 * ccp_fatal_error - returns 1 if decompression was disabled as a
 * result of an error detected after decompression of a packet,
 * 0 otherwise.  This is necessary because of patent nonsense.
 */
#pragma argsused
int ccp_fatal_error(int unit)
{
    /* XXX */
    return 0;
}

/*
 * get_idle_time - return how long the link has been idle.
 */
#pragma argsused
int get_idle_time(int u, struct ppp_idle *ip)
{   
    /* XXX */
    return 0;
}


/*
 * Return user specified netmask, modified by any mask we might determine
 * for address `addr' (in network byte order).
 * Here we scan through the system's list of interfaces, looking for
 * any non-point-to-point interfaces which might appear to be on the same
 * network as `addr'.  If we find any, we OR in their netmask to the
 * user-specified netmask.
 */
u_int32_t GetMask(u_int32_t addr)
{
    u_int32_t mask, nmask;
    
    htonl(addr);
    if (IN_CLASSA(addr))    /* determine network mask for address class */
        nmask = IN_CLASSA_NET;
    else if (IN_CLASSB(addr))
        nmask = IN_CLASSB_NET;
    else
        nmask = IN_CLASSC_NET;
    /* class D nets are disallowed by bad_ip_adrs */
    mask = netMask | htonl(nmask);
    
    /* XXX
     * Scan through the system's network interfaces.
     * Get each netmask and OR them into our mask.
     */
    
    return mask;
}

/*
 * sifvjcomp - config tcp header compression
 */
#pragma argsused
int sifvjcomp(
    int pd, 
    int vjcomp, 
    int cidcomp, 
    int maxcid
)
{
#if VJ_SUPPORT > 0
    PPPControl *pc = &pppControl[pd];
    
    pc->vjEnabled = vjcomp;
    pc->vjComp.compressSlot = cidcomp;
    pc->vjComp.maxSlotIndex = maxcid;
    PPPDEBUG((LOG_INFO, TL_PPP, "sifvjcomp: VJ compress enable=%d slot=%d max slot=%d",
                vjcomp, cidcomp, maxcid));
#endif

    return 0;
}

/*
 * sifup - Config the interface up and enable IP packets to pass.
 */
#pragma argsused
int sifup(int pd)
{
    PPPControl *pc = &pppControl[pd];
    int st = 1;
    
    if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
        st = 0;
        PPPDEBUG((LOG_WARNING, TL_PPP, "sifup[%d]: bad parms", pd));
    } else {
        pc->if_up = 1;
        pc->errCode = 0;
    }
    return st;
}

/*
 * sifnpmode - Set the mode for handling packets for a given NP.
 */
#pragma argsused
int sifnpmode(int u, int proto, enum NPmode mode)
{
    return 0;
}

/*
 * sifdown - Config the interface down and disable IP.
 */
#pragma argsused
int sifdown(int pd)
{
    PPPControl *pc = &pppControl[pd];
    int st = 1;
    
    if (pd < 0 || pd >= NUM_PPP || !pc->openFlag) {
        st = 0;
        PPPDEBUG((LOG_WARNING, TL_PPP, "sifdown[%d]: bad parms", pd));
    } else
        pc->if_up = 0;
    return st;
}

/*
 * sifaddr - Config the interface IP addresses and netmask.
 */
#pragma argsused
int sifaddr(
    int u,              /* Interface unit ??? */
    u_int32_t o,        /* Our IP address ??? */
    u_int32_t h,        /* IP subnet mask ??? */
    u_int32_t m         /* IP broadcast address ??? */
)
{
    return 1;
}

/*
 * cifaddr - Clear the interface IP addresses, and delete routes
 * through the interface if possible.
 */
#pragma argsused
int cifaddr(
    int u,          /* Interface unit ??? */
    u_int32_t o,    /* Our IP address ??? */
    u_int32_t h     /* IP broadcast address ??? */
)
{
    return 1;
}

/*
 * sifdefaultroute - assign a default route through the address given.
 */
#pragma argsused
int sifdefaultroute(int u, u_int32_t l, u_int32_t g)
{
    ipSetDefault(l, g, IFT_PPP, u);
    return !0;
}

/*
 * cifdefaultroute - delete a default route through the address given.
 */
#pragma argsused
int cifdefaultroute(int u, u_int32_t l, u_int32_t g)
{
    ipClearDefault();
    return !0;
}

/**********************************/
/*** LOCAL FUNCTION DEFINITIONS ***/
/**********************************/
/* The main PPP process function.  This implements the state machine according
 * to section 4 of RFC 1661: The Point-To-Point Protocol. */
static void pppMain(void *pd)
{
    PPPControl* pc = &pppControl[(int)pd];
    NBuf* curNBuf = NULL;
    
    /*
     * Start the connection and handle incoming events (packet or timeout).
     */
//    trace(LOG_NOTICE, "Connecting %s <--> %s", pc->ifname, nameForDevice(pc->fd));
    lcp_lowerup((int)pd);
    lcp_open((int)pd);      /* Start protocol */
    while (lcp_phase[(int)pd] != PHASE_DEAD) {
        if (pc->kill_link) {
            /* This will leave us at PHASE_DEAD. */
            lcp_close(0, "User request");
            pc->kill_link = 0;
        }