taglinefilesource code
skb76net/tcp/arp.cstruct sk_buff *skb;
skb83net/tcp/arp.cwhile ((skb = next) != NULL) {
skb84net/tcp/arp.cif (skb->magic != ARP_QUEUE_MAGIC)
skb86net/tcp/arp.cprintk ("arp.c skb with bad magic - %X: squashing queue\n", skb->magic);
skb90net/tcp/arp.cif (skb->next == NULL
skb92net/tcp/arp.c|| (unsigned long)(skb->next) > 16*1024*1024
skb101net/tcp/arp.cnext = skb->next;
skb102net/tcp/arp.cif (next == skb)
skb108net/tcp/arp.cskb->prev->next = next;
skb109net/tcp/arp.cnext->prev = skb->prev;
skb112net/tcp/arp.cskb->magic = 0;
skb113net/tcp/arp.cskb->next = NULL;
skb114net/tcp/arp.cskb->prev = NULL;
skb116net/tcp/arp.cif (!skb->dev->rebuild_header (skb+1, skb->dev))
skb118net/tcp/arp.cskb->next = NULL;
skb119net/tcp/arp.cskb->prev = NULL;
skb120net/tcp/arp.cskb->arp  = 1;
skb121net/tcp/arp.cskb->dev->queue_xmit (skb, skb->dev, 0);
skb126net/tcp/arp.cskb->magic = ARP_QUEUE_MAGIC;      
skb129net/tcp/arp.cskb->next = skb;
skb130net/tcp/arp.cskb->prev = skb;
skb131net/tcp/arp.carp_q = skb;
skb135net/tcp/arp.cskb->next = arp_q;
skb136net/tcp/arp.cskb->prev = arp_q->prev;  
skb137net/tcp/arp.carp_q->prev->next = skb;
skb138net/tcp/arp.carp_q->prev = skb;
skb236net/tcp/arp.cstruct sk_buff *skb;
skb240net/tcp/arp.cskb = arp_malloc (sizeof (*skb) + sizeof (*arp2) +
skb243net/tcp/arp.cif (skb == NULL) return (1);
skb245net/tcp/arp.cskb->lock = 0;
skb246net/tcp/arp.cskb->mem_addr = skb;
skb247net/tcp/arp.cskb->mem_len = sizeof (*skb) + sizeof (*arp2) + 2*arp1->hlen + 
skb249net/tcp/arp.cskb->len = sizeof (*arp2) + 2*arp1->hlen + 
skb252net/tcp/arp.ctmp = dev->hard_header((unsigned char *)(skb+1), dev,
skb254net/tcp/arp.c*arp_targetp(arp1),skb->len);
skb258net/tcp/arp.carp2 =(struct arp *) ((unsigned char *)skb+sizeof (*skb) + tmp );
skb269net/tcp/arp.cskb->free = 1;
skb270net/tcp/arp.cskb->arp = 1; /* so the code will know it's not waiting on an arp. */
skb271net/tcp/arp.cskb->sk = NULL;
skb272net/tcp/arp.cskb->next = NULL;
skb276net/tcp/arp.cdev->queue_xmit (skb, dev, 0);
skb367net/tcp/arp.carp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb374net/tcp/arp.carp = skb->h.arp;
skb380net/tcp/arp.ckfree_skb(skb, FREE_READ);
skb387net/tcp/arp.ckfree_skb (skb, FREE_READ);
skb402net/tcp/arp.ckfree_skb (skb, FREE_READ);
skb414net/tcp/arp.ckfree_skb (skb, FREE_READ);
skb420net/tcp/arp.ckfree_skb (skb, FREE_READ);
skb427net/tcp/arp.cstruct sk_buff *skb;
skb437net/tcp/arp.cskb = arp_malloc (sizeof (*arp) + sizeof (*skb) + dev->hard_header_len +
skb439net/tcp/arp.cif (skb == NULL) return;
skb441net/tcp/arp.cskb->lock = 0;
skb442net/tcp/arp.cskb->sk = NULL;
skb443net/tcp/arp.cskb->mem_addr = skb;
skb444net/tcp/arp.cskb->mem_len = sizeof (*arp) + sizeof (*skb) + dev->hard_header_len +
skb446net/tcp/arp.cskb->arp = 1;
skb447net/tcp/arp.cskb->dev = dev;
skb448net/tcp/arp.cskb->len = sizeof (*arp) + dev->hard_header_len + 2*dev->addr_len+8;
skb449net/tcp/arp.cskb->next = NULL;
skb451net/tcp/arp.ctmp = dev->hard_header ((unsigned char *)(skb+1), dev,
skb452net/tcp/arp.cETHERTYPE_ARP, 0, saddr, skb->len);
skb455net/tcp/arp.carp_free (skb->mem_addr, skb->mem_len);
skb459net/tcp/arp.carp =(struct arp *) ((unsigned char *)skb+sizeof (*skb) + tmp );
skb471net/tcp/arp.cdev->queue_xmit (skb, dev, 0);
skb535net/tcp/arp.carp_queue(struct sk_buff *skb)
skb538net/tcp/arp.cif (skb->next != NULL)
skb542net/tcp/arp.cskb->magic);
skb547net/tcp/arp.carp_q = skb;
skb548net/tcp/arp.cskb->next = skb;
skb549net/tcp/arp.cskb->prev = skb;
skb553net/tcp/arp.cskb->next = arp_q;
skb554net/tcp/arp.cskb->prev = arp_q->prev;
skb555net/tcp/arp.cskb->next->prev = skb;
skb556net/tcp/arp.cskb->prev->next = skb;
skb558net/tcp/arp.cskb->magic = ARP_QUEUE_MAGIC;
skb77net/tcp/arp.hvoid arp_queue (struct sk_buff *skb);
skb157net/tcp/dev.cdev_queue_xmit (struct sk_buff *skb, struct device *dev, int pri)
skb160net/tcp/dev.cPRINTK (("dev_queue_xmit (skb=%X, dev=%X, pri = %d)\n", skb, dev, pri));
skb168net/tcp/dev.cskb->dev = dev;
skb169net/tcp/dev.cif (skb->next != NULL)
skb182net/tcp/dev.cif (dev->hard_start_xmit(skb, dev) == 0)
skb193net/tcp/dev.cdev->buffs[pri]=skb;
skb194net/tcp/dev.cskb->next = skb;
skb195net/tcp/dev.cskb->prev = skb;
skb200net/tcp/dev.cskb->next = skb2;
skb201net/tcp/dev.cskb->prev = skb2->prev;
skb202net/tcp/dev.cskb->next->prev = skb;
skb203net/tcp/dev.cskb->prev->next = skb;
skb205net/tcp/dev.cskb->magic = DEV_QUEUE_MAGIC;
skb230net/tcp/dev.cstruct sk_buff *skb=NULL;
skb238net/tcp/dev.cskb = (struct sk_buff *)buff;
skb242net/tcp/dev.cskb = kmalloc (sizeof (*skb) + len, GFP_ATOMIC);
skb243net/tcp/dev.cif (skb == NULL)
skb248net/tcp/dev.cskb->lock = 0;
skb249net/tcp/dev.cskb->mem_len = sizeof (*skb) + len;
skb250net/tcp/dev.cskb->mem_addr = skb;
skb253net/tcp/dev.cto = (unsigned char *)(skb+1);
skb267net/tcp/dev.cskb->len = len;
skb268net/tcp/dev.cskb->dev = dev;
skb269net/tcp/dev.cskb->sk = NULL;
skb275net/tcp/dev.cskb->prev = skb;
skb276net/tcp/dev.cskb->next = skb;
skb277net/tcp/dev.cbacklog = skb;
skb281net/tcp/dev.cskb ->prev = backlog->prev;
skb282net/tcp/dev.cskb->next = backlog;
skb283net/tcp/dev.cskb->next->prev = skb;
skb284net/tcp/dev.cskb->prev->next = skb;
skb297net/tcp/dev.cstruct sk_buff *skb;
skb316net/tcp/dev.cskb= backlog;
skb317net/tcp/dev.cif (skb->next == skb)
skb323net/tcp/dev.cbacklog = skb->next;
skb324net/tcp/dev.cskb->next->prev = skb->prev;
skb325net/tcp/dev.cskb->prev->next = skb->next;
skb330net/tcp/dev.cskb->h.raw = (unsigned char *)(skb+1) + skb->dev->hard_header_len;
skb331net/tcp/dev.cskb->len -= skb->dev->hard_header_len;
skb334net/tcp/dev.ctype = skb->dev->type_trans (skb, skb->dev);
skb346net/tcp/dev.cskb2 = kmalloc (skb->mem_len, GFP_ATOMIC);
skb348net/tcp/dev.cmemcpy (skb2, skb, skb->mem_len);
skb352net/tcp/dev.c+ (unsigned long)skb->h.raw
skb353net/tcp/dev.c- (unsigned long)skb);
skb358net/tcp/dev.cskb2 = skb;
skb362net/tcp/dev.cptype->func (skb2, skb->dev, ptype);
skb369net/tcp/dev.ckfree_skb (skb, FREE_READ);
skb387net/tcp/dev.cstruct sk_buff *skb;
skb393net/tcp/dev.cskb=dev->buffs[i];
skb394net/tcp/dev.cif (skb->magic != DEV_QUEUE_MAGIC)
skb397net/tcp/dev.cskb->magic);
skb404net/tcp/dev.cskb->magic = 0;
skb406net/tcp/dev.cif (skb->next == skb)
skb413net/tcp/dev.cif (skb->next == NULL
skb415net/tcp/dev.c|| (unsigned long)(skb->next) > 16*1024*1024
skb426net/tcp/dev.cdev->buffs[i]= skb->next;
skb427net/tcp/dev.cskb->prev->next = skb->next;
skb428net/tcp/dev.cskb->next->prev = skb->prev;
skb431net/tcp/dev.cskb->next = NULL;
skb432net/tcp/dev.cskb->prev = NULL;
skb434net/tcp/dev.cif (!skb->arp)
skb436net/tcp/dev.cif (dev->rebuild_header (skb+1, dev))
skb438net/tcp/dev.cskb->dev = dev;
skb440net/tcp/dev.carp_queue (skb);
skb445net/tcp/dev.ctmp = skb->len;
skb450net/tcp/dev.cdev->send_packet(skb, dev);
skb453net/tcp/dev.cmemcpy (buff, skb + 1, tmp);
skb456net/tcp/dev.cprint_eth ((struct enet_header *)(skb+1));
skb468net/tcp/dev.cif (skb->free)
skb470net/tcp/dev.ckfree_skb(skb, FREE_WRITE);
skb73net/tcp/dev.hint (*hard_start_xmit) (struct sk_buff *skb, struct device *dev);
skb77net/tcp/dev.hvoid (*add_arp) (unsigned long addr, struct sk_buff *skb,
skb79net/tcp/dev.hvoid (*queue_xmit)(struct sk_buff *skb, struct device *dev, int pri);
skb81net/tcp/dev.hunsigned short (*type_trans) (struct sk_buff *skb, struct device *dev);
skb82net/tcp/dev.hvoid (*send_packet)(struct sk_buff *skb, struct device *dev);
skb111net/tcp/dev.hvoid dev_queue_xmit (struct sk_buff *skb, struct device *dev, int pri);
skb122net/tcp/eth.ceth_add_arp (unsigned long addr, struct sk_buff *skb, struct device *dev)
skb125net/tcp/eth.ceh = (struct enet_header *)(skb + 1);
skb130net/tcp/eth.ceth_type_trans (struct sk_buff *skb, struct device *dev)
skb133net/tcp/eth.ceh = (struct enet_header *)(skb + 1);
skb99net/tcp/eth.hvoid eth_add_arp (unsigned long addr, struct sk_buff *skb,
skb101net/tcp/eth.hunsigned short eth_type_trans (struct sk_buff *skb, struct device *dev);
skb116net/tcp/icmp.cstruct sk_buff *skb;
skb126net/tcp/icmp.clen = sizeof (*skb) + 8 /* amount of header to return. */ +
skb131net/tcp/icmp.cskb = kmalloc (len, GFP_ATOMIC);
skb132net/tcp/icmp.cif (skb == NULL) return;
skb134net/tcp/icmp.cskb->lock = 0;
skb135net/tcp/icmp.cskb->mem_addr = skb;
skb136net/tcp/icmp.cskb->mem_len = len;
skb138net/tcp/icmp.clen -= sizeof (*skb);
skb145net/tcp/icmp.coffset = ip_build_header( skb, iph->daddr, iph->saddr,
skb150net/tcp/icmp.cskb->sk = NULL;
skb151net/tcp/icmp.ckfree_skb (skb, FREE_READ);
skb156net/tcp/icmp.cskb->len = offset + sizeof (struct icmp_header) + 8;
skb158net/tcp/icmp.cicmph = (struct icmp_header *)((unsigned char *)(skb+1) + offset);
skb165net/tcp/icmp.cip_queue_xmit (NULL, dev, skb, 1);
skb178net/tcp/icmp.cstruct sk_buff *skb;
skb274net/tcp/icmp.cskb = kmalloc( size, GFP_ATOMIC );
skb275net/tcp/icmp.cif (skb == NULL)
skb281net/tcp/icmp.cskb->sk = NULL;
skb282net/tcp/icmp.cskb->lock = 0;
skb283net/tcp/icmp.cskb->mem_addr = skb;
skb284net/tcp/icmp.cskb->mem_len = size;
skb287net/tcp/icmp.coffset = ip_build_header( skb, daddr, saddr, &dev, IPPROTO_ICMP, opt, len );
skb292net/tcp/icmp.ckfree_s (skb->mem_addr, skb->mem_len);
skb299net/tcp/icmp.cskb->len = offset + len;
skb302net/tcp/icmp.cicmphr = (struct icmp_header *)( (char *)( skb + 1 ) + offset );
skb314net/tcp/icmp.cip_queue_xmit( (volatile struct sock *)NULL, dev, skb, 1 );
skb71net/tcp/icmp.hicmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb413net/tcp/ip.cip_build_header (struct sk_buff *skb, unsigned long saddr,
skb426net/tcp/ip.cskb, saddr, daddr, *dev, type, opt, len));
skb427net/tcp/ip.cbuff = (unsigned char *)(skb + 1);
skb459net/tcp/ip.cskb->arp = 0;
skb463net/tcp/ip.cskb->arp = 1;
skb467net/tcp/ip.cskb->dev = *dev;
skb710net/tcp/ip.cip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb719net/tcp/ip.ciph=skb->h.iph;
skb727net/tcp/ip.cskb->sk = NULL;
skb728net/tcp/ip.ckfree_skb(skb, 0);
skb736net/tcp/ip.cskb->sk = NULL;
skb737net/tcp/ip.ckfree_skb(skb, 0);
skb745net/tcp/ip.cskb->sk = NULL;
skb746net/tcp/ip.ckfree_skb(skb, 0);
skb750net/tcp/ip.cskb->h.raw += iph->ihl*4;
skb767net/tcp/ip.cskb2 = kmalloc (skb->mem_len, GFP_ATOMIC);
skb769net/tcp/ip.cmemcpy (skb2, skb, skb->mem_len);
skb773net/tcp/ip.c+ (unsigned long)skb->h.raw
skb774net/tcp/ip.c- (unsigned long)skb);
skb778net/tcp/ip.cskb2 = skb;
skb788net/tcp/ip.cicmp_reply (skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev);
skb789net/tcp/ip.cskb->sk = NULL;
skb790net/tcp/ip.ckfree_skb (skb, 0);
skb805net/tcp/ip.cstruct sk_buff *skb, int free)
skb817net/tcp/ip.cskb->free = free;
skb818net/tcp/ip.cskb->dev = dev;
skb819net/tcp/ip.cskb->when = jiffies;
skb821net/tcp/ip.cptr = (unsigned char *)(skb + 1);
skb824net/tcp/ip.ciph->tot_len = net16(skb->len-dev->hard_header_len);
skb827net/tcp/ip.cskb->next = NULL;
skb831net/tcp/ip.cskb->magic = 1;
skb835net/tcp/ip.cskb->link3 = NULL;
skb840net/tcp/ip.csk->send_tail = skb;
skb841net/tcp/ip.csk->send_head = skb;
skb845net/tcp/ip.csk->send_tail->link3 = skb;
skb846net/tcp/ip.csk->send_tail = skb;
skb855net/tcp/ip.cskb->sk = sk;
skb861net/tcp/ip.cdev->queue_xmit(skb, dev, sk->priority);
skb865net/tcp/ip.cdev->queue_xmit (skb, dev, SOPRI_NORMAL);
skb871net/tcp/ip.ckfree_skb (skb, FREE_WRITE);
skb878net/tcp/ip.cstruct sk_buff * skb;
skb883net/tcp/ip.cskb = sk->send_head;
skb884net/tcp/ip.cwhile (skb != NULL)
skb886net/tcp/ip.cdev = skb->dev;
skb889net/tcp/ip.cif (!skb->arp)
skb891net/tcp/ip.cif (dev->rebuild_header ((struct enet_header *)(skb+1),dev))
skb894net/tcp/ip.cskb=skb->link3;
skb898net/tcp/ip.cskb->arp = 1;
skb899net/tcp/ip.cskb->when = jiffies;
skb903net/tcp/ip.cdev->queue_xmit(skb, dev, sk->priority);
skb905net/tcp/ip.cdev->queue_xmit(skb, dev, SOPRI_NORMAL );
skb914net/tcp/ip.cskb=skb->link3;
skb945net/tcp/ip.cstruct sk_buff *skb;
skb973net/tcp/ip.cskb = sk->rqueue;
skb974net/tcp/ip.cif (skb->next == skb)
skb980net/tcp/ip.csk->rqueue = skb->next;
skb981net/tcp/ip.cskb->next->prev = skb->prev;
skb982net/tcp/ip.cskb->prev->next = skb->next;
skb986net/tcp/ip.cp->handler ((unsigned char *)(skb+1), skb->dev, NULL, skb->saddr,
skb987net/tcp/ip.cskb->len, skb->daddr, p->protocol, 0);
skb989net/tcp/ip.ckfree_skb (skb, FREE_READ);
skb132net/tcp/ip.hint (*handler) (struct sk_buff *skb, struct device *dev,
skb162net/tcp/ip.hint ip_build_header(struct sk_buff *skb, unsigned long saddr,
skb166net/tcp/ip.hstruct sk_buff *skb, int free);
skb77net/tcp/loopback.cloopback_xmit(struct sk_buff *skb, struct device *dev)
skb98net/tcp/loopback.cdone = dev_rint ((unsigned char *)(skb+1), skb->len, 0, dev);
skb100net/tcp/loopback.cif (skb->free)
skb101net/tcp/loopback.ckfree_skb (skb, FREE_WRITE);
skb42net/tcp/pack_type.cextern int arp_rcv (struct sk_buff *skb, struct device *dev,
skb54net/tcp/pack_type.cextern int ip_rcv (struct sk_buff *skb, struct device *dev,
skb70net/tcp/packet.cpacket_rcv (struct sk_buff *skb, struct device *dev,  struct packet_type *pt)
skb75net/tcp/packet.cskb->dev = dev;
skb76net/tcp/packet.cskb->len += dev->hard_header_len;
skb86net/tcp/packet.cskb->sk = NULL;
skb87net/tcp/packet.ckfree_skb (skb, FREE_READ);
skb94net/tcp/packet.cskb->sk = sk;
skb97net/tcp/packet.cif (sk->rmem_alloc + skb->mem_len >= SK_RMEM_MAX)
skb99net/tcp/packet.cskb->sk = NULL;
skb100net/tcp/packet.ckfree_skb (skb, FREE_READ);
skb104net/tcp/packet.csk->rmem_alloc += skb->mem_len;
skb109net/tcp/packet.csk->rqueue = skb;
skb110net/tcp/packet.cskb->next = skb;
skb111net/tcp/packet.cskb->prev = skb;
skb115net/tcp/packet.cskb->next = sk->rqueue;
skb116net/tcp/packet.cskb->prev = sk->rqueue->prev;
skb117net/tcp/packet.cskb->prev->next = skb;
skb118net/tcp/packet.cskb->next->prev = skb;
skb131net/tcp/packet.cstruct sk_buff *skb;
skb150net/tcp/packet.cskb = sk->prot->wmalloc (sk, len+sizeof (*skb) + sk->prot->max_header, 0,
skb153net/tcp/packet.cif (skb == NULL)
skb159net/tcp/packet.cskb->lock = 0;
skb160net/tcp/packet.cskb->mem_addr = skb;
skb161net/tcp/packet.cskb->mem_len = len + sizeof (*skb) +sk->prot->max_header;
skb162net/tcp/packet.cskb->sk = sk;
skb163net/tcp/packet.cskb->free = 1;
skb168net/tcp/packet.csk->prot->wfree (sk, skb->mem_addr, skb->mem_len);
skb172net/tcp/packet.cmemcpy_fromfs (skb+1, from, len);
skb173net/tcp/packet.cskb->len = len;
skb174net/tcp/packet.cskb->next = NULL;
skb176net/tcp/packet.cdev->queue_xmit (skb, dev, sk->priority);
skb178net/tcp/packet.ckfree_skb (skb, FREE_WRITE);
skb226net/tcp/packet.cstruct sk_buff *skb;
skb261net/tcp/packet.cskb = sk->rqueue;
skb265net/tcp/packet.cif (skb->next == skb )
skb272net/tcp/packet.cskb->prev->next = skb->next;
skb273net/tcp/packet.cskb->next->prev = skb->prev;
skb276net/tcp/packet.ccopied = min (len, skb->len);
skb278net/tcp/packet.cmemcpy_tofs (to, skb+1,  copied);
skb283net/tcp/packet.caddr.sa_family = skb->dev->type;
skb284net/tcp/packet.cmemcpy (addr.sa_data,skb->dev->name, 14);
skb291net/tcp/packet.ckfree_skb (skb, FREE_READ);
skb36net/tcp/protocols.cint udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb44net/tcp/protocols.cint tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb51net/tcp/protocols.cint icmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb128net/tcp/raw.craw_rcv (struct sk_buff *skb, struct device *dev, struct options *opt,
skb137net/tcp/raw.cskb, dev, opt, daddr, len, saddr, redo, protocol));
skb139net/tcp/raw.cif (skb == NULL) return (0);
skb142net/tcp/raw.ckfree_skb (skb, FREE_READ);
skb148net/tcp/raw.ckfree_skb (skb, FREE_READ);
skb153net/tcp/raw.cskb->sk = sk;
skb154net/tcp/raw.cskb->len = len;
skb155net/tcp/raw.cskb->dev = dev;
skb156net/tcp/raw.cskb->saddr = daddr;
skb157net/tcp/raw.cskb->daddr = saddr;
skb168net/tcp/raw.csk->back_log = skb;
skb169net/tcp/raw.cskb->next = skb;
skb170net/tcp/raw.cskb->prev = skb;
skb174net/tcp/raw.cskb->next = sk->back_log;
skb175net/tcp/raw.cskb->prev = sk->back_log->prev;
skb176net/tcp/raw.cskb->prev->next = skb;
skb177net/tcp/raw.cskb->next->prev = skb;
skb187net/tcp/raw.cif (sk->rmem_alloc + skb->mem_len >= SK_RMEM_MAX)
skb189net/tcp/raw.cskb->sk = NULL;
skb190net/tcp/raw.ckfree_skb (skb, FREE_READ);
skb194net/tcp/raw.csk->rmem_alloc += skb->mem_len;
skb199net/tcp/raw.csk->rqueue = skb;
skb200net/tcp/raw.cskb->next = skb;
skb201net/tcp/raw.cskb->prev = skb;
skb205net/tcp/raw.cskb->next = sk->rqueue;
skb206net/tcp/raw.cskb->prev = sk->rqueue->prev;
skb207net/tcp/raw.cskb->prev->next = skb;
skb208net/tcp/raw.cskb->next->prev = skb;
skb221net/tcp/raw.cstruct sk_buff *skb;
skb256net/tcp/raw.cskb = NULL;
skb257net/tcp/raw.cwhile (skb == NULL)
skb259net/tcp/raw.cskb = sk->prot->wmalloc (sk, len+sizeof (*skb) + sk->prot->max_header,
skb263net/tcp/raw.cif (skb == NULL)
skb285net/tcp/raw.cskb->lock = 0;
skb286net/tcp/raw.cskb->mem_addr = skb;
skb287net/tcp/raw.cskb->mem_len = len + sizeof (*skb) +sk->prot->max_header;
skb288net/tcp/raw.cskb->sk = sk;
skb290net/tcp/raw.cskb->free = 1; /* these two should be unecessary. */
skb291net/tcp/raw.cskb->arp = 0;
skb293net/tcp/raw.ctmp = sk->prot->build_header (skb, sk->saddr, 
skb295net/tcp/raw.csk->protocol, sk->opt, skb->mem_len);
skb299net/tcp/raw.csk->prot->wfree (sk, skb->mem_addr, skb->mem_len);
skb305net/tcp/raw.cmemcpy_fromfs ((unsigned char *)(skb+1)+tmp, from, len);
skb306net/tcp/raw.cskb->len = tmp + len;
skb307net/tcp/raw.csk->prot->queue_xmit (sk, dev, skb, 1);
skb363net/tcp/raw.cstruct sk_buff *skb;
skb401net/tcp/raw.cskb = sk->rqueue;
skb405net/tcp/raw.cif (skb->next == skb )
skb412net/tcp/raw.cskb->prev->next = skb->next;
skb413net/tcp/raw.cskb->next->prev = skb->prev;
skb416net/tcp/raw.ccopied = min (len, skb->len);
skb418net/tcp/raw.cmemcpy_tofs (to, skb->h.raw,  copied);
skb424net/tcp/raw.caddr.sin_addr.s_addr = skb->daddr;
skb431net/tcp/raw.ckfree_skb (skb, FREE_READ);
skb212net/tcp/sock.cprint_skb(struct sk_buff *skb)
skb214net/tcp/sock.cif (!skb) {
skb218net/tcp/sock.cPRINTK (("  prev = %X, next = %X\n", skb->prev, skb->next));
skb219net/tcp/sock.cPRINTK (("  sk = %X link3 = %X\n", skb->sk, skb->link3));
skb220net/tcp/sock.cPRINTK (("  mem_addr = %X, mem_len = %d\n", skb->mem_addr, skb->mem_len));
skb221net/tcp/sock.cPRINTK (("  used = %d free = %d\n", skb->used,skb->free));
skb232net/tcp/sock.clock_skb (struct sk_buff *skb)
skb234net/tcp/sock.cif (skb->lock)
skb238net/tcp/sock.cskb->lock = 1;
skb243net/tcp/sock.ckfree_skb (struct sk_buff *skb, int rw)
skb245net/tcp/sock.cif (skb == NULL)
skb251net/tcp/sock.cif (skb->lock)
skb253net/tcp/sock.cskb->free = 1;
skb256net/tcp/sock.cskb->magic = 0;
skb257net/tcp/sock.cif (skb->sk)
skb261net/tcp/sock.cskb->sk->prot->rfree (skb->sk, skb->mem_addr, skb->mem_len);
skb265net/tcp/sock.cskb->sk->prot->wfree (skb->sk, skb->mem_addr, skb->mem_len);
skb270net/tcp/sock.ckfree_s (skb->mem_addr, skb->mem_len);
skb275net/tcp/sock.cunlock_skb (struct sk_buff *skb, int rw)
skb277net/tcp/sock.cif (skb->lock != 1)
skb281net/tcp/sock.cskb->lock = 0;
skb282net/tcp/sock.cif (skb->free)
skb283net/tcp/sock.ckfree_skb (skb, rw);
skb456net/tcp/sock.cstruct sk_buff *skb;
skb472net/tcp/sock.cfor (skb = sk->wfront; skb != NULL; )
skb475net/tcp/sock.cskb2=skb->next;
skb476net/tcp/sock.cif (skb->magic != TCP_WRITE_QUEUE_MAGIC)
skb479net/tcp/sock.cskb->magic);
skb482net/tcp/sock.ckfree_skb(skb, FREE_WRITE);
skb483net/tcp/sock.cskb=skb2;
skb491net/tcp/sock.cskb = sk->rqueue;
skb494net/tcp/sock.cskb2=skb->next;
skb499net/tcp/sock.cif (skb->sk != NULL && skb->sk != sk)
skb501net/tcp/sock.cskb->sk->dead = 1;
skb502net/tcp/sock.cskb->sk->prot->close (skb->sk, 0);
skb504net/tcp/sock.ckfree_skb(skb, FREE_READ);
skb505net/tcp/sock.cskb=skb2;
skb506net/tcp/sock.c} while (skb != sk->rqueue);
skb512net/tcp/sock.cfor (skb = sk->send_head; skb != NULL; )
skb522net/tcp/sock.cif (skb->next != NULL)
skb526net/tcp/sock.cif (skb->next != skb)
skb528net/tcp/sock.cskb->next->prev = skb->prev;
skb529net/tcp/sock.cskb->prev->next = skb->next;
skb531net/tcp/sock.cif (skb == arp_q)
skb533net/tcp/sock.cif (skb->magic != ARP_QUEUE_MAGIC)
skb537net/tcp/sock.c"bas magic (%X)\n", skb->magic);
skb542net/tcp/sock.carp_q = skb->next;
skb548net/tcp/sock.cif (skb->dev && skb->dev->buffs[i] == skb)
skb550net/tcp/sock.cif (skb->magic != DEV_QUEUE_MAGIC)
skb554net/tcp/sock.c"with bad magic (%X)\n", skb->magic);
skb558net/tcp/sock.cskb->dev->buffs[i]= skb->next;
skb566net/tcp/sock.cif (skb == arp_q)
skb568net/tcp/sock.cif (skb->magic != ARP_QUEUE_MAGIC)
skb572net/tcp/sock.c"bas magic (%X)\n", skb->magic);
skb581net/tcp/sock.cif (skb->dev && skb->dev->buffs[i] == skb)
skb583net/tcp/sock.cif (skb->magic != DEV_QUEUE_MAGIC)
skb587net/tcp/sock.c"with bad magic (%X)\n", skb->magic);
skb591net/tcp/sock.cskb->dev->buffs[i]= NULL;
skb598net/tcp/sock.cskb->dev = NULL;
skb600net/tcp/sock.cskb2=skb->link3;
skb601net/tcp/sock.ckfree_skb(skb, FREE_WRITE);
skb602net/tcp/sock.cskb=skb2;
skb614net/tcp/sock.cskb = sk->back_log;
skb617net/tcp/sock.cskb2=skb->next;
skb618net/tcp/sock.ckfree_skb(skb, FREE_READ);
skb619net/tcp/sock.cskb=skb2;
skb620net/tcp/sock.c} while (skb != sk->back_log);
skb1813net/tcp/sock.cstruct sk_buff *skb;
skb1815net/tcp/sock.cskb = sk->back_log;
skb1816net/tcp/sock.cPRINTK (("release_sock: skb = %X:\n",skb));
skb1817net/tcp/sock.cprint_skb(skb);
skb1818net/tcp/sock.cif (skb->next != skb)
skb1820net/tcp/sock.csk->back_log = skb->next;
skb1821net/tcp/sock.cskb->prev->next = skb->next;
skb1822net/tcp/sock.cskb->next->prev = skb->prev;
skb1831net/tcp/sock.csk->prot->rcv(skb, skb->dev, sk->opt,
skb1832net/tcp/sock.cskb->saddr, skb->len, skb->daddr, 1,
skb121net/tcp/sock.hint (*build_header) (struct sk_buff *skb, unsigned long saddr,
skb128net/tcp/sock.hstruct sk_buff *skb, int free);
skb205net/tcp/sock.hvoid kfree_skb (struct sk_buff *skb, int rw);
skb206net/tcp/sock.hvoid lock_skb (struct sk_buff *skb);
skb207net/tcp/sock.hvoid unlock_skb (struct sk_buff *skb, int rw);
skb134net/tcp/tcp.cstruct sk_buff *skb;
skb135net/tcp/tcp.cskb = sk->rqueue;
skb136net/tcp/tcp.cif (skb == NULL) return (NULL);
skb137net/tcp/tcp.csk->rqueue = skb->next;
skb138net/tcp/tcp.cif (sk->rqueue == skb)
skb144net/tcp/tcp.csk->rqueue->prev=skb->prev;
skb147net/tcp/tcp.creturn (skb);
skb244net/tcp/tcp.cstruct sk_buff *skb;
skb252net/tcp/tcp.cskb = sk->rqueue->next;
skb263net/tcp/tcp.cif (before (counted+1, skb->h.th->seq)) break;
skb264net/tcp/tcp.csum = skb->len - ( counted - skb->h.th->seq);
skb265net/tcp/tcp.cif (skb->h.th->syn) sum ++;
skb269net/tcp/tcp.cif (skb->h.th->syn) amount --;
skb271net/tcp/tcp.cif (skb->h.th->psh) break;
skb273net/tcp/tcp.cskb = skb->next;
skb274net/tcp/tcp.c} while (skb != sk->rqueue->next);
skb373net/tcp/tcp.cstruct sk_buff *skb;
skb379net/tcp/tcp.cskb = sk->rqueue->next;
skb380net/tcp/tcp.cif (sk->copied_seq+1 == skb->h.th->seq && skb->h.th->urg)
skb487net/tcp/tcp.cstruct sk_buff *skb;
skb491net/tcp/tcp.cskb = sk->send_tmp;
skb493net/tcp/tcp.ctcp_send_check (skb->h.th, sk->saddr, sk->daddr,
skb494net/tcp/tcp.cskb->len-(unsigned long)skb->h.th +
skb495net/tcp/tcp.c(unsigned long)(skb+1), sk);
skb497net/tcp/tcp.cskb->h.seq = sk->send_seq;
skb505net/tcp/tcp.cskb->next = NULL;
skb506net/tcp/tcp.cskb->magic = TCP_WRITE_QUEUE_MAGIC;
skb509net/tcp/tcp.csk->wfront=skb;
skb513net/tcp/tcp.csk->wback->next = skb;
skb515net/tcp/tcp.csk->wback = skb;
skb519net/tcp/tcp.csk->prot->queue_xmit (sk, skb->dev, skb,0);
skb638net/tcp/tcp.cstruct sk_buff *skb;
skb714net/tcp/tcp.cskb = sk->send_tmp;
skb717net/tcp/tcp.ccopy = min (sk->mss - skb->len + 128 + prot->max_header, len);
skb723net/tcp/tcp.cmemcpy_fromfs ((unsigned char *)(skb+1) + skb->len, from, copy);
skb724net/tcp/tcp.cskb->len += copy;
skb731net/tcp/tcp.cif (skb->len - (unsigned long)skb->h.th +
skb732net/tcp/tcp.c(unsigned long)(skb+1) >= sk->mss
skb755net/tcp/tcp.cskb=prot->wmalloc (sk,
skb756net/tcp/tcp.csk->mss + 128 + prot->max_header + sizeof (*skb),
skb759net/tcp/tcp.csk->send_tmp = skb;
skb760net/tcp/tcp.cif (skb != NULL)
skb761net/tcp/tcp.cskb->mem_len = sk->mss + 128 + prot->max_header+sizeof (*skb);
skb767net/tcp/tcp.cskb=prot->wmalloc (sk, copy + prot->max_header+sizeof (*skb),0,
skb770net/tcp/tcp.cif (skb != NULL)
skb771net/tcp/tcp.cskb->mem_len = copy+prot->max_header+sizeof (*skb);
skb775net/tcp/tcp.cif (skb == NULL)
skb809net/tcp/tcp.cskb->mem_addr = skb;
skb810net/tcp/tcp.cskb->len = 0;
skb811net/tcp/tcp.cskb->sk = sk;
skb812net/tcp/tcp.cskb->lock = 0;
skb813net/tcp/tcp.cskb->free = 0;
skb815net/tcp/tcp.cbuff =(unsigned char *)( skb+1);
skb819net/tcp/tcp.ctmp = prot->build_header (skb, sk->saddr, sk->daddr, &dev,
skb820net/tcp/tcp.cIPPROTO_TCP, sk->opt, skb->mem_len);
skb823net/tcp/tcp.cprot->wfree (sk, skb->mem_addr, skb->mem_len);
skb829net/tcp/tcp.cskb->len += tmp;
skb830net/tcp/tcp.cskb->dev = dev;
skb832net/tcp/tcp.cskb->h.th =(struct tcp_header *) buff;
skb837net/tcp/tcp.cprot->wfree (sk, skb->mem_addr, skb->mem_len);
skb849net/tcp/tcp.cskb->len += tmp;
skb855net/tcp/tcp.cskb->len += copy;
skb856net/tcp/tcp.cskb->free = 0;
skb868net/tcp/tcp.cskb->h.seq = sk->send_seq;
skb876net/tcp/tcp.cskb->next = NULL;
skb877net/tcp/tcp.cskb->magic = TCP_WRITE_QUEUE_MAGIC;
skb880net/tcp/tcp.csk->wfront=skb;
skb884net/tcp/tcp.csk->wback->next = skb;
skb886net/tcp/tcp.csk->wback = skb;
skb890net/tcp/tcp.cprot->queue_xmit (sk, dev, skb,0);
skb994net/tcp/tcp.cstruct sk_buff *skb;
skb995net/tcp/tcp.cskb=sk->rqueue->next;
skb996net/tcp/tcp.cif (!skb->used) break;
skb997net/tcp/tcp.cif (sk->rqueue == skb)
skb1003net/tcp/tcp.cskb->next->prev = skb->prev;
skb1004net/tcp/tcp.cskb->prev->next = skb->next;
skb1006net/tcp/tcp.cskb->sk = sk;
skb1007net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb1043net/tcp/tcp.cstruct sk_buff *skb;
skb1107net/tcp/tcp.cfor (skb = sk->rqueue->next; skb->next != sk->rqueue;
skb1108net/tcp/tcp.cskb = skb->next)
skb1112net/tcp/tcp.cif (!skb->h.th->urg) continue;
skb1114net/tcp/tcp.camt = min(skb->h.th->urg_ptr,len);
skb1116net/tcp/tcp.cmemcpy_tofs (to, (unsigned char *)(skb->h.th) +
skb1117net/tcp/tcp.cskb->h.th->doff*4
skb1122net/tcp/tcp.cskb->urg_used = 1;
skb1139net/tcp/tcp.cstruct sk_buff *skb;
skb1159net/tcp/tcp.cskb=sk->rqueue->next;
skb1161net/tcp/tcp.cskb = NULL;
skb1168net/tcp/tcp.cwhile ( skb == NULL || before (sk->copied_seq+1, skb->h.th->seq) ||
skb1169net/tcp/tcp.cskb->used) /* skb->used just checks to see if we've
skb1173net/tcp/tcp.cPRINTK(("skb = %X:\n",skb));
skb1174net/tcp/tcp.cprint_skb(skb);
skb1251net/tcp/tcp.cskb=sk->rqueue->next;
skb1253net/tcp/tcp.cskb = NULL;
skb1260net/tcp/tcp.coffset = sk->copied_seq+1 - skb->h.th->seq;
skb1262net/tcp/tcp.cif (skb->h.th->syn) offset --;
skb1263net/tcp/tcp.cif (offset < skb->len )
skb1267net/tcp/tcp.cif (skb->h.th->urg)
skb1269net/tcp/tcp.cif (skb->urg_used)
skb1272net/tcp/tcp.csk->copied_seq += skb->h.th->urg_ptr;
skb1273net/tcp/tcp.coffset += skb->h.th->urg_ptr;
skb1274net/tcp/tcp.cif (offset > skb->len)
skb1276net/tcp/tcp.cskb->used = 1;
skb1277net/tcp/tcp.cskb=skb->next;
skb1286net/tcp/tcp.cused = min(skb->len - offset, len);
skb1289net/tcp/tcp.cmemcpy_tofs(to, ((unsigned char *)skb->h.th) +
skb1290net/tcp/tcp.cskb->h.th->doff*4 +
skb1303net/tcp/tcp.c(!skb->h.th->urg || skb->urg_used) &&
skb1304net/tcp/tcp.c(used + offset >= skb->len) )
skb1305net/tcp/tcp.cskb->used = 1;
skb1309net/tcp/tcp.cif ( skb->h.th->psh || skb->h.th->urg)
skb1316net/tcp/tcp.cskb->used = 1;
skb1318net/tcp/tcp.cskb=skb->next;
skb1510net/tcp/tcp.ctcp_conn_request(volatile struct sock *sk, struct sk_buff *skb,
skb1520net/tcp/tcp.cth = skb->h.th;
skb1524net/tcp/tcp.csk, skb, daddr, saddr, opt, dev));
skb1535net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb1543net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb1557net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb1584net/tcp/tcp.cnewsk->acked_seq = skb->h.th->seq+1;
skb1585net/tcp/tcp.cnewsk->fin_seq = skb->h.th->seq;
skb1586net/tcp/tcp.cnewsk->copied_seq = skb->h.th->seq;
skb1596net/tcp/tcp.cnewsk->dummy_th.source = skb->h.th->dest;
skb1597net/tcp/tcp.cnewsk->dummy_th.dest = skb->h.th->source;
skb1612net/tcp/tcp.cnewsk->acked_seq = skb->h.th->seq+1;
skb1613net/tcp/tcp.cnewsk->copied_seq = skb->h.th->seq;
skb1615net/tcp/tcp.cif (skb->h.th->doff == 5)
skb1621net/tcp/tcp.cptr = (unsigned char *)(skb->h.th + 1);
skb1640net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb1663net/tcp/tcp.cskb->sk = sk;
skb1664net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb1671net/tcp/tcp.cmemcpy (t1, skb->h.th, sizeof (*t1));
skb1674net/tcp/tcp.ct1->dest = skb->h.th->source;
skb1686net/tcp/tcp.ct1->ack_seq = net32(skb->h.th->seq+1);
skb1701net/tcp/tcp.cskb->sk = newsk;
skb1703net/tcp/tcp.csk->rmem_alloc -= skb->mem_len;
skb1704net/tcp/tcp.cnewsk->rmem_alloc += skb->mem_len;
skb1708net/tcp/tcp.cskb->next = skb;
skb1709net/tcp/tcp.cskb->prev = skb;
skb1710net/tcp/tcp.csk->rqueue = skb;
skb1714net/tcp/tcp.cskb->next = sk->rqueue;
skb1715net/tcp/tcp.cskb->prev = sk->rqueue->prev;
skb1716net/tcp/tcp.csk->rqueue->prev = skb;
skb1717net/tcp/tcp.cskb->prev->next = skb;
skb1748net/tcp/tcp.cstruct sk_buff *skb;
skb1750net/tcp/tcp.cskb = sk->rqueue;
skb1752net/tcp/tcp.cskb2=skb->next;
skb1754net/tcp/tcp.cif (skb->len > 0 &&
skb1755net/tcp/tcp.cafter (skb->h.th->seq + skb->len + 1, sk->copied_seq))
skb1757net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb1758net/tcp/tcp.cskb=skb2;
skb1759net/tcp/tcp.c} while (skb != sk->rqueue);
skb1898net/tcp/tcp.cstruct sk_buff *skb;
skb1903net/tcp/tcp.cskb = sk->wfront;
skb1904net/tcp/tcp.csk->wfront = skb->next;
skb1907net/tcp/tcp.cskb->next = NULL;
skb1908net/tcp/tcp.cif (skb->magic != TCP_WRITE_QUEUE_MAGIC)
skb1911net/tcp/tcp.c"queue\n", skb->magic));
skb1916net/tcp/tcp.cskb->magic = 0;
skb1918net/tcp/tcp.csk->prot->queue_xmit (sk, skb->dev, skb, skb->free);
skb1957net/tcp/tcp.cstruct sk_buff *skb;
skb1963net/tcp/tcp.cfor (skb = sk->send_head; skb != NULL; skb=skb->link3)
skb1965net/tcp/tcp.cif (after( skb->h.seq, sk->window_seq))
skb1971net/tcp/tcp.csk->send_head = skb->link3;
skb1975net/tcp/tcp.cskb2->link3 = skb->link3;
skb1977net/tcp/tcp.cif (sk->send_tail == skb)
skb1981net/tcp/tcp.cif (skb->next != NULL)
skb1984net/tcp/tcp.cif (skb->next != skb)
skb1986net/tcp/tcp.cskb->next->prev = skb->prev;
skb1987net/tcp/tcp.cskb->prev->next = skb->next;
skb1991net/tcp/tcp.cif (skb->dev->buffs[i] == skb)
skb1993net/tcp/tcp.cif (skb->next == skb)
skb1994net/tcp/tcp.cskb->dev->buffs[i] = NULL;
skb1996net/tcp/tcp.cskb->dev->buffs[i] = skb->next;
skb2000net/tcp/tcp.cif (arp_q == skb)
skb2002net/tcp/tcp.cif (skb->next == skb)
skb2005net/tcp/tcp.carp_q = skb->next;
skb2010net/tcp/tcp.cskb->magic = TCP_WRITE_QUEUE_MAGIC;
skb2013net/tcp/tcp.cskb->next = sk->wfront;
skb2014net/tcp/tcp.csk->wfront = skb;
skb2018net/tcp/tcp.cskb->next = wskb->next;
skb2019net/tcp/tcp.cwskb->next = skb;
skb2021net/tcp/tcp.cwskb = skb;
skb2025net/tcp/tcp.cskb2 = skb;
skb2210net/tcp/tcp.ctcp_data (struct sk_buff *skb, volatile struct sock *sk, 
skb2216net/tcp/tcp.cth = skb->h.th;
skb2218net/tcp/tcp.cskb->len = len - (th->doff*4);
skb2220net/tcp/tcp.cPRINTK(("tcp_data len = %d sk = %X:\n",skb->len, sk));
skb2223net/tcp/tcp.csk->bytes_rcv += skb->len;
skb2225net/tcp/tcp.cif (skb->len == 0 && !th->fin && !th->urg && !th->psh)
skb2230net/tcp/tcp.ckfree_skb(skb, FREE_READ);
skb2236net/tcp/tcp.csk->acked_seq = th->seq + skb->len + th->syn + th->fin;
skb2237net/tcp/tcp.ctcp_reset (sk->saddr, sk->daddr, skb->h.th,
skb2238net/tcp/tcp.csk->prot, NULL, skb->dev);
skb2244net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb2257net/tcp/tcp.cPRINTK (("tcp_data: skb = %X:\n",skb));
skb2258net/tcp/tcp.cprint_skb (skb);
skb2260net/tcp/tcp.csk->rqueue = skb;
skb2261net/tcp/tcp.cskb->next = skb;
skb2262net/tcp/tcp.cskb->prev = skb;
skb2277net/tcp/tcp.cskb->prev = skb1;
skb2278net/tcp/tcp.cskb->next = skb1->next;
skb2279net/tcp/tcp.cskb->next->prev = skb;
skb2280net/tcp/tcp.cskb1->next = skb;
skb2282net/tcp/tcp.csk->rqueue = skb;
skb2287net/tcp/tcp.cskb->next= skb1;
skb2288net/tcp/tcp.cskb->prev = skb1->prev;
skb2289net/tcp/tcp.cskb->prev->next = skb;
skb2290net/tcp/tcp.cskb1->prev = skb;
skb2296net/tcp/tcp.cPRINTK (("skb = %X:\n",skb));
skb2297net/tcp/tcp.cprint_skb (skb);
skb2303net/tcp/tcp.cth->ack_seq = th->seq + skb->len;
skb2320net/tcp/tcp.cskb->acked = 1;
skb2323net/tcp/tcp.cif (skb->h.th->fin)  
skb2329net/tcp/tcp.cfor (skb2=skb->next; skb2 != sk->rqueue->next; skb2=skb2->next)
skb2562net/tcp/tcp.cstruct sk_buff *skb;
skb2578net/tcp/tcp.cwhile ( (skb = get_firstr(sk)) == NULL )
skb2602net/tcp/tcp.cnewsk = skb->sk;
skb2604net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb2762net/tcp/tcp.ctcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb2769net/tcp/tcp.cif (!skb)
skb2792net/tcp/tcp.cth = skb->h.th;
skb2797net/tcp/tcp.cPRINTK(("len = %d, redo = %d, skb=%X\n", len, redo, skb));
skb2809net/tcp/tcp.cskb->sk = NULL;
skb2811net/tcp/tcp.ckfree_skb (skb, 0);
skb2822net/tcp/tcp.cskb->sk = NULL;
skb2823net/tcp/tcp.ckfree_skb (skb, 0);
skb2827net/tcp/tcp.cskb->len = len;
skb2828net/tcp/tcp.cskb->sk = sk;
skb2829net/tcp/tcp.cskb->acked = 0;
skb2830net/tcp/tcp.cskb->used = 0;
skb2831net/tcp/tcp.cskb->free = 0;
skb2832net/tcp/tcp.cskb->urg_used = 0;
skb2833net/tcp/tcp.cskb->saddr = daddr;
skb2834net/tcp/tcp.cskb->daddr = saddr;
skb2845net/tcp/tcp.csk->back_log = skb;
skb2846net/tcp/tcp.cskb->next = skb;
skb2847net/tcp/tcp.cskb->prev = skb;
skb2851net/tcp/tcp.cskb->next = sk->back_log;
skb2852net/tcp/tcp.cskb->prev = sk->back_log->prev;
skb2853net/tcp/tcp.cskb->prev->next = skb;
skb2854net/tcp/tcp.cskb->next->prev = skb;
skb2878net/tcp/tcp.cif (sk->rmem_alloc + skb->mem_len >= SK_RMEM_MAX)
skb2880net/tcp/tcp.cskb->sk = NULL;
skb2882net/tcp/tcp.ckfree_skb (skb, 0);
skb2887net/tcp/tcp.csk->rmem_alloc += skb->mem_len;
skb2907net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb2920net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb2945net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb2960net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb2969net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb2978net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb2986net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb2991net/tcp/tcp.cif ( tcp_data (skb, sk, saddr, len))
skb2993net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3006net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3017net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3024net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3031net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3050net/tcp/tcp.ctcp_conn_request (sk, skb, daddr, saddr, opt, dev);
skb3056net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3063net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3078net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3103net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3114net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3124net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3139net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3162net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3166net/tcp/tcp.cif (tcp_data (skb, sk, saddr, len))
skb3167net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3180net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb3186net/tcp/tcp.cif (tcp_data (skb, sk, saddr, len))
skb3188net/tcp/tcp.ckfree_skb (skb, FREE_READ);
skb249net/tcp/udp.cstruct sk_buff *skb;
skb260net/tcp/udp.cskb = pair->prot->rmalloc (pair,
skb261net/tcp/udp.csizeof (*skb) + sizeof (*uh) + len + 4,
skb265net/tcp/udp.cif (skb == NULL) return (len);
skb266net/tcp/udp.cskb->lock = 0;
skb267net/tcp/udp.cskb->mem_addr = skb;
skb268net/tcp/udp.cskb->mem_len = sizeof (*skb) + len + sizeof (*uh) + 4;
skb270net/tcp/udp.cskb->daddr = saddr;
skb271net/tcp/udp.cskb->saddr = daddr;
skb273net/tcp/udp.cskb->len = len;
skb274net/tcp/udp.cskb->h.raw = (unsigned char *)(skb+1);
skb276net/tcp/udp.cuh = skb->h.uh;
skb285net/tcp/udp.cpair->rqueue = skb;
skb286net/tcp/udp.cskb->next = skb;
skb287net/tcp/udp.cskb->prev = skb;
skb291net/tcp/udp.cskb->next = pair->rqueue;
skb292net/tcp/udp.cskb->prev = pair->rqueue->prev;
skb293net/tcp/udp.cskb->prev->next = skb;
skb294net/tcp/udp.cskb->next->prev = skb;
skb309net/tcp/udp.cstruct sk_buff *skb;
skb369net/tcp/udp.cskb = sk->prot->wmalloc (sk, len + sizeof (*skb)
skb374net/tcp/udp.cif (skb == NULL)
skb398net/tcp/udp.cskb->lock = 0;
skb399net/tcp/udp.cskb->mem_addr = skb;
skb400net/tcp/udp.cskb->mem_len = len + sizeof (*skb) + sk->prot->max_header;
skb401net/tcp/udp.cskb->sk = sk;
skb402net/tcp/udp.cskb->free = 1;
skb403net/tcp/udp.cskb->arp = 0;
skb406net/tcp/udp.cbuff = (unsigned char *)(skb+1);
skb407net/tcp/udp.ctmp = sk->prot->build_header (skb, saddr,
skb409net/tcp/udp.cIPPROTO_UDP, sk->opt, skb->mem_len);
skb412net/tcp/udp.csk->prot->wfree (sk, skb->mem_addr, skb->mem_len);
skb425net/tcp/udp.cskb->len = amt;
skb451net/tcp/udp.csk->prot->queue_xmit (sk, dev, skb, 1);
skb488net/tcp/udp.cstruct sk_buff *skb;
skb493net/tcp/udp.cskb = sk->rqueue;
skb494net/tcp/udp.cif (skb != NULL)
skb498net/tcp/udp.camount = skb->len;
skb516net/tcp/udp.cstruct sk_buff *skb;
skb560net/tcp/udp.cskb = sk->rqueue;
skb564net/tcp/udp.cif (skb->next == skb )
skb571net/tcp/udp.cskb->prev->next = skb->next;
skb572net/tcp/udp.cskb->next->prev = skb->prev;
skb575net/tcp/udp.ccopied = min (len, skb->len);
skb577net/tcp/udp.cmemcpy_tofs (to, skb->h.raw + sizeof (struct udp_header), copied);
skb583net/tcp/udp.caddr.sin_port = skb->h.uh->source;
skb584net/tcp/udp.caddr.sin_addr.s_addr = skb->daddr;
skb591net/tcp/udp.ckfree_skb (skb, FREE_READ);
skb633net/tcp/udp.cudp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb642net/tcp/udp.cuh = (struct udp_header *) skb->h.uh;
skb644net/tcp/udp.cif (dev->add_arp) dev->add_arp (saddr, skb, dev);
skb654net/tcp/udp.cicmp_reply (skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, dev);
skb656net/tcp/udp.cskb->sk = NULL;
skb657net/tcp/udp.ckfree_skb (skb, 0);
skb667net/tcp/udp.cskb->sk = NULL;
skb668net/tcp/udp.ckfree_skb (skb, 0);
skb672net/tcp/udp.cskb->sk = sk;
skb673net/tcp/udp.cskb->dev = dev;
skb674net/tcp/udp.cskb->len = len;
skb677net/tcp/udp.cskb->daddr = saddr;
skb678net/tcp/udp.cskb->saddr = daddr;
skb686net/tcp/udp.csk->back_log = skb;
skb687net/tcp/udp.cskb->next = skb;
skb688net/tcp/udp.cskb->prev = skb;
skb692net/tcp/udp.cskb->next = sk->back_log;
skb693net/tcp/udp.cskb->prev = sk->back_log->prev;
skb694net/tcp/udp.cskb->prev->next = skb;
skb695net/tcp/udp.cskb->next->prev = skb;
skb705net/tcp/udp.cif (sk->rmem_alloc + skb->mem_len >= SK_RMEM_MAX)
skb707net/tcp/udp.cskb->sk = NULL;
skb708net/tcp/udp.ckfree_skb (skb, 0);
skb713net/tcp/udp.csk->rmem_alloc += skb->mem_len;
skb722net/tcp/udp.csk->rqueue = skb;
skb723net/tcp/udp.cskb->next = skb;
skb724net/tcp/udp.cskb->prev = skb;
skb728net/tcp/udp.cskb->next = sk->rqueue;
skb729net/tcp/udp.cskb->prev = sk->rqueue->prev;
skb730net/tcp/udp.cskb->prev->next = skb;
skb731net/tcp/udp.cskb->next->prev = skb;
skb734net/tcp/udp.cskb->len = len - sizeof (*uh);
skb224net/tcp/we.cwd8003_start_xmit(struct sk_buff *skb, struct device *dev)
skb242net/tcp/we.cif (skb == NULL)
skb250net/tcp/we.cif (skb->dev != dev)
skb257net/tcp/we.cif (!skb->arp)
skb259net/tcp/we.cif ( dev->rebuild_header (skb+1, dev)) 
skb262net/tcp/we.cif (skb->dev == dev)
skb264net/tcp/we.carp_queue (skb);
skb273net/tcp/we.cmemcpy ((unsigned char *)dev->mem_start, skb+1, skb->len);
skb275net/tcp/we.clen = skb->len;
skb297net/tcp/we.cif (skb->free)
skb299net/tcp/we.ckfree_skb (skb, FREE_WRITE);