taglinefilesource code
skb55drivers/net/3c501.cstatic int  el_start_xmit(struct sk_buff *skb, struct device *dev);
skb230drivers/net/3c501.cel_start_xmit(struct sk_buff *skb, struct device *dev)
skb255drivers/net/3c501.cif (skb == NULL) {
skb260drivers/net/3c501.cif (skb->len <= 0)
skb267drivers/net/3c501.cint gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
skb268drivers/net/3c501.cunsigned char *buf = skb->data;
skb278drivers/net/3c501.coutsb(DATAPORT,buf,skb->len);
skb286drivers/net/3c501.cif (skb->free)
skb287drivers/net/3c501.ckfree_skb (skb, FREE_WRITE);
skb393drivers/net/3c501.cstruct sk_buff *skb;
skb408drivers/net/3c501.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb410drivers/net/3c501.cif (skb == NULL) {
skb415drivers/net/3c501.cskb->len = pkt_len;
skb416drivers/net/3c501.cskb->dev = dev;
skb418drivers/net/3c501.cinsb(DATAPORT, skb->data, pkt_len);
skb420drivers/net/3c501.cnetif_rx(skb);
skb272drivers/net/3c507.cstatic int  el16_send_packet(struct sk_buff *skb, struct device *dev);
skb427drivers/net/3c507.cel16_send_packet(struct sk_buff *skb, struct device *dev)
skb462drivers/net/3c507.cif (skb == NULL) {
skb471drivers/net/3c507.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb472drivers/net/3c507.cunsigned char *buf = skb->data;
skb482drivers/net/3c507.cif (skb->free)
skb483drivers/net/3c507.ckfree_skb (skb, FREE_WRITE);
skb817drivers/net/3c507.cstruct sk_buff *skb;
skb820drivers/net/3c507.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb821drivers/net/3c507.cif (skb == NULL) {
skb826drivers/net/3c507.cskb->len = pkt_len;
skb827drivers/net/3c507.cskb->dev = dev;
skb830drivers/net/3c507.cmemcpy(skb->data, data_frame + 5, pkt_len);
skb832drivers/net/3c507.cnetif_rx(skb);
skb72drivers/net/3c509.cstatic int el3_start_xmit(struct sk_buff *skb, struct device *dev);
skb319drivers/net/3c509.cel3_start_xmit(struct sk_buff *skb, struct device *dev)
skb338drivers/net/3c509.cif (skb == NULL) {
skb343drivers/net/3c509.cif (skb->len <= 0)
skb348drivers/net/3c509.cdev->name, skb->len, inw(ioaddr + EL3_STATUS));
skb371drivers/net/3c509.coutw(skb->len, ioaddr + TX_FIFO);
skb374drivers/net/3c509.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
skb384drivers/net/3c509.cif (skb->free)
skb385drivers/net/3c509.ckfree_skb (skb, FREE_WRITE);
skb535drivers/net/3c509.cstruct sk_buff *skb;
skb537drivers/net/3c509.cskb = alloc_skb(pkt_len+3, GFP_ATOMIC);
skb541drivers/net/3c509.cif (skb != NULL) {
skb542drivers/net/3c509.cskb->len = pkt_len;
skb543drivers/net/3c509.cskb->dev = dev;
skb546drivers/net/3c509.cinsl(ioaddr+RX_FIFO, skb->data,
skb550drivers/net/3c509.cnetif_rx(skb);
skb554drivers/net/3c509.cskb->lock = 0;
skb555drivers/net/3c509.cif (dev_rint((unsigned char *)skb, pkt_len,
skb570drivers/net/3c509.ckfree_s(skb, FREE_READ);
skb125drivers/net/8390.cstatic int ei_start_xmit(struct sk_buff *skb, struct device *dev)
skb163drivers/net/8390.cif (skb == NULL) {
skb168drivers/net/8390.clength = skb->len;
skb169drivers/net/8390.cif (skb->len <= 0)
skb209drivers/net/8390.cei_block_output(dev, length, skb->data, output_page);
skb223drivers/net/8390.cei_block_output(dev, length, skb->data, ei_local->tx_start_page);
skb233drivers/net/8390.cif (skb->free)
skb234drivers/net/8390.ckfree_skb (skb, FREE_WRITE);
skb440drivers/net/8390.cstruct sk_buff *skb;
skb442drivers/net/8390.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb443drivers/net/8390.cif (skb == NULL) {
skb450drivers/net/8390.cskb->len = pkt_len;
skb451drivers/net/8390.cskb->dev = dev;
skb453drivers/net/8390.cei_block_input(dev, pkt_len, (char *) skb->data,
skb455drivers/net/8390.cnetif_rx(skb);
skb113drivers/net/at1700.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb343drivers/net/at1700.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb374drivers/net/at1700.cif (skb == NULL) {
skb384drivers/net/at1700.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb385drivers/net/at1700.cunsigned char *buf = skb->data;
skb409drivers/net/at1700.cif (skb->free)
skb410drivers/net/at1700.ckfree_skb (skb, FREE_WRITE);
skb494drivers/net/at1700.cstruct sk_buff *skb;
skb503drivers/net/at1700.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb504drivers/net/at1700.cif (skb == NULL) {
skb511drivers/net/at1700.cskb->len = pkt_len;
skb512drivers/net/at1700.cskb->dev = dev;
skb514drivers/net/at1700.cinsw(ioaddr + DATAPORT, skb->data, (pkt_len + 1) >> 1);
skb520drivers/net/at1700.cprintk(" %02x", skb->data[i]);
skb524drivers/net/at1700.cnetif_rx(skb);
skb140drivers/net/atp.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb411drivers/net/atp.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb435drivers/net/atp.cif (skb == NULL) {
skb445drivers/net/atp.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb446drivers/net/atp.cunsigned char *buf = skb->data;
skb474drivers/net/atp.cif (skb->free)
skb475drivers/net/atp.ckfree_skb (skb, FREE_WRITE);
skb630drivers/net/atp.cstruct sk_buff *skb;
skb632drivers/net/atp.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb633drivers/net/atp.cif (skb == NULL) {
skb638drivers/net/atp.cskb->len = pkt_len;
skb639drivers/net/atp.cskb->dev = dev;
skb641drivers/net/atp.cread_block(ioaddr, pkt_len, skb->data, dev->if_port);
skb644drivers/net/atp.cunsigned char *data = skb->data;
skb652drivers/net/atp.cnetif_rx(skb);
skb217drivers/net/d_link.cstatic int  d_link_start_xmit(struct sk_buff *skb, struct device *dev);
skb379drivers/net/d_link.cd_link_start_xmit(struct sk_buff *skb, struct device *dev)
skb384drivers/net/d_link.cunsigned char  *buffer = skb->data;
skb392drivers/net/d_link.cif (skb == NULL) {
skb414drivers/net/d_link.cPRINTK(("d_link_start_xmit:len=%d, page %d/%d\n", skb->len, tx_fifo_in, free_tx_pages));
skb416drivers/net/d_link.cif ((len = skb->len) < RUNT)
skb443drivers/net/d_link.cif (skb->free)
skb444drivers/net/d_link.ckfree_skb (skb, FREE_WRITE);
skb544drivers/net/d_link.cstruct sk_buff  *skb;
skb565drivers/net/d_link.cskb = alloc_skb(size, GFP_ATOMIC);
skb567drivers/net/d_link.cif (skb == NULL) {
skb574drivers/net/d_link.cskb->lock = 0;
skb576drivers/net/d_link.cbuffer = skb->data;
skb585drivers/net/d_link.cif (dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev))
skb267drivers/net/depca.cstatic int depca_start_xmit(struct sk_buff *skb, struct device *dev);
skb780drivers/net/depca.cdepca_start_xmit(struct sk_buff *skb, struct device *dev)
skb805drivers/net/depca.cif (skb == NULL) {
skb810drivers/net/depca.cif (skb->len <= 0) {
skb834drivers/net/depca.clong skbL = skb->len;
skb835drivers/net/depca.cchar *p = (char *) skb->data;
skb856drivers/net/depca.cmemcpy((unsigned char *)(buf), skb->data, len);
skb880drivers/net/depca.cmemcpy((unsigned char *)buf, skb->data, PKT_HDR_LEN);
skb917drivers/net/depca.cif (skb->free) {
skb918drivers/net/depca.ckfree_skb (skb, FREE_WRITE);
skb1030drivers/net/depca.cstruct sk_buff *skb;
skb1032drivers/net/depca.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb1033drivers/net/depca.cif (skb == NULL) {
skb1038drivers/net/depca.cskb->len = pkt_len;
skb1039drivers/net/depca.cskb->dev = dev;
skb1040drivers/net/depca.cmemcpy(skb->data,
skb1047drivers/net/depca.cnetif_rx(skb);
skb285drivers/net/eexpress.cstatic int  eexp_send_packet(struct sk_buff *skb, struct device *dev);
skb442drivers/net/eexpress.ceexp_send_packet(struct sk_buff *skb, struct device *dev)
skb477drivers/net/eexpress.cif (skb == NULL) {
skb486drivers/net/eexpress.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb487drivers/net/eexpress.cunsigned char *buf = skb->data;
skb497drivers/net/eexpress.cif (skb->free)
skb498drivers/net/eexpress.ckfree_skb (skb, FREE_WRITE);
skb924drivers/net/eexpress.cstruct sk_buff *skb;
skb927drivers/net/eexpress.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb928drivers/net/eexpress.cif (skb == NULL) {
skb933drivers/net/eexpress.cskb->len = pkt_len;
skb934drivers/net/eexpress.cskb->dev = dev;
skb938drivers/net/eexpress.cinsw(ioaddr, skb->data, (pkt_len + 1) >> 1);
skb940drivers/net/eexpress.cnetif_rx(skb);
skb205drivers/net/lance.cstatic int lance_start_xmit(struct sk_buff *skb, struct device *dev);
skb460drivers/net/lance.clance_start_xmit(struct sk_buff *skb, struct device *dev)
skb501drivers/net/lance.cif (skb == NULL) {
skb506drivers/net/lance.cif (skb->len <= 0)
skb532drivers/net/lance.c-(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
skb534drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
skb540drivers/net/lance.cif ((int)(skb->data) + skb->len > 0x01000000) {
skb543drivers/net/lance.cdev->name, (int)(skb->data));
skb544drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
skb547drivers/net/lance.cif (skb->free)
skb548drivers/net/lance.ckfree_skb (skb, FREE_WRITE);
skb552drivers/net/lance.cif(skb->free==0)
skb553drivers/net/lance.cskb_kept_by_device(skb);
skb554drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
skb637drivers/net/lance.cstruct sk_buff *skb = ((struct sk_buff *)databuff) - 1;
skb638drivers/net/lance.cif (skb->free)
skb639drivers/net/lance.ckfree_skb(skb, FREE_WRITE);
skb641drivers/net/lance.cskb_device_release(skb,FREE_WRITE);
skb707drivers/net/lance.cstruct sk_buff *skb;
skb709drivers/net/lance.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb710drivers/net/lance.cif (skb == NULL) {
skb715drivers/net/lance.cskb->len = pkt_len;
skb716drivers/net/lance.cskb->dev = dev;
skb717drivers/net/lance.cmemcpy(skb->data,
skb720drivers/net/lance.cnetif_rx(skb);
skb42drivers/net/loopback.cloopback_xmit(struct sk_buff *skb, struct device *dev)
skb47drivers/net/loopback.cDPRINTF((DBG_LOOPB, "loopback_xmit(dev=%X, skb=%X)\n", dev, skb));
skb48drivers/net/loopback.cif (skb == NULL || dev == NULL) return(0);
skb59drivers/net/loopback.cdone = dev_rint(skb->data, skb->len, 0, dev);
skb60drivers/net/loopback.cif (skb->free) kfree_skb(skb, FREE_WRITE);
skb138drivers/net/plip.cstatic int plip_tx_packet(struct sk_buff *skb, struct device *dev);
skb141drivers/net/plip.cvoid *source, unsigned len, struct sk_buff *skb);
skb258drivers/net/plip.cplip_tx_packet(struct sk_buff *skb, struct device *dev)
skb275drivers/net/plip.cif (skb == NULL) {
skb281drivers/net/plip.cret_val = plip_send_packet(dev, skb->data, skb->len);
skb282drivers/net/plip.cif (skb->free)
skb283drivers/net/plip.ckfree_skb (skb, FREE_WRITE);
skb292drivers/net/plip.cvoid *saddr, unsigned len, struct sk_buff *skb)
skb298drivers/net/plip.creturn eth_header(buff, dev, type, daddr, saddr, len, skb);
skb408drivers/net/plip.cstruct sk_buff *skb;
skb438drivers/net/plip.cskb = alloc_skb(length, GFP_ATOMIC);
skb439drivers/net/plip.cif (skb == NULL) {
skb444drivers/net/plip.cskb->lock = 0;
skb449drivers/net/plip.cunsigned char *buf = skb->data;
skb466drivers/net/plip.c} else if(dev_rint((unsigned char *)skb, length, IN_SKBUFF, dev)) {
skb103drivers/net/skeleton.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb257drivers/net/skeleton.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb279drivers/net/skeleton.cif (skb == NULL) {
skb289drivers/net/skeleton.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb290drivers/net/skeleton.cunsigned char *buf = skb->data;
skb295drivers/net/skeleton.cif (skb->free)
skb296drivers/net/skeleton.ckfree_skb (skb, FREE_WRITE);
skb367drivers/net/skeleton.cstruct sk_buff *skb;
skb369drivers/net/skeleton.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb370drivers/net/skeleton.cif (skb == NULL) {
skb375drivers/net/skeleton.cskb->len = pkt_len;
skb376drivers/net/skeleton.cskb->dev = dev;
skb379drivers/net/skeleton.cmemcpy(skb->data, (void*)dev->rmem_start,
skb382drivers/net/skeleton.cinsw(ioaddr, skb->data, (pkt_len + 1) >> 1);
skb384drivers/net/skeleton.cnetif_rx(skb);
skb503drivers/net/slip.csl_xmit(struct sk_buff *skb, struct device *dev)
skb513drivers/net/slip.cdev->name, skb, sl->sending));
skb527drivers/net/slip.cif (skb != NULL) {
skb532drivers/net/slip.cif(!skb->arp && dev->rebuild_header(skb->data,dev))
skb534drivers/net/slip.cskb->dev=dev;
skb535drivers/net/slip.carp_queue(skb);
skb538drivers/net/slip.cskb->arp=1;
skb544drivers/net/slip.csize=skb->len;
skb554drivers/net/slip.csize=((struct iphdr *)(skb->data))->tot_len;
skb559drivers/net/slip.csl_encaps(sl, skb->data, size);
skb560drivers/net/slip.cif (skb->free) 
skb561drivers/net/slip.ckfree_skb(skb, FREE_WRITE);
skb569drivers/net/slip.csl_type_trans (struct sk_buff *skb, struct device *dev)
skb583drivers/net/slip.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb)
skb588drivers/net/slip.creturn ax25_encapsulate(buff,dev,type,daddr,saddr,len,skb);
skb598drivers/net/slip.cstruct sk_buff *skb)
skb604drivers/net/slip.creturn ax25_rebuild_header(buff,dev,raddr, skb);
skb34include/linux/etherdevice.hstruct sk_buff *skb);
skb36include/linux/etherdevice.hunsigned long raddr, struct sk_buff *skb);
skb37include/linux/etherdevice.hextern unsigned short  eth_type_trans(struct sk_buff *skb, struct device *dev);
skb120include/linux/netdevice.hint        (*hard_start_xmit) (struct sk_buff *skb,
skb128include/linux/netdevice.hstruct sk_buff *skb);
skb130include/linux/netdevice.hunsigned long raddr, struct sk_buff *skb);
skb131include/linux/netdevice.hunsigned short    (*type_trans) (struct sk_buff *skb,
skb173include/linux/netdevice.hextern void    dev_queue_xmit(struct sk_buff *skb, struct device *dev,
skb176include/linux/netdevice.hextern void    netif_rx(struct sk_buff *skb);
skb94include/linux/skbuff.hextern void      kfree_skb(struct sk_buff *skb, int rw);
skb105include/linux/skbuff.hextern struct sk_buff *    skb_clone(struct sk_buff *skb, int priority);
skb106include/linux/skbuff.hextern void      skb_kept_by_device(struct sk_buff *skb);
skb107include/linux/skbuff.hextern void      skb_device_release(struct sk_buff *skb,
skb109include/linux/skbuff.hextern int      skb_device_locked(struct sk_buff *skb);
skb123include/linux/skbuff.hextern int       skb_check(struct sk_buff *skb,int,int, char *);
skb124include/linux/skbuff.h#define IS_SKB(skb)    skb_check((skb), 0, __LINE__,__FILE__)
skb125include/linux/skbuff.h#define IS_SKB_HEAD(skb)  skb_check((skb), 1, __LINE__,__FILE__)
skb127include/linux/skbuff.h#define IS_SKB(skb)    0
skb128include/linux/skbuff.h#define IS_SKB_HEAD(skb)  0
skb134include/linux/skbuff.hextern void      skb_free_datagram(struct sk_buff *skb);
skb81net/inet/arp.cstruct sk_buff_head    skb;      /* list of queued packets   */
skb228net/inet/arp.cstruct sk_buff *skb;
skb233net/inet/arp.cwhile ((skb = skb_dequeue(&entry->skb)) != NULL)
skb235net/inet/arp.cif (skb->free)
skb236net/inet/arp.ckfree_skb(skb, FREE_WRITE);
skb252net/inet/arp.cstruct sk_buff *skb;
skb267net/inet/arp.cskb = alloc_skb(sizeof(struct arphdr)+ 2*(dev->addr_len+4)
skb269net/inet/arp.cif (skb == NULL)
skb274net/inet/arp.cskb->len = sizeof(struct arphdr) + dev->hard_header_len + 2*(dev->addr_len+4);
skb275net/inet/arp.cskb->arp = 1;
skb276net/inet/arp.cskb->dev = dev;
skb277net/inet/arp.cskb->free = 1;
skb283net/inet/arp.cdev->hard_header(skb->data,dev,ETH_P_ARP,dest_hw?dest_hw:dev->broadcast,src_hw?src_hw:NULL,skb->len,skb);
skb286net/inet/arp.carp = (struct arphdr *) (skb->data + dev->hard_header_len);
skb310net/inet/arp.cdev_queue_xmit(skb, dev, 0);
skb391net/inet/arp.cstruct sk_buff *skb;
skb405net/inet/arp.cwhile((skb = skb_dequeue(&entry->skb)) != NULL)
skb407net/inet/arp.cIS_SKB(skb);
skb408net/inet/arp.cif(!skb->dev->rebuild_header(skb->data,skb->dev,skb->raddr,skb))
skb410net/inet/arp.cskb->arp  = 1;
skb411net/inet/arp.cif(skb->sk==NULL)
skb412net/inet/arp.cdev_queue_xmit(skb, skb->dev, 0);
skb414net/inet/arp.cdev_queue_xmit(skb,skb->dev,skb->sk->priority);
skb422net/inet/arp.cprintk("arp_send_q: failed to find %s\n",in_ntoa(skb->raddr));
skb464net/inet/arp.cint arp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb470net/inet/arp.cstruct arphdr *arp = (struct arphdr *)skb->h.raw;
skb486net/inet/arp.ckfree_skb(skb, FREE_READ);
skb501net/inet/arp.ckfree_skb(skb, FREE_READ);
skb573net/inet/arp.ckfree_skb(skb, FREE_READ);
skb584net/inet/arp.ckfree_skb(skb, FREE_READ);
skb592net/inet/arp.ckfree_skb(skb, FREE_READ);
skb604net/inet/arp.centry->dev = skb->dev;
skb605net/inet/arp.cskb_queue_head_init(&entry->skb);
skb617net/inet/arp.ckfree_skb(skb, FREE_READ);
skb626net/inet/arp.ckfree_skb(skb, FREE_READ);
skb636net/inet/arp.cunsigned long saddr, struct sk_buff *skb)
skb646net/inet/arp.cskb->arp = 1;
skb650net/inet/arp.cskb->arp = 1;
skb674net/inet/arp.cif (skb != NULL)
skb675net/inet/arp.cskb_queue_tail(&entry->skb, skb);
skb686net/inet/arp.cif (skb)
skb687net/inet/arp.cskb->arp = 1;
skb714net/inet/arp.cskb_queue_head_init(&entry->skb);
skb715net/inet/arp.cif (skb != NULL)
skb716net/inet/arp.cskb_queue_tail(&entry->skb, skb);
skb720net/inet/arp.cif (skb != NULL && skb->free)
skb721net/inet/arp.ckfree_skb(skb, FREE_WRITE);
skb894net/inet/arp.cskb_queue_head_init(&entry->skb);
skb7net/inet/arp.hextern int  arp_rcv(struct sk_buff *skb, struct device *dev,
skb10net/inet/arp.hstruct device *dev, unsigned long saddr, struct sk_buff *skb);
skb55net/inet/datagram.cstruct sk_buff *skb;
skb125net/inet/datagram.cskb=skb_dequeue(&sk->receive_queue);
skb126net/inet/datagram.cif(skb!=NULL)
skb127net/inet/datagram.cskb->users++;
skb134net/inet/datagram.cskb=skb_peek(&sk->receive_queue);
skb135net/inet/datagram.cif(skb!=NULL)
skb136net/inet/datagram.cskb->users++;
skb138net/inet/datagram.cif(skb==NULL)  /* shouldn't happen but .. */
skb141net/inet/datagram.creturn skb;
skb144net/inet/datagram.cvoid skb_free_datagram(struct sk_buff *skb)
skb150net/inet/datagram.cskb->users--;
skb151net/inet/datagram.cif(skb->users>0)
skb157net/inet/datagram.cif(!skb->next && !skb->prev)  /* Been dequeued by someone - ie its read */
skb158net/inet/datagram.ckfree_skb(skb,FREE_READ);
skb162net/inet/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
skb166net/inet/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
skb305net/inet/dev.cstruct sk_buff *skb;
skb306net/inet/dev.cwhile((skb=skb_dequeue(&dev->buffs[ct]))!=NULL)
skb307net/inet/dev.cif(skb->free)
skb308net/inet/dev.ckfree_skb(skb,FREE_WRITE);
skb320net/inet/dev.cvoid dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
skb328net/inet/dev.cskb, dev, pri));
skb336net/inet/dev.cIS_SKB(skb);
skb338net/inet/dev.cskb->dev = dev;
skb344net/inet/dev.cif (skb->next != NULL) 
skb377net/inet/dev.cif (!skb->arp && dev->rebuild_header(skb->data, dev, skb->raddr, skb)) {
skb384net/inet/dev.cskb_queue_tail(dev->buffs + pri,skb);
skb385net/inet/dev.cskb = skb_dequeue(dev->buffs + pri);
skb389net/inet/dev.cif (dev->hard_start_xmit(skb, dev) == 0) {
skb397net/inet/dev.cskb_queue_head(dev->buffs + pri,skb);
skb407net/inet/dev.cvoid netif_rx(struct sk_buff *skb)
skb417net/inet/dev.cskb->sk = NULL;
skb418net/inet/dev.cskb->free = 1;
skb419net/inet/dev.cif(skb->stamp.tv_sec==0)
skb420net/inet/dev.cskb->stamp = xtime;
skb433net/inet/dev.ckfree_skb(skb, FREE_READ);
skb441net/inet/dev.cIS_SKB(skb);
skb442net/inet/dev.cskb_queue_tail(&backlog,skb);
skb472net/inet/dev.cstruct sk_buff *skb = NULL;
skb482net/inet/dev.cskb = (struct sk_buff *) buff;
skb494net/inet/dev.cskb = alloc_skb(len, GFP_ATOMIC);
skb495net/inet/dev.cif (skb == NULL) 
skb508net/inet/dev.cto = skb->data;
skb530net/inet/dev.cskb->len = len;
skb531net/inet/dev.cskb->dev = dev;
skb532net/inet/dev.cskb->free = 1;
skb534net/inet/dev.cnetif_rx(skb);
skb591net/inet/dev.cstruct sk_buff *skb;
skb624net/inet/dev.cwhile((skb=skb_dequeue(&backlog))!=NULL)
skb642net/inet/dev.cskb->h.raw = skb->data + skb->dev->hard_header_len;
skb643net/inet/dev.cskb->len -= skb->dev->hard_header_len;
skb656net/inet/dev.ctype = skb->dev->type_trans(skb, skb->dev);
skb684net/inet/dev.cskb2 = alloc_skb(skb->len, GFP_ATOMIC);
skb687net/inet/dev.cmemcpy(skb2, skb, skb2->mem_len);
skb691net/inet/dev.c(unsigned long) skb->h.raw -
skb692net/inet/dev.c(unsigned long) skb
skb696net/inet/dev.cskb2=skb_clone(skb, GFP_ATOMIC);
skb703net/inet/dev.cskb2 = skb;
skb717net/inet/dev.cptype->func(skb2, skb->dev, ptype);
skb728net/inet/dev.ckfree_skb(skb, FREE_WRITE);
skb762net/inet/dev.cstruct sk_buff *skb;
skb774net/inet/dev.cwhile((skb=skb_dequeue(&dev->buffs[i]))!=NULL)
skb780net/inet/dev.cdev_queue_xmit(skb,dev,-i - 1);
skb119net/inet/dev.hint        (*hard_start_xmit) (struct sk_buff *skb,
skb128net/inet/dev.hstruct sk_buff *skb,
skb130net/inet/dev.hvoid        (*queue_xmit)(struct sk_buff *skb,
skb133net/inet/dev.hunsigned short    (*type_trans) (struct sk_buff *skb,
skb175net/inet/dev.hextern void    dev_queue_xmit(struct sk_buff *skb, struct device *dev,
skb178net/inet/dev.hextern void    netif_rx(struct sk_buff *skb);
skb82net/inet/eth.cstruct sk_buff *skb)
skb132net/inet/eth.cstruct sk_buff *skb)
skb151net/inet/eth.creturn arp_find(eth->h_dest, dst, dev, dev->pa_addr, skb)? 1 : 0;
skb161net/inet/eth.cunsigned short eth_type_trans(struct sk_buff *skb, struct device *dev)
skb163net/inet/eth.cstruct ethhdr *eth = (struct ethhdr *) skb->data;
skb31net/inet/eth.hextern void    eth_add_arp(unsigned long addr, struct sk_buff *skb,
skb33net/inet/eth.hextern unsigned short  eth_type_trans(struct sk_buff *skb, struct device *dev);
skb108net/inet/icmp.cstruct sk_buff *skb;
skb183net/inet/icmp.cskb = (struct sk_buff *) alloc_skb(len, GFP_ATOMIC);
skb184net/inet/icmp.cif (skb == NULL) 
skb189net/inet/icmp.cskb->free = 1;
skb195net/inet/icmp.coffset = ip_build_header(skb, dev->pa_addr, iph->saddr,
skb201net/inet/icmp.cskb->sk = NULL;
skb202net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb210net/inet/icmp.cskb->len = offset + sizeof(struct icmphdr) + sizeof(struct iphdr) + 8;
skb216net/inet/icmp.cicmph = (struct icmphdr *) (skb->data + offset);
skb232net/inet/icmp.cip_queue_xmit(NULL, dev, skb, 1);
skb240net/inet/icmp.cstatic void icmp_unreach(struct icmphdr *icmph, struct sk_buff *skb)
skb309net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb317net/inet/icmp.cstatic void icmp_redirect(struct icmphdr *icmph, struct sk_buff *skb,
skb373net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb381net/inet/icmp.cstatic void icmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb399net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb406net/inet/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
skb412net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb441net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb448net/inet/icmp.cstatic void icmp_timestamp(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb463net/inet/icmp.cskb->sk = NULL;
skb464net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb475net/inet/icmp.cskb->ip_hdr->tos, 255);
skb480net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb515net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb525net/inet/icmp.cstatic void icmp_info(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb530net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb538net/inet/icmp.cstatic void icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb555net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb565net/inet/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
skb571net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb598net/inet/icmp.cskb->sk = NULL;
skb599net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb226net/inet/ip.cstatic int ip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev, unsigned long saddr)
skb230net/inet/ip.cskb->dev = dev;
skb231net/inet/ip.cskb->arp = 1;
skb238net/inet/ip.cmac = dev->hard_header(skb->data, dev, ETH_P_IP, NULL, NULL, len, skb);
skb242net/inet/ip.cskb->arp = 0;
skb243net/inet/ip.cskb->raddr = daddr;  /* next routing address */
skb256net/inet/ip.cint ip_build_header(struct sk_buff *skb, unsigned long saddr, unsigned long daddr,
skb277net/inet/ip.cskb, saddr, daddr, *dev, type, opt, len));
skb279net/inet/ip.cbuff = skb->data;
skb287net/inet/ip.cif(skb->localroute)
skb314net/inet/ip.cif(skb->localroute)
skb338net/inet/ip.ctmp = ip_send(skb, raddr, len, *dev, saddr);
skb346net/inet/ip.cskb->dev = *dev;
skb347net/inet/ip.cskb->saddr = saddr;
skb348net/inet/ip.cif (skb->sk) 
skb349net/inet/ip.cskb->sk->saddr = saddr;
skb641net/inet/ip.cstatic struct ipfrag *ip_frag_create(int offset, int end, struct sk_buff *skb, unsigned char *ptr)
skb657net/inet/ip.cfp->skb = skb;
skb729net/inet/ip.cIS_SKB(fp->skb);
skb730net/inet/ip.ckfree_skb(fp->skb,FREE_READ);
skb767net/inet/ip.cicmp_send(qp->fragments->skb,ICMP_TIME_EXCEEDED,
skb784net/inet/ip.cstatic struct ipq *ip_create(struct sk_buff *skb, struct iphdr *iph, struct device *dev)
skb795net/inet/ip.cskb->dev = qp->dev;
skb806net/inet/ip.cmaclen = ((unsigned long) iph) - ((unsigned long) skb->data);
skb830net/inet/ip.cmemcpy(qp->mac, skb->data, maclen);
skb896net/inet/ip.cstruct sk_buff *skb;
skb908net/inet/ip.cif ((skb = alloc_skb(len,GFP_ATOMIC)) == NULL) 
skb917net/inet/ip.cskb->len = (len - qp->maclen);
skb918net/inet/ip.cskb->h.raw = skb->data;
skb919net/inet/ip.cskb->free = 1;
skb922net/inet/ip.cptr = (unsigned char *) skb->h.raw;
skb927net/inet/ip.cskb->h.raw += qp->maclen;
skb935net/inet/ip.cif(count+fp->len>skb->len)
skb939net/inet/ip.ckfree_skb(skb,FREE_WRITE);
skb952net/inet/ip.ciph = skb->h.iph;
skb955net/inet/ip.cskb->ip_hdr = iph;
skb958net/inet/ip.creturn(skb);
skb966net/inet/ip.cstatic struct sk_buff *ip_defrag(struct iphdr *iph, struct sk_buff *skb, struct device *dev)
skb989net/inet/ip.creturn(skb);
skb1013net/inet/ip.cif ((qp = ip_create(skb, iph, dev)) == NULL) 
skb1015net/inet/ip.cskb->sk = NULL;
skb1016net/inet/ip.ckfree_skb(skb, FREE_READ);
skb1033net/inet/ip.cptr = skb->data + dev->hard_header_len + ihl;
skb1101net/inet/ip.ckfree_skb(next->skb,FREE_READ);       
skb1112net/inet/ip.ctfp = ip_frag_create(offset, end, skb, ptr);
skb1120net/inet/ip.cskb->sk = NULL;
skb1121net/inet/ip.ckfree_skb(skb, FREE_READ);
skb1163net/inet/ip.cvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
skb1176net/inet/ip.craw = skb->data;
skb1179net/inet/ip.cskb->ip_hdr = iph;
skb1208net/inet/ip.cicmp_send(skb,ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, dev); 
skb1221net/inet/ip.cicmp_send(skb,ICMP_DEST_UNREACH,ICMP_FRAG_NEEDED,dev);
skb1276net/inet/ip.cskb2->arp = skb->arp;
skb1277net/inet/ip.cskb2->free = skb->free;
skb1336net/inet/ip.cstatic void ip_forward(struct sk_buff *skb, struct device *dev, int is_frag)
skb1352net/inet/ip.cif(memcmp((char *)&skb[1],dev->dev_addr,dev->addr_len))
skb1369net/inet/ip.ciph = skb->h.iph;
skb1378net/inet/ip.cicmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, dev);
skb1404net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, dev);
skb1433net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, dev);
skb1465net/inet/ip.cin_ntoa(raddr), dev2->name, skb->len));
skb1476net/inet/ip.cskb2 = alloc_skb(dev2->hard_header_len + skb->len, GFP_ATOMIC);
skb1488net/inet/ip.cskb2->len = skb->len + dev2->hard_header_len;
skb1494net/inet/ip.cmemcpy(ptr + dev2->hard_header_len, skb->h.raw, skb->len);
skb1497net/inet/ip.c(void) ip_send(skb2, raddr, skb->len, dev2, dev2->pa_addr);
skb1536net/inet/ip.cint ip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb1538net/inet/ip.cstruct iphdr *iph = skb->h.iph;
skb1557net/inet/ip.cskb->ip_hdr = iph;
skb1568net/inet/ip.cif (skb->len<sizeof(struct iphdr) || iph->ihl<5 || iph->version != 4 || ip_fast_csum((unsigned char *)iph, iph->ihl) !=0) 
skb1574net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1583net/inet/ip.cskb->len=ntohs(iph->tot_len);
skb1629net/inet/ip.cip_forward(skb, dev, is_frag);
skb1640net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1652net/inet/ip.cskb=ip_defrag(iph,skb,dev);
skb1653net/inet/ip.cif(skb==NULL)
skb1655net/inet/ip.ciph=skb->h.iph;
skb1660net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev);
skb1661net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1670net/inet/ip.cskb->ip_hdr = iph;
skb1671net/inet/ip.cskb->h.raw += iph->ihl*4;
skb1700net/inet/ip.cskb2 = alloc_skb(skb->mem_len-sizeof(struct sk_buff), GFP_ATOMIC);
skb1703net/inet/ip.cmemcpy(skb2, skb, skb2->mem_len);
skb1706net/inet/ip.c(unsigned long) skb->ip_hdr -
skb1707net/inet/ip.c(unsigned long)skb);
skb1710net/inet/ip.c(unsigned long) skb->h.raw -
skb1711net/inet/ip.c(unsigned long)skb);
skb1714net/inet/ip.cskb2 = skb_clone(skb, GFP_ATOMIC);
skb1721net/inet/ip.cskb2 = skb;
skb1746net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev);
skb1747net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1763net/inet/ip.cstruct sk_buff *skb, int free)
skb1779net/inet/ip.cIS_SKB(skb);
skb1785net/inet/ip.cskb->free = free;
skb1786net/inet/ip.cskb->dev = dev;
skb1787net/inet/ip.cskb->when = jiffies;
skb1799net/inet/ip.cptr = skb->data;
skb1802net/inet/ip.cskb->ip_hdr = iph;
skb1803net/inet/ip.ciph->tot_len = ntohs(skb->len-dev->hard_header_len);
skb1811net/inet/ip.cif(skb->len > dev->mtu)
skb1813net/inet/ip.cip_fragment(sk,skb,dev,0);
skb1814net/inet/ip.cIS_SKB(skb);
skb1815net/inet/ip.ckfree_skb(skb,FREE_WRITE);
skb1834net/inet/ip.cif (skb->next != NULL) 
skb1837net/inet/ip.cskb_unlink(skb);
skb1858net/inet/ip.cif (skb->link3 != NULL) 
skb1861net/inet/ip.cskb->link3 = NULL;
skb1865net/inet/ip.csk->send_tail = skb;
skb1866net/inet/ip.csk->send_head = skb;
skb1870net/inet/ip.csk->send_tail->link3 = skb;
skb1871net/inet/ip.csk->send_tail = skb;
skb1883net/inet/ip.cskb->sk = sk;
skb1899net/inet/ip.cdev_queue_xmit(skb, dev, sk->priority);
skb1903net/inet/ip.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb1910net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1922net/inet/ip.cstruct sk_buff * skb;
skb1928net/inet/ip.cskb = sk->send_head;
skb1931net/inet/ip.cwhile (skb != NULL) 
skb1933net/inet/ip.cdev = skb->dev;
skb1934net/inet/ip.cIS_SKB(skb);
skb1944net/inet/ip.cif (!skb->arp) 
skb1946net/inet/ip.cif (dev->rebuild_header(skb->data, dev, skb->raddr, NULL)) 
skb1950net/inet/ip.cskb = skb->link3;
skb1955net/inet/ip.cskb->when = jiffies;
skb1971net/inet/ip.cif (sk && !skb_device_locked(skb))
skb1974net/inet/ip.cskb_unlink(skb);
skb1977net/inet/ip.cdev_queue_xmit(skb, dev, sk->priority);
skb1998net/inet/ip.cskb = skb->link3;
skb45net/inet/ip.hstruct sk_buff *skb;      /* complete received fragment    */
skb72net/inet/ip.hextern int    ip_build_header(struct sk_buff *skb,
skb79net/inet/ip.hextern int    ip_rcv(struct sk_buff *skb, struct device *dev,
skb82net/inet/ip.hstruct device *dev, struct sk_buff *skb,
skb122net/inet/ipx.cstruct sk_buff *skb;
skb125net/inet/ipx.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
skb127net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb695net/inet/ipx.cint ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb703net/inet/ipx.cbuff=skb->data;
skb712net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb719net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb726net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb748net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb757net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb764net/inet/ipx.cskb2=alloc_skb(skb->len,GFP_ATOMIC);
skb767net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb772net/inet/ipx.cskb2->len=skb->len;
skb773net/inet/ipx.cmemcpy((char *)(skb2+1),(char *)(skb+1),skb->len);
skb779net/inet/ipx.cskb2=skb;
skb780net/inet/ipx.cbuff=(char *)(skb+1);
skb797net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb807net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb813net/inet/ipx.ckfree_skb(skb,FREE_READ);  /* Socket is full */
skb817net/inet/ipx.csock->rmem_alloc+=skb->mem_len;
skb818net/inet/ipx.cskb_queue_tail(&sock->receive_queue,skb);
skb820net/inet/ipx.csock->data_ready(sock,skb->len);
skb834net/inet/ipx.cstruct sk_buff *skb;
skb902net/inet/ipx.cskb=alloc_skb(size,GFP_KERNEL);
skb903net/inet/ipx.cif(skb==NULL)
skb905net/inet/ipx.cif(skb->mem_len+sk->wmem_alloc>sk->sndbuf)
skb907net/inet/ipx.ckfree_skb(skb,FREE_WRITE);
skb911net/inet/ipx.csk->wmem_alloc+=skb->mem_len;
skb912net/inet/ipx.cskb->sk=sk;
skb913net/inet/ipx.cskb->free=1;
skb914net/inet/ipx.cskb->arp=1;
skb915net/inet/ipx.cskb->len=size-sizeof(struct sk_buff);
skb919net/inet/ipx.cskb->dev=rt->dev;
skb921net/inet/ipx.cdev->hard_header(skb->data,skb->dev,
skb926net/inet/ipx.cskb);
skb931net/inet/ipx.cipx=(ipx_packet *)skb->data+skb->dev->hard_header_len;
skb948net/inet/ipx.cipx_rcv(skb,dev,NULL);
skb950net/inet/ipx.cdev_queue_xmit(skb,dev,SOPRI_NORMAL);
skb971net/inet/ipx.cstruct sk_buff *skb;
skb1001net/inet/ipx.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb1002net/inet/ipx.cif(skb==NULL)
skb1004net/inet/ipx.ccopied=(size<skb->len)?size:skb->len;
skb1005net/inet/ipx.cskb_copy_datagram(skb,sizeof(struct ipx_packet),ubuf,copied);
skb1006net/inet/ipx.csk->stamp=skb->stamp;
skb1013net/inet/ipx.caddr.sipx_port=((ipx_packet*)skb->h.raw)->ipx_source.sock;
skb1014net/inet/ipx.cmemcpy(addr.sipx_node,((ipx_packet*)skb->h.raw)->ipx_source.node,sizeof(addr.sipx_node));
skb1015net/inet/ipx.caddr.sipx_network=((ipx_packet*)skb->h.raw)->ipx_source.net;
skb1018net/inet/ipx.cskb_free_datagram(skb);
skb60net/inet/ipx.hextern int ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt);
skb65net/inet/packet.cint packet_rcv(struct sk_buff *skb, struct device *dev,  struct packet_type *pt)
skb82net/inet/packet.cskb->dev = dev;
skb83net/inet/packet.cskb->len += dev->hard_header_len;
skb85net/inet/packet.cskb->sk = sk;
skb92net/inet/packet.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
skb94net/inet/packet.cskb->sk = NULL;
skb95net/inet/packet.ckfree_skb(skb, FREE_READ);
skb98net/inet/packet.csk->rmem_alloc += skb->mem_len;  
skb104net/inet/packet.cskb_queue_tail(&sk->receive_queue,skb);
skb125net/inet/packet.cstruct sk_buff *skb;
skb187net/inet/packet.cskb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL);
skb194net/inet/packet.cif (skb == NULL) 
skb204net/inet/packet.cskb->sk = sk;
skb205net/inet/packet.cskb->free = 1;
skb206net/inet/packet.cmemcpy_fromfs(skb->data, from, len);
skb207net/inet/packet.cskb->len = len;
skb208net/inet/packet.cskb->arp = 1;    /* No ARP needs doing on this (complete) frame */
skb215net/inet/packet.cdev_queue_xmit(skb, dev, sk->priority);
skb217net/inet/packet.ckfree_skb(skb, FREE_WRITE);
skb290net/inet/packet.cstruct sk_buff *skb;
skb337net/inet/packet.cskb=skb_recv_datagram(sk,flags,noblock,&err);
skb345net/inet/packet.cif(skb==NULL)
skb353net/inet/packet.ccopied = min(len, skb->len);
skb355net/inet/packet.cmemcpy_tofs(to, skb->data, copied);  /* We can't use skb_copy_datagram here */
skb365net/inet/packet.caddr.sa_family = skb->dev->type;
skb366net/inet/packet.cmemcpy(addr.sa_data,skb->dev->name, 14);
skb375net/inet/packet.cskb_free_datagram(skb);
skb31net/inet/protocol.hint      (*handler)(struct sk_buff *skb, struct device *dev,
skb35net/inet/protocol.hint      (*frag_handler)(struct sk_buff *skb, struct device *dev,
skb96net/inet/raw.craw_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb104net/inet/raw.cskb, dev, opt, daddr, len, saddr, redo, protocol));
skb106net/inet/raw.cif (skb == NULL)
skb111net/inet/raw.ckfree_skb(skb, FREE_READ);
skb118net/inet/raw.ckfree_skb(skb, FREE_READ);
skb123net/inet/raw.cskb->sk = sk;
skb124net/inet/raw.cskb->len = len + skb->ip_hdr->ihl*sizeof(long);
skb125net/inet/raw.cskb->h.raw = (unsigned char *) skb->ip_hdr;
skb126net/inet/raw.cskb->dev = dev;
skb127net/inet/raw.cskb->saddr = daddr;
skb128net/inet/raw.cskb->daddr = saddr;
skb131net/inet/raw.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) {
skb133net/inet/raw.cskb->sk=NULL;
skb134net/inet/raw.ckfree_skb(skb, FREE_READ);
skb137net/inet/raw.csk->rmem_alloc += skb->mem_len;
skb139net/inet/raw.cskb_queue_tail(&sk->receive_queue,skb);
skb140net/inet/raw.csk->data_ready(sk,skb->len);
skb152net/inet/raw.cstruct sk_buff *skb;
skb207net/inet/raw.cskb = NULL;
skb208net/inet/raw.cwhile (skb == NULL) 
skb218net/inet/raw.cskb = sk->prot->wmalloc(sk,
skb221net/inet/raw.cif (skb == NULL) 
skb242net/inet/raw.cskb->sk = sk;
skb243net/inet/raw.cskb->free = 1;
skb244net/inet/raw.cskb->localroute = sk->localroute | (flags&MSG_DONTROUTE);
skb246net/inet/raw.ctmp = sk->prot->build_header(skb, sk->saddr, 
skb248net/inet/raw.csk->protocol, sk->opt, skb->mem_len, sk->ip_tos,sk->ip_ttl);
skb252net/inet/raw.ckfree_skb(skb,FREE_WRITE);
skb257net/inet/raw.cmemcpy_fromfs(skb->data + tmp, from, len);
skb269net/inet/raw.cbuff = skb->data;
skb276net/inet/raw.cskb->len = tmp + len;
skb278net/inet/raw.csk->prot->queue_xmit(sk, dev, skb, 1);
skb342net/inet/raw.cstruct sk_buff *skb;
skb370net/inet/raw.cskb=skb_recv_datagram(sk,flags,noblock,&err);
skb371net/inet/raw.cif(skb==NULL)
skb374net/inet/raw.ccopied = min(len, skb->len);
skb376net/inet/raw.cskb_copy_datagram(skb, 0, to, copied);
skb377net/inet/raw.csk->stamp=skb->stamp;
skb384net/inet/raw.caddr.sin_addr.s_addr = skb->daddr;
skb388net/inet/raw.cskb_free_datagram(skb);
skb26net/inet/raw.hextern int  raw_rcv(struct sk_buff *skb, struct device *dev,
skb48net/inet/skbuff.cint skb_check(struct sk_buff *skb, int head, int line, char *file)
skb51net/inet/skbuff.cif (skb->magic_debug_cookie != SK_HEAD_SKB) {
skb56net/inet/skbuff.cif (!skb->next || !skb->prev) {
skb60net/inet/skbuff.cif (skb->next->magic_debug_cookie != SK_HEAD_SKB
skb61net/inet/skbuff.c&& skb->next->magic_debug_cookie != SK_GOOD_SKB) {
skb66net/inet/skbuff.cif (skb->prev->magic_debug_cookie != SK_HEAD_SKB
skb67net/inet/skbuff.c&& skb->prev->magic_debug_cookie != SK_GOOD_SKB) {
skb74net/inet/skbuff.cstruct sk_buff *skb2 = skb->next;
skb76net/inet/skbuff.cwhile (skb2 != skb && i < 5) {
skb88net/inet/skbuff.cif (skb->next != NULL && skb->next->magic_debug_cookie != SK_HEAD_SKB
skb89net/inet/skbuff.c&& skb->next->magic_debug_cookie != SK_GOOD_SKB) {
skb94net/inet/skbuff.cif (skb->prev != NULL && skb->prev->magic_debug_cookie != SK_HEAD_SKB
skb95net/inet/skbuff.c&& skb->prev->magic_debug_cookie != SK_GOOD_SKB) {
skb102net/inet/skbuff.cif(skb->magic_debug_cookie==SK_FREED_SKB)
skb107net/inet/skbuff.cskb,skb->truesize,skb->mem_len,skb->free);
skb110net/inet/skbuff.cif(skb->magic_debug_cookie!=SK_GOOD_SKB)
skb114net/inet/skbuff.cskb,skb->truesize,skb->mem_len,skb->free);
skb117net/inet/skbuff.cif(skb->mem_len!=skb->truesize)
skb121net/inet/skbuff.cskb,skb->truesize,skb->mem_len);
skb293net/inet/skbuff.cvoid skb_unlink(struct sk_buff *skb)
skb300net/inet/skbuff.cIS_SKB(skb);
skb302net/inet/skbuff.cif(skb->prev && skb->next)
skb304net/inet/skbuff.cskb->next->prev = skb->prev;
skb305net/inet/skbuff.cskb->prev->next = skb->next;
skb306net/inet/skbuff.cskb->next = NULL;
skb307net/inet/skbuff.cskb->prev = NULL;
skb386net/inet/skbuff.cvoid kfree_skb(struct sk_buff *skb, int rw)
skb388net/inet/skbuff.cif (skb == NULL) 
skb391net/inet/skbuff.c((unsigned long *) &skb)[-1]);
skb394net/inet/skbuff.cIS_SKB(skb);
skb395net/inet/skbuff.cif (skb->lock) 
skb397net/inet/skbuff.cskb->free = 1;    /* Free when unlocked */
skb400net/inet/skbuff.cif (skb->free == 2)
skb402net/inet/skbuff.c((unsigned long *) &skb)[-1]);
skb403net/inet/skbuff.cif (skb->next)
skb405net/inet/skbuff.c((unsigned long *) &skb)[-1]);
skb406net/inet/skbuff.cif (skb->sk) 
skb408net/inet/skbuff.cif(skb->sk->prot!=NULL)
skb411net/inet/skbuff.cskb->sk->prot->rfree(skb->sk, skb->mem_addr, skb->mem_len);
skb413net/inet/skbuff.cskb->sk->prot->wfree(skb->sk, skb->mem_addr, skb->mem_len);
skb420net/inet/skbuff.cskb->sk->rmem_alloc-=skb->mem_len;
skb422net/inet/skbuff.cskb->sk->wmem_alloc-=skb->mem_len;
skb423net/inet/skbuff.cif(!skb->sk->dead)
skb424net/inet/skbuff.cwake_up_interruptible(skb->sk->sleep);
skb425net/inet/skbuff.ckfree_skbmem(skb->mem_addr,skb->mem_len);
skb429net/inet/skbuff.ckfree_skbmem(skb->mem_addr, skb->mem_len);
skb439net/inet/skbuff.cstruct sk_buff *skb;
skb451net/inet/skbuff.cskb=(struct sk_buff *)kmalloc(size,priority);
skb452net/inet/skbuff.cif (skb == NULL)
skb455net/inet/skbuff.cskb->free = 2;  /* Invalid so we pick up forgetful users */
skb456net/inet/skbuff.cskb->lock = 0;
skb457net/inet/skbuff.cskb->truesize = size;
skb458net/inet/skbuff.cskb->mem_len = size;
skb459net/inet/skbuff.cskb->mem_addr = skb;
skb460net/inet/skbuff.cskb->fraglist = NULL;
skb461net/inet/skbuff.cskb->prev = skb->next = NULL;
skb462net/inet/skbuff.cskb->link3 = NULL;
skb463net/inet/skbuff.cskb->sk = NULL;
skb464net/inet/skbuff.cskb->stamp.tv_sec=0;  /* No idea about time */
skb468net/inet/skbuff.cskb->magic_debug_cookie = SK_GOOD_SKB;
skb470net/inet/skbuff.cskb->users = 0;
skb471net/inet/skbuff.creturn skb;
skb502net/inet/skbuff.cstruct sk_buff *skb_clone(struct sk_buff *skb, int priority)
skb507net/inet/skbuff.cn=alloc_skb(skb->mem_len-sizeof(struct sk_buff),priority);
skb511net/inet/skbuff.coffset=((char *)n)-((char *)skb);
skb513net/inet/skbuff.cmemcpy(n->data,skb->data,skb->mem_len-sizeof(struct sk_buff));
skb514net/inet/skbuff.cn->len=skb->len;
skb517net/inet/skbuff.cn->when=skb->when;
skb518net/inet/skbuff.cn->dev=skb->dev;
skb519net/inet/skbuff.cn->h.raw=skb->h.raw+offset;
skb520net/inet/skbuff.cn->ip_hdr=(struct iphdr *)(((char *)skb->ip_hdr)+offset);
skb521net/inet/skbuff.cn->fraglen=skb->fraglen;
skb522net/inet/skbuff.cn->fraglist=skb->fraglist;
skb523net/inet/skbuff.cn->saddr=skb->saddr;
skb524net/inet/skbuff.cn->daddr=skb->daddr;
skb525net/inet/skbuff.cn->raddr=skb->raddr;
skb526net/inet/skbuff.cn->acked=skb->acked;
skb527net/inet/skbuff.cn->used=skb->used;
skb529net/inet/skbuff.cn->arp=skb->arp;
skb541net/inet/skbuff.cvoid skb_kept_by_device(struct sk_buff *skb)
skb543net/inet/skbuff.cskb->lock++;
skb546net/inet/skbuff.cvoid skb_device_release(struct sk_buff *skb, int mode)
skb552net/inet/skbuff.cif (!--skb->lock && skb->free == 1)
skb553net/inet/skbuff.ckfree_skb(skb,mode);
skb557net/inet/skbuff.cint skb_device_locked(struct sk_buff *skb)
skb559net/inet/skbuff.creturn skb->lock? 1 : 0;
skb136net/inet/sock.cprint_skb(struct sk_buff *skb)
skb138net/inet/sock.cif (!skb) {
skb142net/inet/sock.cprintk("  prev = %p, next = %p\n", skb->prev, skb->next);
skb143net/inet/sock.cprintk("  sk = %p link3 = %p\n", skb->sk, skb->link3);
skb144net/inet/sock.cprintk("  mem_addr = %p, mem_len = %lu\n", skb->mem_addr, skb->mem_len);
skb145net/inet/sock.cprintk("  used = %d free = %d\n", skb->used,skb->free);
skb307net/inet/sock.cstruct sk_buff *skb;
skb321net/inet/sock.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL) {
skb322net/inet/sock.cIS_SKB(skb);
skb323net/inet/sock.ckfree_skb(skb, FREE_WRITE);
skb327net/inet/sock.cwhile((skb = skb_dequeue(&sk->write_queue)) != NULL) {
skb328net/inet/sock.cIS_SKB(skb);
skb329net/inet/sock.ckfree_skb(skb, FREE_WRITE);
skb332net/inet/sock.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) {
skb337net/inet/sock.cif (skb->sk != NULL && skb->sk != sk) 
skb339net/inet/sock.cIS_SKB(skb);
skb340net/inet/sock.cskb->sk->dead = 1;
skb341net/inet/sock.cskb->sk->prot->close(skb->sk, 0);
skb343net/inet/sock.cIS_SKB(skb);
skb344net/inet/sock.ckfree_skb(skb, FREE_READ);
skb349net/inet/sock.cfor(skb = sk->send_head; skb != NULL; )
skb357net/inet/sock.cif (skb->next  && skb->prev) {
skb359net/inet/sock.cIS_SKB(skb);
skb360net/inet/sock.cskb_unlink(skb);
skb362net/inet/sock.cskb->dev = NULL;
skb363net/inet/sock.cskb2 = skb->link3;
skb364net/inet/sock.ckfree_skb(skb, FREE_WRITE);
skb365net/inet/sock.cskb = skb2;
skb371net/inet/sock.cwhile((skb=skb_dequeue(&sk->back_log))!=NULL) {
skb374net/inet/sock.ckfree_skb(skb, FREE_READ);
skb1670net/inet/sock.cstruct sk_buff *skb;
skb1679net/inet/sock.cwhile((skb = skb_dequeue(&sk->back_log)) != NULL) {
skb1681net/inet/sock.cDPRINTF((DBG_INET, "release_sock: skb = %X:\n", skb));
skb1682net/inet/sock.cif (sk->prot->rcv) sk->prot->rcv(skb, skb->dev, sk->opt,
skb1683net/inet/sock.cskb->saddr, skb->len, skb->daddr, 1,
skb200net/inet/sock.hint      (*build_header)(struct sk_buff *skb,
skb209net/inet/sock.hstruct device *dev, struct sk_buff *skb,
skb290net/inet/tcp.cstruct sk_buff *skb;
skb300net/inet/tcp.cif (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
skb313net/inet/tcp.cif (before(counted, skb->h.th->seq))   /* Found a hole so stops here */
skb315net/inet/tcp.csum = skb->len -(counted - skb->h.th->seq);  /* Length - header but start from where we are up to (avoid overlaps) */
skb316net/inet/tcp.cif (skb->h.th->syn)
skb320net/inet/tcp.cif (skb->h.th->syn) amount--;
skb323net/inet/tcp.cif (amount && skb->h.th->psh) break;
skb324net/inet/tcp.cskb = skb->next;
skb325net/inet/tcp.c} while(skb != (struct sk_buff *)&sk->receive_queue);
skb559net/inet/tcp.cstatic void tcp_send_skb(struct sock *sk, struct sk_buff *skb)
skb562net/inet/tcp.cstruct tcphdr * th = skb->h.th;
skb565net/inet/tcp.csize = skb->len - ((unsigned char *) th - skb->data);
skb568net/inet/tcp.cif (size < sizeof(struct tcphdr) || size > skb->len) {
skb570net/inet/tcp.cskb, skb->data, th, skb->len);
skb571net/inet/tcp.ckfree_skb(skb, FREE_WRITE);
skb580net/inet/tcp.ckfree_skb(skb,FREE_WRITE);
skb589net/inet/tcp.cskb->h.seq = ntohl(th->seq) + size - 4*th->doff;
skb590net/inet/tcp.cif (after(skb->h.seq, sk->window_seq) ||
skb597net/inet/tcp.cif (skb->next != NULL) {
skb599net/inet/tcp.cskb_unlink(skb);
skb601net/inet/tcp.cskb_queue_tail(&sk->write_queue, skb);
skb608net/inet/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, 0);
skb614net/inet/tcp.cstruct sk_buff * skb;
skb619net/inet/tcp.cskb = sk->partial;
skb620net/inet/tcp.cif (skb) {
skb625net/inet/tcp.creturn skb;
skb630net/inet/tcp.cstruct sk_buff *skb;
skb634net/inet/tcp.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL)
skb635net/inet/tcp.ctcp_send_skb(sk, skb);
skb638net/inet/tcp.cvoid tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk)
skb648net/inet/tcp.csk->partial = skb;
skb785net/inet/tcp.cstruct sk_buff *skb;
skb905net/inet/tcp.cif ((skb = tcp_dequeue_partial(sk)) != NULL) 
skb910net/inet/tcp.chdrlen = ((unsigned long)skb->h.th - (unsigned long)skb->data)
skb916net/inet/tcp.ccopy = min(sk->mss - (skb->len - hdrlen), len);
skb924net/inet/tcp.cmemcpy_fromfs(skb->data + skb->len, from, copy);
skb925net/inet/tcp.cskb->len += copy;
skb931net/inet/tcp.cif ((skb->len - hdrlen) >= sk->mss ||
skb933net/inet/tcp.ctcp_send_skb(sk, skb);
skb935net/inet/tcp.ctcp_enqueue_partial(skb, sk);
skb972net/inet/tcp.cskb = prot->wmalloc(sk, sk->mtu + 128 + prot->max_header, 0, GFP_KERNEL);
skb974net/inet/tcp.csend_tmp = skb;
skb982net/inet/tcp.cskb = prot->wmalloc(sk, copy + prot->max_header , 0, GFP_KERNEL);
skb990net/inet/tcp.cif (skb == NULL) 
skb1030net/inet/tcp.cskb->len = 0;
skb1031net/inet/tcp.cskb->sk = sk;
skb1032net/inet/tcp.cskb->free = 0;
skb1033net/inet/tcp.cskb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
skb1035net/inet/tcp.cbuff = skb->data;
skb1042net/inet/tcp.ctmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
skb1043net/inet/tcp.cIPPROTO_TCP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl);
skb1046net/inet/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
skb1053net/inet/tcp.cskb->len += tmp;
skb1054net/inet/tcp.cskb->dev = dev;
skb1056net/inet/tcp.cskb->h.th =(struct tcphdr *) buff;
skb1060net/inet/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
skb1073net/inet/tcp.cskb->len += tmp;
skb1079net/inet/tcp.cskb->len += copy;
skb1080net/inet/tcp.cskb->free = 0;
skb1088net/inet/tcp.ctcp_send_skb(sk, skb);
skb1219net/inet/tcp.cstruct sk_buff *skb;
skb1234net/inet/tcp.cwhile((skb=skb_peek(&sk->receive_queue)) != NULL) 
skb1236net/inet/tcp.cif (!skb->used) 
skb1238net/inet/tcp.cskb_unlink(skb);
skb1239net/inet/tcp.cskb->sk = sk;
skb1240net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb1392net/inet/tcp.cstruct sk_buff * skb;
skb1403net/inet/tcp.cskb = skb_peek(&sk->receive_queue);
skb1405net/inet/tcp.cif (!skb)
skb1407net/inet/tcp.cif (before(1+*seq, skb->h.th->seq))
skb1409net/inet/tcp.coffset = 1 + *seq - skb->h.th->seq;
skb1410net/inet/tcp.cif (skb->h.th->syn)
skb1412net/inet/tcp.cif (offset < skb->len)
skb1415net/inet/tcp.cskb->used = 1;
skb1416net/inet/tcp.cskb = skb->next;
skb1417net/inet/tcp.c} while (skb != (struct sk_buff *)&sk->receive_queue);
skb1460net/inet/tcp.cused = skb->len - offset;
skb1478net/inet/tcp.cmemcpy_tofs(to,((unsigned char *)skb->h.th) +
skb1479net/inet/tcp.cskb->h.th->doff*4 + offset, used);
skb1486net/inet/tcp.cif (!(flags & MSG_PEEK) && (used + offset >= skb->len))
skb1487net/inet/tcp.cskb->used = 1;
skb1811net/inet/tcp.ctcp_conn_request(struct sock *sk, struct sk_buff *skb,
skb1825net/inet/tcp.csk, skb, daddr, saddr, opt, dev));
skb1827net/inet/tcp.cth = skb->h.th;
skb1836net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb1846net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb1861net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb1895net/inet/tcp.cnewsk->acked_seq = skb->h.th->seq+1;
skb1896net/inet/tcp.cnewsk->fin_seq = skb->h.th->seq;
skb1897net/inet/tcp.cnewsk->copied_seq = skb->h.th->seq;
skb1908net/inet/tcp.cnewsk->dummy_th.source = skb->h.th->dest;
skb1909net/inet/tcp.cnewsk->dummy_th.dest = skb->h.th->source;
skb1925net/inet/tcp.cnewsk->acked_seq = skb->h.th->seq + 1;
skb1926net/inet/tcp.cnewsk->copied_seq = skb->h.th->seq;
skb1930net/inet/tcp.cnewsk->ip_tos=skb->ip_hdr->tos;
skb1950net/inet/tcp.ctcp_options(newsk,skb->h.th);
skb1957net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb1979net/inet/tcp.cskb->sk = sk;
skb1980net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb1988net/inet/tcp.cmemcpy(t1, skb->h.th, sizeof(*t1));
skb1992net/inet/tcp.ct1->dest = skb->h.th->source;
skb2005net/inet/tcp.ct1->ack_seq = ntohl(skb->h.th->seq+1);
skb2018net/inet/tcp.cskb->sk = newsk;
skb2021net/inet/tcp.csk->rmem_alloc -= skb->mem_len;
skb2022net/inet/tcp.cnewsk->rmem_alloc += skb->mem_len;
skb2024net/inet/tcp.cskb_queue_tail(&sk->receive_queue,skb);
skb2058net/inet/tcp.cstruct sk_buff *skb;
skb2061net/inet/tcp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
skb2063net/inet/tcp.cif(skb->len > 0 && after(skb->h.th->seq + skb->len + 1 , sk->copied_seq))
skb2065net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2215net/inet/tcp.cstruct sk_buff *skb;
skb2224net/inet/tcp.cwhile((skb = skb_peek(&sk->write_queue)) != NULL &&
skb2225net/inet/tcp.cbefore(skb->h.seq, sk->window_seq + 1) &&
skb2228net/inet/tcp.cbefore(skb->h.seq, sk->rcv_ack_seq + 1))
skb2230net/inet/tcp.cIS_SKB(skb);
skb2231net/inet/tcp.cskb_unlink(skb);
skb2235net/inet/tcp.cif (before(skb->h.seq, sk->rcv_ack_seq +1)) {
skb2237net/inet/tcp.ckfree_skb(skb, FREE_WRITE);
skb2240net/inet/tcp.csk->sent_seq = skb->h.seq;
skb2241net/inet/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
skb2255net/inet/tcp.cstruct sk_buff *skb,*skb2,*skb3;
skb2257net/inet/tcp.cfor (skb = sk->send_head; skb != NULL; skb = skb2) {
skb2258net/inet/tcp.cskb2 = skb->link3;
skb2260net/inet/tcp.cskb->link3 = list;
skb2261net/inet/tcp.csk->send_tail = skb;
skb2262net/inet/tcp.clist = skb;
skb2266net/inet/tcp.cbefore(skb->h.seq, skb3->link3->h.seq)) {
skb2267net/inet/tcp.cskb->link3 = skb3->link3;
skb2268net/inet/tcp.cskb3->link3 = skb;
skb2269net/inet/tcp.cif (skb->link3 == NULL) sk->send_tail = skb;
skb2331net/inet/tcp.cstruct sk_buff *skb;
skb2344net/inet/tcp.cskb = skb2;
skb2345net/inet/tcp.cskb2 = skb->link3;
skb2346net/inet/tcp.cskb->link3 = NULL;
skb2347net/inet/tcp.cif (after(skb->h.seq, sk->window_seq)) {
skb2350net/inet/tcp.cif (skb->next != NULL) {
skb2351net/inet/tcp.cskb_unlink(skb);        
skb2355net/inet/tcp.cskb_queue_head(&sk->write_queue,skb);
skb2357net/inet/tcp.cskb_append(wskb,skb);
skb2358net/inet/tcp.cwskb = skb;
skb2361net/inet/tcp.csk->send_head = skb;
skb2362net/inet/tcp.csk->send_tail = skb;
skb2364net/inet/tcp.csk->send_tail->link3 = skb;
skb2365net/inet/tcp.csk->send_tail = skb;
skb2367net/inet/tcp.cskb->link3 = NULL;
skb2651net/inet/tcp.ctcp_data(struct sk_buff *skb, struct sock *sk, 
skb2658net/inet/tcp.cth = skb->h.th;
skb2660net/inet/tcp.cskb->len = len -(th->doff*4);
skb2662net/inet/tcp.cDPRINTF((DBG_TCP, "tcp_data len = %d sk = %X:\n", skb->len, sk));
skb2664net/inet/tcp.csk->bytes_rcv += skb->len;
skb2665net/inet/tcp.cif (skb->len == 0 && !th->fin && !th->urg && !th->psh) {
skb2668net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2673net/inet/tcp.csk->acked_seq = th->seq + skb->len + th->syn + th->fin;
skb2674net/inet/tcp.ctcp_reset(sk->saddr, sk->daddr, skb->h.th,
skb2675net/inet/tcp.csk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl);
skb2681net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2696net/inet/tcp.cDPRINTF((DBG_TCP, "tcp_data: skb = %X:\n", skb));
skb2697net/inet/tcp.cskb_queue_head(&sk->receive_queue,skb);
skb2706net/inet/tcp.cprintk("skb->h.th->seq = %ld\n",skb->h.th->seq);
skb2710net/inet/tcp.cif (th->seq==skb1->h.th->seq && skb->len>= skb1->len)
skb2712net/inet/tcp.cskb_append(skb1,skb);
skb2721net/inet/tcp.cskb_append(skb1,skb);
skb2726net/inet/tcp.cskb_queue_head(&sk->receive_queue, skb);
skb2730net/inet/tcp.cDPRINTF((DBG_TCP, "skb = %X:\n", skb));
skb2733net/inet/tcp.cth->ack_seq = th->seq + skb->len;
skb2755net/inet/tcp.cskb->acked = 1;
skb2758net/inet/tcp.cif (skb->h.th->fin) {
skb2763net/inet/tcp.cfor(skb2 = skb->next;
skb2815net/inet/tcp.cif (!skb->acked) {
skb2980net/inet/tcp.cstruct sk_buff *skb;
skb2997net/inet/tcp.cwhile((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
skb3017net/inet/tcp.cnewsk = skb->sk;
skb3019net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3244net/inet/tcp.ctcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb3251net/inet/tcp.cif (!skb) {
skb3264net/inet/tcp.cth = skb->h.th;
skb3269net/inet/tcp.cDPRINTF((DBG_TCP, "len = %d, redo = %d, skb=%X\n", len, redo, skb));
skb3282net/inet/tcp.cskb->sk = NULL;
skb3285net/inet/tcp.ckfree_skb(skb,FREE_READ);
skb3298net/inet/tcp.ctcp_reset(daddr, saddr, th, &tcp_prot, opt,dev,skb->ip_hdr->tos,255);
skb3299net/inet/tcp.cskb->sk = NULL;
skb3300net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3304net/inet/tcp.cskb->len = len;
skb3305net/inet/tcp.cskb->sk = sk;
skb3306net/inet/tcp.cskb->acked = 0;
skb3307net/inet/tcp.cskb->used = 0;
skb3308net/inet/tcp.cskb->free = 0;
skb3309net/inet/tcp.cskb->saddr = daddr;
skb3310net/inet/tcp.cskb->daddr = saddr;
skb3315net/inet/tcp.cskb_queue_head(&sk->back_log, skb);
skb3334net/inet/tcp.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) {
skb3335net/inet/tcp.cskb->sk = NULL;
skb3337net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3341net/inet/tcp.csk->rmem_alloc += skb->mem_len;
skb3360net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3373net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3401net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3416net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3422net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3428net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3433net/inet/tcp.cif (tcp_data(skb, sk, saddr, len)) {
skb3434net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3441net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3452net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3462net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3468net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3474net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3487net/inet/tcp.ctcp_conn_request(sk, skb, daddr, saddr, opt, dev);
skb3492net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3499net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3508net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3525net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3536net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3549net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3560net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3577net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3617net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3622net/inet/tcp.cif (tcp_data(skb, sk, saddr, len))
skb3623net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3632net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3638net/inet/tcp.cif (tcp_data(skb, sk, saddr, len)) {
skb3639net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb119net/inet/tcp.hextern int  tcp_rcv(struct sk_buff *skb, struct device *dev,
skb168net/inet/timer.cstruct sk_buff *skb;
skb173net/inet/timer.cskb = sk->send_head;
skb174net/inet/timer.cif (!skb) {
skb177net/inet/timer.cif (jiffies < skb->when + sk->rto) {
skb178net/inet/timer.creset_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies);
skb256net/inet/udp.cstruct sk_buff *skb;
skb277net/inet/udp.cskb = sk->prot->wmalloc(sk, size, 0, GFP_KERNEL);
skb280net/inet/udp.cif (skb == NULL) 
skb283net/inet/udp.cskb->sk       = NULL;  /* to avoid changing sk->saddr */
skb284net/inet/udp.cskb->free     = 1;
skb285net/inet/udp.cskb->localroute = sk->localroute|(rt&MSG_DONTROUTE);
skb291net/inet/udp.cbuff = skb->data;
skb295net/inet/udp.csaddr, sin->sin_addr.s_addr, dev, IPPROTO_UDP, skb->mem_len));
skb296net/inet/udp.ctmp = sk->prot->build_header(skb, saddr, sin->sin_addr.s_addr,
skb297net/inet/udp.c&dev, IPPROTO_UDP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl);
skb298net/inet/udp.cskb->sk=sk;  /* So memory is freed correctly */
skb306net/inet/udp.csk->prot->wfree(sk, skb->mem_addr, skb->mem_len);
skb311net/inet/udp.csaddr = skb->saddr; /*dev->pa_addr;*/
skb314net/inet/udp.cskb->len = tmp + sizeof(struct udphdr) + len;  /* len + UDP + IP + MAC */
skb315net/inet/udp.cskb->dev = dev;
skb337net/inet/udp.cudp_send_check(uh, saddr, sin->sin_addr.s_addr, skb->len - tmp, sk);
skb345net/inet/udp.csk->prot->queue_xmit(sk, dev, skb, 1);
skb473net/inet/udp.cstruct sk_buff *skb;
skb478net/inet/udp.cskb = skb_peek(&sk->receive_queue);
skb479net/inet/udp.cif (skb != NULL) {
skb485net/inet/udp.camount = skb->len;
skb512net/inet/udp.cstruct sk_buff *skb;
skb567net/inet/udp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb568net/inet/udp.cif(skb==NULL)
skb571net/inet/udp.ccopied = min(len, skb->len);
skb577net/inet/udp.cskb_copy_datagram(skb,sizeof(struct udphdr),to,copied);
skb578net/inet/udp.csk->stamp=skb->stamp;
skb586net/inet/udp.caddr.sin_port = skb->h.uh->source;
skb587net/inet/udp.caddr.sin_addr.s_addr = skb->daddr;
skb591net/inet/udp.cskb_free_datagram(skb);
skb650net/inet/udp.cint udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb660net/inet/udp.cuh = (struct udphdr *) skb->h.uh;
skb671net/inet/udp.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, dev);
skb677net/inet/udp.cskb->sk = NULL;
skb678net/inet/udp.ckfree_skb(skb, FREE_WRITE);
skb687net/inet/udp.ckfree_skb(skb, FREE_WRITE);
skb691net/inet/udp.cskb->sk = sk;
skb692net/inet/udp.cskb->dev = dev;
skb693net/inet/udp.cskb->len = len;
skb699net/inet/udp.cskb->daddr = saddr;
skb700net/inet/udp.cskb->saddr = daddr;
skb707net/inet/udp.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
skb712net/inet/udp.cskb->sk = NULL;
skb713net/inet/udp.ckfree_skb(skb, FREE_WRITE);
skb717net/inet/udp.csk->rmem_alloc += skb->mem_len;
skb731net/inet/udp.cskb->len = len - sizeof(*uh);  
skb732net/inet/udp.cskb_queue_tail(&sk->receive_queue,skb);
skb736net/inet/udp.csk->data_ready(sk,skb->len);
skb43net/inet/udp.hextern int  udp_rcv(struct sk_buff *skb, struct device *dev,