自学教程：C++ DifferentialChecksum函数代码示例

intAliasHandlePptpGreOut(struct ip *pip){    GreHdr		*gr;    struct alias_link	*link;    gr = (GreHdr *)((char *)pip + (pip->ip_hl << 2));    /* Check GRE header bits. */    if ((ntohl(*((u_int32_t *)gr)) & PPTP_INIT_MASK) != PPTP_INIT_VALUE)	return (-1);    link = FindPptpOutByPeerCallId(pip->ip_src, pip->ip_dst, gr->gh_call_id);    if (link != NULL) {	struct in_addr alias_addr = GetAliasAddress(link);	/* Change source IP address. */	DifferentialChecksum(&pip->ip_sum,			     (u_short *)&alias_addr,			     (u_short *)&pip->ip_src,			     2);	pip->ip_src = alias_addr;    }    return (0);}

static intProtoAliasOut(struct libalias *la, struct in_addr *ip_src,     struct in_addr ip_dst, u_char ip_p, u_short *ip_sum, int create){/*  Handle outgoing IP packets. The  only thing which is done in this case is to alias  the source IP address of the packet.*/	struct alias_link *lnk;	LIBALIAS_LOCK_ASSERT(la);	(void)create;/* Return if proxy-only mode is enabled */	if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)		return (PKT_ALIAS_OK);	lnk = FindProtoOut(la, *ip_src, ip_dst, ip_p);	if (lnk != NULL) {		struct in_addr alias_address;		alias_address = GetAliasAddress(lnk);/* Change source address */		DifferentialChecksum(ip_sum,		    &alias_address, ip_src, 2);		*ip_src = alias_address;		return (PKT_ALIAS_OK);	}	return (PKT_ALIAS_IGNORED);}

static intProtoAliasIn(struct libalias *la, struct in_addr ip_src,     struct in_addr *ip_dst, u_char ip_p, u_short *ip_sum){/*  Handle incoming IP packets. The  only thing which is done in this case is to alias  the dest IP address of the packet to our inside  machine.*/	struct alias_link *lnk;	LIBALIAS_LOCK_ASSERT(la);/* Return if proxy-only mode is enabled */	if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)		return (PKT_ALIAS_OK);	lnk = FindProtoIn(la, ip_src, *ip_dst, ip_p);	if (lnk != NULL) {		struct in_addr original_address;		original_address = GetOriginalAddress(lnk);/* Restore original IP address */		DifferentialChecksum(ip_sum,		    &original_address, ip_dst, 2);		*ip_dst = original_address;		return (PKT_ALIAS_OK);	}	return (PKT_ALIAS_IGNORED);}

static intProtoAliasIn(struct ip *pip){/*  Handle incoming IP packets. The  only thing which is done in this case is to alias  the dest IP address of the packet to our inside  machine.*/    struct alias_link *link;/* Return if proxy-only mode is enabled */    if (packetAliasMode & PKT_ALIAS_PROXY_ONLY)        return PKT_ALIAS_OK;    link = FindProtoIn(pip->ip_src, pip->ip_dst, pip->ip_p);    if (link != NULL)    {        struct in_addr original_address;        original_address = GetOriginalAddress(link);/* Restore original IP address */        DifferentialChecksum(&pip->ip_sum,                             (u_short *) &original_address,                             (u_short *) &pip->ip_dst,                             2);        pip->ip_dst = original_address;	return(PKT_ALIAS_OK);    }    return(PKT_ALIAS_IGNORED);}

static intProtoAliasOut(struct ip *pip){/*  Handle outgoing IP packets. The  only thing which is done in this case is to alias  the source IP address of the packet.*/    struct alias_link *link;/* Return if proxy-only mode is enabled */    if (packetAliasMode & PKT_ALIAS_PROXY_ONLY)        return PKT_ALIAS_OK;    link = FindProtoOut(pip->ip_src, pip->ip_dst, pip->ip_p);    if (link != NULL)    {        struct in_addr alias_address;        alias_address = GetAliasAddress(link);/* Change source address */        DifferentialChecksum(&pip->ip_sum,                             (u_short *) &alias_address,                             (u_short *) &pip->ip_src,                             2);        pip->ip_src = alias_address;        return(PKT_ALIAS_OK);    }    return(PKT_ALIAS_IGNORED);}

static intUdpAliasOut(struct libalias *la, struct ip *pip, int create){    struct udphdr *ud;    struct alias_link *lnk;    int error;    LIBALIAS_LOCK_ASSERT(la);/* Return if proxy-only mode is enabled */    if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)        return (PKT_ALIAS_OK);    ud = (struct udphdr *)ip_next(pip);    lnk = FindUdpTcpOut(la, pip->ip_src, pip->ip_dst,        ud->uh_sport, ud->uh_dport,        IPPROTO_UDP, create);    if (lnk != NULL) {        u_short alias_port;        struct in_addr alias_address;        struct alias_data ad;        ad.lnk = lnk;        ad.oaddr = NULL;        ad.aaddr = &alias_address;        ad.aport = &alias_port;        ad.sport = &ud->uh_sport;        ad.dport = &ud->uh_dport;        ad.maxpktsize = 0;        alias_address = GetAliasAddress(lnk);        alias_port = GetAliasPort(lnk);        /* Walk out chain. */        error = find_handler(OUT, UDP, la, pip, &ad);/* If UDP checksum is not zero, adjust since source port is *//* being aliased and source address is being altered        */        if (ud->uh_sum != 0) {            int accumulate;            accumulate = ud->uh_sport;            accumulate -= alias_port;            accumulate += twowords(&pip->ip_src);            accumulate -= twowords(&alias_address);            ADJUST_CHECKSUM(accumulate, ud->uh_sum);        }/* Put alias port in UDP header */        ud->uh_sport = alias_port;/* Change source address */        DifferentialChecksum(&pip->ip_sum,            &alias_address, &pip->ip_src, 2);        pip->ip_src = alias_address;        return (PKT_ALIAS_OK);    }    return (PKT_ALIAS_IGNORED);}

static intFragmentOut(struct libalias *la, struct ip *pip){    struct in_addr alias_address;    LIBALIAS_LOCK_ASSERT(la);    alias_address = FindAliasAddress(la, pip->ip_src);    DifferentialChecksum(&pip->ip_sum,        &alias_address, &pip->ip_src, 2);    pip->ip_src = alias_address;    return (PKT_ALIAS_OK);}

static intFragmentOut(struct ip *pip){    struct in_addr alias_address;    alias_address = FindAliasAddress(pip->ip_src);    DifferentialChecksum(&pip->ip_sum,                         (u_short *) &alias_address,                         (u_short *) &pip->ip_src,                          2);    pip->ip_src = alias_address;    return(PKT_ALIAS_OK);}

static intIcmpAliasOut1(struct ip *pip){/*    Alias outgoing echo and timestamp requests.    De-alias outgoing echo and timestamp replies.*/    struct alias_link *link;    struct icmp *ic;    ic = (struct icmp *) ((char *) pip + (pip->ip_hl << 2));/* Save overwritten data for when echo packet returns */    link = FindIcmpOut(pip->ip_src, pip->ip_dst, ic->icmp_id, 1);    if (link != NULL)    {        u_short alias_id;        int accumulate;        alias_id = GetAliasPort(link);/* Since data field is being modified, adjust ICMP checksum */        accumulate  = ic->icmp_id;        accumulate -= alias_id;        ADJUST_CHECKSUM(accumulate, ic->icmp_cksum);/* Alias sequence number */        ic->icmp_id = alias_id;/* Change source address */        {            struct in_addr alias_address;            alias_address = GetAliasAddress(link);            DifferentialChecksum(&pip->ip_sum,                                 (u_short *) &alias_address,                                 (u_short *) &pip->ip_src,                                 2);            pip->ip_src = alias_address;        }        return(PKT_ALIAS_OK);    }    return(PKT_ALIAS_IGNORED);}

static intIcmpAliasIn1(struct libalias *la, struct ip *pip){/*    De-alias incoming echo and timestamp replies.    Alias incoming echo and timestamp requests.*/    struct alias_link *lnk;    struct icmp *ic;    LIBALIAS_LOCK_ASSERT(la);    ic = (struct icmp *)ip_next(pip);/* Get source address from ICMP data field and restore original data */    lnk = FindIcmpIn(la, pip->ip_src, pip->ip_dst, ic->icmp_id, 1);    if (lnk != NULL) {        u_short original_id;        int accumulate;        original_id = GetOriginalPort(lnk);/* Adjust ICMP checksum */        accumulate = ic->icmp_id;        accumulate -= original_id;        ADJUST_CHECKSUM(accumulate, ic->icmp_cksum);/* Put original sequence number back in */        ic->icmp_id = original_id;/* Put original address back into IP header */        {            struct in_addr original_address;            original_address = GetOriginalAddress(lnk);            DifferentialChecksum(&pip->ip_sum,                &original_address, &pip->ip_dst, 2);            pip->ip_dst = original_address;        }        return (PKT_ALIAS_OK);    }    return (PKT_ALIAS_IGNORED);}

static intFragmentIn(struct libalias *la, struct ip *pip){    struct alias_link *lnk;    LIBALIAS_LOCK_ASSERT(la);    lnk = FindFragmentIn2(la, pip->ip_src, pip->ip_dst, pip->ip_id);    if (lnk != NULL) {        struct in_addr original_address;        GetFragmentAddr(lnk, &original_address);        DifferentialChecksum(&pip->ip_sum,            &original_address, &pip->ip_dst, 2);        pip->ip_dst = original_address;        return (PKT_ALIAS_OK);    }    return (PKT_ALIAS_UNRESOLVED_FRAGMENT);}

voidPacketAliasFragmentIn(char *ptr,          /* Points to correctly de-aliased                                             header fragment */                      char *ptr_fragment  /* Points to fragment which must                                             be de-aliased   */                     ){    struct ip *pip;    struct ip *fpip;    pip = (struct ip *) ptr;    fpip = (struct ip *) ptr_fragment;    DifferentialChecksum(&fpip->ip_sum,                         (u_short *) &pip->ip_dst,                         (u_short *) &fpip->ip_dst,                         2);    fpip->ip_dst = pip->ip_dst;}

voidLibAliasFragmentIn(struct libalias *la, char *ptr,  /* Points to correctly                             * de-aliased header                             * fragment */    char *ptr_fragment      /* Points to fragment which must be                 * de-aliased   */){    struct ip *pip;    struct ip *fpip;    LIBALIAS_LOCK(la);    (void)la;    pip = (struct ip *)ptr;    fpip = (struct ip *)ptr_fragment;    DifferentialChecksum(&fpip->ip_sum,        &pip->ip_dst, &fpip->ip_dst, 2);    fpip->ip_dst = pip->ip_dst;    LIBALIAS_UNLOCK(la);}

static intFragmentIn(struct ip *pip){    struct alias_link *link;    link = FindFragmentIn2(pip->ip_src, pip->ip_dst, pip->ip_id);    if (link != NULL)    {        struct in_addr original_address;        GetFragmentAddr(link, &original_address);        DifferentialChecksum(&pip->ip_sum,                             (u_short *) &original_address,                             (u_short *) &pip->ip_dst,                             2);        pip->ip_dst = original_address;            return(PKT_ALIAS_OK);    }    return(PKT_ALIAS_UNRESOLVED_FRAGMENT);}

//.........这里部分代码省略.........#ifdef LIBALIAS_DEBUG                        fprintf(stderr,                                "PacketAlias/RTSP: Cannot find contiguous RTSP data ports/n");#endif                    } else {                        base_alias = ntohs(salias);                        for (j = 0; j < RTSP_PORT_GROUP; j++) {                            /*                             * Establish link                             * to port found in                             * RTSP packet                             */                            rtsp_lnk = FindRtspOut(la, GetOriginalAddress(lnk), null_addr,                                                   htons(base_port + j), htons(base_alias + j),                                                   IPPROTO_UDP);                            if (rtsp_lnk != NULL) {#ifndef NO_FW_PUNCH                                /*                                 * Punch                                 * hole in                                 * firewall                                 */                                PunchFWHole(rtsp_lnk);#endif                            } else {#ifdef LIBALIAS_DEBUG                                fprintf(stderr,                                        "PacketAlias/RTSP: Cannot allocate RTSP data ports/n");#endif                                break;                            }                        }                    }                    ealias = htons(base_alias + (RTSP_PORT_GROUP - 1));                }                if (salias && rtsp_lnk) {                    pkt_updated = 1;                    /* Copy into IP packet */                    sprintf(stemp, "%d", ntohs(salias));                    memcpy(port_newdata, stemp, strlen(stemp));                    port_newdata += strlen(stemp);                    if (eport != 0) {                        *port_newdata = '-';                        port_newdata++;                        /* Copy into IP packet */                        sprintf(stemp, "%d", ntohs(ealias));                        memcpy(port_newdata, stemp, strlen(stemp));                        port_newdata += strlen(stemp);                    }                    *port_newdata = ';';                    port_newdata++;                }                state++;                break;            }            if (state > 3) {                break;            }        }        port_data += i;        port_dlen -= i;    }    if (!pkt_updated)        return (-1);    memcpy(port_newdata, port_data, port_dlen);    port_newdata += port_dlen;    *port_newdata = '/0';    /* Create new packet */    new_dlen = port_newdata - newdata;    memcpy(data, newdata, new_dlen);    SetAckModified(lnk);    tc = (struct tcphdr *)ip_next(pip);    delta = GetDeltaSeqOut(tc->th_seq, lnk);    AddSeq(lnk, delta + new_dlen - dlen, pip->ip_hl, pip->ip_len,           tc->th_seq, tc->th_off);    new_len = htons(hlen + new_dlen);    DifferentialChecksum(&pip->ip_sum,                         &new_len,                         &pip->ip_len,                         1);    pip->ip_len = new_len;    tc->th_sum = 0;#ifdef _KERNEL    tc->th_x2 = 1;#else    tc->th_sum = TcpChecksum(pip);#endif    return (0);}

static intUdpAliasIn(struct libalias *la, struct ip *pip){	struct udphdr *ud;	struct alias_link *lnk;	LIBALIAS_LOCK_ASSERT(la);	ud = (struct udphdr *)ip_next(pip);	lnk = FindUdpTcpIn(la, pip->ip_src, pip->ip_dst,	    ud->uh_sport, ud->uh_dport,	    IPPROTO_UDP, !(la->packetAliasMode & PKT_ALIAS_PROXY_ONLY));	if (lnk != NULL) {		struct in_addr alias_address;		struct in_addr original_address;		struct in_addr proxy_address;		u_short alias_port;		u_short proxy_port;		int accumulate;		int error;		struct alias_data ad = {			.lnk = lnk, 			.oaddr = &original_address, 			.aaddr = &alias_address,			.aport = &alias_port,			.sport = &ud->uh_sport,			.dport = &ud->uh_dport,			.maxpktsize = 0		};		alias_address = GetAliasAddress(lnk);		original_address = GetOriginalAddress(lnk);		proxy_address = GetProxyAddress(lnk);		alias_port = ud->uh_dport;		ud->uh_dport = GetOriginalPort(lnk);		proxy_port = GetProxyPort(lnk);		/* Walk out chain. */				error = find_handler(IN, UDP, la, pip, &ad);		/* If we cannot figure out the packet, ignore it. */		if (error < 0)			return (PKT_ALIAS_IGNORED);/* If UDP checksum is not zero, then adjust since destination port *//* is being unaliased and destination address is being altered.    */		if (ud->uh_sum != 0) {			accumulate = alias_port;			accumulate -= ud->uh_dport;			accumulate += twowords(&alias_address);			accumulate -= twowords(&original_address);/* If this is a proxy packet, modify checksum because of source change.*/        		if (proxy_port != 0) {		                accumulate += ud->uh_sport;		                accumulate -= proxy_port;	                }	                if (proxy_address.s_addr != 0) {				accumulate += twowords(&pip->ip_src);				accumulate -= twowords(&proxy_address);	                }			ADJUST_CHECKSUM(accumulate, ud->uh_sum);		}/* XXX: Could the two if's below be concatenated to one ? *//* Restore source port and/or address in case of proxying*/    		if (proxy_port != 0)        		ud->uh_sport = proxy_port;    		if (proxy_address.s_addr != 0) {        		DifferentialChecksum(&pip->ip_sum,                	    &proxy_address, &pip->ip_src, 2);	        	pip->ip_src = proxy_address;    		}/* Restore original IP address */		DifferentialChecksum(&pip->ip_sum,		    &original_address, &pip->ip_dst, 2);		pip->ip_dst = original_address;		return (PKT_ALIAS_OK);	}	return (PKT_ALIAS_IGNORED);}static intUdpAliasOut(struct libalias *la, struct ip *pip, int maxpacketsize, int create){	struct udphdr *ud;	struct alias_link *lnk;	struct in_addr dest_address;	struct in_addr proxy_server_address;	u_short dest_port;	u_short proxy_server_port;	int proxy_type;	int error;	LIBALIAS_LOCK_ASSERT(la);//.........这里部分代码省略.........

intPacketUnaliasOut(char *ptr,           /* valid IP packet */                 int  maxpacketsize   /* for error checking */                ){    struct ip		*pip;    struct icmp 	*ic;    struct udphdr	*ud;    struct tcphdr 	*tc;    struct alias_link 	*link;    int 		iresult = PKT_ALIAS_IGNORED;    pip = (struct ip *) ptr;    /* Defense against mangled packets */    if (ntohs(pip->ip_len) > maxpacketsize     || (pip->ip_hl<<2) > maxpacketsize)        return(iresult);    ud = (struct udphdr *) ((char *) pip + (pip->ip_hl << 2));    tc = (struct tcphdr *) ud;    ic = (struct icmp *) ud;    /* Find a link */    if (pip->ip_p == IPPROTO_UDP)        link = FindUdpTcpIn(pip->ip_dst, pip->ip_src,                            ud->uh_dport, ud->uh_sport,                            IPPROTO_UDP, 0);    else if (pip->ip_p == IPPROTO_TCP)        link = FindUdpTcpIn(pip->ip_dst, pip->ip_src,                            tc->th_dport, tc->th_sport,                            IPPROTO_TCP, 0);    else if (pip->ip_p == IPPROTO_ICMP)         link = FindIcmpIn(pip->ip_dst, pip->ip_src, ic->icmp_id, 0);    else        link = NULL;    /* Change it from an aliased packet to an unaliased packet */    if (link != NULL)    {        if (pip->ip_p == IPPROTO_UDP || pip->ip_p == IPPROTO_TCP)        {            u_short        *sptr;            int 	   accumulate;            struct in_addr original_address;            u_short        original_port;            original_address = GetOriginalAddress(link);            original_port = GetOriginalPort(link);                /* Adjust TCP/UDP checksum */            sptr = (u_short *) &(pip->ip_src);            accumulate  = *sptr++;            accumulate += *sptr;            sptr = (u_short *) &original_address;            accumulate -= *sptr++;            accumulate -= *sptr;            if (pip->ip_p == IPPROTO_UDP) {                accumulate += ud->uh_sport;                accumulate -= original_port;                ADJUST_CHECKSUM(accumulate, ud->uh_sum);	    } else {                 accumulate += tc->th_sport;                accumulate -= original_port;                ADJUST_CHECKSUM(accumulate, tc->th_sum);	    }            /* Adjust IP checksum */            DifferentialChecksum(&pip->ip_sum,                                 (u_short *) &original_address,                                 (u_short *) &pip->ip_src,                                 2);            /* Un-alias source address and port number */             pip->ip_src = original_address;            if (pip->ip_p == IPPROTO_UDP)                 ud->uh_sport = original_port; 	    else                   tc->th_sport = original_port;             	    iresult = PKT_ALIAS_OK;        } else if (pip->ip_p == IPPROTO_ICMP) {            u_short        *sptr;            int            accumulate;            struct in_addr original_address;            u_short        original_id;            original_address = GetOriginalAddress(link);            original_id = GetOriginalPort(link);            /* Adjust ICMP checksum */            sptr = (u_short *) &(pip->ip_src);            accumulate  = *sptr++;            accumulate += *sptr;            sptr = (u_short *) &original_address;            accumulate -= *sptr++;            accumulate -= *sptr;//.........这里部分代码省略.........

static intUdpAliasOut(struct ip *pip){    struct udphdr *ud;    struct alias_link *link;/* Return if proxy-only mode is enabled */    if (packetAliasMode & PKT_ALIAS_PROXY_ONLY)        return PKT_ALIAS_OK;    ud = (struct udphdr *) ((char *) pip + (pip->ip_hl << 2));    link = FindUdpTcpOut(pip->ip_src, pip->ip_dst,                         ud->uh_sport, ud->uh_dport,                         IPPROTO_UDP, 1);    if (link != NULL)    {        u_short alias_port;        struct in_addr alias_address;        alias_address = GetAliasAddress(link);        alias_port = GetAliasPort(link);/* Special processing for IP encoding protocols */	if (ntohs(ud->uh_dport) == CUSEEME_PORT_NUMBER)	    AliasHandleCUSeeMeOut(pip, link);/* If NETBIOS Datagram, It should be alias address in UDP Data, too */	else if (ntohs(ud->uh_dport) == NETBIOS_DGM_PORT_NUMBER	      || ntohs(ud->uh_sport) == NETBIOS_DGM_PORT_NUMBER)	    AliasHandleUdpNbt(pip, link, &alias_address, alias_port);	else if (ntohs(ud->uh_dport) == NETBIOS_NS_PORT_NUMBER	      || ntohs(ud->uh_sport) == NETBIOS_NS_PORT_NUMBER)	    AliasHandleUdpNbtNS(pip, link, &pip->ip_src, &ud->uh_sport,				&alias_address, &alias_port);/* * We don't know in advance what TID the TFTP server will choose, * so we create a wilcard link (destination port is unspecified) * that will match any TID from a given destination. */	else if (ntohs(ud->uh_dport) == TFTP_PORT_NUMBER)	    FindRtspOut(pip->ip_src, pip->ip_dst,			ud->uh_sport, alias_port, IPPROTO_UDP);/* If UDP checksum is not zero, adjust since source port is *//* being aliased and source address is being altered        */        if (ud->uh_sum != 0)        {            int accumulate;            u_short *sptr;            accumulate  = ud->uh_sport;            accumulate -= alias_port;            sptr = (u_short *) &(pip->ip_src);            accumulate += *sptr++;            accumulate += *sptr;            sptr = (u_short *) &alias_address;            accumulate -= *sptr++;            accumulate -= *sptr;            ADJUST_CHECKSUM(accumulate, ud->uh_sum);        }/* Put alias port in UDP header */        ud->uh_sport = alias_port;/* Change source address */        DifferentialChecksum(&pip->ip_sum,                             (u_short *) &alias_address,                             (u_short *) &pip->ip_src,                             2);        pip->ip_src = alias_address;        return(PKT_ALIAS_OK);    }    return(PKT_ALIAS_IGNORED);}

static intUdpAliasIn(struct ip *pip){    struct udphdr *ud;    struct alias_link *link;/* Return if proxy-only mode is enabled */    if (packetAliasMode & PKT_ALIAS_PROXY_ONLY)        return PKT_ALIAS_OK;    ud = (struct udphdr *) ((char *) pip + (pip->ip_hl << 2));    link = FindUdpTcpIn(pip->ip_src, pip->ip_dst,                        ud->uh_sport, ud->uh_dport,                        IPPROTO_UDP, 1);    if (link != NULL)    {        struct in_addr alias_address;        struct in_addr original_address;        u_short alias_port;        int accumulate;        u_short *sptr;	int r = 0;        alias_address = GetAliasAddress(link);        original_address = GetOriginalAddress(link);        alias_port = ud->uh_dport;        ud->uh_dport = GetOriginalPort(link);/* Special processing for IP encoding protocols */	if (ntohs(ud->uh_dport) == CUSEEME_PORT_NUMBER)	    AliasHandleCUSeeMeIn(pip, original_address);/* If NETBIOS Datagram, It should be alias address in UDP Data, too */	else if (ntohs(ud->uh_dport) == NETBIOS_DGM_PORT_NUMBER	      || ntohs(ud->uh_sport) == NETBIOS_DGM_PORT_NUMBER)	    r = AliasHandleUdpNbt(pip, link, &original_address, ud->uh_dport);	else if (ntohs(ud->uh_dport) == NETBIOS_NS_PORT_NUMBER	      || ntohs(ud->uh_sport) == NETBIOS_NS_PORT_NUMBER)	    r = AliasHandleUdpNbtNS(pip, link, &alias_address, &alias_port,				    &original_address, &ud->uh_dport);/* If UDP checksum is not zero, then adjust since destination port *//* is being unaliased and destination address is being altered.    */        if (ud->uh_sum != 0)        {            accumulate  = alias_port;            accumulate -= ud->uh_dport;            sptr = (u_short *) &alias_address;            accumulate += *sptr++;            accumulate += *sptr;            sptr = (u_short *) &original_address;            accumulate -= *sptr++;            accumulate -= *sptr;            ADJUST_CHECKSUM(accumulate, ud->uh_sum);        }/* Restore original IP address */        DifferentialChecksum(&pip->ip_sum,                             (u_short *) &original_address,                             (u_short *) &pip->ip_dst,                             2);        pip->ip_dst = original_address;	/*	 * If we cannot figure out the packet, ignore it.	 */	if (r < 0)	    return(PKT_ALIAS_IGNORED);	else	    return(PKT_ALIAS_OK);    }    return(PKT_ALIAS_IGNORED);}

static intIcmpAliasOut2(struct libalias *la, struct ip *pip){/*    Alias outgoing ICMP error messages containing    IP header and first 64 bits of datagram.*/	struct ip *ip;	struct icmp *ic, *ic2;	struct udphdr *ud;	struct tcphdr *tc;	struct alias_link *lnk;	LIBALIAS_LOCK_ASSERT(la);	ic = (struct icmp *)ip_next(pip);	ip = &ic->icmp_ip;	ud = (struct udphdr *)ip_next(ip);	tc = (struct tcphdr *)ip_next(ip);	ic2 = (struct icmp *)ip_next(ip);	if (ip->ip_p == IPPROTO_UDP)		lnk = FindUdpTcpOut(la, ip->ip_dst, ip->ip_src,		    ud->uh_dport, ud->uh_sport,		    IPPROTO_UDP, 0);	else if (ip->ip_p == IPPROTO_TCP)		lnk = FindUdpTcpOut(la, ip->ip_dst, ip->ip_src,		    tc->th_dport, tc->th_sport,		    IPPROTO_TCP, 0);	else if (ip->ip_p == IPPROTO_ICMP) {		if (ic2->icmp_type == ICMP_ECHO || ic2->icmp_type == ICMP_TSTAMP)			lnk = FindIcmpOut(la, ip->ip_dst, ip->ip_src, ic2->icmp_id, 0);		else			lnk = NULL;	} else		lnk = NULL;	if (lnk != NULL) {		if (ip->ip_p == IPPROTO_UDP || ip->ip_p == IPPROTO_TCP) {			int accumulate;			struct in_addr alias_address;			u_short alias_port;			alias_address = GetAliasAddress(lnk);			alias_port = GetAliasPort(lnk);/* Adjust ICMP checksum */			accumulate = twowords(&ip->ip_dst);			accumulate -= twowords(&alias_address);			accumulate += ud->uh_dport;			accumulate -= alias_port;			ADJUST_CHECKSUM(accumulate, ic->icmp_cksum);/* * Alias address in IP header if it comes from the host * the original TCP/UDP packet was destined for. */			if (pip->ip_src.s_addr == ip->ip_dst.s_addr) {				DifferentialChecksum(&pip->ip_sum,				    &alias_address, &pip->ip_src, 2);				pip->ip_src = alias_address;			}/* Alias address and port number of original IP packetfragment contained in ICMP data section */			ip->ip_dst = alias_address;			ud->uh_dport = alias_port;		} else if (ip->ip_p == IPPROTO_ICMP) {			int accumulate;			struct in_addr alias_address;			u_short alias_id;			alias_address = GetAliasAddress(lnk);			alias_id = GetAliasPort(lnk);/* Adjust ICMP checksum */			accumulate = twowords(&ip->ip_dst);			accumulate -= twowords(&alias_address);			accumulate += ic2->icmp_id;			accumulate -= alias_id;			ADJUST_CHECKSUM(accumulate, ic->icmp_cksum);/* * Alias address in IP header if it comes from the host * the original ICMP message was destined for. */			if (pip->ip_src.s_addr == ip->ip_dst.s_addr) {				DifferentialChecksum(&pip->ip_sum,				    &alias_address, &pip->ip_src, 2);				pip->ip_src = alias_address;			}/* Alias address of original IP packet and sequence number of   embedded ICMP datagram */			ip->ip_dst = alias_address;			ic2->icmp_id = alias_id;		}		return (PKT_ALIAS_OK);	}	return (PKT_ALIAS_IGNORED);}

static intIcmpAliasIn2(struct libalias *la, struct ip *pip){	LIBALIAS_LOCK_ASSERT(la);/*    Alias incoming ICMP error messages containing    IP header and first 64 bits of datagram.*/	struct ip *ip;	struct icmp *ic, *ic2;	struct udphdr *ud;	struct tcphdr *tc;	struct alias_link *lnk;	ic = (struct icmp *)ip_next(pip);	ip = &ic->icmp_ip;	ud = (struct udphdr *)ip_next(ip);	tc = (struct tcphdr *)ip_next(ip);	ic2 = (struct icmp *)ip_next(ip);	if (ip->ip_p == IPPROTO_UDP)		lnk = FindUdpTcpIn(la, ip->ip_dst, ip->ip_src,		    ud->uh_dport, ud->uh_sport,		    IPPROTO_UDP, 0);	else if (ip->ip_p == IPPROTO_TCP)		lnk = FindUdpTcpIn(la, ip->ip_dst, ip->ip_src,		    tc->th_dport, tc->th_sport,		    IPPROTO_TCP, 0);	else if (ip->ip_p == IPPROTO_ICMP) {		if (ic2->icmp_type == ICMP_ECHO || ic2->icmp_type == ICMP_TSTAMP)			lnk = FindIcmpIn(la, ip->ip_dst, ip->ip_src, ic2->icmp_id, 0);		else			lnk = NULL;	} else		lnk = NULL;	if (lnk != NULL) {		if (ip->ip_p == IPPROTO_UDP || ip->ip_p == IPPROTO_TCP) {			int accumulate, accumulate2;			struct in_addr original_address;			u_short original_port;			original_address = GetOriginalAddress(lnk);			original_port = GetOriginalPort(lnk);/* Adjust ICMP checksum */			accumulate = twowords(&ip->ip_src);			accumulate -= twowords(&original_address);			accumulate += ud->uh_sport;			accumulate -= original_port;			accumulate2 = accumulate;			accumulate2 += ip->ip_sum;			ADJUST_CHECKSUM(accumulate, ip->ip_sum);			accumulate2 -= ip->ip_sum;			ADJUST_CHECKSUM(accumulate2, ic->icmp_cksum);/* Un-alias address in IP header */			DifferentialChecksum(&pip->ip_sum,			    &original_address, &pip->ip_dst, 2);			pip->ip_dst = original_address;/* Un-alias address and port number of original IP packetfragment contained in ICMP data section */			ip->ip_src = original_address;			ud->uh_sport = original_port;		} else if (ip->ip_p == IPPROTO_ICMP) {			int accumulate, accumulate2;			struct in_addr original_address;			u_short original_id;			original_address = GetOriginalAddress(lnk);			original_id = GetOriginalPort(lnk);/* Adjust ICMP checksum */			accumulate = twowords(&ip->ip_src);			accumulate -= twowords(&original_address);			accumulate += ic2->icmp_id;			accumulate -= original_id;			accumulate2 = accumulate;			accumulate2 += ip->ip_sum;			ADJUST_CHECKSUM(accumulate, ip->ip_sum);			accumulate2 -= ip->ip_sum;			ADJUST_CHECKSUM(accumulate2, ic->icmp_cksum);/* Un-alias address in IP header */			DifferentialChecksum(&pip->ip_sum,			    &original_address, &pip->ip_dst, 2);			pip->ip_dst = original_address;/* Un-alias address of original IP packet and sequence number of   embedded ICMP datagram */			ip->ip_src = original_address;			ic2->icmp_id = original_id;		}		return (PKT_ALIAS_OK);	}	return (PKT_ALIAS_IGNORED);}

intLibAliasUnaliasOut(struct libalias *la, char *ptr,	/* valid IP packet */    int maxpacketsize		/* for error checking */){	struct ip *pip;	struct icmp *ic;	struct udphdr *ud;	struct tcphdr *tc;	struct alias_link *lnk;	int iresult = PKT_ALIAS_IGNORED;	LIBALIAS_LOCK(la);	pip = (struct ip *)ptr;	/* Defense against mangled packets */	if (ntohs(pip->ip_len) > maxpacketsize	    || (pip->ip_hl << 2) > maxpacketsize)		goto getout;	ud = (struct udphdr *)ip_next(pip);	tc = (struct tcphdr *)ip_next(pip);	ic = (struct icmp *)ip_next(pip);	/* Find a link */	if (pip->ip_p == IPPROTO_UDP)		lnk = FindUdpTcpIn(la, pip->ip_dst, pip->ip_src,		    ud->uh_dport, ud->uh_sport,		    IPPROTO_UDP, 0);	else if (pip->ip_p == IPPROTO_TCP)		lnk = FindUdpTcpIn(la, pip->ip_dst, pip->ip_src,		    tc->th_dport, tc->th_sport,		    IPPROTO_TCP, 0);	else if (pip->ip_p == IPPROTO_ICMP)		lnk = FindIcmpIn(la, pip->ip_dst, pip->ip_src, ic->icmp_id, 0);	else		lnk = NULL;	/* Change it from an aliased packet to an unaliased packet */	if (lnk != NULL) {		if (pip->ip_p == IPPROTO_UDP || pip->ip_p == IPPROTO_TCP) {			int accumulate;			struct in_addr original_address;			u_short original_port;			original_address = GetOriginalAddress(lnk);			original_port = GetOriginalPort(lnk);			/* Adjust TCP/UDP checksum */			accumulate = twowords(&pip->ip_src);			accumulate -= twowords(&original_address);			if (pip->ip_p == IPPROTO_UDP) {				accumulate += ud->uh_sport;				accumulate -= original_port;				ADJUST_CHECKSUM(accumulate, ud->uh_sum);			} else {				accumulate += tc->th_sport;				accumulate -= original_port;				ADJUST_CHECKSUM(accumulate, tc->th_sum);			}			/* Adjust IP checksum */			DifferentialChecksum(&pip->ip_sum,			    &original_address, &pip->ip_src, 2);			/* Un-alias source address and port number */			pip->ip_src = original_address;			if (pip->ip_p == IPPROTO_UDP)				ud->uh_sport = original_port;			else				tc->th_sport = original_port;			iresult = PKT_ALIAS_OK;		} else if (pip->ip_p == IPPROTO_ICMP) {			int accumulate;			struct in_addr original_address;			u_short original_id;			original_address = GetOriginalAddress(lnk);			original_id = GetOriginalPort(lnk);			/* Adjust ICMP checksum */			accumulate = twowords(&pip->ip_src);			accumulate -= twowords(&original_address);			accumulate += ic->icmp_id;			accumulate -= original_id;			ADJUST_CHECKSUM(accumulate, ic->icmp_cksum);			/* Adjust IP checksum */			DifferentialChecksum(&pip->ip_sum,			    &original_address, &pip->ip_src, 2);			/* Un-alias source address and port number */			pip->ip_src = original_address;			ic->icmp_id = original_id;			iresult = PKT_ALIAS_OK;//.........这里部分代码省略.........

//.........这里部分代码省略.........			    true_port, 0,			    IPPROTO_TCP, 1);			DBprintf(("Got a DCC link/n"));			if (dcc_lnk) {				struct in_addr alias_address;	/* Address from aliasing */				u_short alias_port;	/* Port given by							 * aliasing */				int n;#ifndef NO_FW_PUNCH				/* Generate firewall hole as appropriate */				PunchFWHole(dcc_lnk);#endif				alias_address = GetAliasAddress(lnk);				n = snprintf(&newpacket[iCopy],				    sizeof(newpacket) - iCopy,				    "%lu ", (u_long) htonl(alias_address.s_addr));				if (n < 0) {					DBprintf(("DCC packet construct failure./n"));					goto lBAD_CTCP;				}				if ((iCopy += n) >= sizeof(newpacket)) {	/* Truncated/fit exactly										 * - bad news */					DBprintf(("DCC constructed packet overflow./n"));					goto lBAD_CTCP;				}				alias_port = GetAliasPort(dcc_lnk);				n = snprintf(&newpacket[iCopy],				    sizeof(newpacket) - iCopy,				    "%u", htons(alias_port));				if (n < 0) {					DBprintf(("DCC packet construct failure./n"));					goto lBAD_CTCP;				}				iCopy += n;				/*				 * Done - truncated cases will be taken				 * care of by lBAD_CTCP				 */				DBprintf(("Aliased IP %lu and port %u/n", alias_address.s_addr, (unsigned)alias_port));			}		}		/*		 * An uninteresting CTCP - state entered right after '/001'		 * has been pushed.  Also used to copy the rest of a DCC,		 * after IP address and port has been handled		 */lBAD_CTCP:		for (; i < dlen && iCopy < sizeof(newpacket); i++, iCopy++) {			newpacket[iCopy] = sptr[i];	/* Copy CTCP unchanged */			if (sptr[i] == '/001') {				goto lNORMAL_TEXT;			}		}		goto lPACKET_DONE;		/* Normal text */lNORMAL_TEXT:		for (; i < dlen && iCopy < sizeof(newpacket); i++, iCopy++) {			newpacket[iCopy] = sptr[i];	/* Copy CTCP unchanged */			if (sptr[i] == '/001') {				goto lCTCP_START;			}		}		/* Handle the end of a packet */lPACKET_DONE:		iCopy = iCopy > maxsize - copyat ? maxsize - copyat : iCopy;		memcpy(sptr + copyat, newpacket, iCopy);/* Save information regarding modified seq and ack numbers */		{			int delta;			SetAckModified(lnk);			delta = GetDeltaSeqOut(pip, lnk);			AddSeq(pip, lnk, delta + copyat + iCopy - dlen);		}		/* Revise IP header */		{			u_short new_len;			new_len = htons(hlen + iCopy + copyat);			DifferentialChecksum(&pip->ip_sum,			    &new_len,			    &pip->ip_len,			    1);			pip->ip_len = new_len;		}		/* Compute TCP checksum for revised packet */		tc->th_sum = 0;#ifdef _KERNEL		tc->th_x2 = 1;#else		tc->th_sum = TcpChecksum(pip);#endif		return;	}}

static intUdpAliasIn(struct libalias *la, struct ip *pip){    struct udphdr *ud;    struct alias_link *lnk;    LIBALIAS_LOCK_ASSERT(la);/* Return if proxy-only mode is enabled */    if (la->packetAliasMode & PKT_ALIAS_PROXY_ONLY)        return (PKT_ALIAS_OK);    ud = (struct udphdr *)ip_next(pip);    lnk = FindUdpTcpIn(la, pip->ip_src, pip->ip_dst,        ud->uh_sport, ud->uh_dport,        IPPROTO_UDP, 1);    if (lnk != NULL) {        struct in_addr alias_address;        struct in_addr original_address;        u_short alias_port;        int accumulate;        int r = 0, error;        struct alias_data ad;        ad.lnk = lnk;        ad.oaddr = &original_address;        ad.aaddr = &alias_address;        ad.aport = &alias_port;        ad.sport = &ud->uh_sport;        ad.dport = &ud->uh_dport;        ad.maxpktsize = 0;        alias_address = GetAliasAddress(lnk);        original_address = GetOriginalAddress(lnk);        alias_port = ud->uh_dport;        ud->uh_dport = GetOriginalPort(lnk);        /* Walk out chain. */        error = find_handler(IN, UDP, la, pip, &ad);/* If UDP checksum is not zero, then adjust since destination port *//* is being unaliased and destination address is being altered.    */        if (ud->uh_sum != 0) {            accumulate = alias_port;            accumulate -= ud->uh_dport;            accumulate += twowords(&alias_address);            accumulate -= twowords(&original_address);            ADJUST_CHECKSUM(accumulate, ud->uh_sum);        }/* Restore original IP address */        DifferentialChecksum(&pip->ip_sum,            &original_address, &pip->ip_dst, 2);        pip->ip_dst = original_address;        /*         * If we cannot figure out the packet, ignore it.         */        if (r < 0)            return (PKT_ALIAS_IGNORED);        else            return (PKT_ALIAS_OK);    }    return (PKT_ALIAS_IGNORED);}