taglinefilesource code
skb61drivers/net/3c501.cstatic int  el_start_xmit(struct sk_buff *skb, struct device *dev);
skb264drivers/net/3c501.cel_start_xmit(struct sk_buff *skb, struct device *dev)
skb289drivers/net/3c501.cif (skb == NULL) {
skb295drivers/net/3c501.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
skb296drivers/net/3c501.cskb->dev = dev;
skb297drivers/net/3c501.carp_queue (skb);
skb300drivers/net/3c501.cskb->arp=1;
skb302drivers/net/3c501.cif (skb->len <= 0)
skb306drivers/net/3c501.cprintk("%s: el_start_xmit(%d)...", dev->name, skb->len);
skb312drivers/net/3c501.cint gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
skb313drivers/net/3c501.cunsigned char *buf = (void *)(skb+1);
skb323drivers/net/3c501.coutsb(DATAPORT,buf,skb->len);
skb331drivers/net/3c501.cif (skb->free)
skb332drivers/net/3c501.ckfree_skb (skb, FREE_WRITE);
skb438drivers/net/3c501.cstruct sk_buff *skb;
skb454drivers/net/3c501.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb456drivers/net/3c501.cif (skb == NULL) {
skb461drivers/net/3c501.cskb->mem_len = sksize;
skb462drivers/net/3c501.cskb->mem_addr = skb;
skb463drivers/net/3c501.cskb->len = pkt_len;
skb464drivers/net/3c501.cskb->dev = dev;
skb466drivers/net/3c501.cinsb(DATAPORT, (void *)(skb+1), pkt_len);
skb469drivers/net/3c501.cnetif_rx(skb);
skb471drivers/net/3c501.cskb->lock = 0;
skb472drivers/net/3c501.cif (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
skb473drivers/net/3c501.ckfree_skbmem(skb, sksize);
skb262drivers/net/3c507.cstatic int  el16_send_packet(struct sk_buff *skb, struct device *dev);
skb445drivers/net/3c507.cel16_send_packet(struct sk_buff *skb, struct device *dev)
skb480drivers/net/3c507.cif (skb == NULL) {
skb487drivers/net/3c507.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
skb488drivers/net/3c507.cskb->dev = dev;
skb489drivers/net/3c507.carp_queue (skb);
skb492drivers/net/3c507.cskb->arp=1;
skb498drivers/net/3c507.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb499drivers/net/3c507.cunsigned char *buf = (void *)(skb+1);
skb509drivers/net/3c507.cif (skb->free)
skb510drivers/net/3c507.ckfree_skb (skb, FREE_WRITE);
skb843drivers/net/3c507.cstruct sk_buff *skb;
skb847drivers/net/3c507.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb848drivers/net/3c507.cif (skb == NULL) {
skb853drivers/net/3c507.cskb->mem_len = sksize;
skb854drivers/net/3c507.cskb->mem_addr = skb;
skb855drivers/net/3c507.cskb->len = pkt_len;
skb856drivers/net/3c507.cskb->dev = dev;
skb859drivers/net/3c507.cmemcpy((unsigned char *) (skb + 1), data_frame + 5, pkt_len);
skb862drivers/net/3c507.cnetif_rx(skb);
skb864drivers/net/3c507.cskb->lock = 0;
skb865drivers/net/3c507.cif (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
skb866drivers/net/3c507.ckfree_skbmem(skb, sksize);
skb76drivers/net/3c509.cstatic int el3_start_xmit(struct sk_buff *skb, struct device *dev);
skb344drivers/net/3c509.cel3_start_xmit(struct sk_buff *skb, struct device *dev)
skb363drivers/net/3c509.cif (skb == NULL) {
skb369drivers/net/3c509.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
skb370drivers/net/3c509.cskb->dev = dev;
skb371drivers/net/3c509.carp_queue (skb);
skb374drivers/net/3c509.cskb->arp=1;
skb376drivers/net/3c509.cif (skb->len <= 0)
skb381drivers/net/3c509.cdev->name, skb->len, inw(ioaddr + EL3_STATUS));
skb404drivers/net/3c509.coutw(skb->len, ioaddr + TX_FIFO);
skb407drivers/net/3c509.coutsl(ioaddr + TX_FIFO, (void *)(skb+1), (skb->len + 3) >> 2);
skb417drivers/net/3c509.cif (skb->free)
skb418drivers/net/3c509.ckfree_skb (skb, FREE_WRITE);
skb567drivers/net/3c509.cstruct sk_buff *skb;
skb569drivers/net/3c509.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb573drivers/net/3c509.cif (skb != NULL) {
skb574drivers/net/3c509.cskb->mem_len = sksize;
skb575drivers/net/3c509.cskb->mem_addr = skb;
skb576drivers/net/3c509.cskb->len = pkt_len;
skb577drivers/net/3c509.cskb->dev = dev;
skb580drivers/net/3c509.cinsl(ioaddr+RX_FIFO, (void *)(skb+1),
skb584drivers/net/3c509.cnetif_rx(skb);
skb588drivers/net/3c509.cskb->lock = 0;
skb589drivers/net/3c509.cif (dev_rint((unsigned char *)skb, pkt_len,
skb604drivers/net/3c509.ckfree_s(skb, sksize);
skb127drivers/net/8390.cstatic int ei_start_xmit(struct sk_buff *skb, struct device *dev)
skb159drivers/net/8390.cif (skb == NULL) {
skb164drivers/net/8390.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
skb165drivers/net/8390.cskb->dev = dev;
skb166drivers/net/8390.carp_queue (skb);
skb169drivers/net/8390.cskb->arp=1;
skb171drivers/net/8390.cif (skb->len <= 0)
skb173drivers/net/8390.clength = skb->len;
skb223drivers/net/8390.cei_block_output(dev, length, (unsigned char *)(skb+1), output_page);
skb237drivers/net/8390.cei_block_output(dev, length, (unsigned char *)(skb+1),
skb243drivers/net/8390.cif (skb->free)
skb244drivers/net/8390.ckfree_skb (skb, FREE_WRITE);
skb484drivers/net/8390.cstruct sk_buff *skb;
skb486drivers/net/8390.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb487drivers/net/8390.cif (skb == NULL) {
skb494drivers/net/8390.cskb->mem_len = sksize;
skb495drivers/net/8390.cskb->mem_addr = skb;
skb496drivers/net/8390.cskb->len = pkt_len;
skb497drivers/net/8390.cskb->dev = dev;
skb500drivers/net/8390.cei_block_input(dev, pkt_len, (char *)(skb+1),
skb503drivers/net/8390.cnetif_rx(skb);
skb505drivers/net/8390.cskb->lock = 0;
skb506drivers/net/8390.cif (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev)) {
skb507drivers/net/8390.ckfree_skbmem(skb, sksize);
skb116drivers/net/at1700.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb367drivers/net/at1700.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb398drivers/net/at1700.cif (skb == NULL) {
skb405drivers/net/at1700.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
skb406drivers/net/at1700.cskb->dev = dev;
skb407drivers/net/at1700.carp_queue (skb);
skb410drivers/net/at1700.cskb->arp=1;
skb417drivers/net/at1700.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb418drivers/net/at1700.cunsigned char *buf = (void *)(skb+1);
skb422drivers/net/at1700.cskb->len);
skb446drivers/net/at1700.cif (skb->free)
skb447drivers/net/at1700.ckfree_skb (skb, FREE_WRITE);
skb532drivers/net/at1700.cstruct sk_buff *skb;
skb541drivers/net/at1700.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb542drivers/net/at1700.cif (skb == NULL) {
skb549drivers/net/at1700.cskb->mem_len = sksize;
skb550drivers/net/at1700.cskb->mem_addr = skb;
skb551drivers/net/at1700.cskb->len = pkt_len;
skb552drivers/net/at1700.cskb->dev = dev;
skb555drivers/net/at1700.cinsw(ioaddr + DATAPORT, (void *)(skb+1), (pkt_len + 1) >> 1);
skb561drivers/net/at1700.cprintk(" %02x", ((unsigned char*)(skb + 1))[i]);
skb566drivers/net/at1700.cnetif_rx(skb);
skb568drivers/net/at1700.cskb->lock = 0;
skb569drivers/net/at1700.cif (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
skb570drivers/net/at1700.ckfree_s(skb, sksize);
skb142drivers/net/atp.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb449drivers/net/atp.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb473drivers/net/atp.cif (skb == NULL) {
skb480drivers/net/atp.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
skb481drivers/net/atp.cskb->dev = dev;
skb482drivers/net/atp.carp_queue (skb);
skb485drivers/net/atp.cskb->arp=1;
skb492drivers/net/atp.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb493drivers/net/atp.cunsigned char *buf = (void *)(skb+1);
skb521drivers/net/atp.cif (skb->free)
skb522drivers/net/atp.ckfree_skb (skb, FREE_WRITE);
skb670drivers/net/atp.cstruct sk_buff *skb;
skb672drivers/net/atp.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb673drivers/net/atp.cif (skb == NULL) {
skb678drivers/net/atp.cskb->mem_len = sksize;
skb679drivers/net/atp.cskb->mem_addr = skb;
skb680drivers/net/atp.cskb->len = pkt_len;
skb681drivers/net/atp.cskb->dev = dev;
skb684drivers/net/atp.cread_block(ioaddr, pkt_len, (unsigned char *)(skb + 1), dev->if_port);
skb687drivers/net/atp.cunsigned char *data = (unsigned char *)(skb + 1);
skb695drivers/net/atp.cnetif_rx(skb);
skb697drivers/net/atp.cskb->lock = 0;
skb698drivers/net/atp.cif (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
skb699drivers/net/atp.ckfree_s(skb, sksize);
skb226drivers/net/d_link.cstatic int  d_link_start_xmit(struct sk_buff *skb, struct device *dev);
skb384drivers/net/d_link.cd_link_start_xmit(struct sk_buff *skb, struct device *dev)
skb389drivers/net/d_link.cunsigned char  *buffer = (unsigned char *)(skb + 1);
skb397drivers/net/d_link.cif (skb == NULL) {
skb403drivers/net/d_link.cif (!skb->arp)
skb404drivers/net/d_link.cif(dev->rebuild_header(skb + 1, dev)) {
skb405drivers/net/d_link.cskb->dev = dev;
skb406drivers/net/d_link.carp_queue (skb);
skb409drivers/net/d_link.cskb->arp = 1;
skb428drivers/net/d_link.cPRINTK(("d_link_start_xmit:len=%d, page %d/%d\n", skb->len, tx_fifo_in, free_tx_pages));
skb430drivers/net/d_link.cif ((len = skb->len) < RUNT)
skb457drivers/net/d_link.cif (skb->free)
skb458drivers/net/d_link.ckfree_skb (skb, FREE_WRITE);
skb558drivers/net/d_link.cstruct sk_buff  *skb;
skb581drivers/net/d_link.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb583drivers/net/d_link.cif (skb == NULL) {
skb590drivers/net/d_link.cskb->lock = 0;
skb591drivers/net/d_link.cskb->mem_len = sksize;
skb592drivers/net/d_link.cskb->mem_addr = skb;
skb594drivers/net/d_link.cbuffer = (unsigned char *)(skb + 1);
skb603drivers/net/d_link.cif (dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev))
skb289drivers/net/eexpress.cstatic int  eexp_send_packet(struct sk_buff *skb, struct device *dev);
skb472drivers/net/eexpress.ceexp_send_packet(struct sk_buff *skb, struct device *dev)
skb507drivers/net/eexpress.cif (skb == NULL) {
skb514drivers/net/eexpress.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
skb515drivers/net/eexpress.cskb->dev = dev;
skb516drivers/net/eexpress.carp_queue (skb);
skb519drivers/net/eexpress.cskb->arp=1;
skb525drivers/net/eexpress.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb526drivers/net/eexpress.cunsigned char *buf = (void *)(skb+1);
skb536drivers/net/eexpress.cif (skb->free)
skb537drivers/net/eexpress.ckfree_skb (skb, FREE_WRITE);
skb946drivers/net/eexpress.cstruct sk_buff *skb;
skb950drivers/net/eexpress.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb951drivers/net/eexpress.cif (skb == NULL) {
skb956drivers/net/eexpress.cskb->mem_len = sksize;
skb957drivers/net/eexpress.cskb->mem_addr = skb;
skb958drivers/net/eexpress.cskb->len = pkt_len;
skb959drivers/net/eexpress.cskb->dev = dev;
skb963drivers/net/eexpress.cinsw(ioaddr, (void *)(skb+1), (pkt_len + 1) >> 1);
skb966drivers/net/eexpress.cnetif_rx(skb);
skb968drivers/net/eexpress.cskb->lock = 0;
skb969drivers/net/eexpress.cif (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
skb970drivers/net/eexpress.ckfree_s(skb, sksize);
skb211drivers/net/lance.cstatic int lance_start_xmit(struct sk_buff *skb, struct device *dev);
skb468drivers/net/lance.clance_start_xmit(struct sk_buff *skb, struct device *dev)
skb509drivers/net/lance.cif (skb == NULL) {
skb515drivers/net/lance.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
skb516drivers/net/lance.cskb->dev = dev;
skb517drivers/net/lance.carp_queue (skb);
skb520drivers/net/lance.cskb->arp=1;
skb522drivers/net/lance.cif (skb->len <= 0)
skb548drivers/net/lance.c-(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
skb550drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
skb556drivers/net/lance.cif ((int)(skb+1) + skb->len > 0x01000000) {
skb559drivers/net/lance.cdev->name, (int)(skb+1));
skb560drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb+1, skb->len);
skb563drivers/net/lance.cif (skb->free)
skb564drivers/net/lance.ckfree_skb (skb, FREE_WRITE);
skb566drivers/net/lance.clp->tx_ring[entry].base = (int)(skb+1) | 0x83000000;
skb648drivers/net/lance.cstruct sk_buff *skb = ((struct sk_buff *)databuff) - 1;
skb649drivers/net/lance.cif (skb->free)
skb650drivers/net/lance.ckfree_skb(skb, FREE_WRITE);
skb710drivers/net/lance.cstruct sk_buff *skb;
skb712drivers/net/lance.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb713drivers/net/lance.cif (skb == NULL) {
skb718drivers/net/lance.cskb->mem_len = sksize;
skb719drivers/net/lance.cskb->mem_addr = skb;
skb720drivers/net/lance.cskb->len = pkt_len;
skb721drivers/net/lance.cskb->dev = dev;
skb722drivers/net/lance.cmemcpy((unsigned char *) (skb + 1),
skb726drivers/net/lance.cnetif_rx(skb);
skb728drivers/net/lance.cskb->lock = 0;
skb729drivers/net/lance.cif (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
skb730drivers/net/lance.ckfree_skbmem(skb, sksize);
skb139drivers/net/plip.cstatic int plip_tx_packet(struct sk_buff *skb, struct device *dev);
skb264drivers/net/plip.cplip_tx_packet(struct sk_buff *skb, struct device *dev)
skb281drivers/net/plip.cif (skb == NULL) {
skb288drivers/net/plip.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
skb289drivers/net/plip.cskb->dev = dev;
skb290drivers/net/plip.carp_queue (skb);
skb293drivers/net/plip.cskb->arp=1;
skb296drivers/net/plip.cret_val = plip_send_packet(dev, (unsigned char *)(skb+1), skb->len);
skb297drivers/net/plip.cif (skb->free)
skb298drivers/net/plip.ckfree_skb (skb, FREE_WRITE);
skb424drivers/net/plip.cstruct sk_buff *skb;
skb474drivers/net/plip.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb475drivers/net/plip.cif (skb == NULL) {
skb480drivers/net/plip.cskb->lock = 0;
skb481drivers/net/plip.cskb->mem_len = sksize;
skb482drivers/net/plip.cskb->mem_addr = skb;
skb487drivers/net/plip.cunsigned char *buf = (unsigned char *) (skb+1);
skb504drivers/net/plip.c} else if(dev_rint((unsigned char *)skb, length, IN_SKBUFF, dev)) {
skb109drivers/net/skeleton.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb290drivers/net/skeleton.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb312drivers/net/skeleton.cif (skb == NULL) {
skb319drivers/net/skeleton.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
skb320drivers/net/skeleton.cskb->dev = dev;
skb321drivers/net/skeleton.carp_queue (skb);
skb324drivers/net/skeleton.cskb->arp=1;
skb331drivers/net/skeleton.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb332drivers/net/skeleton.cunsigned char *buf = (void *)(skb+1);
skb337drivers/net/skeleton.cif (skb->free)
skb338drivers/net/skeleton.ckfree_skb (skb, FREE_WRITE);
skb410drivers/net/skeleton.cstruct sk_buff *skb;
skb412drivers/net/skeleton.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb413drivers/net/skeleton.cif (skb == NULL) {
skb418drivers/net/skeleton.cskb->mem_len = sksize;
skb419drivers/net/skeleton.cskb->mem_addr = skb;
skb420drivers/net/skeleton.cskb->len = pkt_len;
skb421drivers/net/skeleton.cskb->dev = dev;
skb424drivers/net/skeleton.cmemcpy((unsigned char *) (skb + 1), (void*)dev->rmem_start,
skb427drivers/net/skeleton.cinsw(ioaddr, (void *)(skb+1), (pkt_len + 1) >> 1);
skb430drivers/net/skeleton.cnetif_rx(skb);
skb432drivers/net/skeleton.cskb->lock = 0;
skb433drivers/net/skeleton.cif (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
skb434drivers/net/skeleton.ckfree_s(skb, sksize);
skb523drivers/net/slip.csl_xmit(struct sk_buff *skb, struct device *dev)
skb532drivers/net/slip.cdev->name, skb, sl->sending));
skb546drivers/net/slip.cif (skb != NULL) {
skb550drivers/net/slip.cif(!skb->arp && dev->rebuild_header(skb+1,dev))
skb552drivers/net/slip.cskb->dev=dev;
skb553drivers/net/slip.carp_queue(skb);
skb556drivers/net/slip.cskb->arp=1;
skb561drivers/net/slip.csl_encaps(sl, (unsigned char *) (skb + 1), skb->len);
skb562drivers/net/slip.cif (skb->free) kfree_skb(skb, FREE_WRITE);
skb570drivers/net/slip.csl_type_trans (struct sk_buff *skb, struct device *dev)
skb647drivers/net/slip.csl_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
skb653drivers/net/slip.carp_add(addr,((char *)(skb+1))+8,dev);
skb121net/inet/arp.cstruct sk_buff *skb;
skb128net/inet/arp.cwhile((skb=skb_dequeue(&work_q))!=NULL)
skb130net/inet/arp.cIS_SKB(skb);
skb131net/inet/arp.cskb->magic = 0;    /* So everyone knows this is _NOT_ on the arp queue */
skb135net/inet/arp.cskb->tries--;
skb136net/inet/arp.cif (skb->tries == 0) 
skb147net/inet/arp.cskb->sk = NULL;
skb148net/inet/arp.cif(skb->free)
skb149net/inet/arp.ckfree_skb(skb, FREE_WRITE);
skb158net/inet/arp.cif (skb->arp || !skb->dev->rebuild_header(skb+1, skb->dev)) 
skb160net/inet/arp.cskb->arp  = 1;
skb161net/inet/arp.cskb->dev->queue_xmit(skb, skb->dev, 0);
skb166net/inet/arp.cskb->magic = ARP_QUEUE_MAGIC;      
skb167net/inet/arp.cskb_queue_head(&arp_q,skb);
skb180net/inet/arp.cstruct sk_buff *skb;
skb199net/inet/arp.cskb = alloc_skb(sizeof(struct sk_buff) +
skb204net/inet/arp.cif (skb == NULL) 
skb210net/inet/arp.cskb->len      = sizeof(struct arphdr) + (2 * arp1->ar_hln) + 
skb212net/inet/arp.chlen = dev->hard_header((unsigned char *)(skb+1), dev,
skb213net/inet/arp.cETH_P_ARP, src, dst, skb->len);
skb217net/inet/arp.ckfree_skb(skb, FREE_WRITE);
skb226net/inet/arp.carp2 = (struct arphdr *) ((unsigned char *) (skb+1) + hlen);
skb246net/inet/arp.cskb->free = 1;
skb247net/inet/arp.cskb->arp = 1;
skb248net/inet/arp.cskb->sk = NULL;
skb249net/inet/arp.cskb->next = NULL;
skb252net/inet/arp.cdev->queue_xmit(skb, dev, 0);
skb423net/inet/arp.cint arp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb432net/inet/arp.carp = skb->h.arp;
skb438net/inet/arp.ckfree_skb(skb, FREE_READ);
skb447net/inet/arp.ckfree_skb(skb, FREE_READ);
skb472net/inet/arp.ckfree_skb(skb, FREE_READ);
skb480net/inet/arp.ckfree_skb(skb, FREE_READ);
skb499net/inet/arp.ckfree_skb(skb, FREE_READ);
skb509net/inet/arp.ckfree_skb(skb, FREE_READ);
skb517net/inet/arp.ckfree_skb(skb, FREE_READ);
skb526net/inet/arp.ckfree_skb(skb, FREE_READ);
skb537net/inet/arp.cstruct sk_buff *skb;
skb546net/inet/arp.cskb = alloc_skb(sizeof(struct sk_buff) +
skb550net/inet/arp.cif (skb == NULL) 
skb557net/inet/arp.cskb->sk = NULL;
skb558net/inet/arp.cskb->len = sizeof(struct arphdr) +
skb560net/inet/arp.cskb->arp = 1;
skb561net/inet/arp.cskb->dev = dev;
skb562net/inet/arp.cskb->next = NULL;
skb563net/inet/arp.cskb->free = 1;
skb564net/inet/arp.ctmp = dev->hard_header((unsigned char *)(skb+1), dev,
skb565net/inet/arp.cETH_P_ARP, 0, saddr, skb->len);
skb568net/inet/arp.ckfree_skb(skb,FREE_WRITE);
skb571net/inet/arp.carp = (struct arphdr *) ((unsigned char *) (skb+1) + tmp);
skb591net/inet/arp.cdev->queue_xmit(skb, dev, 0);
skb696net/inet/arp.cvoid arp_queue(struct sk_buff *skb)
skb701net/inet/arp.cskb->tries = ARP_MAX_TRIES;
skb703net/inet/arp.cif (skb->next != NULL) 
skb706net/inet/arp.cprintk("ARP: arp_queue skb already on queue magic=%X.\n", skb->magic);
skb709net/inet/arp.cskb_queue_tail(&arp_q,skb);
skb710net/inet/arp.cskb->magic = ARP_QUEUE_MAGIC;
skb54net/inet/arp.hextern int  arp_rcv(struct sk_buff *skb, struct device *dev,
skb61net/inet/arp.hextern void  arp_queue(struct sk_buff *skb);
skb400net/inet/dev.cstruct sk_buff *skb;
skb401net/inet/dev.cwhile((skb=skb_dequeue(&dev->buffs[ct]))!=NULL)
skb402net/inet/dev.cif(skb->free)
skb403net/inet/dev.ckfree_skb(skb,FREE_WRITE);
skb414net/inet/dev.cdev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
skb421net/inet/dev.cskb, dev, pri));
skb428net/inet/dev.cIS_SKB(skb);
skb430net/inet/dev.cskb->dev = dev;
skb431net/inet/dev.cif (skb->next != NULL) {
skb447net/inet/dev.cif (dev->hard_start_xmit(skb, dev) == 0) {
skb457net/inet/dev.cskb->magic = DEV_QUEUE_MAGIC;
skb459net/inet/dev.cskb_queue_head(&dev->buffs[pri],skb);
skb461net/inet/dev.cskb_queue_tail(&dev->buffs[pri],skb);
skb462net/inet/dev.cskb->magic = DEV_QUEUE_MAGIC;
skb471net/inet/dev.cnetif_rx(struct sk_buff *skb)
skb474net/inet/dev.cskb->sk = NULL;
skb475net/inet/dev.cskb->free = 1;
skb478net/inet/dev.cIS_SKB(skb);
skb479net/inet/dev.cskb_queue_tail(&backlog,skb);
skb502net/inet/dev.cstruct sk_buff *skb = NULL;
skb509net/inet/dev.cskb = (struct sk_buff *) buff;
skb518net/inet/dev.cskb = alloc_skb(sizeof(*skb) + len, GFP_ATOMIC);
skb519net/inet/dev.cif (skb == NULL) {
skb525net/inet/dev.cskb->mem_len = sizeof(*skb) + len;
skb526net/inet/dev.cskb->mem_addr = (struct sk_buff *) skb;
skb529net/inet/dev.cto = (unsigned char *) (skb + 1);
skb544net/inet/dev.cskb->len = len;
skb545net/inet/dev.cskb->dev = dev;
skb546net/inet/dev.cskb->free = 1;
skb548net/inet/dev.cnetif_rx(skb);
skb582net/inet/dev.cstruct sk_buff *skb;
skb596net/inet/dev.cwhile((skb=skb_dequeue(&backlog))!=NULL)
skb606net/inet/dev.cskb->h.raw = (unsigned char *) (skb + 1) + skb->dev->hard_header_len;
skb607net/inet/dev.cskb->len -= skb->dev->hard_header_len;
skb619net/inet/dev.ctype = skb->dev->type_trans(skb, skb->dev);
skb632net/inet/dev.cskb2 = alloc_skb(skb->mem_len, GFP_ATOMIC);
skb635net/inet/dev.cmemcpy(skb2, (const void *) skb, skb->mem_len);
skb639net/inet/dev.c(unsigned long) skb->h.raw -
skb640net/inet/dev.c(unsigned long) skb
skb644net/inet/dev.cskb2 = skb;
skb654net/inet/dev.cptype->func(skb2, skb->dev, ptype);
skb665net/inet/dev.cskb->sk = NULL;
skb666net/inet/dev.ckfree_skb(skb, FREE_WRITE);
skb687net/inet/dev.cstruct sk_buff *skb;
skb690net/inet/dev.cwhile((skb=skb_dequeue(&dev->buffs[i]))!=NULL)
skb692net/inet/dev.cskb->magic = 0;
skb693net/inet/dev.cskb->next = NULL;
skb694net/inet/dev.cskb->prev = NULL;
skb695net/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);
skb176net/inet/eth.cvoid eth_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
skb180net/inet/eth.ceth = (struct ethhdr *) (skb + 1);
skb197net/inet/eth.cunsigned short eth_type_trans(struct sk_buff *skb, struct device *dev)
skb201net/inet/eth.ceth = (struct ethhdr *) (skb + 1);
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);
skb93net/inet/icmp.cstruct sk_buff *skb;
skb107net/inet/icmp.cskb = (struct sk_buff *) alloc_skb(len, GFP_ATOMIC);
skb111net/inet/icmp.cif (skb == NULL) 
skb114net/inet/icmp.cskb->sk = NULL;
skb122net/inet/icmp.coffset = ip_build_header(skb, dev->pa_addr, iph->saddr,
skb126net/inet/icmp.cskb->sk = NULL;
skb127net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb132net/inet/icmp.cskb->len = offset + sizeof(struct icmphdr) + sizeof(struct iphdr) + 8;
skb133net/inet/icmp.cicmph = (struct icmphdr *) ((unsigned char *) (skb + 1) + offset);
skb148net/inet/icmp.cip_queue_xmit(NULL, dev, skb, 1);
skb156net/inet/icmp.cstatic void icmp_unreach(struct icmphdr *icmph, struct sk_buff *skb)
skb216net/inet/icmp.cskb->sk = NULL;
skb217net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb225net/inet/icmp.cstatic void icmp_redirect(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev)
skb251net/inet/icmp.cskb->sk = NULL;
skb252net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb257net/inet/icmp.cstatic void icmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb269net/inet/icmp.cskb->sk = NULL;
skb270net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb283net/inet/icmp.cskb->sk = NULL;
skb284net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb302net/inet/icmp.cskb->sk = NULL;
skb303net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb311net/inet/icmp.cstatic void icmp_info(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb316net/inet/icmp.cskb->sk = NULL;
skb317net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb325net/inet/icmp.cstatic void icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb337net/inet/icmp.cskb->sk = NULL;
skb338net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb351net/inet/icmp.cskb->sk = NULL;
skb352net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb373net/inet/icmp.cskb->sk = NULL;
skb374net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb209net/inet/ip.cstatic int ip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev,
skb215net/inet/ip.cptr = (unsigned char *)(skb + 1);
skb217net/inet/ip.cskb->arp = 1;
skb225net/inet/ip.cskb->arp = 0;
skb227net/inet/ip.cskb->dev = dev;
skb238net/inet/ip.cint ip_build_header(struct sk_buff *skb, unsigned long saddr, unsigned long daddr,
skb255net/inet/ip.cskb, saddr, daddr, *dev, type, opt, len));
skb257net/inet/ip.cbuff = (unsigned char *)(skb + 1);
skb284net/inet/ip.ctmp = ip_send(skb, raddr, len, *dev, saddr);
skb288net/inet/ip.cskb->dev = *dev;
skb289net/inet/ip.cskb->saddr = saddr;
skb290net/inet/ip.cif (skb->sk) 
skb291net/inet/ip.cskb->sk->saddr = saddr;
skb640net/inet/ip.cstatic struct ipfrag *ip_frag_create(int offset, int end, struct sk_buff *skb, unsigned char *ptr)
skb656net/inet/ip.cfp->skb = skb;
skb726net/inet/ip.cIS_SKB(fp->skb);
skb727net/inet/ip.ckfree_skb(fp->skb,FREE_READ);
skb764net/inet/ip.cicmp_send(qp->fragments->skb,ICMP_TIME_EXCEEDED,
skb779net/inet/ip.cstatic struct ipq *ip_create(struct sk_buff *skb, struct iphdr *iph, struct device *dev)
skb794net/inet/ip.cmaclen = ((unsigned long) iph) - ((unsigned long) (skb + 1));
skb815net/inet/ip.cmemcpy(qp->mac, (skb + 1), maclen);
skb877net/inet/ip.cstruct sk_buff *skb;
skb885net/inet/ip.cif ((skb = alloc_skb(len,GFP_ATOMIC)) == NULL) 
skb893net/inet/ip.cskb->len = (len - qp->maclen);
skb894net/inet/ip.cskb->h.raw = (unsigned char *) (skb + 1);
skb895net/inet/ip.cskb->free = 1;
skb896net/inet/ip.cskb->lock = 1;
skb899net/inet/ip.cptr = (unsigned char *) skb->h.raw;
skb906net/inet/ip.cskb->h.raw += qp->maclen;
skb915net/inet/ip.cif(count+fp->len>skb->len)
skb919net/inet/ip.ckfree_skb(skb,FREE_WRITE);
skb932net/inet/ip.ciph = skb->h.iph;
skb935net/inet/ip.creturn(skb);
skb943net/inet/ip.cstatic struct sk_buff *ip_defrag(struct iphdr *iph, struct sk_buff *skb, struct device *dev)
skb964net/inet/ip.creturn(skb);
skb983net/inet/ip.cif ((qp = ip_create(skb, iph, dev)) == NULL) 
skb992net/inet/ip.cptr = ((unsigned char *) (skb + 1)) + dev->hard_header_len + ihl;
skb1060net/inet/ip.ctfp = ip_frag_create(offset, end, skb, ptr);
skb1095net/inet/ip.cvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
skb1105net/inet/ip.craw = (unsigned char *) (skb + 1);
skb1133net/inet/ip.cicmp_send(skb,ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, dev); 
skb1171net/inet/ip.cskb2->arp = skb->arp;
skb1172net/inet/ip.cskb2->free = skb->free;
skb1212net/inet/ip.cstatic void ip_forward(struct sk_buff *skb, struct device *dev, int is_frag)
skb1228net/inet/ip.cif(memcmp((char *)&skb[1],dev->dev_addr,dev->addr_len))
skb1237net/inet/ip.ciph = skb->h.iph;
skb1246net/inet/ip.cicmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, dev);
skb1263net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, dev);
skb1284net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, dev);
skb1306net/inet/ip.cin_ntoa(raddr), dev2->name, skb->len));
skb1311net/inet/ip.cdev2->hard_header_len + skb->len, GFP_ATOMIC);
skb1320net/inet/ip.cskb2->len = skb->len + dev2->hard_header_len;
skb1325net/inet/ip.cmemcpy(ptr + dev2->hard_header_len, skb->h.raw, skb->len);
skb1328net/inet/ip.c(void) ip_send(skb2, raddr, skb->len, dev2, dev2->pa_addr);
skb1348net/inet/ip.cint ip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb1350net/inet/ip.cstruct iphdr *iph = skb->h.iph;
skb1363net/inet/ip.cif (skb->len<sizeof(struct iphdr) || iph->ihl<5 || iph->version != 4 || ip_fast_csum((unsigned char *)iph, iph->ihl) !=0) 
skb1368net/inet/ip.cskb->sk = NULL;
skb1369net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1399net/inet/ip.cip_forward(skb, dev, is_frag);
skb1404net/inet/ip.cskb->sk = NULL;
skb1405net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1416net/inet/ip.cskb=ip_defrag(iph,skb,dev);
skb1417net/inet/ip.cif(skb==NULL)
skb1421net/inet/ip.ciph=skb->h.iph;
skb1426net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev);
skb1427net/inet/ip.cskb->sk = NULL;
skb1428net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1435net/inet/ip.cskb->ip_hdr = iph;
skb1436net/inet/ip.cskb->h.raw += iph->ihl*4;
skb1459net/inet/ip.cskb2 = alloc_skb(skb->mem_len, GFP_ATOMIC);
skb1462net/inet/ip.cmemcpy(skb2, skb, skb->mem_len);
skb1466net/inet/ip.c(unsigned long) skb->h.raw -
skb1467net/inet/ip.c(unsigned long)skb);
skb1472net/inet/ip.cskb2 = skb;
skb1496net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev);
skb1497net/inet/ip.cskb->sk = NULL;
skb1498net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1513net/inet/ip.cstruct sk_buff *skb, int free)
skb1525net/inet/ip.cIS_SKB(skb);
skb1526net/inet/ip.cskb->free = free;
skb1527net/inet/ip.cskb->dev = dev;
skb1528net/inet/ip.cskb->when = jiffies;
skb1531net/inet/ip.cptr = (unsigned char *)(skb + 1);
skb1534net/inet/ip.ciph->tot_len = ntohs(skb->len-dev->hard_header_len);
skb1536net/inet/ip.cif(skb->len > dev->mtu)
skb1539net/inet/ip.cip_fragment(sk,skb,dev,0);
skb1540net/inet/ip.cIS_SKB(skb);
skb1541net/inet/ip.ckfree_skb(skb,FREE_WRITE);
skb1549net/inet/ip.cskb->next = NULL;
skb1552net/inet/ip.cskb->magic = 1;
skb1555net/inet/ip.cskb->link3 = NULL;
skb1560net/inet/ip.csk->send_tail = skb;
skb1561net/inet/ip.csk->send_head = skb;
skb1573net/inet/ip.csk->send_tail->link3 = skb;
skb1574net/inet/ip.csk->send_tail = skb;
skb1583net/inet/ip.cskb->sk = sk;
skb1591net/inet/ip.cdev->queue_xmit(skb, dev, sk->priority);
skb1595net/inet/ip.cdev->queue_xmit(skb, dev, SOPRI_NORMAL);
skb1600net/inet/ip.cif (free) kfree_skb(skb, FREE_WRITE);
skb1607net/inet/ip.cstruct sk_buff * skb;
skb1612net/inet/ip.cskb = sk->send_head;
skb1613net/inet/ip.cwhile (skb != NULL) 
skb1615net/inet/ip.cdev = skb->dev;
skb1623net/inet/ip.cIS_SKB(skb);
skb1633net/inet/ip.cif (!skb->arp) 
skb1635net/inet/ip.cif (dev->rebuild_header(skb+1, dev)) 
skb1640net/inet/ip.cskb = (struct sk_buff *)skb->link3;
skb1644net/inet/ip.cskb->arp = 1;
skb1646net/inet/ip.cskb->when = jiffies;
skb1652net/inet/ip.cdev->queue_xmit(skb, dev, sk->priority);
skb1663net/inet/ip.cskb = (struct sk_buff *)skb->link3;
skb41net/inet/ip.hstruct sk_buff *skb;      /* complete received fragment    */
skb68net/inet/ip.hextern int    ip_build_header(struct sk_buff *skb,
skb75net/inet/ip.hextern int    ip_rcv(struct sk_buff *skb, struct device *dev,
skb78net/inet/ip.hstruct device *dev, struct sk_buff *skb,
skb49net/inet/loopback.cstatic int loopback_xmit(struct sk_buff *skb, struct device *dev)
skb54net/inet/loopback.cDPRINTF((DBG_LOOPB, "loopback_xmit(dev=%X, skb=%X)\n", dev, skb));
skb55net/inet/loopback.cif (skb == NULL || dev == NULL) 
skb68net/inet/loopback.cdone = dev_rint((unsigned char *)(skb+1), skb->len, 0, dev);
skb69net/inet/loopback.cif (skb->free) 
skb70net/inet/loopback.ckfree_skb(skb, FREE_WRITE);
skb64net/inet/packet.cint packet_rcv(struct sk_buff *skb, struct device *dev,  struct packet_type *pt)
skb69net/inet/packet.cskb->dev = dev;
skb70net/inet/packet.cskb->len += dev->hard_header_len;
skb72net/inet/packet.cskb->sk = sk;
skb75net/inet/packet.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
skb77net/inet/packet.cskb->sk = NULL;
skb78net/inet/packet.ckfree_skb(skb, FREE_READ);
skb81net/inet/packet.csk->rmem_alloc += skb->mem_len;
skb82net/inet/packet.cskb_queue_tail(&sk->rqueue,skb);
skb84net/inet/packet.csk->data_ready(sk,skb->len);    
skb98net/inet/packet.cstruct sk_buff *skb;
skb137net/inet/packet.cskb = (struct sk_buff *) sk->prot->wmalloc(sk, len+sizeof(*skb), 0, GFP_KERNEL);
skb140net/inet/packet.cif (skb == NULL) 
skb146net/inet/packet.cskb->sk = sk;
skb147net/inet/packet.cskb->free = 1;
skb148net/inet/packet.cmemcpy_fromfs (skb+1, from, len);
skb149net/inet/packet.cskb->len = len;
skb150net/inet/packet.cskb->next = NULL;
skb152net/inet/packet.cdev->queue_xmit(skb, dev, sk->priority);
skb154net/inet/packet.ckfree_skb(skb, FREE_WRITE);
skb206net/inet/packet.cstruct sk_buff *skb;
skb229net/inet/packet.cskb=skb_recv_datagram(sk,flags,noblock,&err);
skb230net/inet/packet.cif(skb==NULL)
skb232net/inet/packet.ccopied = min(len, skb->len);
skb234net/inet/packet.cmemcpy_tofs(to, skb+1, copied);  /* Don't use skb_copy_datagram here: We can't get frag chains */
skb241net/inet/packet.caddr.sa_family = skb->dev->type;
skb242net/inet/packet.cmemcpy(addr.sa_data,skb->dev->name, 14);
skb247net/inet/packet.cskb_free_datagram(skb);    /* Its either been used up, or its a peek_copy anyway */
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,
skb102net/inet/raw.cint raw_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb110net/inet/raw.cskb, dev, opt, daddr, len, saddr, redo, protocol));
skb112net/inet/raw.cif (skb == NULL) 
skb117net/inet/raw.ckfree_skb(skb, FREE_READ);
skb123net/inet/raw.ckfree_skb(skb, FREE_READ);
skb128net/inet/raw.cskb->sk = sk;
skb133net/inet/raw.cskb->len += skb->ip_hdr->ihl*sizeof(long);
skb134net/inet/raw.cskb->h.iph = skb->ip_hdr;
skb135net/inet/raw.cskb->dev = dev;
skb136net/inet/raw.cskb->saddr = daddr;
skb137net/inet/raw.cskb->daddr = saddr;
skb140net/inet/raw.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
skb142net/inet/raw.cskb->sk = NULL;
skb143net/inet/raw.ckfree_skb(skb, FREE_READ);
skb146net/inet/raw.csk->rmem_alloc += skb->mem_len;
skb147net/inet/raw.cskb_queue_tail(&sk->rqueue,skb);
skb149net/inet/raw.csk->data_ready(sk,skb->len);
skb163net/inet/raw.cstruct sk_buff *skb;
skb209net/inet/raw.cskb = NULL;
skb210net/inet/raw.cwhile (skb == NULL) 
skb220net/inet/raw.cskb = (struct sk_buff *) sk->prot->wmalloc(sk,
skb221net/inet/raw.clen+sizeof(*skb) + sk->prot->max_header,
skb223net/inet/raw.cif (skb == NULL) 
skb246net/inet/raw.cskb->sk = sk;
skb248net/inet/raw.cskb->free = 1; /* these two should be unecessary. */
skb249net/inet/raw.cskb->arp = 0;
skb251net/inet/raw.ctmp = sk->prot->build_header(skb, sk->saddr, 
skb253net/inet/raw.csk->protocol, sk->opt, skb->mem_len,
skb258net/inet/raw.ckfree_skb(skb,FREE_WRITE);
skb263net/inet/raw.cmemcpy_fromfs ((unsigned char *)(skb+1)+tmp, from, len);
skb273net/inet/raw.cbuff = (unsigned char *)(skb + 1);
skb279net/inet/raw.cskb->len = tmp + len;
skb281net/inet/raw.cif(dev!=NULL && skb->len > 4095)
skb283net/inet/raw.ckfree_skb(skb, FREE_WRITE);
skb288net/inet/raw.csk->prot->queue_xmit(sk, dev, skb, 1);
skb352net/inet/raw.cstruct sk_buff *skb;
skb377net/inet/raw.cskb=skb_recv_datagram(sk,flags,noblock,&err);
skb378net/inet/raw.cif(skb==NULL)
skb381net/inet/raw.ccopied = min(len, skb->len);
skb383net/inet/raw.cskb_copy_datagram(skb, 0, to, copied);
skb391net/inet/raw.caddr.sin_addr.s_addr = skb->daddr;
skb396net/inet/raw.cskb_free_datagram(skb);
skb26net/inet/raw.hextern int  raw_rcv(struct sk_buff *skb, struct device *dev,
skb134net/inet/sock.cprint_skb(struct sk_buff *skb)
skb136net/inet/sock.cif (!skb) {
skb140net/inet/sock.cprintk("  prev = %p, next = %p\n", skb->prev, skb->next);
skb141net/inet/sock.cprintk("  sk = %p link3 = %p\n", skb->sk, skb->link3);
skb142net/inet/sock.cprintk("  mem_addr = %p, mem_len = %lu\n", skb->mem_addr, skb->mem_len);
skb143net/inet/sock.cprintk("  used = %d free = %d\n", skb->used,skb->free);
skb308net/inet/sock.cstruct sk_buff *skb;
skb330net/inet/sock.cfor(skb = sk->wfront; skb != NULL; ) 
skb334net/inet/sock.cskb2=(struct sk_buff *)skb->next;
skb335net/inet/sock.cif (skb->magic != TCP_WRITE_QUEUE_MAGIC) {
skb337net/inet/sock.cskb->magic);
skb340net/inet/sock.cIS_SKB(skb);
skb341net/inet/sock.ckfree_skb(skb, FREE_WRITE);
skb342net/inet/sock.cskb = skb2;
skb350net/inet/sock.cwhile((skb=skb_dequeue(&sk->rqueue))!=NULL)
skb356net/inet/sock.cif (skb->sk != NULL && skb->sk != sk) 
skb358net/inet/sock.cIS_SKB(skb);
skb359net/inet/sock.cskb->sk->dead = 1;
skb360net/inet/sock.cskb->sk->prot->close(skb->sk, 0);
skb362net/inet/sock.cIS_SKB(skb);
skb363net/inet/sock.ckfree_skb(skb, FREE_READ);
skb369net/inet/sock.cfor(skb = sk->send_head; skb != NULL; ) 
skb381net/inet/sock.cif (skb->next != NULL) 
skb383net/inet/sock.cIS_SKB(skb);
skb384net/inet/sock.cskb_unlink(skb);
skb386net/inet/sock.cskb->dev = NULL;
skb388net/inet/sock.cskb2 = (struct sk_buff *)skb->link3;
skb389net/inet/sock.ckfree_skb(skb, FREE_WRITE);
skb390net/inet/sock.cskb = skb2;
skb400net/inet/sock.cskb = (struct sk_buff *)sk->back_log;
skb405net/inet/sock.cskb2 = (struct sk_buff *)skb->next;
skb406net/inet/sock.ckfree_skb(skb, FREE_READ);
skb407net/inet/sock.cskb = skb2;
skb409net/inet/sock.cwhile(skb != sk->back_log);
skb1669net/inet/sock.cstruct sk_buff *skb;
skb1672net/inet/sock.cskb =(struct sk_buff *)sk->back_log;
skb1673net/inet/sock.cDPRINTF((DBG_INET, "release_sock: skb = %X:\n", skb));
skb1674net/inet/sock.cif (skb->next != skb) {
skb1675net/inet/sock.csk->back_log = skb->next;
skb1676net/inet/sock.cskb->prev->next = skb->next;
skb1677net/inet/sock.cskb->next->prev = skb->prev;
skb1683net/inet/sock.cif (sk->prot->rcv) sk->prot->rcv(skb, skb->dev, sk->opt,
skb1684net/inet/sock.cskb->saddr, skb->len, skb->daddr, 1,
skb176net/inet/sock.hint      (*build_header)(struct sk_buff *skb,
skb185net/inet/sock.hstruct device *dev, struct sk_buff *skb,
skb282net/inet/sockinet.cstruct sk_buff *skb;
skb304net/inet/sockinet.cfor(skb = sk->wfront; skb != NULL; ) 
skb308net/inet/sockinet.cskb2=(struct sk_buff *)skb->next;
skb309net/inet/sockinet.cif (skb->magic != TCP_WRITE_QUEUE_MAGIC) 
skb312net/inet/sockinet.cskb->magic);
skb315net/inet/sockinet.cIS_SKB(skb);
skb316net/inet/sockinet.ckfree_skb(skb, FREE_WRITE);
skb317net/inet/sockinet.cskb = skb2;
skb325net/inet/sockinet.cwhile((skb=skb_dequeue(&sk->rqueue))!=NULL)
skb331net/inet/sockinet.cif (skb->sk != NULL && skb->sk != sk) 
skb333net/inet/sockinet.cIS_SKB(skb);
skb334net/inet/sockinet.cskb->sk->dead = 1;
skb335net/inet/sockinet.cskb->sk->prot->close(skb->sk, 0);
skb337net/inet/sockinet.cIS_SKB(skb);
skb338net/inet/sockinet.ckfree_skb(skb, FREE_READ);
skb344net/inet/sockinet.cfor(skb = sk->send_head; skb != NULL; ) 
skb354net/inet/sockinet.cif (skb->next != NULL) 
skb356net/inet/sockinet.cIS_SKB(skb);
skb357net/inet/sockinet.cskb_unlink(skb);
skb360net/inet/sockinet.cskb->dev = NULL;
skb362net/inet/sockinet.cskb2 = (struct sk_buff *)skb->link3;
skb363net/inet/sockinet.ckfree_skb(skb, FREE_WRITE);
skb364net/inet/sockinet.cskb = skb2;
skb374net/inet/sockinet.cskb = (struct sk_buff *)sk->back_log;
skb379net/inet/sockinet.cskb2 = (struct sk_buff *)skb->next;
skb380net/inet/sockinet.ckfree_skb(skb, FREE_READ);
skb381net/inet/sockinet.cskb = skb2;
skb383net/inet/sockinet.cwhile(skb != sk->back_log);
skb1481net/inet/sockinet.cstruct sk_buff *skb;
skb1484net/inet/sockinet.cskb =(struct sk_buff *)sk->back_log;
skb1485net/inet/sockinet.cDPRINTF((DBG_INET, "release_sock: skb = %X:\n", skb));
skb1486net/inet/sockinet.cif (skb->next != skb) 
skb1488net/inet/sockinet.csk->back_log = skb->next;
skb1489net/inet/sockinet.cskb->prev->next = skb->next;
skb1490net/inet/sockinet.cskb->next->prev = skb->prev;
skb1499net/inet/sockinet.csk->prot->rcv(skb, skb->dev, sk->opt,
skb1500net/inet/sockinet.cskb->saddr, skb->len, skb->daddr, 1,
skb65net/inet/sockinet.hint      (*build_header)(struct sk_buff *skb,
skb75net/inet/sockinet.hstruct device *dev, struct sk_buff *skb,
skb274net/inet/tcp.cstruct sk_buff *skb;
skb295net/inet/tcp.cskb =(struct sk_buff *)sk->rqueue;
skb301net/inet/tcp.cif (before(counted, skb->h.th->seq))   /* Found a hole so stops here */
skb303net/inet/tcp.csum = skb->len -(counted - skb->h.th->seq);  /* Length - header but start from where we are up to (avoid overlaps) */
skb304net/inet/tcp.cif (skb->h.th->syn) 
skb306net/inet/tcp.cif (skb->h.th->urg) 
skb308net/inet/tcp.csum -= ntohs(skb->h.th->urg_ptr);  /* Dont count urg data */
skb313net/inet/tcp.cif (skb->h.th->syn) 
skb319net/inet/tcp.cskb =(struct sk_buff *)skb->next;    /* Move along */
skb321net/inet/tcp.cwhile(skb != sk->rqueue);
skb463net/inet/tcp.cstruct sk_buff *skb;
skb471net/inet/tcp.cif ((skb=skb_peek(&sk->rqueue)) != NULL) 
skb473net/inet/tcp.cif (sk->copied_seq+1 == skb->h.th->seq && skb->h.th->urg) 
skb587net/inet/tcp.cstruct sk_buff *skb;
skb592net/inet/tcp.cskb = sk->send_tmp;
skb600net/inet/tcp.ctcp_send_check(skb->h.th, sk->saddr, sk->daddr,
skb601net/inet/tcp.cskb->len-(unsigned long)skb->h.th +
skb602net/inet/tcp.c(unsigned long)(skb+1), sk);
skb607net/inet/tcp.cskb->h.seq = sk->send_seq;
skb620net/inet/tcp.cskb->next = NULL;
skb621net/inet/tcp.cskb->magic = TCP_WRITE_QUEUE_MAGIC;
skb624net/inet/tcp.csk->wfront=skb;
skb628net/inet/tcp.csk->wback->next = skb;
skb630net/inet/tcp.csk->wback = skb;
skb634net/inet/tcp.csk->prot->queue_xmit(sk, skb->dev, skb,0);
skb764net/inet/tcp.cstruct sk_buff *skb;
skb877net/inet/tcp.cskb = sk->send_tmp;
skb880net/inet/tcp.ccopy = min(sk->mss - skb->len + 128 +
skb894net/inet/tcp.cmemcpy_fromfs((unsigned char *)(skb+1) + skb->len, from, copy);
skb895net/inet/tcp.cskb->len += copy;
skb906net/inet/tcp.cif (skb->len -(unsigned long)skb->h.th + (unsigned long)(skb+1) >= sk->mss ||(flags & MSG_OOB) || copy==0) 
skb940net/inet/tcp.cskb = (struct sk_buff *) prot->wmalloc(sk,
skb942net/inet/tcp.csizeof(*skb), 0, GFP_KERNEL);
skb944net/inet/tcp.csk->send_tmp = skb;
skb945net/inet/tcp.cif (skb != NULL)
skb946net/inet/tcp.cskb->mem_len = sk->mss + 128 + prot->max_header + sizeof(*skb);
skb952net/inet/tcp.cskb = (struct sk_buff *) prot->wmalloc(sk,
skb954net/inet/tcp.csizeof(*skb), 0, GFP_KERNEL);
skb956net/inet/tcp.cif (skb != NULL)
skb957net/inet/tcp.cskb->mem_len = copy+prot->max_header + sizeof(*skb);
skb961net/inet/tcp.cif (skb == NULL) 
skb994net/inet/tcp.cskb->mem_addr = skb;
skb995net/inet/tcp.cskb->len = 0;
skb996net/inet/tcp.cskb->sk = sk;
skb997net/inet/tcp.cskb->free = 0;
skb999net/inet/tcp.cbuff =(unsigned char *)(skb+1);
skb1010net/inet/tcp.ctmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
skb1011net/inet/tcp.cIPPROTO_TCP, sk->opt, skb->mem_len, sk->ip_ttl,sk->ip_tos);
skb1014net/inet/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
skb1022net/inet/tcp.cskb->len += tmp;
skb1023net/inet/tcp.cskb->dev = dev;
skb1025net/inet/tcp.cskb->h.th =(struct tcphdr *) buff;
skb1034net/inet/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
skb1057net/inet/tcp.cskb->len += tmp;
skb1068net/inet/tcp.cskb->len += copy;
skb1069net/inet/tcp.cskb->free = 0;
skb1086net/inet/tcp.cskb->h.seq = sk->send_seq;
skb1104net/inet/tcp.cskb->next = NULL;
skb1105net/inet/tcp.cskb->magic = TCP_WRITE_QUEUE_MAGIC;
skb1108net/inet/tcp.csk->wfront = skb;
skb1112net/inet/tcp.csk->wback->next = skb;
skb1114net/inet/tcp.csk->wback = skb;
skb1122net/inet/tcp.cprot->queue_xmit(sk, dev, skb,0);
skb1251net/inet/tcp.cstruct sk_buff *skb;
skb1266net/inet/tcp.cwhile((skb=skb_peek(&sk->rqueue)) != NULL ) 
skb1268net/inet/tcp.cif (!skb->used) 
skb1270net/inet/tcp.cskb_unlink(skb);
skb1271net/inet/tcp.cskb->sk = sk;
skb1272net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb1331net/inet/tcp.cstruct sk_buff *skb;
skb1406net/inet/tcp.cskb = skb_peek(&sk->rqueue);
skb1411net/inet/tcp.cif (skb->h.th->urg && !skb->urg_used) 
skb1413net/inet/tcp.cif (skb->h.th->urg_ptr == 0) 
skb1415net/inet/tcp.cskb->h.th->urg_ptr = ntohs(skb->len);
skb1417net/inet/tcp.camt = min(ntohs(skb->h.th->urg_ptr),len);
skb1421net/inet/tcp.cmemcpy_tofs(to,(unsigned char *)(skb->h.th) +
skb1422net/inet/tcp.cskb->h.th->doff*4, amt);
skb1427net/inet/tcp.cskb->urg_used = 1;
skb1434net/inet/tcp.cskb =(struct sk_buff *)skb->next;
skb1436net/inet/tcp.cwhile(skb != sk->rqueue);
skb1454net/inet/tcp.cstruct sk_buff *skb;
skb1481net/inet/tcp.cskb=skb_peek(&sk->rqueue);
skb1491net/inet/tcp.cwhile(skb == NULL || before(sk->copied_seq+1, skb->h.th->seq) || skb->used) 
skb1493net/inet/tcp.cDPRINTF((DBG_TCP, "skb = %X:\n", skb));
skb1637net/inet/tcp.cskb=skb_peek(&sk->rqueue);
skb1649net/inet/tcp.coffset = sk->copied_seq+1 - skb->h.th->seq;
skb1651net/inet/tcp.cif (skb->h.th->syn) 
skb1654net/inet/tcp.cif (offset < skb->len) /* Some of the packet is useful */
skb1660net/inet/tcp.cif (skb->h.th->urg) 
skb1662net/inet/tcp.cif (skb->urg_used) 
skb1664net/inet/tcp.csk->copied_seq += ntohs(skb->h.th->urg_ptr);
skb1665net/inet/tcp.coffset += ntohs(skb->h.th->urg_ptr);
skb1666net/inet/tcp.cif (offset >= skb->len) 
skb1668net/inet/tcp.cskb->used = 1;
skb1669net/inet/tcp.cskb =(struct sk_buff *)skb->next;
skb1692net/inet/tcp.cused = min(skb->len - offset, len);
skb1696net/inet/tcp.cmemcpy_tofs(to,((unsigned char *)skb->h.th) +
skb1697net/inet/tcp.cskb->h.th->doff*4 + offset, used);
skb1715net/inet/tcp.cif (!(flags & MSG_PEEK) && (!skb->h.th->urg || skb->urg_used) && (used + offset >= skb->len)) 
skb1716net/inet/tcp.cskb->used = 1;
skb1723net/inet/tcp.cif ((skb->h.th->psh && type) || skb->h.th->urg) 
skb1732net/inet/tcp.cskb->used = 1;
skb1740net/inet/tcp.cskb =(struct sk_buff *)skb->next;
skb2050net/inet/tcp.cstatic void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
skb2063net/inet/tcp.csk, skb, daddr, saddr, opt, dev));
skb2065net/inet/tcp.cth = skb->h.th;
skb2076net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2087net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2102net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2131net/inet/tcp.cnewsk->acked_seq = skb->h.th->seq+1;
skb2132net/inet/tcp.cnewsk->fin_seq = skb->h.th->seq;
skb2133net/inet/tcp.cnewsk->copied_seq = skb->h.th->seq;
skb2143net/inet/tcp.cnewsk->dummy_th.source = skb->h.th->dest;
skb2144net/inet/tcp.cnewsk->dummy_th.dest = skb->h.th->source;
skb2160net/inet/tcp.cnewsk->acked_seq = skb->h.th->seq + 1;
skb2161net/inet/tcp.cnewsk->copied_seq = skb->h.th->seq;
skb2164net/inet/tcp.cnewsk->ip_ttl=skb->ip_hdr->ttl;
skb2165net/inet/tcp.cnewsk->ip_tos=skb->ip_hdr->tos;
skb2167net/inet/tcp.ctcp_options(newsk,skb->h.th);
skb2175net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2198net/inet/tcp.cskb->sk = sk;
skb2199net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2210net/inet/tcp.cmemcpy(t1, skb->h.th, sizeof(*t1));
skb2214net/inet/tcp.ct1->dest = skb->h.th->source;
skb2226net/inet/tcp.ct1->ack_seq = ntohl(skb->h.th->seq+1);
skb2239net/inet/tcp.cskb->sk = newsk;
skb2242net/inet/tcp.csk->rmem_alloc -= skb->mem_len;
skb2243net/inet/tcp.cnewsk->rmem_alloc += skb->mem_len;
skb2245net/inet/tcp.cskb_queue_tail(&sk->rqueue,skb);
skb2276net/inet/tcp.cstruct sk_buff *skb;
skb2279net/inet/tcp.cwhile((skb=skb_dequeue(&sk->rqueue))!=NULL)
skb2281net/inet/tcp.cif(skb->len > 0 && after(skb->h.th->seq + skb->len + 1 , sk->copied_seq))
skb2283net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2431net/inet/tcp.cstruct sk_buff *skb;
skb2444net/inet/tcp.cskb = sk->wfront;
skb2445net/inet/tcp.cIS_SKB(skb);
skb2446net/inet/tcp.csk->wfront =(struct sk_buff *)skb->next;
skb2449net/inet/tcp.cskb->next = NULL;
skb2450net/inet/tcp.cif (skb->magic != TCP_WRITE_QUEUE_MAGIC) 
skb2453net/inet/tcp.c"queue\n", skb->magic);
skb2458net/inet/tcp.cskb->magic = 0;
skb2462net/inet/tcp.cif (before(skb->h.seq, sk->rcv_ack_seq +1)) 
skb2465net/inet/tcp.ckfree_skb(skb, FREE_WRITE);
skb2471net/inet/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
skb2485net/inet/tcp.cstruct sk_buff *skb,*skb2,*skb3;
skb2487net/inet/tcp.cfor (skb = sk->send_head; skb != NULL; skb = skb2) 
skb2489net/inet/tcp.cskb2 = (struct sk_buff *)skb->link3;
skb2492net/inet/tcp.cskb->link3 = list;
skb2493net/inet/tcp.csk->send_tail = skb;
skb2494net/inet/tcp.clist = skb;
skb2500net/inet/tcp.cif (skb3->link3 == NULL || before(skb->h.seq, skb3->link3->h.seq)) 
skb2502net/inet/tcp.cskb->link3 = skb3->link3;
skb2503net/inet/tcp.cskb3->link3 = skb;
skb2504net/inet/tcp.cif (skb->link3 == NULL) 
skb2505net/inet/tcp.csk->send_tail = skb;
skb2558net/inet/tcp.cstruct sk_buff *skb;
skb2572net/inet/tcp.cskb = skb2;
skb2573net/inet/tcp.cskb2 = (struct sk_buff *)skb->link3;
skb2574net/inet/tcp.cskb->link3 = NULL;
skb2575net/inet/tcp.cif (after(skb->h.seq, sk->window_seq)) 
skb2583net/inet/tcp.cif (skb->next != NULL) 
skb2585net/inet/tcp.cskb_unlink(skb);        
skb2588net/inet/tcp.cskb->magic = TCP_WRITE_QUEUE_MAGIC;
skb2591net/inet/tcp.cskb->next = sk->wfront;
skb2592net/inet/tcp.csk->wfront = skb;
skb2596net/inet/tcp.cskb->next = wskb->next;
skb2597net/inet/tcp.cwskb->next = skb;
skb2600net/inet/tcp.csk->wback = skb;
skb2601net/inet/tcp.cwskb = skb;
skb2607net/inet/tcp.csk->send_head = skb;
skb2608net/inet/tcp.csk->send_tail = skb;
skb2612net/inet/tcp.csk->send_tail->link3 = skb;
skb2613net/inet/tcp.csk->send_tail = skb;
skb2615net/inet/tcp.cskb->link3 = NULL;
skb2827net/inet/tcp.cstatic int tcp_data(struct sk_buff *skb, struct sock *sk, 
skb2834net/inet/tcp.cth = skb->h.th;
skb2837net/inet/tcp.cskb->len = len -(th->doff*4);
skb2839net/inet/tcp.cDPRINTF((DBG_TCP, "tcp_data len = %d sk = %X:\n", skb->len, sk));
skb2841net/inet/tcp.csk->bytes_rcv += skb->len;
skb2842net/inet/tcp.cif (skb->len == 0 && !th->fin && !th->urg && !th->psh) 
skb2847net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2853net/inet/tcp.csk->acked_seq = th->seq + skb->len + th->syn + th->fin;
skb2854net/inet/tcp.ctcp_reset(sk->saddr, sk->daddr, skb->h.th, sk->prot, NULL, skb->dev);
skb2859net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2879net/inet/tcp.cDPRINTF((DBG_TCP, "tcp_data: skb = %X:\n", skb));
skb2880net/inet/tcp.cskb_queue_head(&sk->rqueue,skb);
skb2892net/inet/tcp.cprintk("skb->h.th->seq = %ld\n",skb->h.th->seq);
skb2896net/inet/tcp.cif (th->seq==skb1->h.th->seq && skb->len>= skb1->len)
skb2898net/inet/tcp.cskb_append(skb1,skb);
skb2907net/inet/tcp.cskb_append(skb1,skb);
skb2912net/inet/tcp.cskb_queue_head(&sk->rqueue, skb);    
skb2916net/inet/tcp.cDPRINTF((DBG_TCP, "skb = %X:\n", skb));
skb2919net/inet/tcp.cth->ack_seq = th->seq + skb->len;
skb2941net/inet/tcp.cskb->acked = 1;
skb2944net/inet/tcp.cif (skb->h.th->fin) 
skb2951net/inet/tcp.cfor(skb2 = (struct sk_buff *)skb->next;
skb3004net/inet/tcp.cif (!skb->acked) 
skb3171net/inet/tcp.cstruct sk_buff *skb;
skb3191net/inet/tcp.cwhile((skb = get_firstr(sk)) == NULL) 
skb3217net/inet/tcp.cnewsk = skb->sk;
skb3219net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3418net/inet/tcp.cint tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb3425net/inet/tcp.cif (!skb) 
skb3437net/inet/tcp.cth = skb->h.th;
skb3442net/inet/tcp.cDPRINTF((DBG_TCP, "len = %d, redo = %d, skb=%X\n", len, redo, skb));
skb3459net/inet/tcp.cskb->sk = NULL;
skb3463net/inet/tcp.ckfree_skb(skb,FREE_READ);
skb3483net/inet/tcp.cskb->sk = NULL;
skb3484net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3488net/inet/tcp.cskb->len = len;
skb3489net/inet/tcp.cskb->sk = sk;
skb3490net/inet/tcp.cskb->acked = 0;
skb3491net/inet/tcp.cskb->used = 0;
skb3492net/inet/tcp.cskb->free = 0;
skb3493net/inet/tcp.cskb->urg_used = 0;
skb3494net/inet/tcp.cskb->saddr = daddr;
skb3495net/inet/tcp.cskb->daddr = saddr;
skb3505net/inet/tcp.csk->back_log = skb;
skb3506net/inet/tcp.cskb->next = skb;
skb3507net/inet/tcp.cskb->prev = skb;
skb3511net/inet/tcp.cskb->next = sk->back_log;
skb3512net/inet/tcp.cskb->prev = sk->back_log->prev;
skb3513net/inet/tcp.cskb->prev->next = skb;
skb3514net/inet/tcp.cskb->next->prev = skb;
skb3539net/inet/tcp.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
skb3541net/inet/tcp.cskb->sk = NULL;
skb3543net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3548net/inet/tcp.csk->rmem_alloc += skb->mem_len;
skb3573net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3590net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3612net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3627net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3641net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3650net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3660net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3668net/inet/tcp.cif (tcp_data(skb, sk, saddr, len)) 
skb3670net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3678net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3690net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3701net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3708net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3715net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3735net/inet/tcp.ctcp_conn_request(sk, skb, daddr, saddr, opt, dev);
skb3740net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3747net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3763net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3777net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3788net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3801net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3812net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3826net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3854net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3859net/inet/tcp.cif (tcp_data(skb, sk, saddr, len))
skb3860net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3872net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3878net/inet/tcp.cif (tcp_data(skb, sk, saddr, len)) 
skb3880net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb142net/inet/tcp.hextern int  tcp_rcv(struct sk_buff *skb, struct device *dev,
skb227net/inet/udp.cstruct sk_buff *skb;
skb245net/inet/udp.cskb = (struct sk_buff *) sk->prot->wmalloc(sk, size, 0, GFP_KERNEL);
skb246net/inet/udp.cif (skb == NULL) 
skb249net/inet/udp.cskb->sk       = NULL;  /* to avoid changing sk->saddr */
skb250net/inet/udp.cskb->free     = 1;
skb251net/inet/udp.cskb->arp      = 0;
skb254net/inet/udp.cbuff = (unsigned char *) (skb+1);
skb258net/inet/udp.csaddr, sin->sin_addr.s_addr, dev, IPPROTO_UDP, skb->mem_len));
skb259net/inet/udp.ctmp = sk->prot->build_header(skb, saddr, sin->sin_addr.s_addr,
skb260net/inet/udp.c&dev, IPPROTO_UDP, sk->opt, skb->mem_len, 
skb262net/inet/udp.cskb->sk=sk;  /* So memory is freed correctly */
skb266net/inet/udp.csk->prot->wfree(sk, skb->mem_addr, skb->mem_len);
skb273net/inet/udp.cskb->len = tmp + sizeof(struct udphdr) + len;  /* len + UDP + IP + MAC */
skb274net/inet/udp.cskb->dev = dev;
skb275net/inet/udp.cif (skb->len > 4095)
skb278net/inet/udp.csk->prot->wfree(sk, skb->mem_addr, skb->mem_len);
skb293net/inet/udp.cudp_send_check(uh, saddr, sin->sin_addr.s_addr, skb->len - tmp, sk);
skb296net/inet/udp.csk->prot->queue_xmit(sk, dev, skb, 1);
skb408net/inet/udp.cstruct sk_buff *skb;
skb414net/inet/udp.cskb = sk->rqueue;
skb415net/inet/udp.cif (skb != NULL) 
skb422net/inet/udp.camount = skb->len;
skb448net/inet/udp.cstruct sk_buff *skb;
skb486net/inet/udp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb487net/inet/udp.cif(skb==NULL)
skb489net/inet/udp.ccopied = min(len, skb->len);
skb492net/inet/udp.cskb_copy_datagram(skb,sizeof(struct udphdr),to,copied);
skb500net/inet/udp.caddr.sin_port = skb->h.uh->source;
skb501net/inet/udp.caddr.sin_addr.s_addr = skb->daddr;
skb505net/inet/udp.cskb_free_datagram(skb);
skb559net/inet/udp.cint udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb566net/inet/udp.cuh = (struct udphdr *) skb->h.uh;
skb572net/inet/udp.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, dev);
skb579net/inet/udp.cskb->sk = NULL;
skb580net/inet/udp.ckfree_skb(skb, FREE_WRITE);
skb587net/inet/udp.cskb->sk = NULL;
skb588net/inet/udp.ckfree_skb(skb, FREE_WRITE);
skb592net/inet/udp.cskb->sk = sk;
skb593net/inet/udp.cskb->dev = dev;
skb594net/inet/udp.cskb->len = len;
skb597net/inet/udp.cskb->daddr = saddr;
skb598net/inet/udp.cskb->saddr = daddr;
skb602net/inet/udp.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
skb604net/inet/udp.cskb->sk = NULL;
skb605net/inet/udp.ckfree_skb(skb, FREE_WRITE);
skb609net/inet/udp.csk->rmem_alloc += skb->mem_len;
skb617net/inet/udp.cskb_queue_tail(&sk->rqueue,skb);
skb619net/inet/udp.cskb->len = len - sizeof(*uh);
skb624net/inet/udp.csk->data_ready(sk,skb->len);
skb43net/inet/udp.hextern int  udp_rcv(struct sk_buff *skb, struct device *dev,
skb52net/socket/datagram.cstruct sk_buff *skb;
skb122net/socket/datagram.cskb=skb_dequeue(&sk->rqueue);
skb123net/socket/datagram.cif(skb!=NULL)
skb124net/socket/datagram.cskb->users++;
skb131net/socket/datagram.cskb=skb_peek(&sk->rqueue);
skb132net/socket/datagram.cif(skb!=NULL)
skb133net/socket/datagram.cskb->users++;
skb135net/socket/datagram.cif(skb==NULL)  /* shouldn't happen but .. */
skb138net/socket/datagram.creturn skb;
skb148net/socket/datagram.cvoid skb_free_datagram(struct sk_buff *skb)
skb154net/socket/datagram.cskb->users--;
skb155net/socket/datagram.cif(skb->users>0)
skb161net/socket/datagram.cif(skb->list == NULL)  /* Been dequeued by someone - ie its read */
skb162net/socket/datagram.ckfree_skb(skb,FREE_READ);
skb166net/socket/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
skb170net/socket/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
skb294net/socket/dev.cstruct sk_buff *skb;
skb295net/socket/dev.cwhile((skb=skb_dequeue(&dev->buffs[ct]))!=NULL)
skb296net/socket/dev.cif(skb->free)
skb297net/socket/dev.ckfree_skb(skb,FREE_WRITE);
skb310net/socket/dev.cvoid dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
skb317net/socket/dev.cskb, dev, pri));
skb325net/socket/dev.cIS_SKB(skb);
skb327net/socket/dev.cskb->dev = dev;
skb328net/socket/dev.cif (skb->next != NULL) 
skb347net/socket/dev.cif (dev->hard_start_xmit(skb, dev) == 0) 
skb360net/socket/dev.cskb->magic = DEV_QUEUE_MAGIC;
skb362net/socket/dev.cskb_queue_head(&dev->buffs[pri],skb);
skb364net/socket/dev.cskb_queue_tail(&dev->buffs[pri],skb);
skb365net/socket/dev.cskb->magic = DEV_QUEUE_MAGIC;
skb374net/socket/dev.cvoid netif_rx(struct sk_buff *skb)
skb377net/socket/dev.cskb->sk = NULL;
skb378net/socket/dev.cskb->free = 1;
skb381net/socket/dev.cIS_SKB(skb);
skb382net/socket/dev.cskb_queue_tail(&backlog,skb);
skb407net/socket/dev.cstruct sk_buff *skb = NULL;
skb416net/socket/dev.cskb = (struct sk_buff *) buff;
skb428net/socket/dev.cskb = alloc_skb(sizeof(*skb) + len, GFP_ATOMIC);
skb429net/socket/dev.cif (skb == NULL) 
skb438net/socket/dev.cto = (unsigned char *) (skb + 1);
skb454net/socket/dev.cskb->len = len;
skb455net/socket/dev.cskb->dev = dev;
skb456net/socket/dev.cskb->free = 1;
skb458net/socket/dev.cnetif_rx(skb);
skb499net/socket/dev.cstruct sk_buff *skb;
skb513net/socket/dev.cwhile((skb=skb_dequeue(&backlog))!=NULL)
skb523net/socket/dev.cskb->h.raw = (unsigned char *) (skb + 1) + skb->dev->hard_header_len;
skb524net/socket/dev.cskb->len -= skb->dev->hard_header_len;
skb535net/socket/dev.ctype = skb->dev->type_trans(skb, skb->dev);
skb551net/socket/dev.cskb2 = alloc_skb(skb->mem_len, GFP_ATOMIC);
skb554net/socket/dev.cmemcpy(skb2, (const void *) skb, skb->mem_len);
skb559net/socket/dev.c(unsigned long) skb->h.raw -
skb560net/socket/dev.c(unsigned long) skb
skb566net/socket/dev.cskb2 = skb;
skb576net/socket/dev.cptype->func(skb2, skb->dev, ptype);
skb588net/socket/dev.cskb->sk = NULL;
skb589net/socket/dev.ckfree_skb(skb, FREE_WRITE);
skb610net/socket/dev.cstruct sk_buff *skb;
skb614net/socket/dev.cwhile((skb=skb_dequeue(&dev->buffs[i]))!=NULL)
skb616net/socket/dev.cskb->magic = 0;
skb617net/socket/dev.cdev->queue_xmit(skb,dev,-i - 1);
skb119net/socket/dev.hint        (*hard_start_xmit) (struct sk_buff *skb,
skb128net/socket/dev.hstruct sk_buff *skb,
skb130net/socket/dev.hvoid        (*queue_xmit)(struct sk_buff *skb,
skb133net/socket/dev.hunsigned short    (*type_trans) (struct sk_buff *skb,
skb171net/socket/dev.hextern void    dev_queue_xmit(struct sk_buff *skb, struct device *dev,
skb174net/socket/dev.hextern void    netif_rx(struct sk_buff *skb);
skb57net/socket/skbuff.cvoid skb_check(struct sk_buff *skb, int line, char *file)
skb59net/socket/skbuff.cif(skb->magic_debug_cookie==SK_FREED_SKB)
skb64net/socket/skbuff.cskb,skb->truesize,skb->mem_len,skb->magic,skb->list,skb->free);
skb66net/socket/skbuff.cif(skb->magic_debug_cookie!=SK_GOOD_SKB)
skb70net/socket/skbuff.cskb,skb->truesize,skb->mem_len,skb->magic,skb->list,skb->free);
skb72net/socket/skbuff.cif(skb->mem_len!=skb->truesize)
skb76net/socket/skbuff.cskb,skb->truesize,skb->mem_len,skb->magic,skb->list);
skb247net/socket/skbuff.cvoid skb_unlink(struct sk_buff *skb)
skb253net/socket/skbuff.cIS_SKB(skb);
skb255net/socket/skbuff.cif(skb->list)
skb257net/socket/skbuff.cskb->next->prev=skb->prev;
skb258net/socket/skbuff.cskb->prev->next=skb->next;
skb259net/socket/skbuff.cif(*skb->list==skb)
skb261net/socket/skbuff.cif(skb->next==skb)
skb262net/socket/skbuff.c*skb->list=NULL;
skb264net/socket/skbuff.c*skb->list=skb->next;
skb266net/socket/skbuff.cskb->next=0;
skb267net/socket/skbuff.cskb->prev=0;
skb268net/socket/skbuff.cskb->list=0;
skb281net/socket/skbuff.cstruct sk_buff *skb=skb_peek(list);
skb282net/socket/skbuff.cif(skb!=NULL)
skb286net/socket/skbuff.cIS_SKB(skb);
skb287net/socket/skbuff.cskb->list=list;
skb288net/socket/skbuff.cskb=skb->next;
skb290net/socket/skbuff.cwhile(skb!=*list);
skb382net/socket/skbuff.cvoid kfree_skb(struct sk_buff *skb, int rw)
skb384net/socket/skbuff.cif (skb == NULL) {
skb388net/socket/skbuff.cIS_SKB(skb);
skb389net/socket/skbuff.cif(skb->free == 2)
skb391net/socket/skbuff.cif(skb->list)
skb393net/socket/skbuff.cskb->magic = 0;
skb394net/socket/skbuff.cif (skb->sk) 
skb396net/socket/skbuff.cif(skb->sk->prot!=NULL)
skb399net/socket/skbuff.cskb->sk->prot->rfree(skb->sk, skb->mem_addr, skb->mem_len);
skb401net/socket/skbuff.cskb->sk->prot->wfree(skb->sk, skb->mem_addr, skb->mem_len);
skb408net/socket/skbuff.cskb->sk->rmem_alloc-=skb->mem_len;
skb410net/socket/skbuff.cskb->sk->wmem_alloc-=skb->mem_len;
skb411net/socket/skbuff.cif(!skb->sk->dead)
skb412net/socket/skbuff.cskb->sk->write_space(skb->sk);
skb413net/socket/skbuff.ckfree_skbmem(skb->mem_addr,skb->mem_len);
skb418net/socket/skbuff.ckfree_skbmem(skb->mem_addr, skb->mem_len);
skb429net/socket/skbuff.cstruct sk_buff *skb=(struct sk_buff *)kmalloc(size,priority);
skb430net/socket/skbuff.cif(skb==NULL)
skb432net/socket/skbuff.cskb->free= 2;  /* Invalid so we pick up forgetful users */
skb433net/socket/skbuff.cskb->list= 0;  /* Not on a list */
skb434net/socket/skbuff.cskb->truesize=size;
skb435net/socket/skbuff.cskb->mem_len=size;
skb436net/socket/skbuff.cskb->mem_addr=skb;
skb437net/socket/skbuff.cskb->fraglist=NULL;
skb440net/socket/skbuff.cskb->magic_debug_cookie=SK_GOOD_SKB;
skb441net/socket/skbuff.cskb->users=0;
skb442net/socket/skbuff.creturn skb;
skb91net/socket/skbuff.hextern void      kfree_skb(struct sk_buff *skb, int rw);
skb104net/socket/skbuff.hextern void       skb_check(struct sk_buff *skb,int, char *);
skb105net/socket/skbuff.h#define IS_SKB(skb)  skb_check((skb),__LINE__,__FILE__)
skb110net/socket/skbuff.hextern void      skb_free_datagram(struct sk_buff *skb);
skb86net/socket/sock.cvoid print_skb(struct sk_buff *skb)
skb88net/socket/sock.cif (!skb) 
skb93net/socket/sock.cprintk("  prev = %p, next = %p\n", skb->prev, skb->next);
skb94net/socket/sock.cprintk("  sk = %p link3 = %p\n", skb->sk, skb->link3);
skb95net/socket/sock.cprintk("  mem_addr = %p, mem_len = %lu\n", skb->mem_addr, skb->mem_len);
skb96net/socket/sock.cprintk("  used = %d free = %d\n", skb->used,skb->free);
skb373net/socket/sock.cstruct sk_buff *skb;
skb378net/socket/sock.cskb=mem;
skb400net/socket/sock.cstruct sk_buff *skb;
skb405net/socket/sock.cskb=mem;