taglinefilesource code
skb111drivers/net/3c501.cstatic int  el_start_xmit(struct sk_buff *skb, struct device *dev);
skb322drivers/net/3c501.cel_start_xmit(struct sk_buff *skb, struct device *dev)
skb346drivers/net/3c501.cif (skb == NULL) {
skb363drivers/net/3c501.cint gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
skb364drivers/net/3c501.cunsigned char *buf = skb->data;
skb383drivers/net/3c501.coutsb(DATAPORT,buf,skb->len);  /* load buffer (usual thing each byte increments the pointer) */
skb391drivers/net/3c501.cdev_kfree_skb (skb, FREE_WRITE);
skb533drivers/net/3c501.cstruct sk_buff *skb;
skb553drivers/net/3c501.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb558drivers/net/3c501.cif (skb == NULL) {
skb563drivers/net/3c501.cskb->len = pkt_len;
skb564drivers/net/3c501.cskb->dev = dev;
skb572drivers/net/3c501.cinsb(DATAPORT, skb->data, pkt_len);
skb574drivers/net/3c501.cnetif_rx(skb);
skb129drivers/net/3c505.cextern void  skb_check(struct sk_buff *skb,int, char *);
skb131drivers/net/3c505.c#define IS_SKB(skb)  skb_check((skb),__LINE__,filename)
skb135drivers/net/3c505.c#define IS_SKB(skb)  skb_check((skb),0,__LINE__,filename)
skb160drivers/net/3c505.c#define  SKB_DATA  (skb+1)
skb162drivers/net/3c505.c#define  SKB_DATA  (skb->data) 
skb552drivers/net/3c505.cstruct sk_buff *skb;
skb572drivers/net/3c505.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb574drivers/net/3c505.cskb = alloc_skb(rlen, GFP_ATOMIC);
skb585drivers/net/3c505.cif (skb == NULL) {
skb599drivers/net/3c505.cskb->lock     = 0;
skb600drivers/net/3c505.cskb->len = rlen;
skb601drivers/net/3c505.cskb->dev = dev;
skb607drivers/net/3c505.cskb->mem_len = sksize;
skb608drivers/net/3c505.cskb->mem_addr = skb;
skb625drivers/net/3c505.ckfree_s(skb, sksize);
skb627drivers/net/3c505.ckfree_s(skb, rlen);
skb642drivers/net/3c505.cIS_SKB(skb);
skb649drivers/net/3c505.cif (dev_rint((unsigned char *)skb, rlen, IN_SKBUFF, dev) != 0) {
skb651drivers/net/3c505.ckfree_s(skb, sksize);
skb654drivers/net/3c505.cnetif_rx(skb);
skb1031drivers/net/3c505.cstatic int elp_start_xmit(struct sk_buff *skb, struct device *dev)
skb1041drivers/net/3c505.cif (skb == NULL) {
skb1051drivers/net/3c505.cIS_SKB(skb);
skb1052drivers/net/3c505.cif (!skb->arp && dev->rebuild_header(SKB_DATA, dev)) {
skb1053drivers/net/3c505.cskb->dev = dev;
skb1054drivers/net/3c505.cIS_SKB(skb);
skb1055drivers/net/3c505.carp_queue (skb);
skb1063drivers/net/3c505.cif (skb->len <= 0)
skb1067drivers/net/3c505.cprintk("%s: request to send packet of length %d\n", dev->name, (int)skb->len);
skb1087drivers/net/3c505.cif (!send_packet(adapter, (unsigned char *)SKB_DATA, skb->len)) {
skb1093drivers/net/3c505.cprintk("%s: packet of length %d sent\n", dev->name, (int)skb->len);
skb1110drivers/net/3c505.cif (skb->free)
skb1112drivers/net/3c505.cIS_SKB(skb);
skb1113drivers/net/3c505.ckfree_skb(skb, FREE_WRITE);
skb1116drivers/net/3c505.cdev_kfree_skb(skb, FREE_WRITE);
skb284drivers/net/3c507.cstatic int  el16_send_packet(struct sk_buff *skb, struct device *dev);
skb447drivers/net/3c507.cel16_send_packet(struct sk_buff *skb, struct device *dev)
skb482drivers/net/3c507.cif (skb == NULL) {
skb491drivers/net/3c507.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb492drivers/net/3c507.cunsigned char *buf = skb->data;
skb502drivers/net/3c507.cdev_kfree_skb (skb, FREE_WRITE);
skb836drivers/net/3c507.cstruct sk_buff *skb;
skb839drivers/net/3c507.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb840drivers/net/3c507.cif (skb == NULL) {
skb845drivers/net/3c507.cskb->len = pkt_len;
skb846drivers/net/3c507.cskb->dev = dev;
skb849drivers/net/3c507.cmemcpy(skb->data, data_frame + 5, pkt_len);
skb851drivers/net/3c507.cnetif_rx(skb);
skb104drivers/net/3c509.cstatic int el3_start_xmit(struct sk_buff *skb, struct device *dev);
skb378drivers/net/3c509.cel3_start_xmit(struct sk_buff *skb, struct device *dev)
skb397drivers/net/3c509.cif (skb == NULL) {
skb402drivers/net/3c509.cif (skb->len <= 0)
skb407drivers/net/3c509.cdev->name, skb->len, inw(ioaddr + EL3_STATUS));
skb431drivers/net/3c509.coutw(skb->len, ioaddr + TX_FIFO);
skb434drivers/net/3c509.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
skb444drivers/net/3c509.cdev_kfree_skb (skb, FREE_WRITE);
skb593drivers/net/3c509.cstruct sk_buff *skb;
skb595drivers/net/3c509.cskb = alloc_skb(pkt_len+3, GFP_ATOMIC);
skb599drivers/net/3c509.cif (skb != NULL) {
skb600drivers/net/3c509.cskb->len = pkt_len;
skb601drivers/net/3c509.cskb->dev = dev;
skb604drivers/net/3c509.cinsl(ioaddr+RX_FIFO, skb->data,
skb607drivers/net/3c509.cnetif_rx(skb);
skb122drivers/net/8390.cstatic int ei_start_xmit(struct sk_buff *skb, struct device *dev)
skb164drivers/net/8390.cif (skb == NULL) {
skb169drivers/net/8390.clength = skb->len;
skb170drivers/net/8390.cif (skb->len <= 0)
skb210drivers/net/8390.cei_block_output(dev, length, skb->data, output_page);
skb224drivers/net/8390.cei_block_output(dev, length, skb->data, ei_local->tx_start_page);
skb234drivers/net/8390.cdev_kfree_skb (skb, FREE_WRITE);
skb448drivers/net/8390.cstruct sk_buff *skb;
skb450drivers/net/8390.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb451drivers/net/8390.cif (skb == NULL) {
skb458drivers/net/8390.cskb->len = pkt_len;
skb459drivers/net/8390.cskb->dev = dev;
skb461drivers/net/8390.cei_block_input(dev, pkt_len, (char *) skb->data,
skb463drivers/net/8390.cnetif_rx(skb);
skb188drivers/net/apricot.cstatic int i596_start_xmit(struct sk_buff *skb, struct device *dev);
skb345drivers/net/apricot.cstruct sk_buff *skb = alloc_skb(pkt_len, GFP_ATOMIC);
skb349drivers/net/apricot.cif (skb == NULL)
skb356drivers/net/apricot.cskb->len = pkt_len;
skb357drivers/net/apricot.cskb->dev = dev;    
skb358drivers/net/apricot.cmemcpy(skb->data, lp->scb.rfd->data, pkt_len);
skb360drivers/net/apricot.cnetif_rx(skb);
skb363drivers/net/apricot.cif (i596_debug > 4) print_eth(skb->data);
skb411drivers/net/apricot.cstruct sk_buff *skb = ((struct sk_buff *)(tx_cmd->tbd->data)) -1;
skb413drivers/net/apricot.cdev_kfree_skb(skb, FREE_WRITE);
skb576drivers/net/apricot.ci596_start_xmit(struct sk_buff *skb, struct device *dev)
skb614drivers/net/apricot.cif (skb == NULL) {
skb620drivers/net/apricot.cif (skb->len <= 0) return 0;
skb630drivers/net/apricot.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb639drivers/net/apricot.cdev_kfree_skb(skb, FREE_WRITE);
skb653drivers/net/apricot.ctx_cmd->tbd->data = skb->data;
skb655drivers/net/apricot.cif (i596_debug > 3) print_eth(skb->data);
skb813drivers/net/apricot.cstruct sk_buff *skb = ((struct sk_buff *)(tx_cmd->tbd->data)) -1;
skb815drivers/net/apricot.cdev_kfree_skb(skb, FREE_WRITE);
skb819drivers/net/apricot.cif (i596_debug >2) print_eth(skb->data);
skb122drivers/net/at1700.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb362drivers/net/at1700.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb393drivers/net/at1700.cif (skb == NULL) {
skb403drivers/net/at1700.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb404drivers/net/at1700.cunsigned char *buf = skb->data;
skb430drivers/net/at1700.cdev_kfree_skb (skb, FREE_WRITE);
skb516drivers/net/at1700.cstruct sk_buff *skb;
skb525drivers/net/at1700.cskb = alloc_skb(pkt_len+1, GFP_ATOMIC);
skb526drivers/net/at1700.cif (skb == NULL) {
skb533drivers/net/at1700.cskb->len = pkt_len;
skb534drivers/net/at1700.cskb->dev = dev;
skb536drivers/net/at1700.cinsw(ioaddr + DATAPORT, skb->data, (pkt_len + 1) >> 1);
skb542drivers/net/at1700.cprintk(" %02x", skb->data[i]);
skb546drivers/net/at1700.cnetif_rx(skb);
skb139drivers/net/atp.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb410drivers/net/atp.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb434drivers/net/atp.cif (skb == NULL) {
skb444drivers/net/atp.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb445drivers/net/atp.cunsigned char *buf = skb->data;
skb473drivers/net/atp.cdev_kfree_skb (skb, FREE_WRITE);
skb628drivers/net/atp.cstruct sk_buff *skb;
skb630drivers/net/atp.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb631drivers/net/atp.cif (skb == NULL) {
skb636drivers/net/atp.cskb->len = pkt_len;
skb637drivers/net/atp.cskb->dev = dev;
skb639drivers/net/atp.cread_block(ioaddr, pkt_len, skb->data, dev->if_port);
skb642drivers/net/atp.cunsigned char *data = skb->data;
skb650drivers/net/atp.cnetif_rx(skb);
skb249drivers/net/de600.cstatic int  de600_start_xmit(struct sk_buff *skb, struct device *dev);
skb404drivers/net/de600.cde600_start_xmit(struct sk_buff *skb, struct device *dev)
skb409drivers/net/de600.cbyte  *buffer = skb->data;
skb417drivers/net/de600.cif (skb == NULL) {
skb441drivers/net/de600.cPRINTK(("de600_start_xmit:len=%d, page %d/%d\n", skb->len, tx_fifo_in, free_tx_pages));
skb443drivers/net/de600.cif ((len = skb->len) < RUNT)
skb483drivers/net/de600.cif (skb->sk && (skb->sk->protocol == IPPROTO_TCP) &&
skb484drivers/net/de600.c(skb->sk->prot->rspace != &de600_rspace))
skb485drivers/net/de600.cskb->sk->prot->rspace = de600_rspace; /* Ugh! */
skb488drivers/net/de600.cdev_kfree_skb (skb, FREE_WRITE);
skb588drivers/net/de600.cstruct sk_buff  *skb;
skb613drivers/net/de600.cskb = alloc_skb(size, GFP_ATOMIC);
skb615drivers/net/de600.cif (skb == NULL) {
skb622drivers/net/de600.cskb->lock = 0;
skb624drivers/net/de600.cbuffer = skb->data;
skb633drivers/net/de600.cif (dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev))
skb478drivers/net/de620.cde620_start_xmit(struct sk_buff *skb, struct device *dev)
skb483drivers/net/de620.cbyte *buffer = skb->data;
skb492drivers/net/de620.cif (skb == NULL) {
skb517drivers/net/de620.cif ((len = skb->len) < RUNT)
skb527drivers/net/de620.c(int)skb->len, using_txbuf));
skb557drivers/net/de620.cdev_kfree_skb (skb, FREE_WRITE);
skb620drivers/net/de620.cstruct sk_buff *skb;
skb675drivers/net/de620.cskb = alloc_skb(size, GFP_ATOMIC);
skb676drivers/net/de620.cif (skb == NULL) { /* Yeah, but no place to put it... */
skb682drivers/net/de620.cskb->len = size; skb->dev = dev; skb->free = 1;
skb684drivers/net/de620.cbuffer = skb->data;
skb688drivers/net/de620.cnetif_rx(skb); /* deliver it "upstairs" */
skb323drivers/net/depca.cstatic int depca_start_xmit(struct sk_buff *skb, struct device *dev);
skb808drivers/net/depca.cdepca_start_xmit(struct sk_buff *skb, struct device *dev)
skb833drivers/net/depca.cif (skb == NULL) {
skb838drivers/net/depca.cif (skb->len <= 0) {
skb862drivers/net/depca.clong skbL = skb->len;
skb863drivers/net/depca.cchar *p = (char *) skb->data;
skb885drivers/net/depca.cmemcpy((unsigned char *)(buf), skb->data, len);
skb910drivers/net/depca.cmemcpy((unsigned char *)buf, skb->data, PKT_HDR_LEN);
skb948drivers/net/depca.cdev_kfree_skb (skb, FREE_WRITE);
skb1057drivers/net/depca.cstruct sk_buff *skb;
skb1059drivers/net/depca.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb1060drivers/net/depca.cif (skb == NULL) {
skb1065drivers/net/depca.cskb->len = pkt_len;
skb1066drivers/net/depca.cskb->dev = dev;
skb1067drivers/net/depca.cmemcpy(skb->data,
skb1075drivers/net/depca.cnetif_rx(skb);
skb59drivers/net/dummy.cstatic int dummy_xmit(struct sk_buff *skb, struct device *dev);
skb107drivers/net/dummy.cdummy_xmit(struct sk_buff *skb, struct device *dev)
skb113drivers/net/dummy.cif (skb == NULL || dev == NULL)
skb116drivers/net/dummy.cdev_kfree_skb(skb, FREE_WRITE);
skb292drivers/net/eexpress.cstatic int  eexp_send_packet(struct sk_buff *skb, struct device *dev);
skb452drivers/net/eexpress.ceexp_send_packet(struct sk_buff *skb, struct device *dev)
skb487drivers/net/eexpress.cif (skb == NULL) {
skb496drivers/net/eexpress.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb497drivers/net/eexpress.cunsigned char *buf = skb->data;
skb507drivers/net/eexpress.cdev_kfree_skb (skb, FREE_WRITE);
skb942drivers/net/eexpress.cstruct sk_buff *skb;
skb945drivers/net/eexpress.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb946drivers/net/eexpress.cif (skb == NULL) {
skb951drivers/net/eexpress.cskb->len = pkt_len;
skb952drivers/net/eexpress.cskb->dev = dev;
skb956drivers/net/eexpress.cinsw(ioaddr, skb->data, (pkt_len + 1) >> 1);
skb958drivers/net/eexpress.cnetif_rx(skb);
skb291drivers/net/ewrk3.cstatic int ewrk3_queue_pkt(struct sk_buff *skb, struct device *dev);
skb758drivers/net/ewrk3.cewrk3_queue_pkt(struct sk_buff *skb, struct device *dev)
skb794drivers/net/ewrk3.c} else if (skb == NULL) {
skb796drivers/net/ewrk3.c} else if (skb->len > 0) {
skb846drivers/net/ewrk3.cunsigned char *p = skb->data;
skb849drivers/net/ewrk3.coutb((char)(skb->len & 0xff), EWRK3_DATA);
skb850drivers/net/ewrk3.coutb((char)((skb->len >> 8) & 0xff), EWRK3_DATA);
skb852drivers/net/ewrk3.cfor (i=0; i<skb->len; i++) {
skb858drivers/net/ewrk3.c*buf++ = (char)(skb->len & 0xff);         /* length (16 bit xfer)*/
skb860drivers/net/ewrk3.c*buf++ = (char)(((skb->len >> 8) & 0xff) | XCT);
skb862drivers/net/ewrk3.c*(buf + skb->len) = 0x00;               /* Write the XCT flag */
skb863drivers/net/ewrk3.cmemcpy(buf, skb->data, PRELOAD);        /* Write PRELOAD bytes */
skb865drivers/net/ewrk3.cmemcpy(buf + PRELOAD, skb->data + PRELOAD, skb->len - PRELOAD);
skb866drivers/net/ewrk3.c*(buf + skb->len) = 0xff;               /* Write the XCT flag */
skb868drivers/net/ewrk3.c*buf++ = (char)((skb->len >> 8) & 0xff);
skb870drivers/net/ewrk3.cmemcpy(buf, skb->data, skb->len);       /* Write data bytes */
skb877drivers/net/ewrk3.cdev_kfree_skb (skb, FREE_WRITE);
skb1035drivers/net/ewrk3.cstruct sk_buff *skb;
skb1037drivers/net/ewrk3.cif ((skb = alloc_skb(pkt_len, GFP_ATOMIC)) != NULL) {
skb1038drivers/net/ewrk3.cskb->len = pkt_len;
skb1039drivers/net/ewrk3.cskb->dev = dev;
skb1042drivers/net/ewrk3.cunsigned char *p = skb->data;
skb1045drivers/net/ewrk3.cfor (i=0; i<skb->len; i++) {
skb1049drivers/net/ewrk3.cmemcpy(skb->data, buf, pkt_len);
skb1056drivers/net/ewrk3.cnetif_rx(skb);
skb1068drivers/net/ewrk3.cbuf = skb->data;                  /* Look at the dest addr */
skb236drivers/net/lance.cstatic int lance_start_xmit(struct sk_buff *skb, struct device *dev);
skb630drivers/net/lance.clance_start_xmit(struct sk_buff *skb, struct device *dev)
skb672drivers/net/lance.cif (skb == NULL) {
skb677drivers/net/lance.cif (skb->len <= 0)
skb712drivers/net/lance.c-(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
skb714drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
skb720drivers/net/lance.cif ((int)(skb->data) + skb->len > 0x01000000) {
skb723drivers/net/lance.cdev->name, (int)(skb->data));
skb724drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
skb727drivers/net/lance.cdev_kfree_skb (skb, FREE_WRITE);
skb729drivers/net/lance.clp->tx_skbuff[entry] = skb;
skb730drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
skb897drivers/net/lance.cstruct sk_buff *skb;
skb899drivers/net/lance.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb900drivers/net/lance.cif (skb == NULL) {
skb913drivers/net/lance.cskb->len = pkt_len;
skb914drivers/net/lance.cskb->dev = dev;
skb915drivers/net/lance.cmemcpy(skb->data,
skb918drivers/net/lance.cnetif_rx(skb);
skb45drivers/net/loopback.cloopback_xmit(struct sk_buff *skb, struct device *dev)
skb50drivers/net/loopback.cif (skb == NULL || dev == NULL) return(0);
skb64drivers/net/loopback.cdone = dev_rint(skb->data, skb->len, 0, dev);
skb65drivers/net/loopback.cdev_kfree_skb(skb, FREE_WRITE);
skb809drivers/net/ni52.cstruct sk_buff *skb;
skb866drivers/net/ni52.cskb = (struct sk_buff *) alloc_skb(totlen, GFP_ATOMIC);
skb868drivers/net/ni52.cif (skb != NULL) /* copy header */
skb870drivers/net/ni52.cskb->len = totlen;
skb871drivers/net/ni52.cskb->dev = dev;
skb876drivers/net/ni52.cmemcpy( (char *) skb->data,p->max_cbuff32-pnt,pnt);
skb877drivers/net/ni52.cmemcpy( (char *) skb->data+pnt,p->min_cbuff32,totlen-pnt);
skb880drivers/net/ni52.cmemcpy( (char *) skb->data,(char *) p->base+(unsigned long) rbd_first->buffer, totlen);
skb886drivers/net/ni52.cnetif_rx(skb);
skb998drivers/net/ni52.cstatic int ni52_send_packet(struct sk_buff *skb, struct device *dev)
skb1023drivers/net/ni52.cif(skb == NULL)
skb1029drivers/net/ni52.cif (skb->len <= 0)
skb1036drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
skb1037drivers/net/ni52.clen = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
skb1088drivers/net/ni52.cdev_kfree_skb(skb,FREE_WRITE);
skb120drivers/net/ni65.cstatic int   ni65_send_packet(struct sk_buff *skb, struct device *dev);
skb453drivers/net/ni65.cstruct sk_buff *skb;
skb463drivers/net/ni65.cskb = (struct sk_buff *) p->tmdbufs[p->tmdlast];
skb464drivers/net/ni65.cdev_kfree_skb(skb,FREE_WRITE); 
skb501drivers/net/ni65.cstruct sk_buff *skb,*skb1;
skb530drivers/net/ni65.cskb = alloc_skb(R_BUF_SIZE,GFP_ATOMIC);
skb531drivers/net/ni65.cif(skb != NULL)
skb533drivers/net/ni65.cif( (unsigned long) (skb->data + R_BUF_SIZE) & 0xff000000) {
skb534drivers/net/ni65.cmemcpy(skb->data,p->recv_skb[p->rmdnum]->data,len);
skb535drivers/net/ni65.cskb1 = skb;
skb539drivers/net/ni65.cp->recv_skb[p->rmdnum] = skb;
skb540drivers/net/ni65.crmdp->u.buffer = (unsigned long) (skb->data);
skb565drivers/net/ni65.cstatic int ni65_send_packet(struct sk_buff *skb, struct device *dev)
skb582drivers/net/ni65.cif(skb == NULL)
skb588drivers/net/ni65.cif (skb->len <= 0)
skb603drivers/net/ni65.cshort len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb608drivers/net/ni65.ctmdp->u.buffer = (unsigned long) (skb->data);
skb609drivers/net/ni65.cp->tmdbufs[p->tmdnum] = skb;
skb611drivers/net/ni65.cmemcpy((char *) (tmdp->u.buffer & 0x00ffffff),(char *)skb->data,skb->len);
skb612drivers/net/ni65.cdev_kfree_skb (skb, FREE_WRITE);
skb117drivers/net/plip.cstatic int plip_tx_packet(struct sk_buff *skb, struct device *dev);
skb122drivers/net/plip.cunsigned long raddr, struct sk_buff *skb);
skb164drivers/net/plip.cstruct sk_buff *skb;
skb289drivers/net/plip.cstruct sk_buff *skb;
skb307drivers/net/plip.cskb = rcv->skb;
skb308drivers/net/plip.crcv->skb = NULL;
skb310drivers/net/plip.cnetif_rx(skb);
skb323drivers/net/plip.cif (rcv->skb)
skb324drivers/net/plip.cdev_kfree_skb(rcv->skb, FREE_WRITE);
skb326drivers/net/plip.crcv->skb = NULL;
skb327drivers/net/plip.cif (snd->skb)
skb328drivers/net/plip.cdev_kfree_skb(snd->skb, FREE_WRITE);
skb330drivers/net/plip.csnd->skb = NULL;
skb345drivers/net/plip.csnd->skb = NULL;
skb390drivers/net/plip.cif (snd->skb)
skb391drivers/net/plip.cdev_kfree_skb(snd->skb, FREE_WRITE);
skb398drivers/net/plip.cif (rcv->skb)
skb399drivers/net/plip.cdev_kfree_skb(rcv->skb, FREE_WRITE);
skb413drivers/net/plip.cplip_tx_packet(struct sk_buff *skb, struct device *dev)
skb424drivers/net/plip.cif (skb == NULL) {
skb434drivers/net/plip.cif (skb->len > dev->mtu) {
skb435drivers/net/plip.cprintk("%s: packet too big, %d.\n", dev->name, (int)skb->len);
skb443drivers/net/plip.csnd->skb = skb;
skb444drivers/net/plip.csnd->length = skb->len;
skb522drivers/net/plip.cstruct sk_buff *skb)
skb547drivers/net/plip.cnl->rcv_data.skb = NULL;
skb548drivers/net/plip.cnl->snd_data.skb = NULL;
skb651drivers/net/plip.crcv->skb = alloc_skb(rcv->length, GFP_ATOMIC);
skb652drivers/net/plip.cif (rcv->skb == NULL) {
skb656drivers/net/plip.crcv->skb->len = rcv->length;
skb657drivers/net/plip.crcv->skb->dev = dev;
skb663drivers/net/plip.clbuf = rcv->skb->data;
skb799drivers/net/plip.cunsigned char *lbuf = snd->skb->data;
skb866drivers/net/plip.cdev_kfree_skb(snd->skb, FREE_WRITE);
skb120drivers/net/ppp.cstatic void ppp_add_arp(unsigned long addr, struct sk_buff *skb,
skb1677drivers/net/ppp.cppp_xmit(struct sk_buff *skb, struct device *dev)
skb1686drivers/net/ppp.cif (skb == NULL) {
skb1694drivers/net/ppp.cp     = (unsigned char *) (skb + 1);
skb1695drivers/net/ppp.clen   = skb->len;
skb1699drivers/net/ppp.c(unsigned long int) skb, ppp->sending));
skb1720drivers/net/ppp.clen = ntohs( ((struct iphdr *)(skb->data)) -> tot_len );
skb1761drivers/net/ppp.cstruct iphdr *iph = (struct iphdr *) (skb + 1);
skb1808drivers/net/ppp.cdev_kfree_skb(skb, FREE_WRITE);
skb1813drivers/net/ppp.cppp_type_trans (struct sk_buff *skb, struct device *dev)
skb1833drivers/net/ppp.cppp_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
skb1841drivers/net/ppp.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb)
skb1848drivers/net/ppp.cstruct sk_buff *skb)
skb489drivers/net/sk_g16.cstatic int   SK_send_packet(struct sk_buff *skb, struct device *dev);
skb1193drivers/net/sk_g16.cstatic int SK_send_packet(struct sk_buff *skb, struct device *dev)
skb1224drivers/net/sk_g16.cif (skb == NULL)
skb1250drivers/net/sk_g16.cshort len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; 
skb1258drivers/net/sk_g16.cmemcpy((char *) (tmdp->u.buffer & 0x00ffffff), (char *)skb->data,
skb1259drivers/net/sk_g16.cskb->len);
skb1290drivers/net/sk_g16.cdev_kfree_skb(skb, FREE_WRITE);
skb1572drivers/net/sk_g16.cstruct sk_buff *skb;
skb1574drivers/net/sk_g16.cskb = alloc_skb(len, GFP_ATOMIC); /* allocate socket buffer */ 
skb1576drivers/net/sk_g16.cif (skb == NULL)                /* Could not get mem ? */
skb1594drivers/net/sk_g16.cskb->len = len;
skb1595drivers/net/sk_g16.cskb->dev = dev;
skb1604drivers/net/sk_g16.cmemcpy(skb->data, (unsigned char *) (rmdp->u.buffer & 0x00ffffff),
skb1615drivers/net/sk_g16.cnetif_rx(skb);                 /* queue packet and mark it for processing */
skb99drivers/net/skeleton.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb308drivers/net/skeleton.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb330drivers/net/skeleton.cif (skb == NULL) {
skb340drivers/net/skeleton.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb341drivers/net/skeleton.cunsigned char *buf = skb->data;
skb346drivers/net/skeleton.cdev_kfree_skb (skb, FREE_WRITE);
skb418drivers/net/skeleton.cstruct sk_buff *skb;
skb420drivers/net/skeleton.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb421drivers/net/skeleton.cif (skb == NULL) {
skb426drivers/net/skeleton.cskb->len = pkt_len;
skb427drivers/net/skeleton.cskb->dev = dev;
skb430drivers/net/skeleton.cmemcpy(skb->data, (void*)dev->rmem_start,
skb433drivers/net/skeleton.cinsw(ioaddr, skb->data, (pkt_len + 1) >> 1);
skb435drivers/net/skeleton.cnetif_rx(skb);
skb258drivers/net/slip.cstruct sk_buff *skb;
skb295drivers/net/slip.cskb = alloc_skb(count, GFP_ATOMIC);
skb296drivers/net/slip.cif (skb == NULL)  {
skb301drivers/net/slip.cskb->len = count;
skb302drivers/net/slip.cskb->dev = sl->dev;
skb303drivers/net/slip.cmemcpy(skb->data, sl->rbuff, count);
skb304drivers/net/slip.cnetif_rx(skb);
skb393drivers/net/slip.csl_xmit(struct sk_buff *skb, struct device *dev)
skb432drivers/net/slip.cif (skb != NULL) {
skb434drivers/net/slip.csl_encaps(sl, skb->data, skb->len);
skb435drivers/net/slip.cdev_kfree_skb(skb, FREE_WRITE);
skb443drivers/net/slip.csl_type_trans (struct sk_buff *skb, struct device *dev)
skb459drivers/net/slip.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb)
skb466drivers/net/slip.creturn ax25_encapsulate(buff, dev, type, daddr, saddr, len, skb);
skb477drivers/net/slip.cstruct sk_buff *skb)
skb484drivers/net/slip.creturn ax25_rebuild_header(buff, dev, raddr, skb);
skb184drivers/net/znet.cstatic int  znet_send_packet(struct sk_buff *skb, struct device *dev);
skb317drivers/net/znet.cstatic int znet_send_packet(struct sk_buff *skb, struct device *dev)
skb343drivers/net/znet.cif (skb == NULL) {
skb360drivers/net/znet.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb361drivers/net/znet.cunsigned char *buf = (void *)(skb+1);
skb386drivers/net/znet.cmemcpy(zn.tx_cur, buf, skb->len);
skb400drivers/net/znet.cdev_kfree_skb(skb, FREE_WRITE); 
skb550drivers/net/znet.cstruct sk_buff *skb;
skb552drivers/net/znet.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb553drivers/net/znet.cif (skb == NULL) {
skb559drivers/net/znet.cskb->len = pkt_len;
skb560drivers/net/znet.cskb->dev = dev;
skb564drivers/net/znet.cmemcpy((unsigned char *) (skb + 1), zn.rx_cur, semi_cnt);
skb565drivers/net/znet.cmemcpy((unsigned char *) (skb + 1) + semi_cnt, zn.rx_start,
skb568drivers/net/znet.cmemcpy((unsigned char *) (skb + 1), zn.rx_cur, pkt_len);
skb570drivers/net/znet.cunsigned int *packet = (unsigned int *) (skb + 1);
skb577drivers/net/znet.cnetif_rx(skb);
skb579drivers/net/znet.cskb->lock = 0;
skb580drivers/net/znet.cif (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
skb581drivers/net/znet.ckfree_s(skb, sksize);
skb34include/linux/etherdevice.hstruct sk_buff *skb);
skb36include/linux/etherdevice.hunsigned long raddr, struct sk_buff *skb);
skb37include/linux/etherdevice.hextern unsigned short  eth_type_trans(struct sk_buff *skb, struct device *dev);
skb140include/linux/netdevice.hint        (*hard_start_xmit) (struct sk_buff *skb,
skb148include/linux/netdevice.hstruct sk_buff *skb);
skb150include/linux/netdevice.hunsigned long raddr, struct sk_buff *skb);
skb151include/linux/netdevice.hunsigned short    (*type_trans) (struct sk_buff *skb,
skb201include/linux/netdevice.hextern void    dev_queue_xmit(struct sk_buff *skb, struct device *dev,
skb204include/linux/netdevice.hextern void    netif_rx(struct sk_buff *skb);
skb104include/linux/skbuff.hextern void      kfree_skb(struct sk_buff *skb, int rw);
skb114include/linux/skbuff.hextern void      kfree_skbmem(struct sk_buff *skb, unsigned size);
skb115include/linux/skbuff.hextern struct sk_buff *    skb_clone(struct sk_buff *skb, int priority);
skb116include/linux/skbuff.hextern void      skb_device_lock(struct sk_buff *skb);
skb117include/linux/skbuff.hextern void      skb_device_unlock(struct sk_buff *skb);
skb118include/linux/skbuff.hextern void      dev_kfree_skb(struct sk_buff *skb, int mode);
skb119include/linux/skbuff.hextern int      skb_device_locked(struct sk_buff *skb);
skb133include/linux/skbuff.hextern int       skb_check(struct sk_buff *skb,int,int, char *);
skb134include/linux/skbuff.h#define IS_SKB(skb)    skb_check((skb), 0, __LINE__,__FILE__)
skb135include/linux/skbuff.h#define IS_SKB_HEAD(skb)  skb_check((skb), 1, __LINE__,__FILE__)
skb137include/linux/skbuff.h#define IS_SKB(skb)    
skb138include/linux/skbuff.h#define IS_SKB_HEAD(skb)  
skb260include/linux/skbuff.hextern __inline__ void skb_unlink(struct sk_buff *skb)
skb267include/linux/skbuff.hif(skb->prev && skb->next)
skb269include/linux/skbuff.hskb->next->prev = skb->prev;
skb270include/linux/skbuff.hskb->prev->next = skb->next;
skb271include/linux/skbuff.hskb->next = NULL;
skb272include/linux/skbuff.hskb->prev = NULL;
skb282include/linux/skbuff.hextern void      skb_free_datagram(struct sk_buff *skb);
skb251net/inet/af_inet.cstruct sk_buff *skb;
skb266net/inet/af_inet.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL) {
skb267net/inet/af_inet.cIS_SKB(skb);
skb268net/inet/af_inet.ckfree_skb(skb, FREE_WRITE);
skb272net/inet/af_inet.cwhile((skb = skb_dequeue(&sk->write_queue)) != NULL) {
skb273net/inet/af_inet.cIS_SKB(skb);
skb274net/inet/af_inet.ckfree_skb(skb, FREE_WRITE);
skb284net/inet/af_inet.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) 
skb290net/inet/af_inet.cif (skb->sk != NULL && skb->sk != sk) 
skb292net/inet/af_inet.cIS_SKB(skb);
skb293net/inet/af_inet.cskb->sk->dead = 1;
skb294net/inet/af_inet.cskb->sk->prot->close(skb->sk, 0);
skb296net/inet/af_inet.cIS_SKB(skb);
skb297net/inet/af_inet.ckfree_skb(skb, FREE_READ);
skb303net/inet/af_inet.cfor(skb = sk->send_head; skb != NULL; )
skb311net/inet/af_inet.cif (skb->next  && skb->prev) {
skb313net/inet/af_inet.cIS_SKB(skb);
skb314net/inet/af_inet.cskb_unlink(skb);
skb316net/inet/af_inet.cskb->dev = NULL;
skb317net/inet/af_inet.cskb2 = skb->link3;
skb318net/inet/af_inet.ckfree_skb(skb, FREE_WRITE);
skb319net/inet/af_inet.cskb = skb2;
skb325net/inet/af_inet.cwhile((skb=skb_dequeue(&sk->back_log))!=NULL) 
skb329net/inet/af_inet.ckfree_skb(skb, FREE_READ);
skb95net/inet/arp.cstruct sk_buff_head    skb;      /* list of queued packets   */
skb230net/inet/arp.cstruct sk_buff *skb;
skb236net/inet/arp.cwhile ((skb = skb_dequeue(&entry->skb)) != NULL)
skb238net/inet/arp.cskb_device_lock(skb);
skb240net/inet/arp.cdev_kfree_skb(skb, FREE_WRITE);
skb297net/inet/arp.cstruct sk_buff *skb;
skb312net/inet/arp.cskb = alloc_skb(sizeof(struct arphdr)+ 2*(dev->addr_len+4)
skb314net/inet/arp.cif (skb == NULL)
skb319net/inet/arp.cskb->len = sizeof(struct arphdr) + dev->hard_header_len + 2*(dev->addr_len+4);
skb320net/inet/arp.cskb->arp = 1;
skb321net/inet/arp.cskb->dev = dev;
skb322net/inet/arp.cskb->free = 1;
skb328net/inet/arp.cdev->hard_header(skb->data,dev,ptype,dest_hw?dest_hw:dev->broadcast,src_hw?src_hw:NULL,skb->len,skb);
skb331net/inet/arp.carp = (struct arphdr *) (skb->data + dev->hard_header_len);
skb355net/inet/arp.cdev_queue_xmit(skb, dev, 0);
skb443net/inet/arp.cstruct sk_buff *skb;
skb461net/inet/arp.cwhile((skb = skb_dequeue(&entry->skb)) != NULL)
skb463net/inet/arp.cIS_SKB(skb);
skb464net/inet/arp.cskb_device_lock(skb);
skb466net/inet/arp.cif(!skb->dev->rebuild_header(skb->data,skb->dev,skb->raddr,skb))
skb468net/inet/arp.cskb->arp  = 1;
skb469net/inet/arp.cif(skb->sk==NULL)
skb470net/inet/arp.cdev_queue_xmit(skb, skb->dev, 0);
skb472net/inet/arp.cdev_queue_xmit(skb,skb->dev,skb->sk->priority);
skb480net/inet/arp.cprintk("arp_send_q: failed to find %s\n",in_ntoa(skb->raddr));
skb533net/inet/arp.cint arp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb539net/inet/arp.cstruct arphdr *arp = (struct arphdr *)skb->h.raw;
skb561net/inet/arp.ckfree_skb(skb, FREE_READ);
skb577net/inet/arp.ckfree_skb(skb, FREE_READ);
skb586net/inet/arp.ckfree_skb(skb, FREE_READ);
skb593net/inet/arp.ckfree_skb(skb, FREE_READ);
skb617net/inet/arp.ckfree_skb(skb, FREE_READ);
skb647net/inet/arp.ckfree_skb(skb, FREE_READ);
skb689net/inet/arp.ckfree_skb(skb, FREE_READ);
skb695net/inet/arp.ckfree_skb(skb, FREE_READ);
skb762net/inet/arp.ckfree_skb(skb, FREE_READ);
skb774net/inet/arp.centry->dev = skb->dev;
skb775net/inet/arp.cskb_queue_head_init(&entry->skb);
skb784net/inet/arp.ckfree_skb(skb, FREE_READ);
skb794net/inet/arp.cunsigned long saddr, struct sk_buff *skb)
skb807net/inet/arp.cskb->arp = 1;
skb831net/inet/arp.cskb->arp = 1;
skb852net/inet/arp.cif (skb != NULL)
skb854net/inet/arp.cskb_queue_tail(&entry->skb, skb);
skb855net/inet/arp.cskb_device_unlock(skb);
skb867net/inet/arp.cif (skb)
skb868net/inet/arp.cskb->arp = 1;
skb897net/inet/arp.cskb_queue_head_init(&entry->skb);
skb898net/inet/arp.cif (skb != NULL)
skb900net/inet/arp.cskb_queue_tail(&entry->skb, skb);
skb901net/inet/arp.cskb_device_unlock(skb);
skb906net/inet/arp.cif (skb != NULL && skb->free)
skb907net/inet/arp.ckfree_skb(skb, FREE_WRITE);
skb1121net/inet/arp.cskb_queue_head_init(&entry->skb);
skb8net/inet/arp.hextern int  arp_rcv(struct sk_buff *skb, struct device *dev,
skb11net/inet/arp.hstruct device *dev, unsigned long saddr, struct sk_buff *skb);
skb54net/inet/datagram.cstruct sk_buff *skb;
skb126net/inet/datagram.cskb=skb_dequeue(&sk->receive_queue);
skb127net/inet/datagram.cif(skb!=NULL)
skb128net/inet/datagram.cskb->users++;
skb135net/inet/datagram.cskb=skb_peek(&sk->receive_queue);
skb136net/inet/datagram.cif(skb!=NULL)
skb137net/inet/datagram.cskb->users++;
skb139net/inet/datagram.cif(skb==NULL)  /* shouldn't happen but .. */
skb142net/inet/datagram.creturn skb;
skb145net/inet/datagram.cvoid skb_free_datagram(struct sk_buff *skb)
skb151net/inet/datagram.cskb->users--;
skb152net/inet/datagram.cif(skb->users>0)
skb158net/inet/datagram.cif(!skb->next && !skb->prev)  /* Been dequeued by someone - ie its read */
skb159net/inet/datagram.ckfree_skb(skb,FREE_READ);
skb163net/inet/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
skb167net/inet/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
skb263net/inet/dev.cstruct sk_buff *skb;
skb264net/inet/dev.cwhile((skb=skb_dequeue(&dev->buffs[ct]))!=NULL)
skb265net/inet/dev.cif(skb->free)
skb266net/inet/dev.ckfree_skb(skb,FREE_WRITE);
skb299net/inet/dev.cvoid dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
skb314net/inet/dev.cif(pri>=0 && !skb_device_locked(skb))
skb315net/inet/dev.cskb_device_lock(skb);  /* Shove a lock on the frame */
skb325net/inet/dev.cIS_SKB(skb);
skb327net/inet/dev.cskb->dev = dev;
skb333net/inet/dev.cif (skb->next != NULL) 
skb366net/inet/dev.cif (!skb->arp && dev->rebuild_header(skb->data, dev, skb->raddr, skb)) {
skb374net/inet/dev.cskb->in_dev_queue=1;
skb376net/inet/dev.cskb_queue_tail(dev->buffs + pri,skb);
skb377net/inet/dev.cskb_device_unlock(skb);    /* Buffer is on the device queue and can be freed safely */
skb378net/inet/dev.cskb = skb_dequeue(dev->buffs + pri);
skb379net/inet/dev.cskb_device_lock(skb);    /* New buffer needs locking down */
skb381net/inet/dev.cskb->in_dev_queue=0;
skb394net/inet/dev.cif ((skb2 = skb_clone(skb, GFP_ATOMIC)) == NULL)
skb396net/inet/dev.cptype->func(skb2, skb->dev, ptype);
skb401net/inet/dev.cif (dev->hard_start_xmit(skb, dev) == 0) {
skb414net/inet/dev.cskb->in_dev_queue=1;
skb417net/inet/dev.cskb_device_unlock(skb);
skb418net/inet/dev.cskb_queue_head(dev->buffs + pri,skb);
skb428net/inet/dev.cvoid netif_rx(struct sk_buff *skb)
skb437net/inet/dev.cskb->sk = NULL;
skb438net/inet/dev.cskb->free = 1;
skb439net/inet/dev.cif(skb->stamp.tv_sec==0)
skb440net/inet/dev.cskb->stamp = xtime;
skb453net/inet/dev.ckfree_skb(skb, FREE_READ);
skb461net/inet/dev.cIS_SKB(skb);
skb463net/inet/dev.cskb_queue_tail(&backlog,skb);
skb493net/inet/dev.cstruct sk_buff *skb = NULL;
skb503net/inet/dev.cskb = (struct sk_buff *) buff;
skb515net/inet/dev.cskb = alloc_skb(len, GFP_ATOMIC);
skb516net/inet/dev.cif (skb == NULL) 
skb529net/inet/dev.cto = skb->data;
skb551net/inet/dev.cskb->len = len;
skb552net/inet/dev.cskb->dev = dev;
skb553net/inet/dev.cskb->free = 1;
skb555net/inet/dev.cnetif_rx(skb);
skb612net/inet/dev.cstruct sk_buff *skb;
skb644net/inet/dev.cwhile((skb=skb_dequeue(&backlog))!=NULL)
skb660net/inet/dev.cskb->h.raw = skb->data + skb->dev->hard_header_len;
skb661net/inet/dev.cskb->len -= skb->dev->hard_header_len;
skb674net/inet/dev.ctype = skb->dev->type_trans(skb, skb->dev);
skb690net/inet/dev.cif ((ptype->type == type || ptype->type == htons(ETH_P_ALL)) && (!ptype->dev || ptype->dev==skb->dev))
skb700net/inet/dev.cskb2=skb_clone(skb, GFP_ATOMIC);
skb708net/inet/dev.cpt_prev->func(skb2, skb->dev, pt_prev);
skb720net/inet/dev.cpt_prev->func(skb, skb->dev, pt_prev);
skb726net/inet/dev.ckfree_skb(skb, FREE_WRITE);
skb761net/inet/dev.cstruct sk_buff *skb;
skb777net/inet/dev.cwhile((skb=skb_dequeue(&dev->buffs[i]))!=NULL)
skb782net/inet/dev.cskb_device_lock(skb);
skb788net/inet/dev.cdev_queue_xmit(skb,dev,-i - 1);
skb86net/inet/eth.cstruct sk_buff *skb)
skb136net/inet/eth.cstruct sk_buff *skb)
skb155net/inet/eth.creturn arp_find(eth->h_dest, dst, dev, dev->pa_addr, skb)? 1 : 0;
skb168net/inet/eth.cunsigned short eth_type_trans(struct sk_buff *skb, struct device *dev)
skb170net/inet/eth.cstruct ethhdr *eth = (struct ethhdr *) skb->data;
skb176net/inet/eth.cskb->pkt_type=PACKET_BROADCAST;
skb178net/inet/eth.cskb->pkt_type=PACKET_MULTICAST;
skb184net/inet/eth.cskb->pkt_type=PACKET_OTHERHOST;
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);
skb99net/inet/icmp.cstruct sk_buff *skb;
skb195net/inet/icmp.cskb = (struct sk_buff *) alloc_skb(len, GFP_ATOMIC);
skb196net/inet/icmp.cif (skb == NULL) 
skb201net/inet/icmp.cskb->free = 1;
skb210net/inet/icmp.coffset = ip_build_header(skb, our_addr, iph->saddr,
skb216net/inet/icmp.cskb->sk = NULL;
skb217net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb225net/inet/icmp.cskb->len = offset + sizeof(struct icmphdr) + sizeof(struct iphdr) + 8;
skb231net/inet/icmp.cicmph = (struct icmphdr *) (skb->data + offset);
skb244net/inet/icmp.cip_queue_xmit(NULL, ndev, skb, 1);
skb252net/inet/icmp.cstatic void icmp_unreach(struct icmphdr *icmph, struct sk_buff *skb)
skb313net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb321net/inet/icmp.cstatic void icmp_redirect(struct icmphdr *icmph, struct sk_buff *skb,
skb375net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb383net/inet/icmp.cstatic void icmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb401net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb408net/inet/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
skb414net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb443net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb450net/inet/icmp.cstatic void icmp_timestamp(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb477net/inet/icmp.cskb->sk = NULL;
skb478net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb489net/inet/icmp.cskb->ip_hdr->tos, 255);
skb494net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb529net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb539net/inet/icmp.cstatic void icmp_info(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb544net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb552net/inet/icmp.cstatic void icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb569net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb579net/inet/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
skb585net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb612net/inet/icmp.cskb->sk = NULL;
skb613net/inet/icmp.ckfree_skb(skb, FREE_READ);
skb77net/inet/igmp.cstruct sk_buff *skb=alloc_skb(MAX_IGMP_SIZE, GFP_ATOMIC);
skb81net/inet/igmp.cif(skb==NULL)
skb83net/inet/igmp.ctmp=ip_build_header(skb, INADDR_ANY, address, &dev, IPPROTO_IGMP, NULL,
skb84net/inet/igmp.cskb->mem_len, 0, 1);
skb87net/inet/igmp.ckfree_skb(skb, FREE_WRITE);
skb90net/inet/igmp.cigh=(struct igmphdr *)(skb->data+tmp);
skb91net/inet/igmp.cskb->len=tmp+sizeof(*igh);
skb97net/inet/igmp.cip_queue_xmit(NULL,dev,skb,1);
skb192net/inet/igmp.cint igmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb197net/inet/igmp.cstruct igmphdr *igh=(struct igmphdr *)skb->h.raw;
skb199net/inet/igmp.cif(skb->ip_hdr->ttl!=1 || ip_compute_csum((void *)igh,sizeof(*igh)))
skb201net/inet/igmp.ckfree_skb(skb, FREE_READ);
skb209net/inet/igmp.ckfree_skb(skb, FREE_READ);
skb188net/inet/ip.cstatic int ip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev, unsigned long saddr)
skb192net/inet/ip.cskb->dev = dev;
skb193net/inet/ip.cskb->arp = 1;
skb200net/inet/ip.cmac = dev->hard_header(skb->data, dev, ETH_P_IP, NULL, NULL, len, skb);
skb204net/inet/ip.cskb->arp = 0;
skb205net/inet/ip.cskb->raddr = daddr;  /* next routing address */
skb219net/inet/ip.cint ip_build_header(struct sk_buff *skb, unsigned long saddr, unsigned long daddr,
skb230net/inet/ip.cbuff = skb->data;
skb237net/inet/ip.cif(MULTICAST(daddr) && *dev==NULL && skb->sk && *skb->sk->ip_mc_name)
skb238net/inet/ip.c*dev=dev_get(skb->sk->ip_mc_name);
skb242net/inet/ip.cif(skb->localroute)
skb268net/inet/ip.cif(skb->localroute)
skb298net/inet/ip.ctmp = ip_send(skb, raddr, len, *dev, saddr);
skb306net/inet/ip.cskb->dev = *dev;
skb307net/inet/ip.cskb->saddr = saddr;
skb308net/inet/ip.cif (skb->sk)
skb309net/inet/ip.cskb->sk->saddr = saddr;
skb332net/inet/ip.cskb->ip_hdr   = iph;
skb605net/inet/ip.cstatic struct ipfrag *ip_frag_create(int offset, int end, struct sk_buff *skb, unsigned char *ptr)
skb621net/inet/ip.cfp->skb = skb;
skb693net/inet/ip.cIS_SKB(fp->skb);
skb694net/inet/ip.ckfree_skb(fp->skb,FREE_READ);
skb729net/inet/ip.cicmp_send(qp->fragments->skb,ICMP_TIME_EXCEEDED,
skb746net/inet/ip.cstatic struct ipq *ip_create(struct sk_buff *skb, struct iphdr *iph, struct device *dev)
skb757net/inet/ip.cskb->dev = qp->dev;
skb768net/inet/ip.cmaclen = ((unsigned long) iph) - ((unsigned long) skb->data);
skb792net/inet/ip.cmemcpy(qp->mac, skb->data, maclen);
skb858net/inet/ip.cstruct sk_buff *skb;
skb870net/inet/ip.cif ((skb = alloc_skb(len,GFP_ATOMIC)) == NULL)
skb879net/inet/ip.cskb->len = (len - qp->maclen);
skb880net/inet/ip.cskb->h.raw = skb->data;
skb881net/inet/ip.cskb->free = 1;
skb884net/inet/ip.cptr = (unsigned char *) skb->h.raw;
skb889net/inet/ip.cskb->h.raw += qp->maclen;
skb897net/inet/ip.cif(count+fp->len > skb->len)
skb901net/inet/ip.ckfree_skb(skb,FREE_WRITE);
skb914net/inet/ip.ciph = skb->h.iph;
skb917net/inet/ip.cskb->ip_hdr = iph;
skb920net/inet/ip.creturn(skb);
skb928net/inet/ip.cstatic struct sk_buff *ip_defrag(struct iphdr *iph, struct sk_buff *skb, struct device *dev)
skb951net/inet/ip.creturn(skb);
skb975net/inet/ip.cif ((qp = ip_create(skb, iph, dev)) == NULL)
skb977net/inet/ip.cskb->sk = NULL;
skb978net/inet/ip.ckfree_skb(skb, FREE_READ);
skb995net/inet/ip.cptr = skb->data + dev->hard_header_len + ihl;
skb1060net/inet/ip.ckfree_skb(next->skb,FREE_READ);
skb1070net/inet/ip.ctfp = ip_frag_create(offset, end, skb, ptr);
skb1078net/inet/ip.cskb->sk = NULL;
skb1079net/inet/ip.ckfree_skb(skb, FREE_READ);
skb1120net/inet/ip.cvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
skb1134net/inet/ip.craw = skb->data;
skb1137net/inet/ip.cskb->ip_hdr = iph;
skb1156net/inet/ip.cicmp_send(skb,ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, dev);
skb1169net/inet/ip.cicmp_send(skb,ICMP_DEST_UNREACH,ICMP_FRAG_NEEDED,dev);
skb1221net/inet/ip.cskb2->arp = skb->arp;
skb1222net/inet/ip.cif(skb->free==0)
skb1240net/inet/ip.cskb2->raddr = skb->raddr;  /* For rebuild_header - must be here */
skb1289net/inet/ip.cstatic void ip_forward(struct sk_buff *skb, struct device *dev, int is_frag)
skb1303net/inet/ip.cif(!ip_fw_chk(skb->h.iph, ip_fw_fwd_chain))
skb1319net/inet/ip.ciph = skb->h.iph;
skb1324net/inet/ip.cicmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, dev);
skb1348net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, dev);
skb1375net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, dev);
skb1414net/inet/ip.cskb2 = alloc_skb(dev2->hard_header_len + skb->len, GFP_ATOMIC);
skb1426net/inet/ip.cskb2->len = skb->len + dev2->hard_header_len;
skb1432net/inet/ip.cmemcpy(ptr + dev2->hard_header_len, skb->h.raw, skb->len);
skb1435net/inet/ip.c(void) ip_send(skb2, raddr, skb->len, dev2, dev2->pa_addr);
skb1482net/inet/ip.cint ip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb1484net/inet/ip.cstruct iphdr *iph = skb->h.iph;
skb1501net/inet/ip.cskb->ip_hdr = iph;
skb1512net/inet/ip.cif (skb->len<sizeof(struct iphdr) || iph->ihl<5 || iph->version != 4 || ip_fast_csum((unsigned char *)iph, iph->ihl) !=0)
skb1515net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1527net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1538net/inet/ip.cskb->len=ntohs(iph->tot_len);
skb1581net/inet/ip.cif ( iph->daddr != skb->dev->pa_addr && (brd = ip_chk_addr(iph->daddr)) == 0)
skb1587net/inet/ip.cif(skb->pkt_type!=PACKET_HOST || brd==IS_BROADCAST)
skb1589net/inet/ip.ckfree_skb(skb,FREE_WRITE);
skb1598net/inet/ip.cip_forward(skb, dev, is_frag);
skb1609net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1625net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1650net/inet/ip.cskb=ip_defrag(iph,skb,dev);
skb1651net/inet/ip.cif(skb==NULL)
skb1653net/inet/ip.cskb->dev = dev;
skb1654net/inet/ip.ciph=skb->h.iph;
skb1663net/inet/ip.cskb->ip_hdr = iph;
skb1664net/inet/ip.cskb->h.raw += iph->ihl*4;
skb1685net/inet/ip.cskb1=skb_clone(skb, GFP_ATOMIC);
skb1717net/inet/ip.cskb2 = skb_clone(skb, GFP_ATOMIC);
skb1723net/inet/ip.cskb2 = skb;
skb1746net/inet/ip.craw_rcv(raw_sk, skb, dev, iph->saddr, iph->daddr);
skb1750net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev);
skb1751net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb1761net/inet/ip.cstatic void ip_loopback(struct device *old_dev, struct sk_buff *skb)
skb1765net/inet/ip.cint len=skb->len-old_dev->hard_header_len;
skb1774net/inet/ip.cnewskb->saddr=skb->saddr;
skb1775net/inet/ip.cnewskb->daddr=skb->daddr;
skb1776net/inet/ip.cnewskb->raddr=skb->raddr;
skb1780net/inet/ip.cnewskb->pkt_type=skb->pkt_type;
skb1784net/inet/ip.cnewskb->ip_hdr=(struct iphdr *)(newskb->data+ip_send(newskb, skb->ip_hdr->daddr, len, dev, skb->ip_hdr->saddr));
skb1785net/inet/ip.cmemcpy(newskb->ip_hdr,skb->ip_hdr,len);
skb1804net/inet/ip.cstruct sk_buff *skb, int free)
skb1816net/inet/ip.cIS_SKB(skb);
skb1823net/inet/ip.cskb->dev = dev;
skb1824net/inet/ip.cskb->when = jiffies;
skb1834net/inet/ip.cptr = skb->data;
skb1837net/inet/ip.cskb->ip_hdr = iph;
skb1838net/inet/ip.ciph->tot_len = ntohs(skb->len-dev->hard_header_len);
skb1853net/inet/ip.cskb->free = free;
skb1861net/inet/ip.cif(skb->len > dev->mtu + dev->hard_header_len)
skb1863net/inet/ip.cip_fragment(sk,skb,dev,0);
skb1864net/inet/ip.cIS_SKB(skb);
skb1865net/inet/ip.ckfree_skb(skb,FREE_WRITE);
skb1883net/inet/ip.cif (skb->next != NULL)
skb1886net/inet/ip.cskb_unlink(skb);
skb1907net/inet/ip.cif (skb->link3 != NULL)
skb1910net/inet/ip.cskb->link3 = NULL;
skb1914net/inet/ip.csk->send_tail = skb;
skb1915net/inet/ip.csk->send_head = skb;
skb1919net/inet/ip.csk->send_tail->link3 = skb;
skb1920net/inet/ip.csk->send_tail = skb;
skb1929net/inet/ip.cskb->sk = sk;
skb1951net/inet/ip.cip_loopback(dev,skb);
skb1959net/inet/ip.cip_loopback(dev,skb);
skb1968net/inet/ip.cif(skb->ip_hdr->ttl==0)
skb1970net/inet/ip.ckfree_skb(skb, FREE_READ);
skb1976net/inet/ip.cip_loopback(dev,skb);
skb1987net/inet/ip.cdev_queue_xmit(skb, dev, sk->priority);
skb1991net/inet/ip.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb1998net/inet/ip.ckfree_skb(skb, FREE_WRITE);
skb53net/inet/ip.hstruct sk_buff *skb;      /* complete received fragment    */
skb80net/inet/ip.hextern int    ip_build_header(struct sk_buff *skb,
skb87net/inet/ip.hextern int    ip_rcv(struct sk_buff *skb, struct device *dev,
skb92net/inet/ip.hstruct device *dev, struct sk_buff *skb,
skb133net/inet/ipx.cstruct sk_buff *skb;
skb136net/inet/ipx.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
skb138net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb809net/inet/ipx.cint ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb818net/inet/ipx.cipx=(ipx_packet *)skb->h.raw;
skb825net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb832net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb839net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb847net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb872net/inet/ipx.cif((ipx->ipx_tctrl==16) || (skb->pkt_type!=PACKET_HOST))
skb874net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb884net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb889net/inet/ipx.cincoming_size = skb->len - ntohs(ipx->ipx_pktsize);
skb899net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb911net/inet/ipx.c(char *)(skb+1)+incoming_size,
skb916net/inet/ipx.cskb2=skb;
skb930net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb944net/inet/ipx.ckfree_skb(skb,FREE_READ);
skb953net/inet/ipx.cif(sock_queue_rcv_skb(sock, skb)<0)
skb955net/inet/ipx.ckfree_skb(skb,FREE_READ);  /* Socket is full */
skb968net/inet/ipx.cstruct sk_buff *skb;
skb1057net/inet/ipx.cskb=alloc_skb(size,GFP_KERNEL);
skb1058net/inet/ipx.cif(skb==NULL)
skb1061net/inet/ipx.cskb->mem_addr=skb;
skb1062net/inet/ipx.cskb->sk=sk;
skb1063net/inet/ipx.cskb->free=1;
skb1064net/inet/ipx.cskb->arp=1;
skb1065net/inet/ipx.cskb->len=size;
skb1067net/inet/ipx.csk->wmem_alloc+=skb->mem_len;
skb1071net/inet/ipx.cskb->dev=rt->dev;
skb1074net/inet/ipx.cdl->datalink_header(dl, skb, 
skb1079net/inet/ipx.cmemcpy(IPXaddr+(6 - skb->dev->addr_len), skb->dev->dev_addr, 
skb1080net/inet/ipx.cskb->dev->addr_len);
skb1090net/inet/ipx.cipx=(ipx_packet *)skb->h.raw;
skb1111net/inet/ipx.csk->wmem_alloc-=skb->mem_len;
skb1112net/inet/ipx.cskb->sk = NULL;
skb1113net/inet/ipx.cipx_rcv(skb,dev,&pt);
skb1122net/inet/ipx.cskb2=alloc_skb(skb->len, GFP_ATOMIC);
skb1126net/inet/ipx.cskb2->len=skb->len;
skb1130net/inet/ipx.cmemcpy(skb2->data, skb->data, skb->len);
skb1133net/inet/ipx.cdev_queue_xmit(skb,dev,SOPRI_NORMAL);
skb1151net/inet/ipx.cstruct sk_buff *skb;
skb1164net/inet/ipx.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb1165net/inet/ipx.cif(skb==NULL)
skb1168net/inet/ipx.cipx = (ipx_packet *)(skb->h.raw);
skb1170net/inet/ipx.cskb_copy_datagram(skb,sizeof(struct ipx_packet),ubuf,copied);
skb1180net/inet/ipx.cskb_free_datagram(skb);
skb1237net/inet/ipx.cstruct sk_buff *skb;
skb1239net/inet/ipx.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
skb1240net/inet/ipx.camount=skb->len;
skb66net/inet/ipx.hextern int ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt);
skb23net/inet/p8022.cp8022_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb27net/inet/p8022.cproto = find_8022_client(*(skb->h.raw));
skb29net/inet/p8022.cskb->h.raw += 3;
skb30net/inet/p8022.creturn proto->rcvfunc(skb, dev, pt);
skb33net/inet/p8022.cskb->sk = NULL;
skb34net/inet/p8022.ckfree_skb(skb, FREE_READ);
skb40net/inet/p8022.cstruct sk_buff *skb, unsigned char *dest_node)
skb42net/inet/p8022.cstruct device  *dev = skb->dev;
skb43net/inet/p8022.cunsigned long  len = skb->len;
skb47net/inet/p8022.cdev->hard_header(skb->data, dev, len - hard_len,
skb48net/inet/p8022.cdest_node, NULL, len - hard_len, skb);
skb49net/inet/p8022.crawp = skb->data + hard_len;
skb56net/inet/p8022.cskb->h.raw = rawp;
skb9net/inet/p8023.cstruct sk_buff *skb, unsigned char *dest_node)
skb11net/inet/p8023.cstruct device  *dev = skb->dev;
skb12net/inet/p8023.cunsigned long  len = skb->len;
skb15net/inet/p8023.cdev->hard_header(skb->data, dev, len - hard_len,
skb16net/inet/p8023.cdest_node, NULL, len - hard_len, skb);
skb17net/inet/p8023.cskb->h.raw = skb->data + hard_len;
skb70net/inet/packet.cint packet_rcv(struct sk_buff *skb, struct device *dev,  struct packet_type *pt)
skb88net/inet/packet.cskb->dev = dev;
skb89net/inet/packet.cskb->len += dev->hard_header_len;
skb101net/inet/packet.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
skb104net/inet/packet.cskb->sk = NULL;
skb105net/inet/packet.ckfree_skb(skb, FREE_READ);
skb112net/inet/packet.cskb->sk = sk;
skb113net/inet/packet.csk->rmem_alloc += skb->mem_len;  
skb119net/inet/packet.cskb_queue_tail(&sk->receive_queue,skb);
skb121net/inet/packet.csk->data_ready(sk,skb->len);
skb143net/inet/packet.cstruct sk_buff *skb;
skb185net/inet/packet.cskb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL);
skb192net/inet/packet.cif (skb == NULL) 
skb201net/inet/packet.cskb->sk = sk;
skb202net/inet/packet.cskb->free = 1;
skb203net/inet/packet.cmemcpy_fromfs(skb->data, from, len);
skb204net/inet/packet.cskb->len = len;
skb205net/inet/packet.cskb->arp = 1;    /* No ARP needs doing on this (complete) frame */
skb212net/inet/packet.cdev_queue_xmit(skb, dev, sk->priority);
skb214net/inet/packet.ckfree_skb(skb, FREE_WRITE);
skb288net/inet/packet.cstruct sk_buff *skb;
skb312net/inet/packet.cskb=skb_recv_datagram(sk,flags,noblock,&err);
skb320net/inet/packet.cif(skb==NULL)
skb328net/inet/packet.ctruesize = skb->len;
skb331net/inet/packet.cmemcpy_tofs(to, skb->data, copied);  /* We can't use skb_copy_datagram here */
skb339net/inet/packet.csaddr->sa_family = skb->dev->type;
skb340net/inet/packet.cmemcpy(saddr->sa_data,skb->dev->name, 14);
skb348net/inet/packet.cskb_free_datagram(skb);
skb9net/inet/pe2.cstruct sk_buff *skb, unsigned char *dest_node)
skb11net/inet/pe2.cstruct device  *dev = skb->dev;
skb12net/inet/pe2.cunsigned long  len = skb->len;
skb15net/inet/pe2.cdev->hard_header(skb->data, dev, ETH_P_IPX,
skb16net/inet/pe2.cdest_node, NULL, len - hard_len, skb);
skb17net/inet/pe2.cskb->h.raw = skb->data + hard_len;
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,
skb142net/inet/rarp.cint rarp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb147net/inet/rarp.cstruct arphdr *rarp = (struct arphdr *)skb->h.raw;
skb160net/inet/rarp.ckfree_skb(skb, FREE_READ);
skb169net/inet/rarp.ckfree_skb(skb, FREE_READ);
skb187net/inet/rarp.ckfree_skb(skb, FREE_READ);
skb223net/inet/rarp.ckfree_skb(skb, FREE_READ);
skb6net/inet/rarp.hextern int rarp_rcv(struct sk_buff *skb, 
skb97net/inet/raw.cint raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, long saddr, long daddr)
skb100net/inet/raw.cskb->sk = sk;
skb101net/inet/raw.cskb->len = ntohs(skb->ip_hdr->tot_len);
skb102net/inet/raw.cskb->h.raw = (unsigned char *) skb->ip_hdr;
skb103net/inet/raw.cskb->dev = dev;
skb104net/inet/raw.cskb->saddr = daddr;
skb105net/inet/raw.cskb->daddr = saddr;
skb109net/inet/raw.cif(sock_queue_rcv_skb(sk,skb)<0)
skb112net/inet/raw.cskb->sk=NULL;
skb113net/inet/raw.ckfree_skb(skb, FREE_READ);
skb129net/inet/raw.cstruct sk_buff *skb;
skb173net/inet/raw.cskb=sock_alloc_send_skb(sk, len+sk->prot->max_header, noblock, &err);
skb174net/inet/raw.cif(skb==NULL)
skb177net/inet/raw.cskb->sk = sk;
skb178net/inet/raw.cskb->free = 1;
skb179net/inet/raw.cskb->localroute = sk->localroute | (flags&MSG_DONTROUTE);
skb181net/inet/raw.ctmp = sk->prot->build_header(skb, sk->saddr, 
skb183net/inet/raw.csk->protocol, sk->opt, skb->mem_len, sk->ip_tos,sk->ip_ttl);
skb186net/inet/raw.ckfree_skb(skb,FREE_WRITE);
skb191net/inet/raw.cmemcpy_fromfs(skb->data + tmp, from, len);
skb203net/inet/raw.cbuff = skb->data;
skb210net/inet/raw.cskb->len = tmp + len;
skb212net/inet/raw.csk->prot->queue_xmit(sk, dev, skb, 1);
skb247net/inet/raw.cstruct sk_buff *skb;
skb260net/inet/raw.cskb=skb_recv_datagram(sk,flags,noblock,&err);
skb261net/inet/raw.cif(skb==NULL)
skb264net/inet/raw.ctruesize=skb->len;
skb267net/inet/raw.cskb_copy_datagram(skb, 0, to, copied);
skb268net/inet/raw.csk->stamp=skb->stamp;
skb274net/inet/raw.csin->sin_addr.s_addr = skb->daddr;
skb276net/inet/raw.cskb_free_datagram(skb);
skb71net/inet/skbuff.cint skb_check(struct sk_buff *skb, int head, int line, char *file)
skb74net/inet/skbuff.cif (skb->magic_debug_cookie != SK_HEAD_SKB) {
skb79net/inet/skbuff.cif (!skb->next || !skb->prev) {
skb83net/inet/skbuff.cif (skb->next->magic_debug_cookie != SK_HEAD_SKB
skb84net/inet/skbuff.c&& skb->next->magic_debug_cookie != SK_GOOD_SKB) {
skb89net/inet/skbuff.cif (skb->prev->magic_debug_cookie != SK_HEAD_SKB
skb90net/inet/skbuff.c&& skb->prev->magic_debug_cookie != SK_GOOD_SKB) {
skb97net/inet/skbuff.cstruct sk_buff *skb2 = skb->next;
skb99net/inet/skbuff.cwhile (skb2 != skb && i < 5) {
skb111net/inet/skbuff.cif (skb->next != NULL && skb->next->magic_debug_cookie != SK_HEAD_SKB
skb112net/inet/skbuff.c&& skb->next->magic_debug_cookie != SK_GOOD_SKB) {
skb117net/inet/skbuff.cif (skb->prev != NULL && skb->prev->magic_debug_cookie != SK_HEAD_SKB
skb118net/inet/skbuff.c&& skb->prev->magic_debug_cookie != SK_GOOD_SKB) {
skb125net/inet/skbuff.cif(skb->magic_debug_cookie==SK_FREED_SKB)
skb130net/inet/skbuff.cskb,skb->truesize,skb->mem_len,skb->free);
skb133net/inet/skbuff.cif(skb->magic_debug_cookie!=SK_GOOD_SKB)
skb137net/inet/skbuff.cskb,skb->truesize,skb->mem_len,skb->free);
skb140net/inet/skbuff.cif(skb->mem_len!=skb->truesize)
skb144net/inet/skbuff.cskb,skb->truesize,skb->mem_len);
skb303net/inet/skbuff.cvoid skb_unlink(struct sk_buff *skb)
skb310net/inet/skbuff.cIS_SKB(skb);
skb312net/inet/skbuff.cif(skb->prev && skb->next)
skb314net/inet/skbuff.cskb->next->prev = skb->prev;
skb315net/inet/skbuff.cskb->prev->next = skb->next;
skb316net/inet/skbuff.cskb->next = NULL;
skb317net/inet/skbuff.cskb->prev = NULL;
skb333net/inet/skbuff.cvoid kfree_skb(struct sk_buff *skb, int rw)
skb335net/inet/skbuff.cif (skb == NULL)
skb342net/inet/skbuff.cIS_SKB(skb);
skb344net/inet/skbuff.cif (skb->lock)
skb346net/inet/skbuff.cskb->free = 3;    /* Free when unlocked */
skb350net/inet/skbuff.cif (skb->free == 2)
skb353net/inet/skbuff.cif (skb->next)
skb356net/inet/skbuff.cif (skb->sk)
skb358net/inet/skbuff.cif(skb->sk->prot!=NULL)
skb361net/inet/skbuff.cskb->sk->prot->rfree(skb->sk, skb, skb->mem_len);
skb363net/inet/skbuff.cskb->sk->prot->wfree(skb->sk, skb, skb->mem_len);
skb373net/inet/skbuff.cskb->sk->rmem_alloc-=skb->mem_len;
skb375net/inet/skbuff.cskb->sk->wmem_alloc-=skb->mem_len;
skb377net/inet/skbuff.cif(!skb->sk->dead)
skb378net/inet/skbuff.cskb->sk->write_space(skb->sk);
skb379net/inet/skbuff.ckfree_skbmem(skb,skb->mem_len);
skb383net/inet/skbuff.ckfree_skbmem(skb, skb->mem_len);
skb392net/inet/skbuff.cstruct sk_buff *skb;
skb405net/inet/skbuff.cskb=(struct sk_buff *)kmalloc(size,priority);
skb406net/inet/skbuff.cif (skb == NULL)
skb412net/inet/skbuff.cif(skb->magic_debug_cookie == SK_GOOD_SKB)
skb413net/inet/skbuff.cprintk("Kernel kmalloc handed us an existing skb (%p)\n",skb);
skb418net/inet/skbuff.cskb->free = 2;  /* Invalid so we pick up forgetful users */
skb419net/inet/skbuff.cskb->lock = 0;
skb420net/inet/skbuff.cskb->pkt_type = PACKET_HOST;  /* Default type */
skb421net/inet/skbuff.cskb->truesize = size;
skb422net/inet/skbuff.cskb->mem_len = size;
skb423net/inet/skbuff.cskb->mem_addr = skb;
skb425net/inet/skbuff.cskb->in_dev_queue = 0;
skb427net/inet/skbuff.cskb->fraglist = NULL;
skb428net/inet/skbuff.cskb->prev = skb->next = NULL;
skb429net/inet/skbuff.cskb->link3 = NULL;
skb430net/inet/skbuff.cskb->sk = NULL;
skb431net/inet/skbuff.cskb->localroute=0;
skb432net/inet/skbuff.cskb->stamp.tv_sec=0;  /* No idea about time */
skb433net/inet/skbuff.cskb->localroute = 0;
skb440net/inet/skbuff.cskb->magic_debug_cookie = SK_GOOD_SKB;
skb442net/inet/skbuff.cskb->users = 0;
skb443net/inet/skbuff.creturn skb;
skb450net/inet/skbuff.cvoid kfree_skbmem(struct sk_buff *skb,unsigned size)
skb456net/inet/skbuff.cif(skb->in_dev_queue && skb->dev!=NULL)
skb457net/inet/skbuff.cskb->dev->pkt_queue--;
skb461net/inet/skbuff.cIS_SKB(skb);
skb462net/inet/skbuff.cif(size!=skb->truesize)
skb465net/inet/skbuff.cif(skb->magic_debug_cookie == SK_GOOD_SKB)
skb469net/inet/skbuff.cIS_SKB(skb);
skb470net/inet/skbuff.cskb->magic_debug_cookie = SK_FREED_SKB;
skb471net/inet/skbuff.ckfree_s((void *)skb,size);
skb481net/inet/skbuff.ckfree_s((void *)skb,size);
skb493net/inet/skbuff.cstruct sk_buff *skb_clone(struct sk_buff *skb, int priority)
skb498net/inet/skbuff.cn=alloc_skb(skb->mem_len-sizeof(struct sk_buff),priority);
skb502net/inet/skbuff.coffset=((char *)n)-((char *)skb);
skb504net/inet/skbuff.cmemcpy(n->data,skb->data,skb->mem_len-sizeof(struct sk_buff));
skb505net/inet/skbuff.cn->len=skb->len;
skb508net/inet/skbuff.cn->when=skb->when;
skb509net/inet/skbuff.cn->dev=skb->dev;
skb510net/inet/skbuff.cn->h.raw=skb->h.raw+offset;
skb511net/inet/skbuff.cn->ip_hdr=(struct iphdr *)(((char *)skb->ip_hdr)+offset);
skb512net/inet/skbuff.cn->fraglen=skb->fraglen;
skb513net/inet/skbuff.cn->fraglist=skb->fraglist;
skb514net/inet/skbuff.cn->saddr=skb->saddr;
skb515net/inet/skbuff.cn->daddr=skb->daddr;
skb516net/inet/skbuff.cn->raddr=skb->raddr;
skb517net/inet/skbuff.cn->acked=skb->acked;
skb518net/inet/skbuff.cn->used=skb->used;
skb520net/inet/skbuff.cn->arp=skb->arp;
skb524net/inet/skbuff.cn->pkt_type=skb->pkt_type;
skb533net/inet/skbuff.cvoid skb_device_lock(struct sk_buff *skb)
skb535net/inet/skbuff.cif(skb->lock)
skb539net/inet/skbuff.cskb->lock++;
skb542net/inet/skbuff.cvoid skb_device_unlock(struct sk_buff *skb)
skb544net/inet/skbuff.cif(skb->lock==0)
skb546net/inet/skbuff.cskb->lock--;
skb547net/inet/skbuff.cif(skb->lock==0)
skb551net/inet/skbuff.cvoid dev_kfree_skb(struct sk_buff *skb, int mode)
skb557net/inet/skbuff.cif(skb->lock==1)
skb560net/inet/skbuff.cif (!--skb->lock && (skb->free == 1 || skb->free == 3))
skb563net/inet/skbuff.ckfree_skb(skb,mode);
skb569net/inet/skbuff.cint skb_device_locked(struct sk_buff *skb)
skb571net/inet/skbuff.creturn skb->lock? 1 : 0;
skb391net/inet/sock.cvoid sock_wfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
skb394net/inet/sock.cIS_SKB(skb);
skb396net/inet/sock.ckfree_skbmem(skb, size);
skb412net/inet/sock.cvoid sock_rfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
skb415net/inet/sock.cIS_SKB(skb);
skb417net/inet/sock.ckfree_skbmem(skb, size);
skb434net/inet/sock.cstruct sk_buff *skb;
skb457net/inet/sock.cskb = sock_wmalloc(sk, size, 0, GFP_KERNEL);
skb459net/inet/sock.cif(skb==NULL)
skb497net/inet/sock.cwhile(skb==NULL);
skb499net/inet/sock.creturn skb;
skb507net/inet/sock.cint sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
skb510net/inet/sock.cif(sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
skb514net/inet/sock.csk->rmem_alloc+=skb->mem_len;
skb515net/inet/sock.cskb->sk=sk;
skb517net/inet/sock.cskb_queue_tail(&sk->receive_queue,skb);
skb519net/inet/sock.csk->data_ready(sk,skb->len);
skb525net/inet/sock.cstruct sk_buff *skb;
skb549net/inet/sock.cwhile((skb = skb_dequeue(&sk->back_log)) != NULL) 
skb553net/inet/sock.csk->prot->rcv(skb, skb->dev, sk->opt,
skb554net/inet/sock.cskb->saddr, skb->len, skb->daddr, 1,
skb197net/inet/sock.hvoid      (*wfree)(struct sock *sk, struct sk_buff *skb,
skb199net/inet/sock.hvoid      (*rfree)(struct sock *sk, struct sk_buff *skb,
skb216net/inet/sock.hint      (*build_header)(struct sk_buff *skb,
skb225net/inet/sock.hstruct device *dev, struct sk_buff *skb,
skb284net/inet/sock.hextern void      sock_wfree(struct sock *sk, struct sk_buff *skb,
skb286net/inet/sock.hextern void      sock_rfree(struct sock *sk, struct sk_buff *skb,
skb294net/inet/sock.hextern struct sk_buff     *sock_alloc_send_skb(struct sock *skb, unsigned long size, int noblock, int *errcode);
skb295net/inet/sock.hextern int      sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
skb328net/inet/tcp.cstruct sk_buff *skb;
skb330net/inet/tcp.cwhile ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
skb331net/inet/tcp.ctcp_close(skb->sk, timeout);
skb332net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb339net/inet/tcp.cstruct sk_buff *skb;
skb343net/inet/tcp.cskb=tcp_find_established(s);
skb344net/inet/tcp.cif(skb!=NULL)
skb345net/inet/tcp.cskb_unlink(skb);  /* Take it off the queue */
skb347net/inet/tcp.creturn skb;
skb371net/inet/tcp.cstruct sk_buff * skb;
skb376net/inet/tcp.cskb = sk->send_head;
skb378net/inet/tcp.cwhile (skb != NULL)
skb384net/inet/tcp.cdev = skb->dev;
skb385net/inet/tcp.cIS_SKB(skb);
skb386net/inet/tcp.cskb->when = jiffies;
skb398net/inet/tcp.ciph = (struct iphdr *)(skb->data + dev->hard_header_len);
skb400net/inet/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
skb434net/inet/tcp.cif (sk && !skb_device_locked(skb))
skb437net/inet/tcp.cskb_unlink(skb);
skb440net/inet/tcp.cdev_queue_xmit(skb, dev, sk->priority);
skb461net/inet/tcp.cskb = skb->link3;
skb590net/inet/tcp.cstruct sk_buff *skb;
skb595net/inet/tcp.cskb = sk->send_head;
skb596net/inet/tcp.cif (!skb) 
skb602net/inet/tcp.cif (jiffies < skb->when + sk->rto) 
skb604net/inet/tcp.creset_xmit_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies);
skb762net/inet/tcp.cstruct sk_buff *skb;
skb771net/inet/tcp.cif (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
skb785net/inet/tcp.cif (before(counted, skb->h.th->seq))   /* Found a hole so stops here */
skb787net/inet/tcp.csum = skb->len -(counted - skb->h.th->seq);  /* Length - header but start from where we are up to (avoid overlaps) */
skb788net/inet/tcp.cif (skb->h.th->syn)
skb793net/inet/tcp.cif (skb->h.th->syn) 
skb813net/inet/tcp.cif (skb->h.th->urg)
skb815net/inet/tcp.cif (amount && skb->h.th->psh) break;
skb816net/inet/tcp.cskb = skb->next;
skb818net/inet/tcp.cwhile(skb != (struct sk_buff *)&sk->receive_queue);
skb1040net/inet/tcp.cstatic void tcp_send_skb(struct sock *sk, struct sk_buff *skb)
skb1043net/inet/tcp.cstruct tcphdr * th = skb->h.th;
skb1046net/inet/tcp.csize = skb->len - ((unsigned char *) th - skb->data);
skb1049net/inet/tcp.cif (size < sizeof(struct tcphdr) || size > skb->len) 
skb1052net/inet/tcp.cskb, skb->data, th, skb->len);
skb1053net/inet/tcp.ckfree_skb(skb, FREE_WRITE);
skb1064net/inet/tcp.ckfree_skb(skb,FREE_WRITE);
skb1071net/inet/tcp.cskb->h.seq = ntohl(th->seq) + size - 4*th->doff;
skb1072net/inet/tcp.cif (after(skb->h.seq, sk->window_seq) ||
skb1079net/inet/tcp.cif (skb->next != NULL) 
skb1082net/inet/tcp.cskb_unlink(skb);
skb1084net/inet/tcp.cskb_queue_tail(&sk->write_queue, skb);
skb1098net/inet/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, 0);
skb1105net/inet/tcp.cstruct sk_buff * skb;
skb1110net/inet/tcp.cskb = sk->partial;
skb1111net/inet/tcp.cif (skb) {
skb1116net/inet/tcp.creturn skb;
skb1121net/inet/tcp.cstruct sk_buff *skb;
skb1125net/inet/tcp.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL)
skb1126net/inet/tcp.ctcp_send_skb(sk, skb);
skb1129net/inet/tcp.cvoid tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk)
skb1139net/inet/tcp.csk->partial = skb;
skb1280net/inet/tcp.cstruct sk_buff *skb;
skb1394net/inet/tcp.cif ((skb = tcp_dequeue_partial(sk)) != NULL) 
skb1399net/inet/tcp.chdrlen = ((unsigned long)skb->h.th - (unsigned long)skb->data)
skb1405net/inet/tcp.ccopy = min(sk->mss - (skb->len - hdrlen), len);
skb1413net/inet/tcp.cmemcpy_fromfs(skb->data + skb->len, from, copy);
skb1414net/inet/tcp.cskb->len += copy;
skb1420net/inet/tcp.cif ((skb->len - hdrlen) >= sk->mss ||
skb1422net/inet/tcp.ctcp_send_skb(sk, skb);
skb1424net/inet/tcp.ctcp_enqueue_partial(skb, sk);
skb1461net/inet/tcp.cskb = prot->wmalloc(sk, sk->mtu + 128 + prot->max_header, 0, GFP_KERNEL);
skb1463net/inet/tcp.csend_tmp = skb;
skb1471net/inet/tcp.cskb = prot->wmalloc(sk, copy + prot->max_header , 0, GFP_KERNEL);
skb1479net/inet/tcp.cif (skb == NULL) 
skb1519net/inet/tcp.cskb->len = 0;
skb1520net/inet/tcp.cskb->sk = sk;
skb1521net/inet/tcp.cskb->free = 0;
skb1522net/inet/tcp.cskb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
skb1524net/inet/tcp.cbuff = skb->data;
skb1531net/inet/tcp.ctmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
skb1532net/inet/tcp.cIPPROTO_TCP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl);
skb1535net/inet/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
skb1541net/inet/tcp.cskb->len += tmp;
skb1542net/inet/tcp.cskb->dev = dev;
skb1544net/inet/tcp.cskb->h.th =(struct tcphdr *) buff;
skb1548net/inet/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
skb1560net/inet/tcp.cskb->len += tmp;
skb1566net/inet/tcp.cskb->len += copy;
skb1567net/inet/tcp.cskb->free = 0;
skb1575net/inet/tcp.ctcp_send_skb(sk, skb);
skb1702net/inet/tcp.cstruct sk_buff *skb;
skb1718net/inet/tcp.cwhile((skb=skb_peek(&sk->receive_queue)) != NULL) 
skb1720net/inet/tcp.cif (!skb->used) 
skb1722net/inet/tcp.cskb_unlink(skb);
skb1723net/inet/tcp.cskb->sk = sk;
skb1724net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb1864net/inet/tcp.cstruct sk_buff * skb;
skb1875net/inet/tcp.cskb = skb_peek(&sk->receive_queue);
skb1878net/inet/tcp.cif (!skb)
skb1880net/inet/tcp.cif (before(*seq, skb->h.th->seq))
skb1882net/inet/tcp.coffset = *seq - skb->h.th->seq;
skb1883net/inet/tcp.cif (skb->h.th->syn)
skb1885net/inet/tcp.cif (offset < skb->len)
skb1887net/inet/tcp.cif (skb->h.th->fin)
skb1890net/inet/tcp.cskb->used = 1;
skb1891net/inet/tcp.cskb = skb->next;
skb1893net/inet/tcp.cwhile (skb != (struct sk_buff *)&sk->receive_queue);
skb1944net/inet/tcp.cused = skb->len - offset;
skb1967net/inet/tcp.cmemcpy_tofs(to,((unsigned char *)skb->h.th) +
skb1968net/inet/tcp.cskb->h.th->doff*4 + offset, used);
skb1975net/inet/tcp.cif (used + offset < skb->len)
skb1977net/inet/tcp.cif (skb->h.th->fin)
skb1981net/inet/tcp.cskb->used = 1;
skb1988net/inet/tcp.cskb->used = 1;
skb2355net/inet/tcp.cstatic void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
skb2368net/inet/tcp.cth = skb->h.th;
skb2381net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2393net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2410net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2443net/inet/tcp.cnewsk->acked_seq = skb->h.th->seq+1;
skb2444net/inet/tcp.cnewsk->copied_seq = skb->h.th->seq+1;
skb2445net/inet/tcp.cnewsk->fin_seq = skb->h.th->seq;
skb2462net/inet/tcp.cnewsk->dummy_th.source = skb->h.th->dest;
skb2463net/inet/tcp.cnewsk->dummy_th.dest = skb->h.th->source;
skb2482net/inet/tcp.cnewsk->acked_seq = skb->h.th->seq + 1;
skb2483net/inet/tcp.cnewsk->copied_seq = skb->h.th->seq + 1;
skb2491net/inet/tcp.cnewsk->ip_tos=skb->ip_hdr->tos;
skb2534net/inet/tcp.ctcp_options(newsk,skb->h.th);
skb2542net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2571net/inet/tcp.cskb->sk = sk;
skb2572net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2580net/inet/tcp.cmemcpy(t1, skb->h.th, sizeof(*t1));
skb2585net/inet/tcp.ct1->dest = skb->h.th->source;
skb2598net/inet/tcp.ct1->ack_seq = ntohl(skb->h.th->seq+1);
skb2611net/inet/tcp.cskb->sk = newsk;
skb2617net/inet/tcp.csk->rmem_alloc -= skb->mem_len;
skb2618net/inet/tcp.cnewsk->rmem_alloc += skb->mem_len;
skb2620net/inet/tcp.cskb_queue_tail(&sk->receive_queue,skb);
skb2656net/inet/tcp.cstruct sk_buff *skb;
skb2659net/inet/tcp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
skb2660net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb2841net/inet/tcp.cstruct sk_buff *skb;
skb2851net/inet/tcp.cwhile((skb = skb_peek(&sk->write_queue)) != NULL &&
skb2852net/inet/tcp.cbefore(skb->h.seq, sk->window_seq + 1) &&
skb2855net/inet/tcp.cbefore(skb->h.seq, sk->rcv_ack_seq + 1))
skb2858net/inet/tcp.cIS_SKB(skb);
skb2859net/inet/tcp.cskb_unlink(skb);
skb2861net/inet/tcp.cif (before(skb->h.seq, sk->rcv_ack_seq +1)) 
skb2864net/inet/tcp.ckfree_skb(skb, FREE_WRITE);
skb2880net/inet/tcp.ciph = (struct iphdr *)(skb->data +
skb2881net/inet/tcp.cskb->dev->hard_header_len);
skb2883net/inet/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
skb2890net/inet/tcp.csk->sent_seq = skb->h.seq;
skb2891net/inet/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
skb2966net/inet/tcp.cstruct sk_buff *skb;
skb2985net/inet/tcp.cskb = skb2;
skb2986net/inet/tcp.cskb2 = skb->link3;
skb2987net/inet/tcp.cskb->link3 = NULL;
skb2988net/inet/tcp.cif (after(skb->h.seq, sk->window_seq)) 
skb2993net/inet/tcp.cif (skb->next != NULL) 
skb2995net/inet/tcp.cskb_unlink(skb);        
skb2999net/inet/tcp.cskb_queue_head(&sk->write_queue,skb);
skb3001net/inet/tcp.cskb_append(wskb,skb);
skb3002net/inet/tcp.cwskb = skb;
skb3008net/inet/tcp.csk->send_head = skb;
skb3009net/inet/tcp.csk->send_tail = skb;
skb3013net/inet/tcp.csk->send_tail->link3 = skb;
skb3014net/inet/tcp.csk->send_tail = skb;
skb3016net/inet/tcp.cskb->link3 = NULL;
skb3443net/inet/tcp.cstatic int tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
skb3445net/inet/tcp.csk->fin_seq = th->seq + skb->len + th->syn + th->fin;
skb3531net/inet/tcp.cextern __inline__ int tcp_data(struct sk_buff *skb, struct sock *sk, 
skb3540net/inet/tcp.cth = skb->h.th;
skb3541net/inet/tcp.cskb->len = len -(th->doff*4);
skb3548net/inet/tcp.csk->bytes_rcv += skb->len;
skb3550net/inet/tcp.cif (skb->len == 0 && !th->fin && !th->urg && !th->psh) 
skb3558net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3575net/inet/tcp.cif(skb->len)  /* We don't care if its just an ack or
skb3578net/inet/tcp.cnew_seq= th->seq + skb->len + th->syn;  /* Right edge of _data_ part of frame */
skb3601net/inet/tcp.ctcp_reset(sk->saddr, sk->daddr, skb->h.th,
skb3602net/inet/tcp.csk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl);
skb3607net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb3632net/inet/tcp.cskb_queue_head(&sk->receive_queue,skb);
skb3643net/inet/tcp.cprintk("skb->h.th->seq = %ld\n",skb->h.th->seq);
skb3656net/inet/tcp.cif (th->seq==skb1->h.th->seq && skb->len>= skb1->len)
skb3658net/inet/tcp.cskb_append(skb1,skb);
skb3672net/inet/tcp.cskb_append(skb1,skb);
skb3681net/inet/tcp.cskb_queue_head(&sk->receive_queue, skb);
skb3691net/inet/tcp.cth->ack_seq = th->seq + skb->len;
skb3723net/inet/tcp.cskb->acked = 1;
skb3730net/inet/tcp.cif (skb->h.th->fin) 
skb3732net/inet/tcp.ctcp_fin(skb,sk,skb->h.th);
skb3735net/inet/tcp.cfor(skb2 = skb->next;
skb3757net/inet/tcp.ctcp_fin(skb,sk,skb->h.th);
skb3796net/inet/tcp.cif (!skb->acked) 
skb3934net/inet/tcp.cstruct sk_buff *skb;
skb3951net/inet/tcp.cwhile((skb = tcp_dequeue_established(sk)) == NULL) 
skb3977net/inet/tcp.cnewsk = skb->sk;
skb3979net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4206net/inet/tcp.cstatic int tcp_std_reset(struct sock *sk, struct sk_buff *skb)
skb4229net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4238net/inet/tcp.cint tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb4246net/inet/tcp.cif (!skb) 
skb4260net/inet/tcp.cif(skb->pkt_type!=PACKET_HOST)
skb4262net/inet/tcp.ckfree_skb(skb,FREE_READ);
skb4266net/inet/tcp.cth = skb->h.th;
skb4290net/inet/tcp.cskb->sk = NULL;
skb4291net/inet/tcp.ckfree_skb(skb,FREE_READ);
skb4306net/inet/tcp.ctcp_reset(daddr, saddr, th, &tcp_prot, opt,dev,skb->ip_hdr->tos,255);
skb4307net/inet/tcp.cskb->sk = NULL;
skb4311net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4315net/inet/tcp.cskb->len = len;
skb4316net/inet/tcp.cskb->acked = 0;
skb4317net/inet/tcp.cskb->used = 0;
skb4318net/inet/tcp.cskb->free = 0;
skb4319net/inet/tcp.cskb->saddr = daddr;
skb4320net/inet/tcp.cskb->daddr = saddr;
skb4326net/inet/tcp.cskb_queue_tail(&sk->back_log, skb);
skb4337net/inet/tcp.ctcp_reset(daddr, saddr, th, &tcp_prot, opt,dev,skb->ip_hdr->tos,255);
skb4338net/inet/tcp.cskb->sk = NULL;
skb4339net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4356net/inet/tcp.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
skb4358net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4363net/inet/tcp.cskb->sk=sk;
skb4364net/inet/tcp.csk->rmem_alloc += skb->mem_len;
skb4394net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4403net/inet/tcp.ctcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq());
skb4421net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4444net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4449net/inet/tcp.creturn tcp_std_reset(sk,skb);
skb4454net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4493net/inet/tcp.creturn tcp_std_reset(sk,skb);
skb4503net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4526net/inet/tcp.csk->rmem_alloc -= skb->mem_len;
skb4527net/inet/tcp.cskb->sk = NULL;
skb4536net/inet/tcp.cskb->sk = sk;
skb4537net/inet/tcp.csk->rmem_alloc += skb->mem_len;
skb4538net/inet/tcp.ctcp_conn_request(sk, skb, daddr, saddr,opt, dev,seq+128000);
skb4542net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4554net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4560net/inet/tcp.creturn tcp_std_reset(sk,skb);
skb4568net/inet/tcp.ctcp_reset(daddr,saddr,th, &tcp_prot, opt, dev, skb->ip_hdr->tos, 255);
skb4569net/inet/tcp.creturn tcp_std_reset(sk,skb);  
skb4587net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4600net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb4610net/inet/tcp.cif(tcp_data(skb,sk, saddr, len))
skb4612net/inet/tcp.ckfree_skb(skb, FREE_READ);
skb120net/inet/tcp.hextern int  tcp_rcv(struct sk_buff *skb, struct device *dev,
skb167net/inet/timer.cstruct sk_buff *skb;
skb172net/inet/timer.cskb = sk->send_head;
skb173net/inet/timer.cif (!skb) 
skb179net/inet/timer.cif (jiffies < skb->when + sk->rto) 
skb181net/inet/timer.creset_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies);
skb83net/inet/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len);
skb254net/inet/udp.cstruct sk_buff *skb;
skb267net/inet/udp.cskb = sock_alloc_send_skb(sk, size, 0, &tmp);
skb270net/inet/udp.cif (skb == NULL) 
skb273net/inet/udp.cskb->sk       = NULL;  /* to avoid changing sk->saddr */
skb274net/inet/udp.cskb->free     = 1;
skb275net/inet/udp.cskb->localroute = sk->localroute|(rt&MSG_DONTROUTE);
skb281net/inet/udp.cbuff = skb->data;
skb289net/inet/udp.ctmp = sk->prot->build_header(skb, saddr, sin->sin_addr.s_addr,
skb290net/inet/udp.c&dev, IPPROTO_UDP, sk->opt, skb->mem_len,sk->ip_tos,ttl);
skb292net/inet/udp.cskb->sk=sk;  /* So memory is freed correctly */
skb300net/inet/udp.csk->prot->wfree(sk, skb->mem_addr, skb->mem_len);
skb305net/inet/udp.csaddr = skb->saddr; /*dev->pa_addr;*/
skb306net/inet/udp.cskb->len = tmp + sizeof(struct udphdr) + len;  /* len + UDP + IP + MAC */
skb307net/inet/udp.cskb->dev = dev;
skb329net/inet/udp.cudp_send_check(uh, saddr, sin->sin_addr.s_addr, skb->len - tmp, sk);
skb337net/inet/udp.csk->prot->queue_xmit(sk, dev, skb, 1);
skb433net/inet/udp.cstruct sk_buff *skb;
skb438net/inet/udp.cskb = skb_peek(&sk->receive_queue);
skb439net/inet/udp.cif (skb != NULL) {
skb445net/inet/udp.camount = skb->len;
skb473net/inet/udp.cstruct sk_buff *skb;
skb488net/inet/udp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb489net/inet/udp.cif(skb==NULL)
skb492net/inet/udp.ctruesize = skb->len;
skb499net/inet/udp.cskb_copy_datagram(skb,sizeof(struct udphdr),to,copied);
skb500net/inet/udp.csk->stamp=skb->stamp;
skb506net/inet/udp.csin->sin_port = skb->h.uh->source;
skb507net/inet/udp.csin->sin_addr.s_addr = skb->daddr;
skb510net/inet/udp.cskb_free_datagram(skb);
skb567net/inet/udp.cint udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb582net/inet/udp.cuh = (struct udphdr *) skb->h.uh;
skb596net/inet/udp.ckfree_skb(skb, FREE_WRITE);
skb604net/inet/udp.ckfree_skb(skb, FREE_WRITE);
skb628net/inet/udp.cskb1=skb_clone(skb,GFP_ATOMIC);
skb630net/inet/udp.cskb1=skb;
skb638net/inet/udp.ckfree_skb(skb, FREE_READ);
skb648net/inet/udp.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, dev);
skb654net/inet/udp.cskb->sk = NULL;
skb655net/inet/udp.ckfree_skb(skb, FREE_WRITE);
skb659net/inet/udp.creturn udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
skb662net/inet/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
skb664net/inet/udp.cskb->sk = sk;
skb665net/inet/udp.cskb->dev = dev;
skb666net/inet/udp.cskb->len = len;
skb672net/inet/udp.cskb->daddr = saddr;
skb673net/inet/udp.cskb->saddr = daddr;
skb680net/inet/udp.cskb->len = len - sizeof(*uh);  
skb682net/inet/udp.cif (sock_queue_rcv_skb(sk,skb)<0) 
skb687net/inet/udp.cskb->sk = NULL;
skb688net/inet/udp.ckfree_skb(skb, FREE_WRITE);
skb43net/inet/udp.hextern int  udp_rcv(struct sk_buff *skb, struct device *dev,