taglinefilesource code
skb123drivers/net/3c501.cstatic int  el_start_xmit(struct sk_buff *skb, struct device *dev);
skb333drivers/net/3c501.cel_start_xmit(struct sk_buff *skb, struct device *dev)
skb357drivers/net/3c501.cif (skb == NULL) {
skb374drivers/net/3c501.cint gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
skb375drivers/net/3c501.cunsigned char *buf = skb->data;
skb398drivers/net/3c501.coutsb(DATAPORT,buf,skb->len);  /* load buffer (usual thing each byte increments the pointer) */
skb412drivers/net/3c501.cdev_kfree_skb (skb, FREE_WRITE);
skb555drivers/net/3c501.cstruct sk_buff *skb;
skb575drivers/net/3c501.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb580drivers/net/3c501.cif (skb == NULL) {
skb585drivers/net/3c501.cskb->len = pkt_len;
skb586drivers/net/3c501.cskb->dev = dev;
skb594drivers/net/3c501.cinsb(DATAPORT, skb->data, pkt_len);
skb595drivers/net/3c501.cskb->protocol=eth_type_trans(skb,dev);
skb596drivers/net/3c501.cnetif_rx(skb);
skb548drivers/net/3c505.cstruct sk_buff *skb;
skb563drivers/net/3c505.cskb = alloc_skb(rlen, GFP_ATOMIC);
skb574drivers/net/3c505.cif (skb == NULL) {
skb590drivers/net/3c505.cskb->len = rlen;
skb591drivers/net/3c505.cskb->dev = dev;
skb596drivers/net/3c505.cptr = (unsigned short *)(skb->data);
skb605drivers/net/3c505.ckfree_skb(skb, FREE_WRITE);
skb614drivers/net/3c505.cskb->protocol=eth_type_trans(skb,dev);
skb615drivers/net/3c505.cnetif_rx(skb);
skb994drivers/net/3c505.celp_start_xmit (struct sk_buff *skb, struct device *dev)
skb1001drivers/net/3c505.cif (skb == NULL) {
skb1009drivers/net/3c505.cif (skb->len <= 0)
skb1013drivers/net/3c505.cprintk("%s: request to send packet of length %d\n", dev->name, (int)skb->len);
skb1034drivers/net/3c505.cif (!send_packet(dev, skb->data, skb->len)) {
skb1040drivers/net/3c505.cprintk("%s: packet of length %d sent\n", dev->name, (int)skb->len);
skb1056drivers/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);
skb835drivers/net/3c507.cstruct sk_buff *skb;
skb838drivers/net/3c507.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb839drivers/net/3c507.cif (skb == NULL) {
skb844drivers/net/3c507.cskb->len = pkt_len;
skb845drivers/net/3c507.cskb->dev = dev;
skb848drivers/net/3c507.cmemcpy(skb->data, data_frame + 5, pkt_len);
skb850drivers/net/3c507.cskb->protocol=eth_type_trans(skb,dev);
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);
skb592drivers/net/3c509.cstruct sk_buff *skb;
skb594drivers/net/3c509.cskb = alloc_skb(pkt_len+3, GFP_ATOMIC);
skb598drivers/net/3c509.cif (skb != NULL) {
skb599drivers/net/3c509.cskb->len = pkt_len;
skb600drivers/net/3c509.cskb->dev = dev;
skb603drivers/net/3c509.cinsl(ioaddr+RX_FIFO, skb->data,
skb606drivers/net/3c509.cskb->protocol=eth_type_trans(skb,dev);
skb607drivers/net/3c509.cnetif_rx(skb);
skb127drivers/net/8390.cstatic int ei_start_xmit(struct sk_buff *skb, struct device *dev)
skb171drivers/net/8390.cif (skb == NULL) {
skb176drivers/net/8390.clength = skb->len;
skb177drivers/net/8390.cif (skb->len <= 0)
skb225drivers/net/8390.cei_block_output(dev, length, skb->data, output_page);
skb239drivers/net/8390.cei_block_output(dev, length, skb->data, ei_local->tx_start_page);
skb250drivers/net/8390.cdev_kfree_skb (skb, FREE_WRITE);
skb465drivers/net/8390.cstruct sk_buff *skb;
skb467drivers/net/8390.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb468drivers/net/8390.cif (skb == NULL) {
skb475drivers/net/8390.cskb->len = pkt_len;
skb476drivers/net/8390.cskb->dev = dev;
skb478drivers/net/8390.cei_block_input(dev, pkt_len, (char *) skb->data,
skb480drivers/net/8390.cskb->protocol=eth_type_trans(skb,dev);
skb481drivers/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.cskb->protocol=eth_type_trans(skb,dev);
skb361drivers/net/apricot.cnetif_rx(skb);
skb364drivers/net/apricot.cif (i596_debug > 4) print_eth(skb->data);
skb412drivers/net/apricot.cstruct sk_buff *skb = ((struct sk_buff *)(tx_cmd->tbd->data)) -1;
skb414drivers/net/apricot.cdev_kfree_skb(skb, FREE_WRITE);
skb577drivers/net/apricot.ci596_start_xmit(struct sk_buff *skb, struct device *dev)
skb615drivers/net/apricot.cif (skb == NULL) {
skb621drivers/net/apricot.cif (skb->len <= 0) return 0;
skb631drivers/net/apricot.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb640drivers/net/apricot.cdev_kfree_skb(skb, FREE_WRITE);
skb654drivers/net/apricot.ctx_cmd->tbd->data = skb->data;
skb656drivers/net/apricot.cif (i596_debug > 3) print_eth(skb->data);
skb814drivers/net/apricot.cstruct sk_buff *skb = ((struct sk_buff *)(tx_cmd->tbd->data)) -1;
skb816drivers/net/apricot.cdev_kfree_skb(skb, FREE_WRITE);
skb820drivers/net/apricot.cif (i596_debug >2) print_eth(skb->data);
skb309drivers/net/arcnet.cstruct sk_buff *skb;    /* packet data buffer             */
skb317drivers/net/arcnet.cstruct sk_buff *skb;    /* buffer from upper levels */
skb356drivers/net/arcnet.cstatic int arcnet_send_packet(struct sk_buff *skb, struct device *dev);
skb380drivers/net/arcnet.cvoid *daddr,void *saddr,unsigned len,struct sk_buff *skb);
skb382drivers/net/arcnet.cstruct sk_buff *skb);
skb383drivers/net/arcnet.cunsigned short arc_type_trans(struct sk_buff *skb,struct device *dev);
skb908drivers/net/arcnet.carcnet_send_packet(struct sk_buff *skb, struct device *dev)
skb944drivers/net/arcnet.cstatus,tickssofar,lp->outgoing.skb,
skb962drivers/net/arcnet.cif (lp->outgoing.skb)
skb963drivers/net/arcnet.cdev_kfree_skb(lp->outgoing.skb,FREE_WRITE);
skb964drivers/net/arcnet.clp->outgoing.skb=NULL;
skb979drivers/net/arcnet.cif (skb == NULL) {
skb1007drivers/net/arcnet.cout->length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb1008drivers/net/arcnet.cout->hdr=(struct ClientData*)skb->data;
skb1009drivers/net/arcnet.cout->skb=skb;
skb1012drivers/net/arcnet.cfor( i=0; i< skb->len; i++)
skb1015drivers/net/arcnet.cprintk("%02hX ",((unsigned char*)skb->data)[i]);
skb1037drivers/net/arcnet.c((char *)skb->data)+sizeof(struct ClientData));
skb1041drivers/net/arcnet.cdev_kfree_skb(out->skb,FREE_WRITE);
skb1042drivers/net/arcnet.cout->skb=NULL;
skb1057drivers/net/arcnet.cout->data=(u_char *)skb->data
skb1094drivers/net/arcnet.cif (out->skb)
skb1095drivers/net/arcnet.cdev_kfree_skb(out->skb,FREE_WRITE);
skb1096drivers/net/arcnet.cout->skb=NULL;
skb1113drivers/net/arcnet.cdev_kfree_skb(out->skb,FREE_WRITE);
skb1114drivers/net/arcnet.cout->skb=NULL;
skb1435drivers/net/arcnet.cstatus,out->numsegs,out->segnum,out->skb);
skb1450drivers/net/arcnet.cif (!lp->outgoing.skb)
skb1483drivers/net/arcnet.cif (out->skb)
skb1484drivers/net/arcnet.cdev_kfree_skb(out->skb,FREE_WRITE);
skb1485drivers/net/arcnet.cout->skb=NULL;
skb1524drivers/net/arcnet.cstruct sk_buff *skb;
skb1582drivers/net/arcnet.cif (in->skb)  /* already assembling one! */
skb1587drivers/net/arcnet.ckfree_skb(in->skb,FREE_WRITE);
skb1588drivers/net/arcnet.cin->skb=NULL;
skb1593drivers/net/arcnet.cskb = alloc_skb(length, GFP_ATOMIC);
skb1594drivers/net/arcnet.cif (skb == NULL) {
skb1600drivers/net/arcnet.csoft=(struct ClientData *)skb->data;
skb1602drivers/net/arcnet.cskb->len = length;
skb1603drivers/net/arcnet.cskb->dev = dev;
skb1665drivers/net/arcnet.cskb->protocol=arc_type_trans(skb,dev);
skb1666drivers/net/arcnet.cnetif_rx(skb);
skb1693drivers/net/arcnet.cif (in->skb && in->sequence!=arcsoft->sequence)
skb1698drivers/net/arcnet.ckfree_skb(in->skb,FREE_WRITE);
skb1699drivers/net/arcnet.cin->skb=NULL;
skb1707drivers/net/arcnet.cif (in->skb)  /* already assembling one! */
skb1712drivers/net/arcnet.ckfree_skb(in->skb,FREE_WRITE);
skb1727drivers/net/arcnet.cin->skb=skb=alloc_skb(508*in->numpackets
skb1730drivers/net/arcnet.cif (skb == NULL) {
skb1740drivers/net/arcnet.cskb->free=1;
skb1742drivers/net/arcnet.csoft=(struct ClientData *)skb->data;
skb1744drivers/net/arcnet.cskb->len=sizeof(struct ClientData);
skb1745drivers/net/arcnet.cskb->dev=dev;
skb1759drivers/net/arcnet.cif (!in->skb)
skb1781drivers/net/arcnet.ckfree_skb(in->skb,FREE_WRITE);
skb1782drivers/net/arcnet.cin->skb=NULL;
skb1787drivers/net/arcnet.csoft=(struct ClientData *)in->skb->data;
skb1790drivers/net/arcnet.cskb=in->skb;
skb1792drivers/net/arcnet.cmemcpy(skb->data+skb->len,
skb1796drivers/net/arcnet.cskb->len+=length-sizeof(struct ClientData);
skb1824drivers/net/arcnet.cif (!skb || !in->skb)
skb1826drivers/net/arcnet.cskb,in->skb);
skb1827drivers/net/arcnet.cin->skb=NULL;
skb1829drivers/net/arcnet.cskb->protocol=arc_type_trans(skb,dev);             
skb1830drivers/net/arcnet.cnetif_rx(skb);
skb1971drivers/net/arcnet.cvoid *daddr,void *saddr,unsigned len,struct sk_buff *skb)
skb2049drivers/net/arcnet.cstruct sk_buff *skb)
skb2070drivers/net/arcnet.creturn arp_find(&(head->daddr), dst, dev, dev->pa_addr, skb)? 1 : 0;
skb2081drivers/net/arcnet.cunsigned short arc_type_trans(struct sk_buff *skb,struct device *dev)
skb2083drivers/net/arcnet.cstruct ClientData *head = (struct ClientData *) skb->data;
skb2086drivers/net/arcnet.cskb->pkt_type=PACKET_BROADCAST;
skb2091drivers/net/arcnet.cskb->pkt_type=PACKET_OTHERHOST;
skb121drivers/net/at1700.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb363drivers/net/at1700.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb397drivers/net/at1700.cif (skb == NULL) {
skb407drivers/net/at1700.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb408drivers/net/at1700.cunsigned char *buf = skb->data;
skb434drivers/net/at1700.cdev_kfree_skb (skb, FREE_WRITE);
skb519drivers/net/at1700.cstruct sk_buff *skb;
skb530drivers/net/at1700.cskb = alloc_skb(pkt_len+1, GFP_ATOMIC);
skb531drivers/net/at1700.cif (skb == NULL) {
skb540drivers/net/at1700.cskb->len = pkt_len;
skb541drivers/net/at1700.cskb->dev = dev;
skb543drivers/net/at1700.cinsw(ioaddr + DATAPORT, skb->data, (pkt_len + 1) >> 1);
skb544drivers/net/at1700.cskb->protocol=eth_type_trans(skb, dev);
skb545drivers/net/at1700.cnetif_rx(skb);
skb137drivers/net/atp.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb414drivers/net/atp.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb438drivers/net/atp.cif (skb == NULL) {
skb448drivers/net/atp.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb449drivers/net/atp.cunsigned char *buf = skb->data;
skb477drivers/net/atp.cdev_kfree_skb (skb, FREE_WRITE);
skb671drivers/net/atp.cstruct sk_buff *skb;
skb673drivers/net/atp.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb674drivers/net/atp.cif (skb == NULL) {
skb679drivers/net/atp.cskb->len = pkt_len;
skb680drivers/net/atp.cskb->dev = dev;
skb682drivers/net/atp.cread_block(ioaddr, pkt_len, skb->data, dev->if_port);
skb685drivers/net/atp.cunsigned char *data = skb->data;
skb693drivers/net/atp.cskb->protocol=eth_type_trans(skb,dev);
skb694drivers/net/atp.cnetif_rx(skb);
skb335drivers/net/de4x5.cstruct sk_buff *skb[NUM_TX_DESC];        /* TX skb for freeing when sent */
skb377drivers/net/de4x5.cstatic int     de4x5_queue_pkt(struct sk_buff *skb, struct device *dev);
skb396drivers/net/de4x5.cstatic void    load_packet(struct device *dev, char *buf, u_long flags, struct sk_buff *skb);
skb901drivers/net/de4x5.cde4x5_queue_pkt(struct sk_buff *skb, struct device *dev)
skb950drivers/net/de4x5.c} else if (skb == NULL) {
skb952drivers/net/de4x5.c} else if (skb->len > 0) {
skb962drivers/net/de4x5.cload_packet(dev, skb->data, TD_IC | TD_LS | TD_FS | skb->len, skb);
skb1060drivers/net/de4x5.cstruct sk_buff *skb;
skb1063drivers/net/de4x5.cif ((skb = alloc_skb(pkt_len, GFP_ATOMIC)) != NULL) {
skb1064drivers/net/de4x5.cskb->len = pkt_len;
skb1065drivers/net/de4x5.cskb->dev = dev;
skb1069drivers/net/de4x5.cmemcpy(skb->data, lp->rx_ring[lp->rx_old].buf, len);
skb1070drivers/net/de4x5.cmemcpy(skb->data + len, lp->rx_ring[0].buf, pkt_len - len);
skb1072drivers/net/de4x5.cmemcpy(skb->data, lp->rx_ring[lp->rx_old].buf, pkt_len);
skb1079drivers/net/de4x5.cskb->protocol=eth_type_trans(skb,dev);
skb1080drivers/net/de4x5.cnetif_rx(skb);
skb1092drivers/net/de4x5.cbuf = skb->data;                  /* Look at the dest addr */
skb1164drivers/net/de4x5.cif (lp->skb[entry] != NULL) {
skb1165drivers/net/de4x5.cdev_kfree_skb(lp->skb[entry], FREE_WRITE);
skb1225drivers/net/de4x5.cstatic void load_packet(struct device *dev, char *buf, u_long flags, struct sk_buff *skb)
skb1232drivers/net/de4x5.clp->skb[lp->tx_new] = skb;
skb250drivers/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);
skb587drivers/net/de600.cstruct sk_buff  *skb;
skb612drivers/net/de600.cskb = alloc_skb(size, GFP_ATOMIC);
skb614drivers/net/de600.cif (skb == NULL) {
skb621drivers/net/de600.cskb->lock = 0;
skb623drivers/net/de600.cbuffer = skb->data;
skb632drivers/net/de600.cskb->protocol=eth_type_trans(skb,dev);
skb633drivers/net/de600.cif (dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev))
skb485drivers/net/de620.cde620_start_xmit(struct sk_buff *skb, struct device *dev)
skb490drivers/net/de620.cbyte *buffer = skb->data;
skb499drivers/net/de620.cif (skb == NULL) {
skb524drivers/net/de620.cif ((len = skb->len) < RUNT)
skb534drivers/net/de620.c(int)skb->len, using_txbuf));
skb564drivers/net/de620.cdev_kfree_skb (skb, FREE_WRITE);
skb626drivers/net/de620.cstruct sk_buff *skb;
skb681drivers/net/de620.cskb = alloc_skb(size, GFP_ATOMIC);
skb682drivers/net/de620.cif (skb == NULL) { /* Yeah, but no place to put it... */
skb688drivers/net/de620.cskb->len = size; skb->dev = dev; skb->free = 1;
skb690drivers/net/de620.cbuffer = skb->data;
skb694drivers/net/de620.cskb->protocol=eth_type_trans(skb,dev);
skb695drivers/net/de620.cnetif_rx(skb); /* deliver it "upstairs" */
skb327drivers/net/depca.cstatic int depca_start_xmit(struct sk_buff *skb, struct device *dev);
skb809drivers/net/depca.cdepca_start_xmit(struct sk_buff *skb, struct device *dev)
skb834drivers/net/depca.cif (skb == NULL) {
skb839drivers/net/depca.cif (skb->len <= 0) {
skb863drivers/net/depca.clong skbL = skb->len;
skb864drivers/net/depca.cchar *p = (char *) skb->data;
skb886drivers/net/depca.cmemcpy((unsigned char *)(buf), skb->data, len);
skb911drivers/net/depca.cmemcpy((unsigned char *)buf, skb->data, PKT_HDR_LEN);
skb949drivers/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.cskb->protocol=eth_type_trans(skb,dev);
skb1076drivers/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);
skb941drivers/net/eexpress.cstruct sk_buff *skb;
skb944drivers/net/eexpress.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb945drivers/net/eexpress.cif (skb == NULL) {
skb950drivers/net/eexpress.cskb->len = pkt_len;
skb951drivers/net/eexpress.cskb->dev = dev;
skb955drivers/net/eexpress.cinsw(ioaddr, skb->data, (pkt_len + 1) >> 1);
skb957drivers/net/eexpress.cskb->protocol=eth_type_trans(skb,dev);
skb958drivers/net/eexpress.cnetif_rx(skb);
skb144drivers/net/eql.cstatic int eql_slave_xmit(struct sk_buff *skb, struct device *dev); /*  */
skb149drivers/net/eql.cunsigned len, struct sk_buff *skb); /*  */
skb151drivers/net/eql.cunsigned long raddr, struct sk_buff *skb); /*  */
skb345drivers/net/eql.ceql_slave_xmit(struct sk_buff *skb, struct device *dev)
skb351drivers/net/eql.cif (skb == NULL)
skb366drivers/net/eql.cdev->name, eql_number_slaves (eql->queue), skb->len,
skb370drivers/net/eql.cdev_queue_xmit (skb, slave_dev, 1);
skb372drivers/net/eql.cslave->bytes_queued += skb->len; 
skb380drivers/net/eql.cdev_kfree_skb(skb, FREE_WRITE);
skb400drivers/net/eql.cunsigned len, struct sk_buff *skb)
skb409drivers/net/eql.cunsigned long raddr, struct sk_buff *skb)
skb292drivers/net/ewrk3.cstatic int ewrk3_queue_pkt(struct sk_buff *skb, struct device *dev);
skb760drivers/net/ewrk3.cewrk3_queue_pkt(struct sk_buff *skb, struct device *dev)
skb796drivers/net/ewrk3.c} else if (skb == NULL) {
skb798drivers/net/ewrk3.c} else if (skb->len > 0) {
skb848drivers/net/ewrk3.cunsigned char *p = skb->data;
skb851drivers/net/ewrk3.coutb((char)(skb->len & 0xff), EWRK3_DATA);
skb852drivers/net/ewrk3.coutb((char)((skb->len >> 8) & 0xff), EWRK3_DATA);
skb854drivers/net/ewrk3.cfor (i=0; i<skb->len; i++) {
skb860drivers/net/ewrk3.c*buf++ = (char)(skb->len & 0xff);         /* length (16 bit xfer)*/
skb862drivers/net/ewrk3.c*buf++ = (char)(((skb->len >> 8) & 0xff) | XCT);
skb864drivers/net/ewrk3.c*(buf + skb->len) = 0x00;               /* Write the XCT flag */
skb865drivers/net/ewrk3.cmemcpy(buf, skb->data, PRELOAD);        /* Write PRELOAD bytes */
skb867drivers/net/ewrk3.cmemcpy(buf + PRELOAD, skb->data + PRELOAD, skb->len - PRELOAD);
skb868drivers/net/ewrk3.c*(buf + skb->len) = 0xff;               /* Write the XCT flag */
skb870drivers/net/ewrk3.c*buf++ = (char)((skb->len >> 8) & 0xff);
skb872drivers/net/ewrk3.cmemcpy(buf, skb->data, skb->len);       /* Write data bytes */
skb879drivers/net/ewrk3.cdev_kfree_skb (skb, FREE_WRITE);
skb1036drivers/net/ewrk3.cstruct sk_buff *skb;
skb1038drivers/net/ewrk3.cif ((skb = alloc_skb(pkt_len, GFP_ATOMIC)) != NULL) {
skb1039drivers/net/ewrk3.cskb->len = pkt_len;
skb1040drivers/net/ewrk3.cskb->dev = dev;
skb1043drivers/net/ewrk3.cunsigned char *p = skb->data;
skb1046drivers/net/ewrk3.cfor (i=0; i<skb->len; i++) {
skb1050drivers/net/ewrk3.cmemcpy(skb->data, buf, pkt_len);
skb1058drivers/net/ewrk3.cskb->protocol=eth_type_trans(skb,dev);
skb1059drivers/net/ewrk3.cnetif_rx(skb);
skb1071drivers/net/ewrk3.cbuf = skb->data;                  /* Look at the dest addr */
skb113drivers/net/ibmtr.cstatic int tok_send_packet(struct sk_buff *skb, struct device *dev);
skb1033drivers/net/ibmtr.cstruct sk_buff *skb;
skb1076drivers/net/ibmtr.cif(!(skb=alloc_skb(ntohs(rec_req->frame_len)-lan_hdr_len+sizeof(struct trh_hdr), GFP_ATOMIC))) {
skb1084drivers/net/ibmtr.cskb->len=ntohs(rec_req->frame_len)-lan_hdr_len+sizeof(struct trh_hdr);
skb1085drivers/net/ibmtr.cskb->dev=dev;
skb1092drivers/net/ibmtr.cdata=skb->data;
skb1122drivers/net/ibmtr.cskb->protocol=tr_type_trans(skb,dev);
skb1123drivers/net/ibmtr.cnetif_rx(skb);
skb1128drivers/net/ibmtr.cstatic int tok_send_packet(struct sk_buff *skb, struct device *dev) {
skb1149drivers/net/ibmtr.cif(skb==NULL) {
skb1159drivers/net/ibmtr.cti->current_skb=skb; /* save skb. We will need it when the adapter
skb254drivers/net/lance.cstatic int lance_start_xmit(struct sk_buff *skb, struct device *dev);
skb708drivers/net/lance.clance_start_xmit(struct sk_buff *skb, struct device *dev)
skb750drivers/net/lance.cif (skb == NULL) {
skb755drivers/net/lance.cif (skb->len <= 0)
skb790drivers/net/lance.c-(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
skb792drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
skb798drivers/net/lance.cif ((int)(skb->data) + skb->len > 0x01000000) {
skb801drivers/net/lance.cdev->name, (int)(skb->data));
skb802drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
skb805drivers/net/lance.cdev_kfree_skb (skb, FREE_WRITE);
skb807drivers/net/lance.clp->tx_skbuff[entry] = skb;
skb808drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
skb985drivers/net/lance.cstruct sk_buff *skb;
skb987drivers/net/lance.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb988drivers/net/lance.cif (skb == NULL) {
skb1001drivers/net/lance.cskb->len = pkt_len;
skb1002drivers/net/lance.cskb->dev = dev;
skb1003drivers/net/lance.cmemcpy(skb->data,
skb1006drivers/net/lance.cskb->protocol=eth_type_trans(skb,dev);
skb1007drivers/net/lance.cnetif_rx(skb);
skb47drivers/net/loopback.cstatic int loopback_xmit(struct sk_buff *skb, struct device *dev)
skb53drivers/net/loopback.cif (skb == NULL || dev == NULL) 
skb72drivers/net/loopback.cif(skb->free==0)
skb74drivers/net/loopback.cstruct sk_buff *skb2=skb;
skb75drivers/net/loopback.cskb=skb_clone(skb, GFP_ATOMIC);    /* Clone the buffer */
skb76drivers/net/loopback.cif(skb==NULL)
skb81drivers/net/loopback.celse if(skb->sk)
skb89drivers/net/loopback.cskb->sk->wmem_alloc-=skb->mem_len;
skb90drivers/net/loopback.cskb->sk->write_space(skb->sk);
skb94drivers/net/loopback.cskb->protocol=eth_type_trans(skb,dev);
skb95drivers/net/loopback.cskb->dev=dev;
skb98drivers/net/loopback.cnetif_rx(skb);
skb100drivers/net/loopback.cskb_device_unlock(skb);
skb792drivers/net/ni52.cstruct sk_buff *skb;
skb806drivers/net/ni52.cskb = (struct sk_buff *) alloc_skb(totlen, GFP_ATOMIC);
skb807drivers/net/ni52.cif(skb != NULL)
skb809drivers/net/ni52.cskb->len = totlen;
skb810drivers/net/ni52.cskb->dev = dev;
skb811drivers/net/ni52.cmemcpy( (char *) skb->data,(char *) p->base+(unsigned long) rbd->buffer, totlen);
skb812drivers/net/ni52.cskb->protocol=eth_type_trans(skb,dev);
skb813drivers/net/ni52.cnetif_rx(skb);
skb928drivers/net/ni52.cstatic int ni52_send_packet(struct sk_buff *skb, struct device *dev)
skb972drivers/net/ni52.cif(skb == NULL)
skb978drivers/net/ni52.cif (skb->len <= 0)
skb980drivers/net/ni52.cif(skb->len > XMIT_BUFF_SIZE)
skb982drivers/net/ni52.cprintk("%s: Sorry, max. framelength is %d bytes. The length of your frame is %ld bytes.\n",dev->name,XMIT_BUFF_SIZE,skb->len);
skb990drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
skb991drivers/net/ni52.clen = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
skb1005drivers/net/ni52.cdev_kfree_skb(skb,FREE_WRITE);
skb1025drivers/net/ni52.cdev_kfree_skb(skb,FREE_WRITE);
skb1045drivers/net/ni52.cdev_kfree_skb(skb,FREE_WRITE);
skb120drivers/net/ni65.cstatic int   ni65_send_packet(struct sk_buff *skb, struct device *dev);
skb452drivers/net/ni65.cstruct sk_buff *skb;
skb462drivers/net/ni65.cskb = (struct sk_buff *) p->tmdbufs[p->tmdlast];
skb463drivers/net/ni65.cdev_kfree_skb(skb,FREE_WRITE); 
skb500drivers/net/ni65.cstruct sk_buff *skb,*skb1;
skb529drivers/net/ni65.cskb = alloc_skb(R_BUF_SIZE,GFP_ATOMIC);
skb530drivers/net/ni65.cif(skb != NULL)
skb532drivers/net/ni65.cif( (unsigned long) (skb->data + R_BUF_SIZE) & 0xff000000) {
skb533drivers/net/ni65.cmemcpy(skb->data,p->recv_skb[p->rmdnum]->data,len);
skb534drivers/net/ni65.cskb1 = skb;
skb538drivers/net/ni65.cp->recv_skb[p->rmdnum] = skb;
skb539drivers/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);
skb151drivers/net/pi2.cstatic int pi_send_packet(struct sk_buff *skb, struct device *dev);
skb208drivers/net/pi2.cstatic void hardware_send_packet(struct pi_local *lp, struct sk_buff *skb)
skb220drivers/net/pi2.cskb_queue_tail(&lp->sndq, skb);
skb338drivers/net/pi2.cstatic void free_p(struct sk_buff *skb)
skb340drivers/net/pi2.cdev_kfree_skb(skb, FREE_WRITE);
skb510drivers/net/pi2.cstruct sk_buff *skb;
skb553drivers/net/pi2.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb554drivers/net/pi2.cif (skb == NULL) {
skb560drivers/net/pi2.cskb->len = (unsigned long) pkt_len;
skb561drivers/net/pi2.cskb->dev = dev;
skb564drivers/net/pi2.cskb->data[0] = 0;
skb566drivers/net/pi2.cmemcpy(&skb->data[1], (char *) cur_buf->data,
skb568drivers/net/pi2.cskb->protocol=ntohs(ETH_P_AX25);
skb569drivers/net/pi2.cnetif_rx(skb);
skb582drivers/net/pi2.cstruct sk_buff *skb;
skb639drivers/net/pi2.cskb = alloc_skb(sksize, GFP_ATOMIC);
skb640drivers/net/pi2.cif (skb == NULL) {
skb646drivers/net/pi2.cskb->len = pkt_len;
skb647drivers/net/pi2.cskb->dev = dev;
skb650drivers/net/pi2.cskb->data[0] = 0;
skb652drivers/net/pi2.cmemcpy(&skb->data[1], lp->rcvbuf->data, pkt_len - 1);
skb653drivers/net/pi2.cskb->protocol=ntohs(ETH_P_AX25);
skb654drivers/net/pi2.cnetif_rx(skb);
skb1072drivers/net/pi2.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb)
skb1074drivers/net/pi2.creturn ax25_encapsulate(buff, dev, type, daddr, saddr, len, skb);
skb1079drivers/net/pi2.cstruct sk_buff *skb)
skb1081drivers/net/pi2.creturn ax25_rebuild_header(buff, dev, raddr, skb);
skb1494drivers/net/pi2.cstatic int pi_send_packet(struct sk_buff *skb, struct device *dev)
skb1501drivers/net/pi2.cif (skb == NULL) {
skb1505drivers/net/pi2.chardware_send_packet(lp, skb);
skb133drivers/net/plip.cunsigned long raddr, struct sk_buff *skb);
skb134drivers/net/plip.cstatic int plip_tx_packet(struct sk_buff *skb, struct device *dev);
skb184drivers/net/plip.cstruct sk_buff *skb;
skb199drivers/net/plip.cunsigned long raddr, struct sk_buff *skb);
skb398drivers/net/plip.cif (rcv->skb) {
skb399drivers/net/plip.crcv->skb->free = 1;
skb400drivers/net/plip.ckfree_skb(rcv->skb, FREE_READ);
skb401drivers/net/plip.crcv->skb = NULL;
skb404drivers/net/plip.cif (snd->skb) {
skb405drivers/net/plip.cdev_kfree_skb(snd->skb, FREE_WRITE);
skb406drivers/net/plip.csnd->skb = NULL;
skb525drivers/net/plip.crcv->skb = alloc_skb(rcv->length.h, GFP_ATOMIC);
skb526drivers/net/plip.cif (rcv->skb == NULL) {
skb530drivers/net/plip.crcv->skb->len = rcv->length.h;
skb531drivers/net/plip.crcv->skb->dev = dev;
skb537drivers/net/plip.clbuf = rcv->skb->data;
skb562drivers/net/plip.crcv->skb->protocol=eth_type_trans(rcv->skb, dev);
skb563drivers/net/plip.cnetif_rx(rcv->skb);
skb565drivers/net/plip.crcv->skb = NULL;
skb648drivers/net/plip.cif (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) {
skb651drivers/net/plip.csnd->skb = NULL;
skb720drivers/net/plip.cdev_kfree_skb(snd->skb, FREE_WRITE);
skb727drivers/net/plip.csnd->skb = NULL;
skb836drivers/net/plip.cstruct sk_buff *skb)
skb843drivers/net/plip.creturn nl->orig_rebuild_header(buff, dev, dst, skb);
skb858drivers/net/plip.cplip_tx_packet(struct sk_buff *skb, struct device *dev)
skb869drivers/net/plip.cif (skb == NULL) {
skb879drivers/net/plip.cif (skb->len > dev->mtu) {
skb880drivers/net/plip.cprintk("%s: packet too big, %d.\n", dev->name, (int)skb->len);
skb890drivers/net/plip.csnd->skb = skb;
skb891drivers/net/plip.csnd->length.h = skb->len;
skb937drivers/net/plip.cnl->rcv_data.skb = nl->snd_data.skb = NULL;
skb972drivers/net/plip.cif (snd->skb) {
skb973drivers/net/plip.cdev_kfree_skb(snd->skb, FREE_WRITE);
skb974drivers/net/plip.csnd->skb = NULL;
skb977drivers/net/plip.cif (rcv->skb) {
skb978drivers/net/plip.crcv->skb->free = 1;
skb979drivers/net/plip.ckfree_skb(rcv->skb, FREE_READ);
skb980drivers/net/plip.crcv->skb = NULL;
skb126drivers/net/ppp.cstatic void ppp_add_arp(unsigned long addr, struct sk_buff *skb,
skb1086drivers/net/ppp.cstruct sk_buff *skb;
skb1155drivers/net/ppp.cskb=alloc_skb(count, GFP_ATOMIC);
skb1156drivers/net/ppp.cif(skb)
skb1158drivers/net/ppp.cmemcpy(skb->data, c,count);
skb1159drivers/net/ppp.cskb->protocol=htons(ETH_P_IP);
skb1160drivers/net/ppp.cskb->dev=ppp->dev;
skb1161drivers/net/ppp.cskb->len=count;
skb1162drivers/net/ppp.cnetif_rx(skb);
skb1705drivers/net/ppp.cppp_xmit(struct sk_buff *skb, struct device *dev)
skb1714drivers/net/ppp.cif (skb == NULL) {
skb1722drivers/net/ppp.cp     = (unsigned char *) (skb + 1);
skb1723drivers/net/ppp.clen   = skb->len;
skb1727drivers/net/ppp.c(unsigned long int) skb, ppp->sending));
skb1731drivers/net/ppp.cdev_kfree_skb(skb, FREE_WRITE);
skb1754drivers/net/ppp.clen = ntohs( ((struct iphdr *)(skb->data)) -> tot_len );
skb1796drivers/net/ppp.cstruct iphdr *iph = (struct iphdr *) (skb + 1);
skb1843drivers/net/ppp.cdev_kfree_skb(skb, FREE_WRITE);
skb1862drivers/net/ppp.cppp_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
skb1870drivers/net/ppp.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb)
skb1877drivers/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);
skb1571drivers/net/sk_g16.cstruct sk_buff *skb;
skb1573drivers/net/sk_g16.cskb = alloc_skb(len, GFP_ATOMIC); /* allocate socket buffer */ 
skb1575drivers/net/sk_g16.cif (skb == NULL)                /* Could not get mem ? */
skb1593drivers/net/sk_g16.cskb->len = len;
skb1594drivers/net/sk_g16.cskb->dev = dev;
skb1603drivers/net/sk_g16.cmemcpy(skb->data, (unsigned char *) (rmdp->u.buffer & 0x00ffffff),
skb1614drivers/net/sk_g16.cskb->protocol=eth_type_trans(skb,dev);
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);
skb417drivers/net/skeleton.cstruct sk_buff *skb;
skb419drivers/net/skeleton.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb420drivers/net/skeleton.cif (skb == NULL) {
skb425drivers/net/skeleton.cskb->len = pkt_len;
skb426drivers/net/skeleton.cskb->dev = dev;
skb429drivers/net/skeleton.cmemcpy(skb->data, (void*)dev->rmem_start,
skb432drivers/net/skeleton.cinsw(ioaddr, skb->data, (pkt_len + 1) >> 1);
skb434drivers/net/skeleton.cnetif_rx(skb);
skb279drivers/net/slip.cstruct sk_buff *skb;
skb316drivers/net/slip.cskb = alloc_skb(count, GFP_ATOMIC);
skb317drivers/net/slip.cif (skb == NULL)  {
skb322drivers/net/slip.cskb->len = count;
skb323drivers/net/slip.cskb->dev = sl->dev;
skb324drivers/net/slip.cmemcpy(skb->data, sl->rbuff, count);
skb326drivers/net/slip.cskb->protocol=htons(ETH_P_AX25);
skb328drivers/net/slip.cskb->protocol=htons(ETH_P_IP);
skb329drivers/net/slip.cnetif_rx(skb);
skb418drivers/net/slip.csl_xmit(struct sk_buff *skb, struct device *dev)
skb461drivers/net/slip.cif (skb->data[15] == LAPB_UI && skb->data[16] == AX25_P_IP) {
skb465drivers/net/slip.cmode = ax25_ip_mode_get((ax25_address *)(skb->data + 1), dev);
skb468drivers/net/slip.cif ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL) {
skb474drivers/net/slip.cdev_kfree_skb(skb, FREE_WRITE);
skb483drivers/net/slip.cif (skb != NULL) {
skb485drivers/net/slip.csl_encaps(sl, skb->data, skb->len);
skb486drivers/net/slip.cdev_kfree_skb(skb, FREE_WRITE);
skb497drivers/net/slip.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb)
skb504drivers/net/slip.creturn ax25_encapsulate(buff, dev, type, daddr, saddr, len, skb);
skb515drivers/net/slip.cstruct sk_buff *skb)
skb522drivers/net/slip.creturn ax25_rebuild_header(buff, dev, raddr, skb);
skb160drivers/net/tulip.cstatic int tulip_start_xmit(struct sk_buff *skb, struct device *dev);
skb376drivers/net/tulip.ctulip_start_xmit(struct sk_buff *skb, struct device *dev)
skb406drivers/net/tulip.cif (skb == NULL || skb->len <= 0) {
skb428drivers/net/tulip.ctp->tx_skbuff[entry] = skb;
skb429drivers/net/tulip.ctp->tx_ring[entry].length = skb->len |
skb431drivers/net/tulip.ctp->tx_ring[entry].buffer1 = skb->data;
skb601drivers/net/tulip.cstruct sk_buff *skb;
skb603drivers/net/tulip.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb604drivers/net/tulip.cif (skb == NULL) {
skb619drivers/net/tulip.cskb->len = pkt_len;
skb620drivers/net/tulip.cskb->dev = dev;
skb621drivers/net/tulip.cmemcpy(skb->data, lp->rx_ring[entry].buffer1, pkt_len);
skb622drivers/net/tulip.cskb->protocol=eth_type_trans(skb,dev);
skb623drivers/net/tulip.cnetif_rx(skb);
skb46drivers/net/tunnel.cstatic int tunnel_xmit(struct sk_buff *skb, struct device *dev);
skb120drivers/net/tunnel.cstatic int tunnel_xmit(struct sk_buff *skb, struct device *dev)
skb131drivers/net/tunnel.cif (skb == NULL || dev == NULL)
skb156drivers/net/tunnel.cdev_kfree_skb(skb, FREE_WRITE);
skb161drivers/net/tunnel.ciph=(struct iphdr *)skb->data;
skb168drivers/net/tunnel.cdev_kfree_skb(skb, FREE_WRITE);
skb185drivers/net/tunnel.cdev_kfree_skb(skb, FREE_WRITE);
skb192drivers/net/tunnel.cdev_kfree_skb(skb, FREE_WRITE);
skb206drivers/net/tunnel.cnewlen = (skb->len + ip_header_len);
skb210drivers/net/tunnel.cdev_kfree_skb(skb, FREE_WRITE);
skb220drivers/net/tunnel.cmemcpy(skb2->h.iph, skb->data, ip_header_len );
skb221drivers/net/tunnel.cmemcpy(skb2->data + ip_header_len, skb->data, skb->len);
skb223drivers/net/tunnel.cdev_kfree_skb(skb, FREE_WRITE);
skb1313drivers/net/wavelan.cwavelan_send_packet(struct sk_buff *skb, device *dev)
skb1354drivers/net/wavelan.cif (skb == (struct sk_buff *)0)
skb1368drivers/net/wavelan.clength = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
skb1369drivers/net/wavelan.cbuf = skb->data;
skb1376drivers/net/wavelan.cdev_kfree_skb(skb, FREE_WRITE);
skb1421drivers/net/wavelan.cstruct sk_buff  *skb;
skb1564drivers/net/wavelan.cif ((skb = alloc_skb(sksize, GFP_ATOMIC)) == (struct sk_buff *)0)
skb1571drivers/net/wavelan.cskb->len = pkt_len;
skb1572drivers/net/wavelan.cskb->dev = dev;
skb1574drivers/net/wavelan.cobram_read(ioaddr, rbd.rbd_bufl, skb->data, pkt_len);
skb1590drivers/net/wavelan.cc = skb->data[i];
skb1592drivers/net/wavelan.cprintk(" %c", skb->data[i]);
skb1594drivers/net/wavelan.cprintk("%02x", skb->data[i]);
skb1603drivers/net/wavelan.cskb->protocol=eth_type_trans(skb,dev);
skb1604drivers/net/wavelan.cnetif_rx(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); 
skb549drivers/net/znet.cstruct sk_buff *skb;
skb551drivers/net/znet.cskb = alloc_skb(pkt_len, GFP_ATOMIC);
skb552drivers/net/znet.cif (skb == NULL) {
skb558drivers/net/znet.cskb->len = pkt_len;
skb559drivers/net/znet.cskb->dev = dev;
skb563drivers/net/znet.cmemcpy((unsigned char *) (skb + 1), zn.rx_cur, semi_cnt);
skb564drivers/net/znet.cmemcpy((unsigned char *) (skb + 1) + semi_cnt, zn.rx_start,
skb567drivers/net/znet.cmemcpy((unsigned char *) (skb + 1), zn.rx_cur, pkt_len);
skb569drivers/net/znet.cunsigned int *packet = (unsigned int *) (skb + 1);
skb574drivers/net/znet.cskb->protocol=eth_type_trans(skb,dev);
skb575drivers/net/znet.cnetif_rx(skb);
skb34include/linux/etherdevice.hstruct sk_buff *skb);
skb36include/linux/etherdevice.hunsigned long raddr, struct sk_buff *skb);
skb37include/linux/etherdevice.hextern unsigned short  eth_type_trans(struct sk_buff *skb, struct device *dev);
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);
skb199include/linux/netdevice.hextern void    dev_queue_xmit(struct sk_buff *skb, struct device *dev,
skb202include/linux/netdevice.hextern void    netif_rx(struct sk_buff *skb);
skb108include/linux/skbuff.hextern void      kfree_skb(struct sk_buff *skb, int rw);
skb118include/linux/skbuff.hextern void      kfree_skbmem(struct sk_buff *skb, unsigned size);
skb119include/linux/skbuff.hextern struct sk_buff *    skb_clone(struct sk_buff *skb, int priority);
skb120include/linux/skbuff.hextern void      skb_device_lock(struct sk_buff *skb);
skb121include/linux/skbuff.hextern void      skb_device_unlock(struct sk_buff *skb);
skb122include/linux/skbuff.hextern void      dev_kfree_skb(struct sk_buff *skb, int mode);
skb123include/linux/skbuff.hextern int      skb_device_locked(struct sk_buff *skb);
skb137include/linux/skbuff.hextern int       skb_check(struct sk_buff *skb,int,int, char *);
skb138include/linux/skbuff.h#define IS_SKB(skb)    skb_check((skb), 0, __LINE__,__FILE__)
skb139include/linux/skbuff.h#define IS_SKB_HEAD(skb)  skb_check((skb), 1, __LINE__,__FILE__)
skb141include/linux/skbuff.h#define IS_SKB(skb)    
skb142include/linux/skbuff.h#define IS_SKB_HEAD(skb)  
skb269include/linux/skbuff.hextern __inline__ void skb_unlink(struct sk_buff *skb)
skb276include/linux/skbuff.hif(skb->prev && skb->next)
skb278include/linux/skbuff.hskb->next->prev = skb->prev;
skb279include/linux/skbuff.hskb->prev->next = skb->next;
skb280include/linux/skbuff.hskb->next = NULL;
skb281include/linux/skbuff.hskb->prev = NULL;
skb291include/linux/skbuff.hextern void      skb_free_datagram(struct sk_buff *skb);
skb34include/linux/trdevice.hstruct sk_buff *skb);
skb36include/linux/trdevice.hunsigned long raddr, struct sk_buff *skb);
skb37include/linux/trdevice.hextern unsigned short  tr_type_trans(struct sk_buff *skb, struct device *dev);
skb8include/net/arp.hextern int  arp_rcv(struct sk_buff *skb, struct device *dev,
skb11include/net/arp.hstruct device *dev, unsigned long saddr, struct sk_buff *skb);
skb141include/net/atalk.hextern int aarp_send_ddp(struct device *dev,struct sk_buff *skb, struct at_addr *sa, void *hwaddr);
skb31include/net/eth.hextern void    eth_add_arp(unsigned long addr, struct sk_buff *skb,
skb33include/net/eth.hextern unsigned short  eth_type_trans(struct sk_buff *skb, struct device *dev);
skb56include/net/ip.hstruct sk_buff *skb;      /* complete received fragment    */
skb83include/net/ip.hextern int    ip_build_header(struct sk_buff *skb,
skb90include/net/ip.hextern int    ip_rcv(struct sk_buff *skb, struct device *dev,
skb92include/net/ip.hextern void    ip_forward(struct sk_buff *skb, struct device *dev, int is_frag, unsigned long target_addr, int target_strict);           
skb96include/net/ip.hstruct device *dev, struct sk_buff *skb,
skb1include/net/ipip.hextern int ipip_rcv(struct sk_buff *skb, struct device *dev, struct options *opt, 
skb48include/net/ipx.hextern int ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt);
skb31include/net/protocol.hint      (*handler)(struct sk_buff *skb, struct device *dev,
skb35include/net/protocol.hint      (*frag_handler)(struct sk_buff *skb, struct device *dev,
skb6include/net/rarp.hextern int rarp_rcv(struct sk_buff *skb, 
skb216include/net/sock.hvoid      (*wfree)(struct sock *sk, struct sk_buff *skb,
skb218include/net/sock.hvoid      (*rfree)(struct sock *sk, struct sk_buff *skb,
skb235include/net/sock.hint      (*build_header)(struct sk_buff *skb,
skb244include/net/sock.hstruct device *dev, struct sk_buff *skb,
skb306include/net/sock.hextern void      sock_wfree(struct sock *sk, struct sk_buff *skb,
skb308include/net/sock.hextern void      sock_rfree(struct sock *sk, struct sk_buff *skb,
skb316include/net/sock.hextern struct sk_buff     *sock_alloc_send_skb(struct sock *skb, unsigned long size, int noblock, int *errcode);
skb326include/net/sock.hextern __inline__ int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
skb329include/net/sock.hif(sk->rmem_alloc + skb->mem_len >= sk->rcvbuf)
skb333include/net/sock.hsk->rmem_alloc+=skb->mem_len;
skb334include/net/sock.hskb->sk=sk;
skb336include/net/sock.hskb_queue_tail(&sk->receive_queue,skb);
skb338include/net/sock.hsk->data_ready(sk,skb->len);
skb127include/net/tcp.hextern int  tcp_rcv(struct sk_buff *skb, struct device *dev,
skb45include/net/udp.hextern int  udp_rcv(struct sk_buff *skb, struct device *dev,
skb6net/802/llc.cint llc_rx_adm(struct sock *sk,struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
skb36net/802/llc.cint llc_rx_setup(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
skb70net/802/llc.cint llc_rx_reset(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
skb114net/802/llc.cint llc_rx_d_conn(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
skb150net/802/llc.cint llc_rx_error(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
skb199net/802/llc.cint llc_rx_nr_shared(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
skb288net/802/llc.cint llc_rx_normal(struct sock *sk, struct sk_buff *skb, int type, int cmd, int pf, int nr, int ns)
skb290net/802/llc.cif(llc_rx_nr_shared(sk, skb, type, cmd, pf, nr, ns))
skb364net/802/llc.cllc_queue_data(sk,skb);
skb23net/802/p8022.cp8022_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb27net/802/p8022.cproto = find_8022_client(*(skb->h.raw));
skb29net/802/p8022.cskb->h.raw += 3;
skb30net/802/p8022.cskb->len -= 3;
skb31net/802/p8022.creturn proto->rcvfunc(skb, dev, pt);
skb34net/802/p8022.cskb->sk = NULL;
skb35net/802/p8022.ckfree_skb(skb, FREE_READ);
skb41net/802/p8022.cstruct sk_buff *skb, unsigned char *dest_node)
skb43net/802/p8022.cstruct device  *dev = skb->dev;
skb44net/802/p8022.cunsigned long  len = skb->len;
skb48net/802/p8022.cdev->hard_header(skb->data, dev, len - hard_len,
skb49net/802/p8022.cdest_node, NULL, len - hard_len, skb);
skb50net/802/p8022.crawp = skb->data + hard_len;
skb57net/802/p8022.cskb->h.raw = rawp;
skb9net/802/p8023.cstruct sk_buff *skb, unsigned char *dest_node)
skb11net/802/p8023.cstruct device  *dev = skb->dev;
skb12net/802/p8023.cunsigned long  len = skb->len;
skb15net/802/p8023.cdev->hard_header(skb->data, dev, len - hard_len,
skb16net/802/p8023.cdest_node, NULL, len - hard_len, skb);
skb17net/802/p8023.cskb->h.raw = skb->data + hard_len;
skb40net/802/psnap.cint snap_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb53net/802/psnap.cproto = find_snap_client(skb->h.raw);
skb60net/802/psnap.cskb->h.raw += 5;
skb61net/802/psnap.cskb->len -= 5;
skb64net/802/psnap.creturn proto->rcvfunc(skb, dev, &psnap_packet_type);
skb66net/802/psnap.cskb->sk = NULL;
skb67net/802/psnap.ckfree_skb(skb, FREE_READ);
skb75net/802/psnap.cstatic void snap_datalink_header(struct datalink_proto *dl, struct sk_buff *skb, unsigned char *dest_node)
skb77net/802/psnap.cstruct device  *dev = skb->dev;
skb80net/802/psnap.crawp = skb->data + snap_dl->header_length+dev->hard_header_len;
skb82net/802/psnap.cskb->h.raw = rawp+5;
skb83net/802/psnap.csnap_dl->datalink_header(snap_dl, skb, dest_node);
skb42net/802/tr.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb) {
skb71net/802/tr.cstruct sk_buff *skb) {
skb81net/802/tr.cif(arp_find(trh->daddr, dest, dev, dev->pa_addr, skb)) {
skb90net/802/tr.cunsigned short tr_type_trans(struct sk_buff *skb, struct device *dev) {
skb92net/802/tr.cstruct trh_hdr *trh=(struct trh_hdr *)skb->data;
skb93net/802/tr.cstruct trllc *trllc=(struct trllc *)(skb->data+sizeof(struct trh_hdr));
skb101net/802/tr.cskb->pkt_type=PACKET_BROADCAST;
skb103net/802/tr.cskb->pkt_type=PACKET_MULTICAST;
skb109net/802/tr.cskb->pkt_type=PACKET_OTHERHOST;
skb89net/appletalk/aarp.cstruct sk_buff *skb;
skb91net/appletalk/aarp.cwhile((skb=skb_dequeue(&a->packet_queue))!=NULL)
skb92net/appletalk/aarp.ckfree_skb(skb, FREE_WRITE);
skb105net/appletalk/aarp.cstruct sk_buff *skb=alloc_skb(len, GFP_ATOMIC);
skb106net/appletalk/aarp.cstruct elapaarp *eah=(struct elapaarp *)(skb->data+dev->hard_header_len+aarp_dl->header_length);
skb109net/appletalk/aarp.cif(skb==NULL || sat==NULL)
skb116net/appletalk/aarp.cskb->arp  =  1;
skb117net/appletalk/aarp.cskb->free  =  1;
skb118net/appletalk/aarp.cskb->len  =  len;
skb119net/appletalk/aarp.cskb->dev  =  a->dev;
skb147net/appletalk/aarp.caarp_dl->datalink_header(aarp_dl, skb, aarp_eth_multicast);  
skb154net/appletalk/aarp.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb166net/appletalk/aarp.cstruct sk_buff *skb=alloc_skb(len, GFP_ATOMIC);
skb167net/appletalk/aarp.cstruct elapaarp *eah=(struct elapaarp *)(skb->data+dev->hard_header_len+aarp_dl->header_length);
skb169net/appletalk/aarp.cif(skb==NULL)
skb176net/appletalk/aarp.cskb->arp  =  1;
skb177net/appletalk/aarp.cskb->free  =  1;
skb178net/appletalk/aarp.cskb->len  =  len;
skb179net/appletalk/aarp.cskb->dev  =  dev;
skb210net/appletalk/aarp.caarp_dl->datalink_header(aarp_dl, skb, sha);  
skb216net/appletalk/aarp.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb227net/appletalk/aarp.cstruct sk_buff *skb=alloc_skb(len, GFP_ATOMIC);
skb228net/appletalk/aarp.cstruct elapaarp *eah=(struct elapaarp *)(skb->data+dev->hard_header_len+aarp_dl->header_length);
skb231net/appletalk/aarp.cif(skb==NULL)
skb238net/appletalk/aarp.cskb->arp  =  1;
skb239net/appletalk/aarp.cskb->free  =  1;
skb240net/appletalk/aarp.cskb->len  =  len;
skb241net/appletalk/aarp.cskb->dev  =  dev;
skb269net/appletalk/aarp.caarp_dl->datalink_header(aarp_dl, skb, aarp_eth_multicast);  
skb275net/appletalk/aarp.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb423net/appletalk/aarp.cint aarp_send_ddp(struct device *dev,struct sk_buff *skb, struct at_addr *sa, void *hwaddr)
skb438net/appletalk/aarp.cskb->dev = dev;
skb450net/appletalk/aarp.cddp_dl->datalink_header(ddp_dl, skb, ddp_eth_multicast);
skb451net/appletalk/aarp.cif(skb->sk==NULL)
skb452net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, SOPRI_NORMAL);
skb454net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
skb465net/appletalk/aarp.cddp_dl->datalink_header(ddp_dl, skb, a->hwaddr);
skb466net/appletalk/aarp.cif(skb->sk==NULL)
skb467net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, SOPRI_NORMAL);
skb469net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
skb482net/appletalk/aarp.cskb_queue_tail(&a->packet_queue, skb);
skb502net/appletalk/aarp.cskb_queue_tail(&a->packet_queue, skb);
skb533net/appletalk/aarp.cstruct sk_buff *skb;
skb544net/appletalk/aarp.cwhile((skb=skb_dequeue(&a->packet_queue))!=NULL)
skb547net/appletalk/aarp.cddp_dl->datalink_header(ddp_dl,skb,a->hwaddr);
skb548net/appletalk/aarp.cif(skb->sk==NULL)
skb549net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, SOPRI_NORMAL);
skb551net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
skb559net/appletalk/aarp.cstatic int aarp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb561net/appletalk/aarp.cstruct elapaarp *ea=(struct elapaarp *)skb->h.raw;
skb575net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb583net/appletalk/aarp.cif(skb->len<sizeof(*ea))
skb585net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb598net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb629net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb641net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb698net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb184net/appletalk/ddp.cstruct sk_buff *skb;
skb187net/appletalk/ddp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
skb189net/appletalk/ddp.ckfree_skb(skb,FREE_READ);
skb1327net/appletalk/ddp.cint atalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb1330net/appletalk/ddp.cstruct ddpehdr *ddp=(void *)skb->h.raw;
skb1335net/appletalk/ddp.cif(skb->len<sizeof(*ddp))
skb1337net/appletalk/ddp.ckfree_skb(skb,FREE_READ);
skb1354net/appletalk/ddp.cskb->len=min(skb->len,ddp->deh_len);
skb1362net/appletalk/ddp.cif(skb->len<sizeof(*ddp))
skb1364net/appletalk/ddp.ckfree_skb(skb,FREE_READ);
skb1376net/appletalk/ddp.ckfree_skb(skb,FREE_READ);
skb1398net/appletalk/ddp.ckfree_skb(skb, FREE_READ);
skb1406net/appletalk/ddp.cif(aarp_send_ddp(dev,skb, &ta, NULL)==-1)
skb1407net/appletalk/ddp.ckfree_skb(skb, FREE_READ);
skb1421net/appletalk/ddp.ckfree_skb(skb,FREE_READ);
skb1430net/appletalk/ddp.cskb->sk = sock;
skb1432net/appletalk/ddp.cif(sock_queue_rcv_skb(sock,skb)<0)
skb1434net/appletalk/ddp.cskb->sk=NULL;
skb1435net/appletalk/ddp.ckfree_skb(skb, FREE_WRITE);
skb1446net/appletalk/ddp.cstruct sk_buff *skb;
skb1519net/appletalk/ddp.cskb = sock_alloc_send_skb(sk, size, 0 , &err);
skb1520net/appletalk/ddp.cif(skb==NULL)
skb1523net/appletalk/ddp.cskb->sk=sk;
skb1524net/appletalk/ddp.cskb->free=1;
skb1525net/appletalk/ddp.cskb->arp=1;
skb1526net/appletalk/ddp.cskb->len=size;
skb1528net/appletalk/ddp.cskb->dev=dev;
skb1533net/appletalk/ddp.cskb->h.raw=skb->data+ddp_dl->header_length+dev->hard_header_len;  
skb1535net/appletalk/ddp.cddp=(struct ddpehdr *)skb->h.raw;
skb1572net/appletalk/ddp.cstruct sk_buff *skb2=skb_clone(skb, GFP_KERNEL);
skb1590net/appletalk/ddp.csk->wmem_alloc-=skb->mem_len;
skb1591net/appletalk/ddp.cddp_dl->datalink_header(ddp_dl, skb, dev->dev_addr);
skb1592net/appletalk/ddp.cskb->sk = NULL;
skb1593net/appletalk/ddp.cskb->h.raw = skb->data + ddp_dl->header_length + dev->hard_header_len;
skb1594net/appletalk/ddp.cskb->len -= ddp_dl->header_length ;
skb1595net/appletalk/ddp.cskb->len -= dev->hard_header_len ;
skb1596net/appletalk/ddp.catalk_rcv(skb,dev,NULL);
skb1608net/appletalk/ddp.cif(aarp_send_ddp(dev,skb,&usat->sat_addr, NULL)==-1)
skb1609net/appletalk/ddp.ckfree_skb(skb, FREE_WRITE);
skb1629net/appletalk/ddp.cstruct sk_buff *skb;
skb1642net/appletalk/ddp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb1643net/appletalk/ddp.cif(skb==NULL)
skb1646net/appletalk/ddp.cddp = (struct ddpehdr *)(skb->h.raw);
skb1652net/appletalk/ddp.cskb_copy_datagram(skb,0,ubuf,copied);
skb1659net/appletalk/ddp.cskb_copy_datagram(skb,sizeof(*ddp),ubuf,copied);
skb1668net/appletalk/ddp.cskb_free_datagram(skb);
skb1729net/appletalk/ddp.cstruct sk_buff *skb;
skb1731net/appletalk/ddp.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
skb1732net/appletalk/ddp.cv=skb->len-sizeof(struct ddpehdr);
skb336net/ax25/af_ax25.cstatic void ax25_send_to_raw(struct sock *sk, struct sk_buff *skb, int proto)
skb342net/ax25/af_ax25.cif ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
skb349net/ax25/af_ax25.csk->data_ready(sk, skb->len - 2);
skb377net/ax25/af_ax25.cstruct sk_buff *skb;
skb389net/ax25/af_ax25.cwhile ((skb = skb_dequeue(&ax25->sk->receive_queue)) != NULL) {
skb390net/ax25/af_ax25.cif (skb->sk != ax25->sk) {      /* A pending connection */
skb391net/ax25/af_ax25.cskb->sk->dead = 1;  /* Queue the unaccepted socket for death */
skb392net/ax25/af_ax25.cax25_set_timer(skb->sk->ax25);
skb393net/ax25/af_ax25.cskb->sk->ax25->state = AX25_STATE_0;
skb396net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb533net/ax25/af_ax25.cint ax25_send_frame(struct sk_buff *skb, ax25_address *src, ax25_address *dest, struct device *dev)
skb537net/ax25/af_ax25.cif (skb == NULL)
skb540net/ax25/af_ax25.cskb->h.raw = skb->data + 15;
skb550net/ax25/af_ax25.cax25_output(ax25, skb);
skb570net/ax25/af_ax25.cax25_output(ax25, skb);
skb1148net/ax25/af_ax25.cstruct sk_buff *skb;
skb1167net/ax25/af_ax25.cif ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
skb1178net/ax25/af_ax25.c} while (skb == NULL);
skb1180net/ax25/af_ax25.cnewsk = skb->sk;
skb1185net/ax25/af_ax25.cskb->sk = NULL;
skb1186net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1228net/ax25/af_ax25.cint ax25_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *ptype)
skb1230net/ax25/af_ax25.cunsigned char *data = skb->data;
skb1240net/ax25/af_ax25.cskb->sk = NULL;    /* Initially we don't know who its for */
skb1243net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);  /* Not a KISS data frame */
skb1252net/ax25/af_ax25.cif ((data = ax25_parse_addr(data, skb->len + dev->hard_header_len - 1, &src, &dest, &dp, &type)) == NULL) {
skb1253net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1281net/ax25/af_ax25.cbuild_ax25_addr(skb->data + 1, &src, &dest, &dp, type);
skb1282net/ax25/af_ax25.cskb->len += dev->hard_header_len;
skb1283net/ax25/af_ax25.cskb->arp = 1;
skb1284net/ax25/af_ax25.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);      
skb1286net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1295net/ax25/af_ax25.cskb->len -= sizeof(ax25_address) * dp.ndigi;
skb1309net/ax25/af_ax25.cskb->h.raw = data + 1;    /* skip pid */
skb1312net/ax25/af_ax25.cax25_send_to_raw(raw, skb, (int)*data);
skb1315net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1324net/ax25/af_ax25.cip_rcv(skb, dev, ptype);  /* Note ptype here is the wrong one, fix me later */
skb1328net/ax25/af_ax25.carp_rcv(skb, dev, ptype);  /* Note ptype here is wrong... */
skb1335net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1337net/ax25/af_ax25.cskb_queue_tail(&sk->receive_queue, skb);
skb1338net/ax25/af_ax25.cskb->sk = sk;
skb1339net/ax25/af_ax25.csk->rmem_alloc += skb->mem_len;
skb1341net/ax25/af_ax25.csk->data_ready(sk, skb->len - 2);
skb1344net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1349net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);  /* Will scan SOCK_AX25 RAW sockets */
skb1358net/ax25/af_ax25.cskb->h.raw = data;
skb1362net/ax25/af_ax25.cif (ax25_process_rx_frame(ax25, skb, type) == 0)
skb1363net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1376net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1385net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1395net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1410net/ax25/af_ax25.cskb_queue_head(&sk->receive_queue, skb);
skb1412net/ax25/af_ax25.cskb->sk     = make;
skb1420net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1426net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1432net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1439net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1460net/ax25/af_ax25.csk->data_ready(sk, skb->len - 2);
skb1462net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1476net/ax25/af_ax25.cstruct sk_buff *skb;
skb1556net/ax25/af_ax25.cif ((skb = sock_alloc_send_skb(sk, size, 0, &err)) == NULL)
skb1559net/ax25/af_ax25.cskb->sk   = sk;
skb1560net/ax25/af_ax25.cskb->free = 1;
skb1561net/ax25/af_ax25.cskb->arp  = 1;
skb1562net/ax25/af_ax25.cskb->len  = size;
skb1564net/ax25/af_ax25.casmptr = skb->data;
skb1576net/ax25/af_ax25.cskb->h.raw = asmptr;
skb1579net/ax25/af_ax25.cprintk("base=%p pos=%p\n", skb->data, asmptr);
skb1593net/ax25/af_ax25.ckfree_skb(skb, FREE_WRITE);
skb1596net/ax25/af_ax25.cax25_output(sk->ax25, skb);  /* Shove it onto the queue and kick */
skb1600net/ax25/af_ax25.cdev_queue_xmit(skb, sk->ax25->device, SOPRI_NORMAL);
skb1622net/ax25/af_ax25.cstruct sk_buff *skb;
skb1639net/ax25/af_ax25.cif ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
skb1642net/ax25/af_ax25.ccopied= (size < skb->len) ? size : skb->len;
skb1643net/ax25/af_ax25.cskb_copy_datagram(skb, sk->type == SOCK_SEQPACKET ? 2 : 0, ubuf, copied);
skb1649net/ax25/af_ax25.cunsigned char *dp = skb->data;
skb1652net/ax25/af_ax25.cax25_parse_addr(dp, skb->len, NULL, &dest, &digi, NULL);
skb1667net/ax25/af_ax25.cskb_free_datagram(skb);
skb1719net/ax25/af_ax25.cstruct sk_buff *skb;
skb1721net/ax25/af_ax25.cif ((skb = skb_peek(&sk->receive_queue)) != NULL)
skb1722net/ax25/af_ax25.camount = skb->len;
skb1911net/ax25/af_ax25.cvoid *saddr, unsigned len, struct sk_buff *skb)
skb1955net/ax25/af_ax25.cint ax25_rebuild_header(unsigned char *bp, struct device *dev, unsigned long dest, struct sk_buff *skb)
skb1957net/ax25/af_ax25.cif (arp_find(bp + 1, dest, dev, dev->pa_addr, skb))
skb60net/ax25/ax25_in.cstatic int ax25_rx_iframe(ax25_cb *ax25, struct sk_buff *skb, unsigned char *iframe)
skb69net/ax25/ax25_in.cqueued = nr_route_frame(skb, ax25->device);
skb75net/ax25/ax25_in.cskb->h.raw = ((char *)(iframe)) + 2;
skb76net/ax25/ax25_in.cskb->len  -= 2;
skb77net/ax25/ax25_in.cip_rcv(skb, skb->dev, NULL);  /* Wrong ptype */
skb83net/ax25/ax25_in.cif (sock_queue_rcv_skb(ax25->sk, skb) == 0) {
skb103net/ax25/ax25_in.cstatic int ax25_state1_machine(ax25_cb *ax25, struct sk_buff *skb, unsigned char *frame, int frametype, int type)
skb161net/ax25/ax25_in.cstatic int ax25_state2_machine(ax25_cb *ax25, struct sk_buff *skb, unsigned char *frame, int frametype, int type)
skb220net/ax25/ax25_in.cstatic int ax25_state3_machine(ax25_cb *ax25, struct sk_buff *skb, unsigned char *frame, int frametype, int type)
skb324net/ax25/ax25_in.cqueued = ax25_rx_iframe(ax25, skb, frame);
skb368net/ax25/ax25_in.cstatic int ax25_state4_machine(ax25_cb *ax25, struct sk_buff *skb, unsigned char *frame, int frametype, int type)
skb515net/ax25/ax25_in.cqueued = ax25_rx_iframe(ax25, skb, frame);
skb557net/ax25/ax25_in.cint ax25_process_rx_frame(ax25_cb *ax25, struct sk_buff *skb, int type)
skb564net/ax25/ax25_in.cframe = skb->h.raw;
skb570net/ax25/ax25_in.cqueued = ax25_state1_machine(ax25, skb, frame, frametype, type);
skb573net/ax25/ax25_in.cqueued = ax25_state2_machine(ax25, skb, frame, frametype, type);
skb576net/ax25/ax25_in.cqueued = ax25_state3_machine(ax25, skb, frame, frametype, type);
skb579net/ax25/ax25_in.cqueued = ax25_state4_machine(ax25, skb, frame, frametype, type);
skb50net/ax25/ax25_out.cint ax25_output(ax25_cb *ax25, struct sk_buff *skb)
skb52net/ax25/ax25_out.cskb_queue_tail(&ax25->write_queue, skb);  /* Throw it on the queue */
skb64net/ax25/ax25_out.cstatic void ax25_send_iframe(ax25_cb *ax25, struct sk_buff *skb, int poll_bit)
skb68net/ax25/ax25_out.cif (skb == NULL)
skb71net/ax25/ax25_out.cframe = skb->h.raw;  /* KISS + header */
skb78net/ax25/ax25_out.cax25_transmit_buffer(ax25, skb, C_COMMAND);  
skb83net/ax25/ax25_out.cstruct sk_buff *skb, *skbn;
skb107net/ax25/ax25_out.cskb  = skb_dequeue(&ax25->write_queue);
skb109net/ax25/ax25_out.cif ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL) {
skb110net/ax25/ax25_out.cskb_queue_head(&ax25->write_queue, skb);
skb130net/ax25/ax25_out.cskb_queue_tail(&ax25->ack_queue, skb);
skb147net/ax25/ax25_out.cvoid ax25_transmit_buffer(ax25_cb *ax25, struct sk_buff *skb, int type)
skb149net/ax25/ax25_out.cunsigned char *ptr = skb->data;
skb165net/ax25/ax25_out.cskb->arp = 1;
skb167net/ax25/ax25_out.cdev_queue_xmit(skb, ax25->device, SOPRI_NORMAL);
skb54net/ax25/ax25_subr.cstruct sk_buff *skb;
skb56net/ax25/ax25_subr.cwhile ((skb = skb_dequeue(&ax25->write_queue)) != NULL) {
skb57net/ax25/ax25_subr.cskb->free = 1;
skb58net/ax25/ax25_subr.ckfree_skb(skb, FREE_WRITE);
skb61net/ax25/ax25_subr.cwhile ((skb = skb_dequeue(&ax25->ack_queue)) != NULL) {
skb62net/ax25/ax25_subr.cskb->free = 1;
skb63net/ax25/ax25_subr.ckfree_skb(skb, FREE_WRITE);
skb74net/ax25/ax25_subr.cstruct sk_buff *skb, *skb_prev = NULL;
skb81net/ax25/ax25_subr.cskb = skb_dequeue(&ax25->ack_queue);
skb82net/ax25/ax25_subr.cskb->free = 1;
skb83net/ax25/ax25_subr.ckfree_skb(skb, FREE_WRITE);
skb93net/ax25/ax25_subr.cwhile ((skb = skb_dequeue(&ax25->ack_queue)) != NULL) {
skb95net/ax25/ax25_subr.cskb_queue_head(&ax25->write_queue, skb);
skb97net/ax25/ax25_subr.cskb_append(skb_prev, skb);
skb98net/ax25/ax25_subr.cskb_prev = skb;
skb141net/ax25/ax25_subr.cstruct sk_buff *skb;
skb149net/ax25/ax25_subr.cif ((skb = alloc_skb(16 + 1 + size_ax25_addr(ax25->digipeat), GFP_ATOMIC)) == NULL)
skb153net/ax25/ax25_subr.cskb->sk = ax25->sk;
skb154net/ax25/ax25_subr.cax25->sk->wmem_alloc += skb->mem_len;
skb157net/ax25/ax25_subr.cdptr = skb->data;
skb169net/ax25/ax25_subr.cskb->free = 1;
skb170net/ax25/ax25_subr.cskb->len  = len + size_ax25_addr(ax25->digipeat) + 1;
skb172net/ax25/ax25_subr.cax25_transmit_buffer(ax25, skb, type);
skb182net/ax25/ax25_subr.cstruct sk_buff *skb;
skb187net/ax25/ax25_subr.cif ((skb = alloc_skb(len, GFP_ATOMIC)) == NULL)
skb190net/ax25/ax25_subr.cskb->len = len;
skb194net/ax25/ax25_subr.cdptr = skb->data + 1 + size_ax25_addr(digi);
skb195net/ax25/ax25_subr.cskb->sk = NULL;
skb202net/ax25/ax25_subr.cdptr    = skb->data;
skb206net/ax25/ax25_subr.cskb->arp  = 1;
skb207net/ax25/ax25_subr.cskb->free = 1;
skb209net/ax25/ax25_subr.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb55net/core/datagram.cstruct sk_buff *skb;
skb127net/core/datagram.cskb=skb_dequeue(&sk->receive_queue);
skb128net/core/datagram.cif(skb!=NULL)
skb129net/core/datagram.cskb->users++;
skb136net/core/datagram.cskb=skb_peek(&sk->receive_queue);
skb137net/core/datagram.cif(skb!=NULL)
skb138net/core/datagram.cskb->users++;
skb140net/core/datagram.cif(skb==NULL)  /* shouldn't happen but .. */
skb143net/core/datagram.creturn skb;
skb146net/core/datagram.cvoid skb_free_datagram(struct sk_buff *skb)
skb152net/core/datagram.cskb->users--;
skb153net/core/datagram.cif(skb->users>0)
skb159net/core/datagram.cif(!skb->next && !skb->prev)  /* Been dequeued by someone - ie it's read */
skb160net/core/datagram.ckfree_skb(skb,FREE_READ);
skb164net/core/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
skb168net/core/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
skb276net/core/dev.cstruct sk_buff *skb;
skb277net/core/dev.cwhile((skb=skb_dequeue(&dev->buffs[ct]))!=NULL)
skb278net/core/dev.cif(skb->free)
skb279net/core/dev.ckfree_skb(skb,FREE_WRITE);
skb312net/core/dev.cvoid dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
skb321net/core/dev.cif(pri>=0 && !skb_device_locked(skb))
skb322net/core/dev.cskb_device_lock(skb);  /* Shove a lock on the frame */
skb324net/core/dev.cIS_SKB(skb);
skb326net/core/dev.cskb->dev = dev;
skb353net/core/dev.cif (!skb->arp && dev->rebuild_header(skb->data, dev, skb->raddr, skb)) {
skb361net/core/dev.cskb_queue_tail(dev->buffs + pri,skb);
skb362net/core/dev.cskb_device_unlock(skb);    /* Buffer is on the device queue and can be freed safely */
skb363net/core/dev.cskb = skb_dequeue(dev->buffs + pri);
skb364net/core/dev.cskb_device_lock(skb);    /* New buffer needs locking down */
skb371net/core/dev.cskb->stamp=xtime;
skb378net/core/dev.c((struct sock *)ptype->data != skb->sk))
skb381net/core/dev.cif ((skb2 = skb_clone(skb, GFP_ATOMIC)) == NULL)
skb387net/core/dev.cskb2->len-=skb->dev->hard_header_len;
skb388net/core/dev.cptype->func(skb2, skb->dev, ptype);
skb394net/core/dev.cif (dev->hard_start_xmit(skb, dev) == 0) {
skb408net/core/dev.cskb_device_unlock(skb);
skb409net/core/dev.cskb_queue_head(dev->buffs + pri,skb);
skb419net/core/dev.cvoid netif_rx(struct sk_buff *skb)
skb428net/core/dev.cskb->sk = NULL;
skb429net/core/dev.cskb->free = 1;
skb430net/core/dev.cif(skb->stamp.tv_sec==0)
skb431net/core/dev.cskb->stamp = xtime;
skb444net/core/dev.ckfree_skb(skb, FREE_READ);
skb452net/core/dev.cIS_SKB(skb);
skb454net/core/dev.cskb_queue_tail(&backlog,skb);
skb488net/core/dev.cstruct sk_buff *skb = NULL;
skb498net/core/dev.cskb = (struct sk_buff *) buff;
skb510net/core/dev.cskb = alloc_skb(len, GFP_ATOMIC);
skb511net/core/dev.cif (skb == NULL) 
skb524net/core/dev.cto = skb->data;
skb546net/core/dev.cskb->len = len;
skb547net/core/dev.cskb->dev = dev;
skb548net/core/dev.cskb->free = 1;
skb550net/core/dev.cnetif_rx(skb);
skb607net/core/dev.cstruct sk_buff *skb;
skb639net/core/dev.cwhile((skb=skb_dequeue(&backlog))!=NULL)
skb655net/core/dev.cskb->h.raw = skb->data + skb->dev->hard_header_len;
skb656net/core/dev.cskb->len -= skb->dev->hard_header_len;
skb662net/core/dev.ctype = skb->protocol;
skb674net/core/dev.cstruct sk_buff *skb2=skb_clone(skb, GFP_ATOMIC);
skb676net/core/dev.cpt_prev->func(skb2,skb->dev, pt_prev);
skb683net/core/dev.cif ((ptype->type == type || ptype->type == htons(ETH_P_ALL)) && (!ptype->dev || ptype->dev==skb->dev))
skb693net/core/dev.cskb2=skb_clone(skb, GFP_ATOMIC);
skb701net/core/dev.cpt_prev->func(skb2, skb->dev, pt_prev);
skb713net/core/dev.cpt_prev->func(skb, skb->dev, pt_prev);
skb719net/core/dev.ckfree_skb(skb, FREE_WRITE);
skb755net/core/dev.cstruct sk_buff *skb;
skb771net/core/dev.cwhile((skb=skb_dequeue(&dev->buffs[i]))!=NULL)
skb776net/core/dev.cskb_device_lock(skb);
skb782net/core/dev.cdev_queue_xmit(skb,dev,-i - 1);
skb72net/core/skbuff.cint skb_check(struct sk_buff *skb, int head, int line, char *file)
skb75net/core/skbuff.cif (skb->magic_debug_cookie != SK_HEAD_SKB) {
skb80net/core/skbuff.cif (!skb->next || !skb->prev) {
skb84net/core/skbuff.cif (skb->next->magic_debug_cookie != SK_HEAD_SKB
skb85net/core/skbuff.c&& skb->next->magic_debug_cookie != SK_GOOD_SKB) {
skb90net/core/skbuff.cif (skb->prev->magic_debug_cookie != SK_HEAD_SKB
skb91net/core/skbuff.c&& skb->prev->magic_debug_cookie != SK_GOOD_SKB) {
skb98net/core/skbuff.cstruct sk_buff *skb2 = skb->next;
skb100net/core/skbuff.cwhile (skb2 != skb && i < 5) {
skb112net/core/skbuff.cif (skb->next != NULL && skb->next->magic_debug_cookie != SK_HEAD_SKB
skb113net/core/skbuff.c&& skb->next->magic_debug_cookie != SK_GOOD_SKB) {
skb118net/core/skbuff.cif (skb->prev != NULL && skb->prev->magic_debug_cookie != SK_HEAD_SKB
skb119net/core/skbuff.c&& skb->prev->magic_debug_cookie != SK_GOOD_SKB) {
skb126net/core/skbuff.cif(skb->magic_debug_cookie==SK_FREED_SKB)
skb131net/core/skbuff.cskb,skb->truesize,skb->mem_len,skb->free);
skb134net/core/skbuff.cif(skb->magic_debug_cookie!=SK_GOOD_SKB)
skb138net/core/skbuff.cskb,skb->truesize,skb->mem_len,skb->free);
skb141net/core/skbuff.cif(skb->mem_len!=skb->truesize)
skb145net/core/skbuff.cskb,skb->truesize,skb->mem_len);
skb304net/core/skbuff.cvoid skb_unlink(struct sk_buff *skb)
skb311net/core/skbuff.cIS_SKB(skb);
skb313net/core/skbuff.cif(skb->prev && skb->next)
skb315net/core/skbuff.cskb->next->prev = skb->prev;
skb316net/core/skbuff.cskb->prev->next = skb->next;
skb317net/core/skbuff.cskb->next = NULL;
skb318net/core/skbuff.cskb->prev = NULL;
skb334net/core/skbuff.cvoid kfree_skb(struct sk_buff *skb, int rw)
skb336net/core/skbuff.cif (skb == NULL)
skb343net/core/skbuff.cIS_SKB(skb);
skb345net/core/skbuff.cif (skb->lock)
skb347net/core/skbuff.cskb->free = 3;    /* Free when unlocked */
skb351net/core/skbuff.cif (skb->free == 2)
skb354net/core/skbuff.cif (skb->next)
skb357net/core/skbuff.cif (skb->sk)
skb359net/core/skbuff.cif(skb->sk->prot!=NULL)
skb362net/core/skbuff.cskb->sk->prot->rfree(skb->sk, skb, skb->mem_len);
skb364net/core/skbuff.cskb->sk->prot->wfree(skb->sk, skb, skb->mem_len);
skb374net/core/skbuff.cskb->sk->rmem_alloc-=skb->mem_len;
skb376net/core/skbuff.cskb->sk->wmem_alloc-=skb->mem_len;
skb378net/core/skbuff.cif(!skb->sk->dead)
skb379net/core/skbuff.cskb->sk->write_space(skb->sk);
skb380net/core/skbuff.ckfree_skbmem(skb,skb->mem_len);
skb384net/core/skbuff.ckfree_skbmem(skb, skb->mem_len);
skb393net/core/skbuff.cstruct sk_buff *skb;
skb406net/core/skbuff.cskb=(struct sk_buff *)kmalloc(size,priority);
skb407net/core/skbuff.cif (skb == NULL)
skb413net/core/skbuff.cif(skb->magic_debug_cookie == SK_GOOD_SKB)
skb414net/core/skbuff.cprintk("Kernel kmalloc handed us an existing skb (%p)\n",skb);
skb419net/core/skbuff.cskb->free = 2;  /* Invalid so we pick up forgetful users */
skb420net/core/skbuff.cskb->lock = 0;
skb421net/core/skbuff.cskb->pkt_type = PACKET_HOST;  /* Default type */
skb422net/core/skbuff.cskb->truesize = size;
skb423net/core/skbuff.cskb->mem_len = size;
skb424net/core/skbuff.cskb->mem_addr = skb;
skb426net/core/skbuff.cskb->in_dev_queue = 0;
skb428net/core/skbuff.cskb->fraglist = NULL;
skb429net/core/skbuff.cskb->prev = skb->next = NULL;
skb430net/core/skbuff.cskb->link3 = NULL;
skb431net/core/skbuff.cskb->sk = NULL;
skb432net/core/skbuff.cskb->localroute=0;
skb433net/core/skbuff.cskb->stamp.tv_sec=0;  /* No idea about time */
skb434net/core/skbuff.cskb->localroute = 0;
skb441net/core/skbuff.cskb->magic_debug_cookie = SK_GOOD_SKB;
skb443net/core/skbuff.cskb->users = 0;
skb444net/core/skbuff.creturn skb;
skb451net/core/skbuff.cvoid kfree_skbmem(struct sk_buff *skb,unsigned size)
skb457net/core/skbuff.cif(skb->in_dev_queue && skb->dev!=NULL)
skb458net/core/skbuff.cskb->dev->pkt_queue--;
skb462net/core/skbuff.cIS_SKB(skb);
skb463net/core/skbuff.cif(size!=skb->truesize)
skb466net/core/skbuff.cif(skb->magic_debug_cookie == SK_GOOD_SKB)
skb470net/core/skbuff.cIS_SKB(skb);
skb471net/core/skbuff.cskb->magic_debug_cookie = SK_FREED_SKB;
skb472net/core/skbuff.ckfree_s((void *)skb,size);
skb482net/core/skbuff.ckfree_s((void *)skb,size);
skb494net/core/skbuff.cstruct sk_buff *skb_clone(struct sk_buff *skb, int priority)
skb499net/core/skbuff.cn=alloc_skb(skb->mem_len-sizeof(struct sk_buff),priority);
skb503net/core/skbuff.coffset=((char *)n)-((char *)skb);
skb505net/core/skbuff.cmemcpy(n->data,skb->data,skb->mem_len-sizeof(struct sk_buff));
skb506net/core/skbuff.cn->len=skb->len;
skb509net/core/skbuff.cn->when=skb->when;
skb510net/core/skbuff.cn->dev=skb->dev;
skb511net/core/skbuff.cn->h.raw=skb->h.raw+offset;
skb512net/core/skbuff.cn->ip_hdr=(struct iphdr *)(((char *)skb->ip_hdr)+offset);
skb513net/core/skbuff.cn->fraglen=skb->fraglen;
skb514net/core/skbuff.cn->fraglist=skb->fraglist;
skb515net/core/skbuff.cn->saddr=skb->saddr;
skb516net/core/skbuff.cn->daddr=skb->daddr;
skb517net/core/skbuff.cn->raddr=skb->raddr;
skb518net/core/skbuff.cn->acked=skb->acked;
skb519net/core/skbuff.cn->used=skb->used;
skb521net/core/skbuff.cn->arp=skb->arp;
skb525net/core/skbuff.cn->pkt_type=skb->pkt_type;
skb526net/core/skbuff.cn->stamp=skb->stamp;
skb535net/core/skbuff.cvoid skb_device_lock(struct sk_buff *skb)
skb537net/core/skbuff.cif(skb->lock)
skb541net/core/skbuff.cskb->lock++;
skb544net/core/skbuff.cvoid skb_device_unlock(struct sk_buff *skb)
skb546net/core/skbuff.cif(skb->lock==0)
skb548net/core/skbuff.cskb->lock--;
skb549net/core/skbuff.cif(skb->lock==0)
skb553net/core/skbuff.cvoid dev_kfree_skb(struct sk_buff *skb, int mode)
skb559net/core/skbuff.cif(skb->lock==1)
skb562net/core/skbuff.cif (!--skb->lock && (skb->free == 1 || skb->free == 3))
skb565net/core/skbuff.ckfree_skb(skb,mode);
skb571net/core/skbuff.cint skb_device_locked(struct sk_buff *skb)
skb573net/core/skbuff.creturn skb->lock? 1 : 0;
skb382net/core/sock.cvoid sock_wfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
skb385net/core/sock.cIS_SKB(skb);
skb387net/core/sock.ckfree_skbmem(skb, size);
skb402net/core/sock.cvoid sock_rfree(struct sock *sk, struct sk_buff *skb, unsigned long size)
skb405net/core/sock.cIS_SKB(skb);
skb407net/core/sock.ckfree_skbmem(skb, size);
skb424net/core/sock.cstruct sk_buff *skb;
skb447net/core/sock.cskb = sock_wmalloc(sk, size, 0, GFP_KERNEL);
skb449net/core/sock.cif(skb==NULL)
skb487net/core/sock.cwhile(skb==NULL);
skb489net/core/sock.creturn skb;
skb497net/core/sock.cstruct sk_buff *skb;
skb521net/core/sock.cwhile((skb = skb_dequeue(&sk->back_log)) != NULL) 
skb525net/core/sock.csk->prot->rcv(skb, skb->dev, sk->opt,
skb526net/core/sock.cskb->saddr, skb->len, skb->daddr, 1,
skb86net/ethernet/eth.cstruct sk_buff *skb)
skb136net/ethernet/eth.cstruct sk_buff *skb)
skb155net/ethernet/eth.creturn arp_find(eth->h_dest, dst, dev, dev->pa_addr, skb)? 1 : 0;
skb168net/ethernet/eth.cunsigned short eth_type_trans(struct sk_buff *skb, struct device *dev)
skb170net/ethernet/eth.cstruct ethhdr *eth = (struct ethhdr *) skb->data;
skb176net/ethernet/eth.cskb->pkt_type=PACKET_BROADCAST;
skb178net/ethernet/eth.cskb->pkt_type=PACKET_MULTICAST;
skb184net/ethernet/eth.cskb->pkt_type=PACKET_OTHERHOST;
skb9net/ethernet/pe2.cstruct sk_buff *skb, unsigned char *dest_node)
skb11net/ethernet/pe2.cstruct device  *dev = skb->dev;
skb12net/ethernet/pe2.cunsigned long  len = skb->len;
skb15net/ethernet/pe2.cdev->hard_header(skb->data, dev, ETH_P_IPX,
skb16net/ethernet/pe2.cdest_node, NULL, len - hard_len, skb);
skb17net/ethernet/pe2.cskb->h.raw = skb->data + hard_len;
skb282net/ipv4/af_inet.cstruct sk_buff *skb;
skb297net/ipv4/af_inet.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL) {
skb298net/ipv4/af_inet.cIS_SKB(skb);
skb299net/ipv4/af_inet.ckfree_skb(skb, FREE_WRITE);
skb303net/ipv4/af_inet.cwhile((skb = skb_dequeue(&sk->write_queue)) != NULL) {
skb304net/ipv4/af_inet.cIS_SKB(skb);
skb305net/ipv4/af_inet.ckfree_skb(skb, FREE_WRITE);
skb315net/ipv4/af_inet.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) 
skb321net/ipv4/af_inet.cif (skb->sk != NULL && skb->sk != sk) 
skb323net/ipv4/af_inet.cIS_SKB(skb);
skb324net/ipv4/af_inet.cskb->sk->dead = 1;
skb325net/ipv4/af_inet.cskb->sk->prot->close(skb->sk, 0);
skb327net/ipv4/af_inet.cIS_SKB(skb);
skb328net/ipv4/af_inet.ckfree_skb(skb, FREE_READ);
skb334net/ipv4/af_inet.cfor(skb = sk->send_head; skb != NULL; )
skb342net/ipv4/af_inet.cif (skb->next  && skb->prev) {
skb344net/ipv4/af_inet.cIS_SKB(skb);
skb345net/ipv4/af_inet.cskb_unlink(skb);
skb347net/ipv4/af_inet.cskb->dev = NULL;
skb348net/ipv4/af_inet.cskb2 = skb->link3;
skb349net/ipv4/af_inet.ckfree_skb(skb, FREE_WRITE);
skb350net/ipv4/af_inet.cskb = skb2;
skb356net/ipv4/af_inet.cwhile((skb=skb_dequeue(&sk->back_log))!=NULL) 
skb360net/ipv4/af_inet.ckfree_skb(skb, FREE_READ);
skb102net/ipv4/arp.cstruct sk_buff_head    skb;      /* list of queued packets   */
skb246net/ipv4/arp.cstruct sk_buff *skb;
skb252net/ipv4/arp.cwhile ((skb = skb_dequeue(&entry->skb)) != NULL)
skb254net/ipv4/arp.cskb_device_lock(skb);
skb256net/ipv4/arp.cdev_kfree_skb(skb, FREE_WRITE);
skb314net/ipv4/arp.cstruct sk_buff *skb;
skb329net/ipv4/arp.cskb = alloc_skb(sizeof(struct arphdr)+ 2*(dev->addr_len+4)
skb331net/ipv4/arp.cif (skb == NULL)
skb336net/ipv4/arp.cskb->len = sizeof(struct arphdr) + dev->hard_header_len + 2*(dev->addr_len+4);
skb337net/ipv4/arp.cskb->arp = 1;
skb338net/ipv4/arp.cskb->dev = dev;
skb339net/ipv4/arp.cskb->free = 1;
skb345net/ipv4/arp.cdev->hard_header(skb->data,dev,ptype,dest_hw?dest_hw:dev->broadcast,src_hw?src_hw:NULL,skb->len,skb);
skb348net/ipv4/arp.carp = (struct arphdr *) (skb->data + dev->hard_header_len);
skb376net/ipv4/arp.cdev_queue_xmit(skb, dev, 0);
skb465net/ipv4/arp.cstruct sk_buff *skb;
skb483net/ipv4/arp.cwhile((skb = skb_dequeue(&entry->skb)) != NULL)
skb485net/ipv4/arp.cIS_SKB(skb);
skb486net/ipv4/arp.cskb_device_lock(skb);
skb488net/ipv4/arp.cif(!skb->dev->rebuild_header(skb->data,skb->dev,skb->raddr,skb))
skb490net/ipv4/arp.cskb->arp  = 1;
skb491net/ipv4/arp.cif(skb->sk==NULL)
skb492net/ipv4/arp.cdev_queue_xmit(skb, skb->dev, 0);
skb494net/ipv4/arp.cdev_queue_xmit(skb,skb->dev,skb->sk->priority);
skb502net/ipv4/arp.cprintk("arp_send_q: failed to find %s\n",in_ntoa(skb->raddr));
skb561net/ipv4/arp.cint arp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb567net/ipv4/arp.cstruct arphdr *arp = (struct arphdr *)skb->h.raw;
skb589net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb605net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb614net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb623net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb631net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb638net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb662net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb692net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb737net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb743net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb809net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb821net/ipv4/arp.centry->dev = skb->dev;
skb822net/ipv4/arp.cskb_queue_head_init(&entry->skb);
skb831net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb841net/ipv4/arp.cunsigned long saddr, struct sk_buff *skb)
skb854net/ipv4/arp.cskb->arp = 1;
skb878net/ipv4/arp.cskb->arp = 1;
skb899net/ipv4/arp.cif (skb != NULL)
skb901net/ipv4/arp.cskb_queue_tail(&entry->skb, skb);
skb902net/ipv4/arp.cskb_device_unlock(skb);
skb914net/ipv4/arp.cif (skb)
skb915net/ipv4/arp.cskb->arp = 1;
skb944net/ipv4/arp.cskb_queue_head_init(&entry->skb);
skb945net/ipv4/arp.cif (skb != NULL)
skb947net/ipv4/arp.cskb_queue_tail(&entry->skb, skb);
skb948net/ipv4/arp.cskb_device_unlock(skb);
skb953net/ipv4/arp.cif (skb != NULL && skb->free)
skb954net/ipv4/arp.ckfree_skb(skb, FREE_WRITE);
skb1244net/ipv4/arp.cskb_queue_head_init(&entry->skb);
skb102net/ipv4/icmp.cstruct sk_buff *skb;
skb216net/ipv4/icmp.cskb = (struct sk_buff *) alloc_skb(len, GFP_ATOMIC);
skb217net/ipv4/icmp.cif (skb == NULL) 
skb222net/ipv4/icmp.cskb->free = 1;
skb231net/ipv4/icmp.coffset = ip_build_header(skb, our_addr, iph->saddr,
skb237net/ipv4/icmp.cskb->sk = NULL;
skb238net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb246net/ipv4/icmp.cskb->len = offset + sizeof(struct icmphdr) + sizeof(struct iphdr) + 8;
skb252net/ipv4/icmp.cicmph = (struct icmphdr *) (skb->data + offset);
skb267net/ipv4/icmp.cip_queue_xmit(NULL, ndev, skb, 1);
skb275net/ipv4/icmp.cstatic void icmp_unreach(struct icmphdr *icmph, struct sk_buff *skb)
skb342net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb350net/ipv4/icmp.cstatic void icmp_redirect(struct icmphdr *icmph, struct sk_buff *skb,
skb415net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb423net/ipv4/icmp.cstatic void icmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb441net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb448net/ipv4/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
skb454net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb483net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb490net/ipv4/icmp.cstatic void icmp_timestamp(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb515net/ipv4/icmp.cskb->sk = NULL;
skb516net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb527net/ipv4/icmp.cskb->ip_hdr->tos, 255);
skb532net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb567net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb577net/ipv4/icmp.cstatic void icmp_info(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb582net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb590net/ipv4/icmp.cstatic void icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
skb607net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb617net/ipv4/icmp.cIPPROTO_ICMP, opt, len, skb->ip_hdr->tos,255);
skb623net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb650net/ipv4/icmp.cskb->sk = NULL;
skb651net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb85net/ipv4/igmp.cstruct sk_buff *skb=alloc_skb(MAX_IGMP_SIZE, GFP_ATOMIC);
skb89net/ipv4/igmp.cif(skb==NULL)
skb91net/ipv4/igmp.ctmp=ip_build_header(skb, INADDR_ANY, address, &dev, IPPROTO_IGMP, NULL,
skb92net/ipv4/igmp.cskb->mem_len, 0, 1);
skb95net/ipv4/igmp.ckfree_skb(skb, FREE_WRITE);
skb98net/ipv4/igmp.cdp=skb->data+tmp;
skb99net/ipv4/igmp.cskb->len=tmp+sizeof(struct igmphdr);
skb103net/ipv4/igmp.cskb->h.raw=dp;
skb106net/ipv4/igmp.cimp_putn16(skb->h.raw,ip_compute_csum(skb->data+tmp,sizeof(struct igmphdr)));  /* Checksum fill */
skb107net/ipv4/igmp.cip_queue_xmit(NULL,dev,skb,1);
skb202net/ipv4/igmp.cint igmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb210net/ipv4/igmp.cigmp_explode(skb->h.raw,&igh);
skb212net/ipv4/igmp.cif(skb->len <sizeof(struct igmphdr) || skb->ip_hdr->ttl!=1 || ip_compute_csum((void *)skb->h.raw,sizeof(struct igmphdr)))
skb214net/ipv4/igmp.ckfree_skb(skb, FREE_READ);
skb222net/ipv4/igmp.ckfree_skb(skb, FREE_READ);
skb176net/ipv4/ip.cstatic int ip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev, unsigned long saddr)
skb180net/ipv4/ip.cskb->dev = dev;
skb181net/ipv4/ip.cskb->arp = 1;
skb188net/ipv4/ip.cmac = dev->hard_header(skb->data, dev, ETH_P_IP, NULL, NULL, len, skb);
skb192net/ipv4/ip.cskb->arp = 0;
skb193net/ipv4/ip.cskb->raddr = daddr;  /* next routing address */
skb207net/ipv4/ip.cint ip_build_header(struct sk_buff *skb, unsigned long saddr, unsigned long daddr,
skb217net/ipv4/ip.cbuff = skb->data;
skb224net/ipv4/ip.cif(MULTICAST(daddr) && *dev==NULL && skb->sk && *skb->sk->ip_mc_name)
skb225net/ipv4/ip.c*dev=dev_get(skb->sk->ip_mc_name);
skb229net/ipv4/ip.cif(skb->localroute)
skb254net/ipv4/ip.cif(skb->localroute)
skb284net/ipv4/ip.ctmp = ip_send(skb, raddr, len, *dev, saddr);
skb292net/ipv4/ip.cskb->dev = *dev;
skb293net/ipv4/ip.cskb->saddr = saddr;
skb294net/ipv4/ip.cif (skb->sk)
skb295net/ipv4/ip.cskb->sk->saddr = saddr;
skb323net/ipv4/ip.cskb->ip_hdr   = iph;
skb353net/ipv4/ip.cstatic struct ipfrag *ip_frag_create(int offset, int end, struct sk_buff *skb, unsigned char *ptr)
skb369net/ipv4/ip.cfp->skb = skb;
skb441net/ipv4/ip.cIS_SKB(fp->skb);
skb442net/ipv4/ip.ckfree_skb(fp->skb,FREE_READ);
skb477net/ipv4/ip.cicmp_send(qp->fragments->skb,ICMP_TIME_EXCEEDED,
skb494net/ipv4/ip.cstatic struct ipq *ip_create(struct sk_buff *skb, struct iphdr *iph, struct device *dev)
skb505net/ipv4/ip.cskb->dev = qp->dev;
skb516net/ipv4/ip.cmaclen = ((unsigned long) iph) - ((unsigned long) skb->data);
skb540net/ipv4/ip.cmemcpy(qp->mac, skb->data, maclen);
skb606net/ipv4/ip.cstruct sk_buff *skb;
skb618net/ipv4/ip.cif ((skb = alloc_skb(len,GFP_ATOMIC)) == NULL)
skb627net/ipv4/ip.cskb->len = (len - qp->maclen);
skb628net/ipv4/ip.cskb->h.raw = skb->data;
skb629net/ipv4/ip.cskb->free = 1;
skb632net/ipv4/ip.cptr = (unsigned char *) skb->h.raw;
skb637net/ipv4/ip.cskb->h.raw += qp->maclen;
skb645net/ipv4/ip.cif(count+fp->len > skb->len)
skb649net/ipv4/ip.ckfree_skb(skb,FREE_WRITE);
skb662net/ipv4/ip.ciph = skb->h.iph;
skb665net/ipv4/ip.cskb->ip_hdr = iph;
skb668net/ipv4/ip.creturn(skb);
skb676net/ipv4/ip.cstatic struct sk_buff *ip_defrag(struct iphdr *iph, struct sk_buff *skb, struct device *dev)
skb699net/ipv4/ip.creturn(skb);
skb723net/ipv4/ip.cif ((qp = ip_create(skb, iph, dev)) == NULL)
skb725net/ipv4/ip.cskb->sk = NULL;
skb726net/ipv4/ip.ckfree_skb(skb, FREE_READ);
skb743net/ipv4/ip.cptr = skb->data + dev->hard_header_len + ihl;
skb809net/ipv4/ip.ckfree_skb(tmp->skb,FREE_READ);
skb819net/ipv4/ip.ctfp = ip_frag_create(offset, end, skb, ptr);
skb827net/ipv4/ip.cskb->sk = NULL;
skb828net/ipv4/ip.ckfree_skb(skb, FREE_READ);
skb869net/ipv4/ip.cvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
skb883net/ipv4/ip.craw = skb->data;
skb886net/ipv4/ip.cskb->ip_hdr = iph;
skb908net/ipv4/ip.cicmp_send(skb,ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, dev->mtu, dev);
skb921net/ipv4/ip.cicmp_send(skb,ICMP_DEST_UNREACH,ICMP_FRAG_NEEDED,dev->mtu, dev);
skb973net/ipv4/ip.cskb2->arp = skb->arp;
skb974net/ipv4/ip.cif(skb->free==0)
skb992net/ipv4/ip.cskb2->raddr = skb->raddr;  /* For rebuild_header - must be here */
skb1041net/ipv4/ip.cvoid ip_forward(struct sk_buff *skb, struct device *dev, int is_frag, unsigned long target_addr, int target_strict)
skb1058net/ipv4/ip.cif(!(is_frag&4) && (fw_res=ip_fw_chk(skb->h.iph, dev, ip_fw_fwd_chain, ip_fw_fwd_policy, 0))!=1)
skb1061net/ipv4/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, dev);
skb1076net/ipv4/ip.ciph = skb->h.iph;
skb1093net/ipv4/ip.cicmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, 0, dev);
skb1109net/ipv4/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, 0, dev);
skb1132net/ipv4/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_SR_FAILED, 0, dev);
skb1133net/ipv4/ip.ckfree_skb(skb, FREE_READ);
skb1148net/ipv4/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, dev);
skb1170net/ipv4/ip.cicmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, raddr, dev);
skb1186net/ipv4/ip.cip_fw_masquerade(&skb, dev2);
skb1195net/ipv4/ip.cskb2 = alloc_skb(dev2->hard_header_len + skb->len, GFP_ATOMIC);
skb1207net/ipv4/ip.cskb2->len = skb->len + dev2->hard_header_len;
skb1213net/ipv4/ip.cmemcpy(ptr + dev2->hard_header_len, skb->h.raw, skb->len);
skb1216net/ipv4/ip.c(void) ip_send(skb2, raddr, skb->len, dev2, dev2->pa_addr);
skb1263net/ipv4/ip.cint ip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb1265net/ipv4/ip.cstruct iphdr *iph = skb->h.iph;
skb1284net/ipv4/ip.cskb->ip_hdr = iph;
skb1299net/ipv4/ip.cif (skb->len<sizeof(struct iphdr) || iph->ihl<5 || iph->version != 4 || ip_fast_csum((unsigned char *)iph, iph->ihl) !=0
skb1300net/ipv4/ip.c|| skb->len < ntohs(iph->tot_len))
skb1303net/ipv4/ip.ckfree_skb(skb, FREE_WRITE);
skb1312net/ipv4/ip.cskb->len=ntohs(iph->tot_len);
skb1323net/ipv4/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);
skb1324net/ipv4/ip.ckfree_skb(skb, FREE_WRITE);
skb1352net/ipv4/ip.cunsigned char *opt_ptr=skb->h.raw+sizeof(struct iphdr);
skb1369net/ipv4/ip.cicmp_send(skb, ICMP_PARAMETERPROB, 0, 0, skb->dev);
skb1370net/ipv4/ip.ckfree_skb(skb, FREE_READ);
skb1383net/ipv4/ip.ckfree_skb(skb, FREE_READ);
skb1390net/ipv4/ip.cif (iph->daddr!=skb->dev->pa_addr && (brd = ip_chk_addr(iph->daddr)) == 0) 
skb1395net/ipv4/ip.cicmp_send(skb, ICMP_PARAMETERPROB, 0, 0, skb->dev);
skb1396net/ipv4/ip.ckfree_skb(skb, FREE_READ);
skb1411net/ipv4/ip.cicmp_send(skb, ICMP_PARAMETERPROB, 0, 0, skb->dev);
skb1412net/ipv4/ip.ckfree_skb(skb,FREE_READ);
skb1416net/ipv4/ip.c*(long *)(&opt_ptr[opt_ptr[2]])=skb->dev->pa_addr;  /* Record hop */
skb1463net/ipv4/ip.cif ( iph->daddr == skb->dev->pa_addr || (brd = ip_chk_addr(iph->daddr)) != 0)
skb1477net/ipv4/ip.ckfree_skb(skb, FREE_WRITE);
skb1492net/ipv4/ip.cif (ip_fw_demasquerade(skb)) 
skb1494net/ipv4/ip.cstruct iphdr *iph=skb->h.iph;
skb1495net/ipv4/ip.cip_forward(skb, dev, is_frag|4, iph->daddr, 0);
skb1496net/ipv4/ip.ckfree_skb(skb, FREE_WRITE);
skb1516net/ipv4/ip.cskb=ip_defrag(iph,skb,dev);
skb1517net/ipv4/ip.cif(skb==NULL)
skb1519net/ipv4/ip.cskb->dev = dev;
skb1520net/ipv4/ip.ciph=skb->h.iph;
skb1527net/ipv4/ip.cskb->ip_hdr = iph;
skb1528net/ipv4/ip.cskb->h.raw += iph->ihl*4;
skb1554net/ipv4/ip.cskb1=skb_clone(skb, GFP_ATOMIC);
skb1593net/ipv4/ip.cskb2 = skb_clone(skb, GFP_ATOMIC);
skb1599net/ipv4/ip.cskb2 = skb;
skb1623net/ipv4/ip.craw_rcv(raw_sk, skb, dev, iph->saddr, iph->daddr);
skb1627net/ipv4/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, 0, dev);  
skb1628net/ipv4/ip.ckfree_skb(skb, FREE_WRITE);
skb1650net/ipv4/ip.cif(skb->pkt_type!=PACKET_HOST || brd==IS_BROADCAST)
skb1652net/ipv4/ip.ckfree_skb(skb,FREE_WRITE);
skb1661net/ipv4/ip.cip_forward(skb, dev, is_frag, target_addr, target_strict);
skb1672net/ipv4/ip.ckfree_skb(skb, FREE_WRITE);
skb1681net/ipv4/ip.cstatic void ip_loopback(struct device *old_dev, struct sk_buff *skb)
skb1685net/ipv4/ip.cint len=skb->len-old_dev->hard_header_len;
skb1694net/ipv4/ip.cnewskb->saddr=skb->saddr;
skb1695net/ipv4/ip.cnewskb->daddr=skb->daddr;
skb1696net/ipv4/ip.cnewskb->raddr=skb->raddr;
skb1700net/ipv4/ip.cnewskb->pkt_type=skb->pkt_type;
skb1704net/ipv4/ip.cnewskb->ip_hdr=(struct iphdr *)(newskb->data+ip_send(newskb, skb->ip_hdr->daddr, len, dev, skb->ip_hdr->saddr));
skb1705net/ipv4/ip.cmemcpy(newskb->ip_hdr,skb->ip_hdr,len);
skb1724net/ipv4/ip.cstruct sk_buff *skb, int free)
skb1736net/ipv4/ip.cIS_SKB(skb);
skb1743net/ipv4/ip.cskb->dev = dev;
skb1744net/ipv4/ip.cskb->when = jiffies;
skb1754net/ipv4/ip.cptr = skb->data;
skb1757net/ipv4/ip.cskb->ip_hdr = iph;
skb1758net/ipv4/ip.ciph->tot_len = ntohs(skb->len-dev->hard_header_len);
skb1779net/ipv4/ip.cskb->free = free;
skb1787net/ipv4/ip.cif(skb->len > dev->mtu + dev->hard_header_len)
skb1789net/ipv4/ip.cip_fragment(sk,skb,dev,0);
skb1790net/ipv4/ip.cIS_SKB(skb);
skb1791net/ipv4/ip.ckfree_skb(skb,FREE_WRITE);
skb1809net/ipv4/ip.cif (skb->next != NULL)
skb1812net/ipv4/ip.cskb_unlink(skb);
skb1833net/ipv4/ip.cif (skb->link3 != NULL)
skb1836net/ipv4/ip.cskb->link3 = NULL;
skb1840net/ipv4/ip.csk->send_tail = skb;
skb1841net/ipv4/ip.csk->send_head = skb;
skb1845net/ipv4/ip.csk->send_tail->link3 = skb;
skb1846net/ipv4/ip.csk->send_tail = skb;
skb1855net/ipv4/ip.cskb->sk = sk;
skb1877net/ipv4/ip.cip_loopback(dev,skb);
skb1885net/ipv4/ip.cip_loopback(dev,skb);
skb1894net/ipv4/ip.cif(skb->ip_hdr->ttl==0)
skb1896net/ipv4/ip.ckfree_skb(skb, FREE_READ);
skb1902net/ipv4/ip.cip_loopback(dev,skb);
skb1913net/ipv4/ip.cdev_queue_xmit(skb, dev, sk->priority);
skb1917net/ipv4/ip.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb1924net/ipv4/ip.ckfree_skb(skb, FREE_WRITE);
skb2355net/ipv4/ip.cdev=dev_get(skb->ip_mc_name);
skb2483net/ipv4/ip.cstruct sk_buff * skb;
skb2491net/ipv4/ip.cskb = sock_alloc_send_skb(sk, fraglen, 0, &error);
skb2492net/ipv4/ip.cif (skb == NULL)
skb2499net/ipv4/ip.cskb->next = skb->prev = NULL;
skb2500net/ipv4/ip.cskb->dev = dev;
skb2501net/ipv4/ip.cskb->when = jiffies;
skb2502net/ipv4/ip.cskb->free = 1; /* dubious, this one */
skb2503net/ipv4/ip.cskb->sk = sk;
skb2504net/ipv4/ip.cskb->arp = 0;
skb2505net/ipv4/ip.cskb->saddr = saddr;
skb2506net/ipv4/ip.cskb->raddr = (rt&&rt->rt_gateway) ? rt->rt_gateway : daddr;
skb2507net/ipv4/ip.cskb->len = fraglen;
skb2518net/ipv4/ip.cmemcpy(skb->data,sk->ip_hcache_data, dev->hard_header_len);
skb2519net/ipv4/ip.cskb->arp=1;
skb2523net/ipv4/ip.cif(dev->hard_header(skb->data, dev, ETH_P_IP, 
skb2525net/ipv4/ip.cskb->arp=1;
skb2532net/ipv4/ip.cdata = (char *)skb->data + dev->hard_header_len;
skb2601net/ipv4/ip.cif(skb->daddr==IGMP_ALL_HOSTS)
skb2602net/ipv4/ip.cip_loopback(rt->rt_dev,skb);
skb2610net/ipv4/ip.cip_loopback(rt->rt_dev,skb);
skb2623net/ipv4/ip.cif(skb->ip_hdr->ttl==0)
skb2624net/ipv4/ip.ckfree_skb(skb, FREE_READ);
skb2633net/ipv4/ip.cdev_queue_xmit(skb, dev, sk->priority);
skb2646net/ipv4/ip.ckfree_skb(skb, FREE_WRITE);
skb518net/ipv4/ip_fw.cstatic struct sk_buff *revamp(struct sk_buff *skb, struct device *dev, struct ip_masq *ftp)
skb520net/ipv4/ip_fw.cstruct iphdr *iph = skb->h.iph;
skb540net/ipv4/ip_fw.cwhile (skb->len - ((unsigned char *)data - skb->h.raw) > 18)
skb576net/ipv4/ip_fw.creturn skb;
skb605net/ipv4/ip_fw.creturn skb;
skb611net/ipv4/ip_fw.cprintk("MASQUERADE: resizing needed for %d bytes (%ld)\n",ftp->delta, skb->len);
skb615net/ipv4/ip_fw.cskb2 = alloc_skb(skb->mem_len-sizeof(struct sk_buff)+ftp->delta, GFP_ATOMIC);
skb618net/ipv4/ip_fw.creturn skb;
skb620net/ipv4/ip_fw.cskb2->free = skb->free;
skb621net/ipv4/ip_fw.cskb2->len = skb->len + ftp->delta;
skb622net/ipv4/ip_fw.cskb2->h.raw = &skb2->data[skb->h.raw - skb->data];
skb628net/ipv4/ip_fw.cmemcpy(skb2->data, skb->data, (p - (char *)skb->data));
skb629net/ipv4/ip_fw.cmemcpy(&skb2->data[(p - (char *)skb->data)], buf, strlen(buf));
skb630net/ipv4/ip_fw.cmemcpy(&skb2->data[(p - (char *)skb->data) + strlen(buf)], data,
skb631net/ipv4/ip_fw.cskb->mem_len - sizeof(struct sk_buff) - ((char *)skb->h.raw - data));
skb638net/ipv4/ip_fw.ckfree_skb(skb, FREE_WRITE);
skb641net/ipv4/ip_fw.creturn skb;
skb656net/ipv4/ip_fw.cstruct sk_buff  *skb=*skb_ptr;
skb657net/ipv4/ip_fw.cstruct iphdr  *iph = skb->h.iph;
skb717net/ipv4/ip_fw.csize = skb->len - ((unsigned char *)portptr - skb->h.raw);
skb735net/ipv4/ip_fw.cskb = revamp(*skb_ptr, dev, ms);
skb736net/ipv4/ip_fw.cskb = *skb_ptr;
skb737net/ipv4/ip_fw.ciph = skb->h.iph;
skb752net/ipv4/ip_fw.ctcp_send_check(th,iph->saddr,iph->daddr,size,skb->sk);
skb50net/ipv4/ipip.cint ipip_rcv(struct sk_buff *skb, struct device *dev, struct options *opt, 
skb59net/ipv4/ipip.cip_forward(skb, dev, 0, daddr, 0);
skb60net/ipv4/ipip.ckfree_skb(skb, FREE_READ);
skb72net/ipv4/packet.cint packet_rcv(struct sk_buff *skb, struct device *dev,  struct packet_type *pt)
skb90net/ipv4/packet.cskb->dev = dev;
skb91net/ipv4/packet.cskb->len += dev->hard_header_len;
skb103net/ipv4/packet.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
skb106net/ipv4/packet.cskb->sk = NULL;
skb107net/ipv4/packet.ckfree_skb(skb, FREE_READ);
skb114net/ipv4/packet.cskb->sk = sk;
skb115net/ipv4/packet.csk->rmem_alloc += skb->mem_len;  
skb121net/ipv4/packet.cskb_queue_tail(&sk->receive_queue,skb);
skb123net/ipv4/packet.csk->data_ready(sk,skb->len);
skb144net/ipv4/packet.cstruct sk_buff *skb;
skb186net/ipv4/packet.cskb = sk->prot->wmalloc(sk, len, 0, GFP_KERNEL);
skb193net/ipv4/packet.cif (skb == NULL) 
skb202net/ipv4/packet.cskb->sk = sk;
skb203net/ipv4/packet.cskb->free = 1;
skb204net/ipv4/packet.cmemcpy_fromfs(skb->data, from, len);
skb205net/ipv4/packet.cskb->len = len;
skb206net/ipv4/packet.cskb->arp = 1;    /* No ARP needs doing on this (complete) frame */
skb213net/ipv4/packet.cdev_queue_xmit(skb, dev, sk->priority);
skb215net/ipv4/packet.ckfree_skb(skb, FREE_WRITE);
skb289net/ipv4/packet.cstruct sk_buff *skb;
skb313net/ipv4/packet.cskb=skb_recv_datagram(sk,flags,noblock,&err);
skb321net/ipv4/packet.cif(skb==NULL)
skb329net/ipv4/packet.ctruesize = skb->len;
skb332net/ipv4/packet.cmemcpy_tofs(to, skb->data, copied);  /* We can't use skb_copy_datagram here */
skb333net/ipv4/packet.csk->stamp=skb->stamp;
skb341net/ipv4/packet.csaddr->sa_family = skb->dev->type;
skb342net/ipv4/packet.cmemcpy(saddr->sa_data,skb->dev->name, 14);
skb350net/ipv4/packet.cskb_free_datagram(skb);
skb143net/ipv4/rarp.cint rarp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb148net/ipv4/rarp.cstruct arphdr *rarp = (struct arphdr *)skb->h.raw;
skb161net/ipv4/rarp.ckfree_skb(skb, FREE_READ);
skb170net/ipv4/rarp.ckfree_skb(skb, FREE_READ);
skb188net/ipv4/rarp.ckfree_skb(skb, FREE_READ);
skb224net/ipv4/rarp.ckfree_skb(skb, FREE_READ);
skb97net/ipv4/raw.cint raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, long saddr, long daddr)
skb100net/ipv4/raw.cskb->sk = sk;
skb101net/ipv4/raw.cskb->len = ntohs(skb->ip_hdr->tot_len);
skb102net/ipv4/raw.cskb->h.raw = (unsigned char *) skb->ip_hdr;
skb103net/ipv4/raw.cskb->dev = dev;
skb104net/ipv4/raw.cskb->saddr = daddr;
skb105net/ipv4/raw.cskb->daddr = saddr;
skb109net/ipv4/raw.cif(sock_queue_rcv_skb(sk,skb)<0)
skb112net/ipv4/raw.cskb->sk=NULL;
skb113net/ipv4/raw.ckfree_skb(skb, FREE_READ);
skb239net/ipv4/raw.cstruct sk_buff *skb;
skb252net/ipv4/raw.cskb=skb_recv_datagram(sk,flags,noblock,&err);
skb253net/ipv4/raw.cif(skb==NULL)
skb256net/ipv4/raw.ctruesize=skb->len;
skb259net/ipv4/raw.cskb_copy_datagram(skb, 0, to, copied);
skb260net/ipv4/raw.csk->stamp=skb->stamp;
skb266net/ipv4/raw.csin->sin_addr.s_addr = skb->daddr;
skb268net/ipv4/raw.cskb_free_datagram(skb);
skb383net/ipv4/tcp.cstruct sk_buff *skb;
skb387net/ipv4/tcp.cskb=tcp_find_established(s);
skb388net/ipv4/tcp.cif(skb!=NULL)
skb389net/ipv4/tcp.cskb_unlink(skb);  /* Take it off the queue */
skb391net/ipv4/tcp.creturn skb;
skb402net/ipv4/tcp.cstruct sk_buff *skb;
skb404net/ipv4/tcp.cwhile ((skb = skb_dequeue(&sk->receive_queue)) != NULL) 
skb406net/ipv4/tcp.cskb->sk->dead=1;
skb407net/ipv4/tcp.ctcp_close(skb->sk, 0);
skb408net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb433net/ipv4/tcp.cstruct sk_buff * skb;
skb439net/ipv4/tcp.cskb = sk->send_head;
skb441net/ipv4/tcp.cwhile (skb != NULL)
skb447net/ipv4/tcp.cdev = skb->dev;
skb448net/ipv4/tcp.cIS_SKB(skb);
skb449net/ipv4/tcp.cskb->when = jiffies;
skb460net/ipv4/tcp.ciph = (struct iphdr *)(skb->data + dev->hard_header_len);
skb462net/ipv4/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
skb504net/ipv4/tcp.cif (sk && !skb_device_locked(skb))
skb507net/ipv4/tcp.cskb_unlink(skb);
skb510net/ipv4/tcp.cdev_queue_xmit(skb, dev, sk->priority);
skb534net/ipv4/tcp.cskb = skb->link3;
skb719net/ipv4/tcp.cstruct sk_buff *skb;
skb724net/ipv4/tcp.cskb = sk->send_head;
skb725net/ipv4/tcp.cif (!skb) 
skb735net/ipv4/tcp.cif (jiffies < skb->when + sk->rto) 
skb737net/ipv4/tcp.creset_xmit_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies);
skb846net/ipv4/tcp.cstruct sk_buff *skb;
skb855net/ipv4/tcp.cif (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
skb872net/ipv4/tcp.cif (before(counted, skb->h.th->seq))   /* Found a hole so stops here */
skb874net/ipv4/tcp.csum = skb->len -(counted - skb->h.th->seq);  /* Length - header but start from where we are up to (avoid overlaps) */
skb875net/ipv4/tcp.cif (skb->h.th->syn)
skb880net/ipv4/tcp.cif (skb->h.th->syn) 
skb900net/ipv4/tcp.cif (skb->h.th->urg)
skb902net/ipv4/tcp.cif (amount && skb->h.th->psh) break;
skb903net/ipv4/tcp.cskb = skb->next;
skb905net/ipv4/tcp.cwhile(skb != (struct sk_buff *)&sk->receive_queue);
skb1073net/ipv4/tcp.cstatic void tcp_send_skb(struct sock *sk, struct sk_buff *skb)
skb1076net/ipv4/tcp.cstruct tcphdr * th = skb->h.th;
skb1082net/ipv4/tcp.csize = skb->len - ((unsigned char *) th - skb->data);
skb1088net/ipv4/tcp.cif (size < sizeof(struct tcphdr) || size > skb->len) 
skb1091net/ipv4/tcp.cskb, skb->data, th, skb->len);
skb1092net/ipv4/tcp.ckfree_skb(skb, FREE_WRITE);
skb1107net/ipv4/tcp.ckfree_skb(skb,FREE_WRITE);
skb1117net/ipv4/tcp.cskb->h.seq = ntohl(th->seq) + size - 4*th->doff;
skb1127net/ipv4/tcp.cif (after(skb->h.seq, sk->window_seq) ||
skb1134net/ipv4/tcp.cif (skb->next != NULL) 
skb1137net/ipv4/tcp.cskb_unlink(skb);
skb1139net/ipv4/tcp.cskb_queue_tail(&sk->write_queue, skb);
skb1171net/ipv4/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, 0);
skb1194net/ipv4/tcp.cstruct sk_buff * skb;
skb1199net/ipv4/tcp.cskb = sk->partial;
skb1200net/ipv4/tcp.cif (skb) {
skb1205net/ipv4/tcp.creturn skb;
skb1214net/ipv4/tcp.cstruct sk_buff *skb;
skb1218net/ipv4/tcp.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL)
skb1219net/ipv4/tcp.ctcp_send_skb(sk, skb);
skb1226net/ipv4/tcp.cvoid tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk)
skb1236net/ipv4/tcp.csk->partial = skb;
skb1404net/ipv4/tcp.cstruct sk_buff *skb;
skb1517net/ipv4/tcp.cif ((skb = tcp_dequeue_partial(sk)) != NULL) 
skb1522net/ipv4/tcp.chdrlen = ((unsigned long)skb->h.th - (unsigned long)skb->data)
skb1528net/ipv4/tcp.ccopy = min(sk->mss - (skb->len - hdrlen), len);
skb1536net/ipv4/tcp.cmemcpy_fromfs(skb->data + skb->len, from, copy);
skb1537net/ipv4/tcp.cskb->len += copy;
skb1543net/ipv4/tcp.cif ((skb->len - hdrlen) >= sk->mss ||
skb1545net/ipv4/tcp.ctcp_send_skb(sk, skb);
skb1547net/ipv4/tcp.ctcp_enqueue_partial(skb, sk);
skb1584net/ipv4/tcp.cskb = prot->wmalloc(sk, sk->mtu + 128 + prot->max_header, 0, GFP_KERNEL);
skb1586net/ipv4/tcp.csend_tmp = skb;
skb1594net/ipv4/tcp.cskb = prot->wmalloc(sk, copy + prot->max_header , 0, GFP_KERNEL);
skb1602net/ipv4/tcp.cif (skb == NULL) 
skb1642net/ipv4/tcp.cskb->len = 0;
skb1643net/ipv4/tcp.cskb->sk = sk;
skb1644net/ipv4/tcp.cskb->free = 0;
skb1645net/ipv4/tcp.cskb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
skb1647net/ipv4/tcp.cbuff = skb->data;
skb1654net/ipv4/tcp.ctmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
skb1655net/ipv4/tcp.cIPPROTO_TCP, sk->opt, skb->mem_len,sk->ip_tos,sk->ip_ttl);
skb1658net/ipv4/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
skb1664net/ipv4/tcp.cskb->len += tmp;
skb1665net/ipv4/tcp.cskb->dev = dev;
skb1667net/ipv4/tcp.cskb->h.th =(struct tcphdr *) buff;
skb1671net/ipv4/tcp.cprot->wfree(sk, skb->mem_addr, skb->mem_len);
skb1683net/ipv4/tcp.cskb->len += tmp;
skb1689net/ipv4/tcp.cskb->len += copy;
skb1690net/ipv4/tcp.cskb->free = 0;
skb1698net/ipv4/tcp.ctcp_send_skb(sk, skb);
skb1833net/ipv4/tcp.cstruct sk_buff *skb;
skb1849net/ipv4/tcp.cwhile((skb=skb_peek(&sk->receive_queue)) != NULL) 
skb1851net/ipv4/tcp.cif (!skb->used || skb->users) 
skb1853net/ipv4/tcp.cskb_unlink(skb);
skb1854net/ipv4/tcp.cskb->sk = sk;
skb1855net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb2012net/ipv4/tcp.cstruct sk_buff * skb;
skb2028net/ipv4/tcp.cskb = skb_peek(&sk->receive_queue);
skb2031net/ipv4/tcp.cif (!skb)
skb2033net/ipv4/tcp.cif (before(*seq, skb->h.th->seq))
skb2035net/ipv4/tcp.coffset = *seq - skb->h.th->seq;
skb2036net/ipv4/tcp.cif (skb->h.th->syn)
skb2038net/ipv4/tcp.cif (offset < skb->len)
skb2040net/ipv4/tcp.cif (skb->h.th->fin)
skb2043net/ipv4/tcp.cskb->used = 1;
skb2044net/ipv4/tcp.cskb = skb->next;
skb2046net/ipv4/tcp.cwhile (skb != (struct sk_buff *)&sk->receive_queue);
skb2103net/ipv4/tcp.cskb->users++;
skb2109net/ipv4/tcp.cused = skb->len - offset;
skb2148net/ipv4/tcp.cmemcpy_tofs(to,((unsigned char *)skb->h.th) +
skb2149net/ipv4/tcp.cskb->h.th->doff*4 + offset, used);
skb2160net/ipv4/tcp.cskb->users --;
skb2164net/ipv4/tcp.cif (used + offset < skb->len)
skb2171net/ipv4/tcp.cif (skb->h.th->fin)
skb2175net/ipv4/tcp.cskb->used = 1;
skb2187net/ipv4/tcp.cskb->used = 1;
skb2632net/ipv4/tcp.cstatic void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
skb2645net/ipv4/tcp.cth = skb->h.th;
skb2658net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb2670net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb2687net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb2720net/ipv4/tcp.cnewsk->acked_seq = skb->h.th->seq+1;
skb2721net/ipv4/tcp.cnewsk->copied_seq = skb->h.th->seq+1;
skb2722net/ipv4/tcp.cnewsk->fin_seq = skb->h.th->seq;
skb2739net/ipv4/tcp.cnewsk->dummy_th.source = skb->h.th->dest;
skb2740net/ipv4/tcp.cnewsk->dummy_th.dest = skb->h.th->source;
skb2759net/ipv4/tcp.cnewsk->acked_seq = skb->h.th->seq + 1;
skb2760net/ipv4/tcp.cnewsk->copied_seq = skb->h.th->seq + 1;
skb2768net/ipv4/tcp.cnewsk->ip_tos=skb->ip_hdr->tos;
skb2811net/ipv4/tcp.ctcp_options(newsk,skb->h.th);
skb2823net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb2853net/ipv4/tcp.cskb->sk = sk;
skb2854net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb2862net/ipv4/tcp.cmemcpy(t1, skb->h.th, sizeof(*t1));
skb2867net/ipv4/tcp.ct1->dest = skb->h.th->source;
skb2880net/ipv4/tcp.ct1->ack_seq = ntohl(skb->h.th->seq+1);
skb2891net/ipv4/tcp.cskb->sk = newsk;
skb2897net/ipv4/tcp.csk->rmem_alloc -= skb->mem_len;
skb2898net/ipv4/tcp.cnewsk->rmem_alloc += skb->mem_len;
skb2900net/ipv4/tcp.cskb_queue_tail(&sk->receive_queue,skb);
skb2935net/ipv4/tcp.cstruct sk_buff *skb;
skb2943net/ipv4/tcp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
skb2944net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb2982net/ipv4/tcp.cstruct sk_buff *skb;
skb3000net/ipv4/tcp.cwhile((skb = skb_peek(&sk->write_queue)) != NULL &&
skb3001net/ipv4/tcp.cbefore(skb->h.seq, sk->window_seq + 1) &&
skb3004net/ipv4/tcp.cbefore(skb->h.seq, sk->rcv_ack_seq + 1))
skb3007net/ipv4/tcp.cIS_SKB(skb);
skb3008net/ipv4/tcp.cskb_unlink(skb);
skb3014net/ipv4/tcp.cif (before(skb->h.seq, sk->rcv_ack_seq +1)) 
skb3022net/ipv4/tcp.ckfree_skb(skb, FREE_WRITE);
skb3038net/ipv4/tcp.ciph = (struct iphdr *)(skb->data +
skb3039net/ipv4/tcp.cskb->dev->hard_header_len);
skb3041net/ipv4/tcp.csize = skb->len - (((unsigned char *) th) - skb->data);
skb3048net/ipv4/tcp.csk->sent_seq = skb->h.seq;
skb3054net/ipv4/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
skb3162net/ipv4/tcp.cstruct sk_buff *skb;
skb3181net/ipv4/tcp.cskb = skb2;
skb3182net/ipv4/tcp.cskb2 = skb->link3;
skb3183net/ipv4/tcp.cskb->link3 = NULL;
skb3184net/ipv4/tcp.cif (after(skb->h.seq, sk->window_seq)) 
skb3189net/ipv4/tcp.cif (skb->next != NULL) 
skb3191net/ipv4/tcp.cskb_unlink(skb);        
skb3195net/ipv4/tcp.cskb_queue_head(&sk->write_queue,skb);
skb3197net/ipv4/tcp.cskb_append(wskb,skb);
skb3198net/ipv4/tcp.cwskb = skb;
skb3204net/ipv4/tcp.csk->send_head = skb;
skb3205net/ipv4/tcp.csk->send_tail = skb;
skb3209net/ipv4/tcp.csk->send_tail->link3 = skb;
skb3210net/ipv4/tcp.csk->send_tail = skb;
skb3212net/ipv4/tcp.cskb->link3 = NULL;
skb3673net/ipv4/tcp.cstatic int tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
skb3675net/ipv4/tcp.csk->fin_seq = th->seq + skb->len + th->syn + th->fin;
skb3760net/ipv4/tcp.cextern __inline__ int tcp_data(struct sk_buff *skb, struct sock *sk, 
skb3769net/ipv4/tcp.cth = skb->h.th;
skb3770net/ipv4/tcp.cskb->len = len -(th->doff*4);
skb3777net/ipv4/tcp.csk->bytes_rcv += skb->len;
skb3779net/ipv4/tcp.cif (skb->len == 0 && !th->fin) 
skb3787net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb3806net/ipv4/tcp.cif(skb->len)  /* We don't care if it's just an ack or
skb3809net/ipv4/tcp.cnew_seq= th->seq + skb->len + th->syn;  /* Right edge of _data_ part of frame */
skb3832net/ipv4/tcp.ctcp_reset(sk->saddr, sk->daddr, skb->h.th,
skb3833net/ipv4/tcp.csk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl);
skb3838net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb3861net/ipv4/tcp.cskb_queue_head(&sk->receive_queue,skb);
skb3872net/ipv4/tcp.cprintk("skb->h.th->seq = %ld\n",skb->h.th->seq);
skb3885net/ipv4/tcp.cif (th->seq==skb1->h.th->seq && skb->len>= skb1->len)
skb3887net/ipv4/tcp.cskb_append(skb1,skb);
skb3901net/ipv4/tcp.cskb_append(skb1,skb);
skb3910net/ipv4/tcp.cskb_queue_head(&sk->receive_queue, skb);
skb3920net/ipv4/tcp.cth->ack_seq = th->seq + skb->len;
skb3952net/ipv4/tcp.cskb->acked = 1;
skb3959net/ipv4/tcp.cif (skb->h.th->fin) 
skb3961net/ipv4/tcp.ctcp_fin(skb,sk,skb->h.th);
skb3964net/ipv4/tcp.cfor(skb2 = skb->next;
skb3986net/ipv4/tcp.ctcp_fin(skb,sk,skb->h.th);
skb4025net/ipv4/tcp.cif (!skb->acked) 
skb4163net/ipv4/tcp.cstruct sk_buff *skb;
skb4180net/ipv4/tcp.cwhile((skb = tcp_dequeue_established(sk)) == NULL) 
skb4206net/ipv4/tcp.cnewsk = skb->sk;
skb4208net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4438net/ipv4/tcp.cstatic int tcp_std_reset(struct sock *sk, struct sk_buff *skb)
skb4461net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4470net/ipv4/tcp.cint tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb4480net/ipv4/tcp.cif(skb->pkt_type!=PACKET_HOST)
skb4482net/ipv4/tcp.ckfree_skb(skb,FREE_READ);
skb4486net/ipv4/tcp.cth = skb->h.th;
skb4520net/ipv4/tcp.cskb->sk = NULL;
skb4521net/ipv4/tcp.ckfree_skb(skb,FREE_READ);
skb4536net/ipv4/tcp.ctcp_reset(daddr, saddr, th, &tcp_prot, opt,dev,skb->ip_hdr->tos,255);
skb4537net/ipv4/tcp.cskb->sk = NULL;
skb4541net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4545net/ipv4/tcp.cskb->len = len;
skb4546net/ipv4/tcp.cskb->acked = 0;
skb4547net/ipv4/tcp.cskb->used = 0;
skb4548net/ipv4/tcp.cskb->free = 0;
skb4549net/ipv4/tcp.cskb->saddr = daddr;
skb4550net/ipv4/tcp.cskb->daddr = saddr;
skb4556net/ipv4/tcp.cskb_queue_tail(&sk->back_log, skb);
skb4567net/ipv4/tcp.ctcp_reset(daddr, saddr, th, &tcp_prot, opt,dev,skb->ip_hdr->tos,255);
skb4568net/ipv4/tcp.cskb->sk = NULL;
skb4569net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4586net/ipv4/tcp.cif (sk->rmem_alloc + skb->mem_len >= sk->rcvbuf) 
skb4588net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4593net/ipv4/tcp.cskb->sk=sk;
skb4594net/ipv4/tcp.csk->rmem_alloc += skb->mem_len;
skb4624net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4633net/ipv4/tcp.ctcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq());
skb4651net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4674net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4679net/ipv4/tcp.creturn tcp_std_reset(sk,skb);
skb4684net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4723net/ipv4/tcp.creturn tcp_std_reset(sk,skb);
skb4733net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4758net/ipv4/tcp.csk->rmem_alloc -= skb->mem_len;
skb4759net/ipv4/tcp.cskb->sk = NULL;
skb4768net/ipv4/tcp.cskb->sk = sk;
skb4769net/ipv4/tcp.csk->rmem_alloc += skb->mem_len;
skb4770net/ipv4/tcp.ctcp_conn_request(sk, skb, daddr, saddr,opt, dev,seq+128000);
skb4774net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4788net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4794net/ipv4/tcp.creturn tcp_std_reset(sk,skb);
skb4802net/ipv4/tcp.ctcp_reset(daddr,saddr,th, &tcp_prot, opt, dev, skb->ip_hdr->tos, 255);
skb4803net/ipv4/tcp.creturn tcp_std_reset(sk,skb);  
skb4821net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4834net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4844net/ipv4/tcp.cif(tcp_data(skb,sk, saddr, len))
skb4846net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb4866net/ipv4/tcp.cstruct sk_buff *buff,*skb;
skb4891net/ipv4/tcp.c(skb=skb_peek(&sk->write_queue)))
skb4907net/ipv4/tcp.ciph = (struct iphdr *)(skb->data + skb->dev->hard_header_len);
skb4912net/ipv4/tcp.cskb->dev->hard_header_len, 
skb4951net/ipv4/tcp.ctcp_data_start = skb->data + skb->dev->hard_header_len + 
skb4963net/ipv4/tcp.cow_size = skb->len - win_size - 
skb4964net/ipv4/tcp.c((unsigned long) (tcp_data_start - (void *) skb->data));
skb4967net/ipv4/tcp.cskb->len -= win_size;
skb109net/ipv4/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len);
skb372net/ipv4/udp.cstruct sk_buff *skb;
skb377net/ipv4/udp.cskb = skb_peek(&sk->receive_queue);
skb378net/ipv4/udp.cif (skb != NULL) {
skb384net/ipv4/udp.camount = skb->len;
skb412net/ipv4/udp.cstruct sk_buff *skb;
skb427net/ipv4/udp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb428net/ipv4/udp.cif(skb==NULL)
skb431net/ipv4/udp.ctruesize = skb->len;
skb438net/ipv4/udp.cskb_copy_datagram(skb,sizeof(struct udphdr),to,copied);
skb439net/ipv4/udp.csk->stamp=skb->stamp;
skb445net/ipv4/udp.csin->sin_port = skb->h.uh->source;
skb446net/ipv4/udp.csin->sin_addr.s_addr = skb->daddr;
skb449net/ipv4/udp.cskb_free_datagram(skb);
skb511net/ipv4/udp.cint udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb527net/ipv4/udp.cuh = (struct udphdr *) skb->h.uh;
skb541net/ipv4/udp.ckfree_skb(skb, FREE_WRITE);
skb554net/ipv4/udp.ckfree_skb(skb, FREE_WRITE);
skb578net/ipv4/udp.cskb1=skb_clone(skb,GFP_ATOMIC);
skb580net/ipv4/udp.cskb1=skb;
skb588net/ipv4/udp.ckfree_skb(skb, FREE_READ);
skb609net/ipv4/udp.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);
skb615net/ipv4/udp.cskb->sk = NULL;
skb616net/ipv4/udp.ckfree_skb(skb, FREE_WRITE);
skb619net/ipv4/udp.creturn udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
skb622net/ipv4/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
skb624net/ipv4/udp.cskb->sk = sk;
skb625net/ipv4/udp.cskb->dev = dev;
skb626net/ipv4/udp.cskb->len = len;
skb632net/ipv4/udp.cskb->daddr = saddr;
skb633net/ipv4/udp.cskb->saddr = daddr;
skb640net/ipv4/udp.cskb->len = len - sizeof(*uh);  
skb642net/ipv4/udp.cif (sock_queue_rcv_skb(sk,skb)<0) 
skb647net/ipv4/udp.cskb->sk = NULL;
skb648net/ipv4/udp.ckfree_skb(skb, FREE_WRITE);
skb175net/ipx/af_ipx.cstruct sk_buff  *skb;
skb178net/ipx/af_ipx.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) {
skb179net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb323net/ipx/af_ipx.cipxitf_def_skb_handler(struct sock *sock, struct sk_buff *skb)
skb327net/ipx/af_ipx.cif((retval = sock_queue_rcv_skb(sock, skb))<0) {
skb336net/ipx/af_ipx.ckfree_skb(skb,FREE_WRITE);
skb342net/ipx/af_ipx.cipxitf_demux_socket(ipx_interface *intrfc, struct sk_buff *skb, int copy) 
skb344net/ipx/af_ipx.cipx_packet  *ipx = (ipx_packet *)(skb->h.raw);
skb380net/ipx/af_ipx.ckfree_skb(skb,FREE_WRITE);
skb384net/ipx/af_ipx.cipx_offset = (char *)(skb->h.raw) - (char *)(skb->data);
skb393net/ipx/af_ipx.cskb1 = skb_clone(skb, GFP_ATOMIC);
skb399net/ipx/af_ipx.cskb1 = skb;
skb429net/ipx/af_ipx.cipxitf_adjust_skbuff(ipx_interface *intrfc, struct sk_buff *skb)
skb432net/ipx/af_ipx.cint  in_offset = skb->h.raw - skb->data;
skb439net/ipx/af_ipx.cskb->len += out_offset;
skb440net/ipx/af_ipx.cskb->arp = skb->free = 1;
skb441net/ipx/af_ipx.creturn skb;
skb446net/ipx/af_ipx.coldraw = skb->h.raw;
skb447net/ipx/af_ipx.cskb->h.raw = &(skb->data[out_offset]);
skb448net/ipx/af_ipx.cmemmove(skb->h.raw, oldraw, skb->len);
skb449net/ipx/af_ipx.cskb->len += out_offset;
skb450net/ipx/af_ipx.cskb->arp = skb->free = 1;
skb451net/ipx/af_ipx.creturn skb;
skb455net/ipx/af_ipx.clen = skb->len + out_offset;
skb462net/ipx/af_ipx.cmemcpy(skb2->h.raw, skb->h.raw, skb->len);
skb464net/ipx/af_ipx.ckfree_skb(skb, FREE_WRITE);
skb469net/ipx/af_ipx.cipxitf_send(ipx_interface *intrfc, struct sk_buff *skb, char *node)
skb471net/ipx/af_ipx.cipx_packet  *ipx = (ipx_packet *)(skb->h.raw);
skb487net/ipx/af_ipx.creturn ipxitf_demux_socket(intrfc, skb, 0);
skb489net/ipx/af_ipx.cipxitf_demux_socket(intrfc, skb, send_to_wire);
skb509net/ipx/af_ipx.ckfree_skb(skb,FREE_WRITE);
skb522net/ipx/af_ipx.cskb = ipxitf_adjust_skbuff(intrfc, skb);
skb523net/ipx/af_ipx.cif (skb == NULL) return 0;
skb526net/ipx/af_ipx.cskb->dev = dev;
skb527net/ipx/af_ipx.cdl->datalink_header(dl, skb, dest_node);
skb529net/ipx/af_ipx.cif (skb->sk != NULL) {
skb533net/ipx/af_ipx.cskb->sk->wmem_alloc += skb->mem_len;
skb537net/ipx/af_ipx.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb555net/ipx/af_ipx.cipxitf_rcv(ipx_interface *intrfc, struct sk_buff *skb)
skb557net/ipx/af_ipx.cipx_packet  *ipx = (ipx_packet *) (skb->h.raw);
skb588net/ipx/af_ipx.cif ((skb->pkt_type != PACKET_BROADCAST) &&
skb589net/ipx/af_ipx.c(skb->pkt_type != PACKET_MULTICAST))
skb590net/ipx/af_ipx.creturn ipxrtr_route_skb(skb);
skb592net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb599net/ipx/af_ipx.creturn ipxitf_demux_socket(intrfc, skb, 0);
skb603net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb985net/ipx/af_ipx.cstruct sk_buff *skb;
skb1010net/ipx/af_ipx.cskb=alloc_skb(size,GFP_KERNEL);
skb1011net/ipx/af_ipx.cif(skb==NULL) return -ENOMEM;
skb1013net/ipx/af_ipx.cskb->sk=sk;
skb1014net/ipx/af_ipx.cskb->len=size;
skb1015net/ipx/af_ipx.cskb->free=1;
skb1016net/ipx/af_ipx.cskb->arp=1;
skb1019net/ipx/af_ipx.cipx=(ipx_packet *)&(skb->data[ipx_offset]);
skb1024net/ipx/af_ipx.cskb->h.raw = (unsigned char *)ipx;
skb1034net/ipx/af_ipx.creturn ipxitf_send(intrfc, skb, (rt && rt->ir_routed) ? 
skb1039net/ipx/af_ipx.cipxrtr_route_skb(struct sk_buff *skb)
skb1041net/ipx/af_ipx.cipx_packet  *ipx = (ipx_packet *) (skb->h.raw);
skb1048net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb1052net/ipx/af_ipx.c(void)ipxitf_send(i, skb, (r->ir_routed) ? 
skb1631net/ipx/af_ipx.cint ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb1637net/ipx/af_ipx.cipx=(ipx_packet *)skb->h.raw;
skb1643net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb1649net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb1662net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb1667net/ipx/af_ipx.creturn ipxitf_rcv(intrfc, skb);
skb1726net/ipx/af_ipx.cstruct sk_buff *skb;
skb1740net/ipx/af_ipx.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb1741net/ipx/af_ipx.cif(skb==NULL)
skb1746net/ipx/af_ipx.cipx = (ipx_packet *)(skb->h.raw);
skb1749net/ipx/af_ipx.cskb_copy_datagram(skb,sizeof(struct ipx_packet),ubuf,copied);
skb1759net/ipx/af_ipx.cskb_free_datagram(skb);
skb1815net/ipx/af_ipx.cstruct sk_buff *skb;
skb1817net/ipx/af_ipx.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
skb1818net/ipx/af_ipx.camount=skb->len;
skb217net/netrom/af_netrom.cstruct sk_buff *skb;
skb228net/netrom/af_netrom.cwhile ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
skb229net/netrom/af_netrom.cif (skb->sk != sk) {      /* A pending connection */
skb230net/netrom/af_netrom.cskb->sk->dead = 1;  /* Queue the unaccepted socket for death */
skb231net/netrom/af_netrom.cnr_set_timer(skb->sk);
skb232net/netrom/af_netrom.cskb->sk->nr->state = NR_STATE_0;
skb235net/netrom/af_netrom.ckfree_skb(skb, FREE_READ);
skb790net/netrom/af_netrom.cstruct sk_buff *skb;
skb809net/netrom/af_netrom.cif ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
skb820net/netrom/af_netrom.c} while (skb == NULL);
skb822net/netrom/af_netrom.cnewsk = skb->sk;
skb827net/netrom/af_netrom.cskb->sk = NULL;
skb828net/netrom/af_netrom.ckfree_skb(skb, FREE_READ);
skb861net/netrom/af_netrom.cint nr_rx_frame(struct sk_buff *skb, struct device *dev)
skb869net/netrom/af_netrom.cskb->sk = NULL;    /* Initially we don't know who its for */
skb871net/netrom/af_netrom.csrc  = (ax25_address *)(skb->data + 17);
skb872net/netrom/af_netrom.cdest = (ax25_address *)(skb->data + 24);
skb874net/netrom/af_netrom.ccircuit_index = skb->data[32];
skb875net/netrom/af_netrom.ccircuit_id    = skb->data[33];
skb876net/netrom/af_netrom.cframetype     = skb->data[36];
skb883net/netrom/af_netrom.cskb->h.raw = skb->data + 37;
skb885net/netrom/af_netrom.creturn nr_rx_ip(skb, dev);
skb895net/netrom/af_netrom.cskb->h.raw = skb->data + 37;
skb896net/netrom/af_netrom.cskb->len  -= 20;
skb898net/netrom/af_netrom.creturn nr_process_rx_frame(sk, skb);
skb907net/netrom/af_netrom.cnr_transmit_dm(skb);
skb911net/netrom/af_netrom.cuser   = (ax25_address *)(skb->data + 38);
skb912net/netrom/af_netrom.cwindow = skb->data[37];
skb914net/netrom/af_netrom.cskb->sk             = make;
skb947net/netrom/af_netrom.cskb_queue_head(&sk->receive_queue, skb);
skb952net/netrom/af_netrom.csk->data_ready(sk, skb->len);
skb964net/netrom/af_netrom.cstruct sk_buff *skb;
skb1004net/netrom/af_netrom.cif ((skb = sock_alloc_send_skb(sk, size, 0, &err)) == NULL)
skb1007net/netrom/af_netrom.cskb->sk   = sk;
skb1008net/netrom/af_netrom.cskb->free = 1;
skb1009net/netrom/af_netrom.cskb->arp  = 1;
skb1010net/netrom/af_netrom.cskb->len  = size;
skb1012net/netrom/af_netrom.casmptr = skb->data + 16;
skb1046net/netrom/af_netrom.cskb->h.raw = asmptr;
skb1058net/netrom/af_netrom.ckfree_skb(skb, FREE_WRITE);
skb1062net/netrom/af_netrom.cnr_output(sk, skb);  /* Shove it onto the queue */
skb1083net/netrom/af_netrom.cstruct sk_buff *skb;
skb1100net/netrom/af_netrom.cif ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
skb1103net/netrom/af_netrom.ccopied = (size < skb->len) ? size : skb->len;
skb1105net/netrom/af_netrom.cskb_copy_datagram(skb, 0, ubuf, copied);
skb1111net/netrom/af_netrom.cmemcpy(&addr.sax25_call, skb->data + 24, sizeof(ax25_address));
skb1118net/netrom/af_netrom.cskb_free_datagram(skb);
skb1169net/netrom/af_netrom.cstruct sk_buff *skb;
skb1171net/netrom/af_netrom.cif ((skb = skb_peek(&sk->receive_queue)) != NULL)
skb1172net/netrom/af_netrom.camount = skb->len;
skb52net/netrom/nr_dev.cint nr_rx_ip(struct sk_buff *skb, struct device *dev)
skb62net/netrom/nr_dev.cskb->protocol=htons(ETH_P_IP);
skb64net/netrom/nr_dev.cskb->dev=dev;
skb66net/netrom/nr_dev.cip_rcv(skb, dev, NULL);
skb77net/netrom/nr_dev.cvoid *daddr, void *saddr, unsigned len, struct sk_buff *skb)
skb117net/netrom/nr_dev.cunsigned long raddr, struct sk_buff *skb)
skb121net/netrom/nr_dev.cif (arp_find(bp + 24, raddr, dev, dev->pa_addr, skb))
skb158net/netrom/nr_dev.cstatic int nr_xmit(struct sk_buff *skb, struct device *dev)
skb163net/netrom/nr_dev.cif (skb == NULL || dev == NULL)
skb183net/netrom/nr_dev.cif (skb->data[0] != 0xFF && skb->data[1] != 0xFE) {
skb184net/netrom/nr_dev.cif ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL) {
skb199net/netrom/nr_dev.cdev_kfree_skb(skb, FREE_WRITE);
skb55net/netrom/nr_in.cstatic int nr_state1_machine(struct sock *sk, struct sk_buff *skb, int frametype)
skb61net/netrom/nr_in.csk->window         = skb->data[37];
skb62net/netrom/nr_in.csk->nr->your_index = skb->data[34];
skb63net/netrom/nr_in.csk->nr->your_id    = skb->data[35];
skb101net/netrom/nr_in.cstatic int nr_state2_machine(struct sock *sk, struct sk_buff *skb, int frametype)
skb130net/netrom/nr_in.cstatic int nr_state3_machine(struct sock *sk, struct sk_buff *skb, int frametype)
skb138net/netrom/nr_in.cnr = skb->data[35];
skb139net/netrom/nr_in.cns = skb->data[34];
skb237net/netrom/nr_in.cskb_queue_head(&sk->nr->reseq_queue, skb);
skb284net/netrom/nr_in.cint nr_process_rx_frame(struct sock *sk, struct sk_buff *skb)
skb290net/netrom/nr_in.cframetype = skb->data[36];
skb295net/netrom/nr_in.cqueued = nr_state1_machine(sk, skb, frametype);
skb298net/netrom/nr_in.cqueued = nr_state2_machine(sk, skb, frametype);
skb301net/netrom/nr_in.cqueued = nr_state3_machine(sk, skb, frametype);
skb43net/netrom/nr_out.cint nr_output(struct sock *sk, struct sk_buff *skb)
skb45net/netrom/nr_out.cskb_queue_tail(&sk->write_queue, skb);  /* Throw it on the queue */
skb57net/netrom/nr_out.cstatic void nr_send_iframe(struct sock *sk, struct sk_buff *skb)
skb61net/netrom/nr_out.cif (skb == NULL)
skb64net/netrom/nr_out.cdptr = skb->data + 34;
skb69net/netrom/nr_out.cnr_transmit_buffer(sk, skb);  
skb74net/netrom/nr_out.cstruct sk_buff *skb, *skbn;
skb76net/netrom/nr_out.cif ((skb = skb_peek(&sk->nr->ack_queue)) == NULL)
skb79net/netrom/nr_out.cif ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL)
skb91net/netrom/nr_out.cstruct sk_buff *skb, *skbn;
skb114net/netrom/nr_out.cskb  = skb_dequeue(&sk->write_queue);
skb116net/netrom/nr_out.cif ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL) {
skb117net/netrom/nr_out.cskb_queue_head(&sk->write_queue, skb);
skb134net/netrom/nr_out.cskb_queue_tail(&sk->nr->ack_queue, skb);
skb149net/netrom/nr_out.cvoid nr_transmit_buffer(struct sock *sk, struct sk_buff *skb)
skb153net/netrom/nr_out.cdptr = skb->data + 16;
skb171net/netrom/nr_out.cskb->arp = 1;
skb173net/netrom/nr_out.cif (!nr_route_frame(skb, NULL)) {
skb174net/netrom/nr_out.ckfree_skb(skb, FREE_WRITE);
skb612net/netrom/nr_route.cint nr_route_frame(struct sk_buff *skb, struct device *device)
skb620net/netrom/nr_route.cax25_dest = (ax25_address *)(skb->data + 1);
skb621net/netrom/nr_route.cax25_src  = (ax25_address *)(skb->data + 8);
skb622net/netrom/nr_route.cnr_src    = (ax25_address *)(skb->data + 17);
skb623net/netrom/nr_route.cnr_dest   = (ax25_address *)(skb->data + 24);
skb629net/netrom/nr_route.creturn nr_rx_frame(skb, dev);
skb632net/netrom/nr_route.cif (--skb->data[31] == 0)
skb653net/netrom/nr_route.cskb->len += dev->hard_header_len;
skb655net/netrom/nr_route.cax25_send_frame(skb, (ax25_address *)dev->dev_addr, &nr_neigh->callsign, nr_neigh->dev);
skb48net/netrom/nr_subr.cstruct sk_buff *skb;
skb50net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->write_queue)) != NULL) {
skb51net/netrom/nr_subr.cskb->sk   = sk;
skb52net/netrom/nr_subr.cskb->free = 1;
skb53net/netrom/nr_subr.ckfree_skb(skb, FREE_WRITE);
skb56net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->ack_queue)) != NULL) {
skb57net/netrom/nr_subr.cskb->sk   = sk;
skb58net/netrom/nr_subr.cskb->free = 1;
skb59net/netrom/nr_subr.ckfree_skb(skb, FREE_WRITE);
skb62net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->reseq_queue)) != NULL) {
skb63net/netrom/nr_subr.cskb->free = 1;
skb64net/netrom/nr_subr.ckfree_skb(skb, FREE_READ);
skb75net/netrom/nr_subr.cstruct sk_buff *skb;
skb82net/netrom/nr_subr.cskb = skb_dequeue(&sk->nr->ack_queue);
skb83net/netrom/nr_subr.cskb->sk   = sk;
skb84net/netrom/nr_subr.cskb->free = 1;
skb85net/netrom/nr_subr.ckfree_skb(skb, FREE_WRITE);
skb98net/netrom/nr_subr.cstruct sk_buff *skb, *skb_prev = NULL;
skb100net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->ack_queue)) != NULL) {
skb102net/netrom/nr_subr.cskb_queue_head(&sk->write_queue, skb);
skb104net/netrom/nr_subr.cskb_append(skb_prev, skb);
skb105net/netrom/nr_subr.cskb_prev = skb;
skb151net/netrom/nr_subr.cstruct sk_buff *skb;
skb166net/netrom/nr_subr.cif ((skb = alloc_skb(len, GFP_ATOMIC)) == NULL)
skb169net/netrom/nr_subr.cdptr = skb->data + 32;
skb218net/netrom/nr_subr.cskb->free = 1;
skb219net/netrom/nr_subr.cskb->len  = len;
skb221net/netrom/nr_subr.cnr_transmit_buffer(sk, skb);
skb228net/netrom/nr_subr.cvoid nr_transmit_dm(struct sk_buff *skb)
skb240net/netrom/nr_subr.cmemcpy(dptr, skb->data + 24, 7);
skb246net/netrom/nr_subr.cmemcpy(dptr, skb->data + 17, 7);
skb254net/netrom/nr_subr.c*dptr++ = skb->data[32];
skb255net/netrom/nr_subr.c*dptr++ = skb->data[33];