File Manager

003 File Manager

Current Path: /usr/src/sys/net

📁 ..
📁 altq
📄 bpf.c(69.94 KB)
📄 bpf.h(14.6 KB)
📄 bpf_buffer.c(6.39 KB)
📄 bpf_buffer.h(2.04 KB)
📄 bpf_filter.c(12.09 KB)
📄 bpf_jitter.c(3.43 KB)
📄 bpf_jitter.h(3.3 KB)
📄 bpf_zerocopy.c(16.12 KB)
📄 bpf_zerocopy.h(2.36 KB)
📄 bpfdesc.h(6.04 KB)
📄 bridgestp.c(55.53 KB)
📄 bridgestp.h(13.06 KB)
📄 debugnet.c(26.35 KB)
📄 debugnet.h(8.54 KB)
📄 debugnet_inet.c(12.67 KB)
📄 debugnet_int.h(3.11 KB)
📄 dlt.h(44.23 KB)
📄 ethernet.h(22.17 KB)
📄 firewire.h(3.95 KB)
📄 ieee8023ad_lacp.c(53.91 KB)
📄 ieee8023ad_lacp.h(9.22 KB)
📄 ieee_oui.h(3.64 KB)
📄 if.c(105.86 KB)
📄 if.h(22.3 KB)
📄 if_arp.h(5.41 KB)
📄 if_bridge.c(89.97 KB)
📄 if_bridgevar.h(11.54 KB)
📄 if_clone.c(17.42 KB)
📄 if_clone.h(3.38 KB)
📄 if_dead.c(3.83 KB)
📄 if_debug.c(4.02 KB)
📄 if_disc.c(5.95 KB)
📄 if_dl.h(3.56 KB)
📄 if_edsc.c(9.93 KB)
📄 if_enc.c(12.02 KB)
📄 if_enc.h(1.65 KB)
📄 if_epair.c(27.75 KB)
📄 if_ethersubr.c(37.23 KB)
📄 if_fwsubr.c(19.22 KB)
📄 if_gif.c(16.66 KB)
📄 if_gif.h(4.16 KB)
📄 if_gre.c(18.8 KB)
📄 if_gre.h(5.69 KB)
📄 if_infiniband.c(14.99 KB)
📄 if_ipsec.c(24.98 KB)
📄 if_ipsec.h(1.62 KB)
📄 if_lagg.c(62.68 KB)
📄 if_lagg.h(8.94 KB)
📄 if_llatbl.c(20.5 KB)
📄 if_llatbl.h(9.52 KB)
📄 if_llc.h(4.53 KB)
📄 if_loop.c(10.62 KB)
📄 if_me.c(16.73 KB)
📄 if_media.c(12.81 KB)
📄 if_media.h(36.45 KB)
📄 if_mib.c(4.6 KB)
📄 if_mib.h(5.58 KB)
📄 if_pflog.h(2.24 KB)
📄 if_pfsync.h(6.85 KB)
📄 if_sppp.h(8.37 KB)
📄 if_spppfr.c(15.11 KB)
📄 if_spppsubr.c(132.44 KB)
📄 if_stf.c(19.3 KB)
📄 if_tap.h(2.54 KB)
📄 if_tun.h(1.43 KB)
📄 if_tuntap.c(47.67 KB)
📄 if_types.h(12.2 KB)
📄 if_var.h(29.92 KB)
📄 if_vlan.c(53.04 KB)
📄 if_vlan_var.h(6.1 KB)
📄 if_vxlan.c(88.14 KB)
📄 if_vxlan.h(4.71 KB)
📄 ifdi_if.m(8.4 KB)
📄 iflib.c(185.91 KB)
📄 iflib.h(14.41 KB)
📄 iflib_clone.c(7.37 KB)
📄 iflib_private.h(2.31 KB)
📄 ifq.h(12.2 KB)
📄 infiniband.h(2.64 KB)
📄 mp_ring.c(13.3 KB)
📄 mp_ring.h(2.77 KB)
📄 mppc.h(2.37 KB)
📄 mppcc.c(8.88 KB)
📄 mppcd.c(7.89 KB)
📄 netisr.c(44.33 KB)
📄 netisr.h(9.31 KB)
📄 netisr_internal.h(4.77 KB)
📄 netmap.h(32.93 KB)
📄 netmap_legacy.h(9.49 KB)
📄 netmap_user.h(30.33 KB)
📄 netmap_virt.h(3.89 KB)
📄 paravirt.h(6.91 KB)
📄 pfil.c(16.83 KB)
📄 pfil.h(5.86 KB)
📄 pfkeyv2.h(14.54 KB)
📄 pfvar.h(48.83 KB)
📄 ppp_defs.h(5.41 KB)
📄 radix.c(30.87 KB)
📄 radix.h(6.83 KB)
📄 raw_cb.c(3.77 KB)
📄 raw_cb.h(3.04 KB)
📄 raw_usrreq.c(6.26 KB)
📄 rndis.h(10.74 KB)
📁 route
📄 route.c(19.25 KB)
📄 route.h(16.54 KB)
📄 rss_config.c(14.12 KB)
📄 rss_config.h(4.69 KB)
📄 rtsock.c(62.94 KB)
📄 sff8436.h(8.3 KB)
📄 sff8472.h(18.95 KB)
📄 slcompress.c(16.25 KB)
📄 slcompress.h(6.4 KB)
📄 toeplitz.c(1.96 KB)
📄 toeplitz.h(1.72 KB)
📄 vnet.c(22.42 KB)
📄 vnet.h(14.62 KB)

Editing: mppcc.c

/*-
 * Copyright (c) 2002-2004 Jan Dubiec <jdx@slackware.pl>
 * Copyright (c) 2007 Alexander Motin <mav@freebsd.org>
 * 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 unmodified, 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS 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 THE AUTHOR OR 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.
 *
 * $FreeBSD$
 */

/*
 * MPPC decompression library.
 * Version 1.0
 *
 * Note that Hi/Fn (later acquired by Exar Corporation) held US patents
 * on some implementation-critical aspects of MPPC compression.
 * These patents lapsed due to non-payment of fees in 2007 and by 2015
 * expired altogether.
 */

#include <sys/param.h>
#include <sys/systm.h>

#include <net/mppc.h>

#define	MPPE_HIST_LEN          8192

#define	HASH(x)		(((40543*(((((x)[0]<<4)^(x)[1])<<4)^(x)[2]))>>4) & 0x1fff)

struct MPPC_comp_state {
    uint8_t	hist[2*MPPE_HIST_LEN];
    uint16_t	histptr;
    uint16_t	hash[MPPE_HIST_LEN];
};

/* Inserts 1 to 8 bits into the output buffer. */
static void __inline 
putbits8(uint8_t *buf, uint32_t val, const uint32_t n, uint32_t *i, uint32_t *l)
{
    buf += *i;
    if (*l >= n) {
	*l = (*l) - n;
	val <<= *l;
	*buf = *buf | (val & 0xff);
	if (*l == 0) {
	    *l = 8;
	    (*i)++;
	    *(++buf) = 0;
	}
    } else {
	(*i)++;
	*l = 8 - n + (*l);
	val <<= *l;
	*buf = *buf | ((val >> 8) & 0xff);
	*(++buf) = val & 0xff;
    }
}

/* Inserts 9 to 16 bits into the output buffer. */
static void __inline
putbits16(uint8_t *buf, uint32_t val, const uint32_t n, uint32_t *i, uint32_t *l)
{
    buf += *i;
    if (*l >= n - 8) {
	(*i)++;
	*l = 8 - n + (*l);
	val <<= *l;
	*buf = *buf | ((val >> 8) & 0xff);
	*(++buf) = val & 0xff;
	if (*l == 0) {
	    *l = 8;
	    (*i)++;
	    *(++buf) = 0;
	}
    } else {
	(*i)++; (*i)++;
	*l = 16 - n + (*l);
	val <<= *l;
	*buf = *buf | ((val >> 16) & 0xff);
	*(++buf) = (val >> 8) & 0xff;
	*(++buf) = val & 0xff;
    }
}

/* Inserts 17 to 24 bits into the output buffer. */
static void __inline
putbits24(uint8_t *buf, uint32_t val, const uint32_t n, uint32_t *i, uint32_t *l)
{
    buf += *i;
    if (*l >= n - 16) {
	(*i)++; (*i)++;
	*l = 16 - n + (*l);
	val <<= *l;
	*buf = *buf | ((val >> 16) & 0xff);
	*(++buf) = (val >> 8) & 0xff;
	*(++buf) = val & 0xff;
	if (*l == 0) {
	    *l = 8;
	    (*i)++;
	    *(++buf) = 0;
	}
    } else {
	(*i)++; (*i)++; (*i)++;
	*l = 24 - n + (*l);
	val <<= *l;
	*buf = *buf | ((val >> 24) & 0xff);
	*(++buf) = (val >> 16) & 0xff;
	*(++buf) = (val >> 8) & 0xff;
	*(++buf) = val & 0xff;
    }
}

size_t MPPC_SizeOfCompressionHistory(void)
{
    return (sizeof(struct MPPC_comp_state));
}

void MPPC_InitCompressionHistory(char *history)
{
    struct MPPC_comp_state      *state = (struct MPPC_comp_state*)history;

bzero(history, sizeof(struct MPPC_comp_state));
    state->histptr = MPPE_HIST_LEN;
}

int MPPC_Compress(u_char **src, u_char **dst, u_long *srcCnt, u_long *dstCnt, char *history, int flags, int undef)
{
    struct MPPC_comp_state	*state = (struct MPPC_comp_state*)history;
    uint32_t olen, off, len, idx, i, l;
    uint8_t *hist, *sbuf, *p, *q, *r, *s;    
    int	rtn = MPPC_OK;

/*
    * At this point, to avoid possible buffer overflow caused by packet
    * expansion during/after compression, we should make sure we have
    * space for the worst case.

* Maximum MPPC packet expansion is 12.5%. This is the worst case when
    * all octets in the input buffer are >= 0x80 and we cannot find any
    * repeated tokens.
    */
    if (*dstCnt < (*srcCnt * 9 / 8 + 2)) {
	rtn &= ~MPPC_OK;
	return (rtn);
    }

/* We can't compress more then MPPE_HIST_LEN bytes in a call. */
    if (*srcCnt > MPPE_HIST_LEN) {
	rtn &= ~MPPC_OK;
	return (rtn);
    }

hist = state->hist + MPPE_HIST_LEN;
    /* check if there is enough room at the end of the history */
    if (state->histptr + *srcCnt >= 2*MPPE_HIST_LEN) {
	rtn |= MPPC_RESTART_HISTORY;
	state->histptr = MPPE_HIST_LEN;
	memcpy(state->hist, hist, MPPE_HIST_LEN);
    }
    /* Add packet to the history. */
    sbuf = state->hist + state->histptr;
    memcpy(sbuf, *src, *srcCnt);
    state->histptr += *srcCnt;

/* compress data */
    r = sbuf + *srcCnt;
    **dst = olen = i = 0;
    l = 8;
    while (i < *srcCnt - 2) {
	s = q = sbuf + i;

/* Prognose matching position using hash function. */
	idx = HASH(s);
	p = hist + state->hash[idx];
	state->hash[idx] = (uint16_t) (s - hist);
	if (p > s)	/* It was before MPPC_RESTART_HISTORY. */
	    p -= MPPE_HIST_LEN;	/* Try previous history buffer. */
	off = s - p;

/* Check our prognosis. */
	if (off > MPPE_HIST_LEN - 1 || off < 1 || *p++ != *s++ ||
	    *p++ != *s++ || *p++ != *s++) {
	    /* No match found; encode literal byte. */
	    if ((*src)[i] < 0x80) {		/* literal byte < 0x80 */
		putbits8(*dst, (uint32_t) (*src)[i], 8, &olen, &l);
	    } else {				/* literal byte >= 0x80 */
		putbits16(*dst, (uint32_t) (0x100|((*src)[i]&0x7f)), 9,
		    &olen, &l);
	    }
	    ++i;
	    continue;
	}

/* Find length of the matching fragment */
#if defined(__amd64__) || defined(__i386__)
	/* Optimization for CPUs without strict data aligning requirements */
	while ((*((uint32_t*)p) == *((uint32_t*)s)) && (s < (r - 3))) {
	    p+=4;
	    s+=4;
	}
#endif
	while((*p++ == *s++) && (s <= r));
	len = s - q - 1;
	i += len;

/* At least 3 character match found; code data. */
	/* Encode offset. */
	if (off < 64) {			/* 10-bit offset; 0 <= offset < 64 */
	    putbits16(*dst, 0x3c0|off, 10, &olen, &l);
	} else if (off < 320) {		/* 12-bit offset; 64 <= offset < 320 */
	    putbits16(*dst, 0xe00|(off-64), 12, &olen, &l);
	} else if (off < 8192) {	/* 16-bit offset; 320 <= offset < 8192 */
	    putbits16(*dst, 0xc000|(off-320), 16, &olen, &l);
	} else {		/* NOTREACHED */
	    __assert_unreachable();
	    rtn &= ~MPPC_OK;
	    return (rtn);
	}

/* Encode length of match. */
	if (len < 4) {			/* length = 3 */
	    putbits8(*dst, 0, 1, &olen, &l);
	} else if (len < 8) {		/* 4 <= length < 8 */
	    putbits8(*dst, 0x08|(len&0x03), 4, &olen, &l);
	} else if (len < 16) {		/* 8 <= length < 16 */
	    putbits8(*dst, 0x30|(len&0x07), 6, &olen, &l);
	} else if (len < 32) {		/* 16 <= length < 32 */
	    putbits8(*dst, 0xe0|(len&0x0f), 8, &olen, &l);
	} else if (len < 64) {		/* 32 <= length < 64 */
	    putbits16(*dst, 0x3c0|(len&0x1f), 10, &olen, &l);
	} else if (len < 128) {		/* 64 <= length < 128 */
	    putbits16(*dst, 0xf80|(len&0x3f), 12, &olen, &l);
	} else if (len < 256) {		/* 128 <= length < 256 */
	    putbits16(*dst, 0x3f00|(len&0x7f), 14, &olen, &l);
	} else if (len < 512) {		/* 256 <= length < 512 */
	    putbits16(*dst, 0xfe00|(len&0xff), 16, &olen, &l);
	} else if (len < 1024) {	/* 512 <= length < 1024 */
	    putbits24(*dst, 0x3fc00|(len&0x1ff), 18, &olen, &l);
	} else if (len < 2048) {	/* 1024 <= length < 2048 */
	    putbits24(*dst, 0xff800|(len&0x3ff), 20, &olen, &l);
	} else if (len < 4096) {	/* 2048 <= length < 4096 */
	    putbits24(*dst, 0x3ff000|(len&0x7ff), 22, &olen, &l);
	} else if (len < 8192) {	/* 4096 <= length < 8192 */
	    putbits24(*dst, 0xffe000|(len&0xfff), 24, &olen, &l);
	} else {	/* NOTREACHED */
	    rtn &= ~MPPC_OK;
	    return (rtn);
	}
    }

/* Add remaining octets to the output. */
    while(*srcCnt - i > 0) {
	if ((*src)[i] < 0x80) {	/* literal byte < 0x80 */
	    putbits8(*dst, (uint32_t) (*src)[i++], 8, &olen, &l);
	} else {		/* literal byte >= 0x80 */
	    putbits16(*dst, (uint32_t) (0x100|((*src)[i++]&0x7f)), 9, &olen,
	        &l);
	}
    }

/* Reset unused bits of the last output octet. */
    if ((l != 0) && (l != 8)) {
	putbits8(*dst, 0, l, &olen, &l);
    }

/* If result is bigger then original, set flag and flush history. */
    if ((*srcCnt < olen) || ((flags & MPPC_SAVE_HISTORY) == 0)) {
	if (*srcCnt < olen)
	    rtn |= MPPC_EXPANDED;
	bzero(history, sizeof(struct MPPC_comp_state));
	state->histptr = MPPE_HIST_LEN;
    }

*src += *srcCnt;
    *srcCnt = 0;
    *dst += olen;
    *dstCnt -= olen;

return (rtn);
}

003 File Manager

Editing: mppcc.c

Upload File

Create Folder