taglinefilesource code
skb1594drivers/isdn/isdn_common.cvoid isdn_receive_skb_callback(int drvidx, int chan, struct sk_buff *skb) 
skb1602drivers/isdn/isdn_common.cif (isdn_net_rcv_skb(i, skb) == 0) {
skb1603drivers/isdn/isdn_common.cisdn_receive_callback(drvidx, chan, skb->data, skb->len);
skb1604drivers/isdn/isdn_common.cskb->free = 1;
skb1605drivers/isdn/isdn_common.ckfree_skb(skb, FREE_READ);
skb1616drivers/isdn/isdn_common.cstruct sk_buff * skb;
skb1618drivers/isdn/isdn_common.cskb = alloc_skb(dev->drv[drvidx]->interface->hl_hdrlen + len, GFP_ATOMIC);
skb1619drivers/isdn/isdn_common.cif (skb == NULL)
skb1622drivers/isdn/isdn_common.cskb_reserve(skb, dev->drv[drvidx]->interface->hl_hdrlen);
skb1623drivers/isdn/isdn_common.cskb->free = 1;
skb1626drivers/isdn/isdn_common.cmemcpy_fromfs(skb_put(skb, len), buf, len);
skb1628drivers/isdn/isdn_common.cmemcpy(skb_put(skb, len), buf, len);
skb1630drivers/isdn/isdn_common.creturn dev->drv[drvidx]->interface->writebuf_skb(drvidx, chan, skb);
skb632drivers/isdn/isdn_net.cstruct sk_buff *skb)
skb636drivers/isdn/isdn_net.clp->transcount += skb->len;
skb639drivers/isdn/isdn_net.cwritebuf_skb(lp->isdn_device, lp->isdn_channel, skb);
skb641drivers/isdn/isdn_net.cif ((ret = isdn_net_send(skb->data, lp->isdn_device,
skb642drivers/isdn/isdn_net.clp->isdn_channel, skb->len)))
skb643drivers/isdn/isdn_net.cdev_kfree_skb(skb, FREE_WRITE);
skb664drivers/isdn/isdn_net.cisdn_net_xmit(struct device *ndev, isdn_net_local *lp, struct sk_buff *skb) 
skb671drivers/isdn/isdn_net.creturn (isdn_ppp_xmit(skb, ndev));
skb684drivers/isdn/isdn_net.cret = isdn_net_send_skb(ndev, lp, skb);
skb689drivers/isdn/isdn_net.cret = isdn_net_send_skb(ndev, lp, skb);
skb691drivers/isdn/isdn_net.cret = ndev->tbusy = isdn_net_start_xmit(skb, lp->srobin);
skb713drivers/isdn/isdn_net.cret = isdn_net_send_skb(ndev, lp, skb);
skb726drivers/isdn/isdn_net.cisdn_net_start_xmit(struct sk_buff *skb, struct device *ndev)
skb739drivers/isdn/isdn_net.cif (skb == NULL) {
skb749drivers/isdn/isdn_net.cu_char *buf = skb->data;
skb751drivers/isdn/isdn_net.cisdn_dumppkt("S:", buf, skb->len, 40);
skb793drivers/isdn/isdn_net.clp->first_skb = skb;
skb814drivers/isdn/isdn_net.cdev_kfree_skb(skb, FREE_WRITE);
skb827drivers/isdn/isdn_net.creturn(isdn_net_xmit(ndev, lp, skb));
skb878drivers/isdn/isdn_net.cunsigned short isdn_net_type_trans(struct sk_buff *skb, struct device *dev)
skb883drivers/isdn/isdn_net.cskb_pull(skb,ETH_HLEN);
skb884drivers/isdn/isdn_net.ceth= skb->mac.ethernet;
skb888drivers/isdn/isdn_net.cskb->pkt_type=PACKET_BROADCAST;
skb890drivers/isdn/isdn_net.cskb->pkt_type=PACKET_MULTICAST;
skb900drivers/isdn/isdn_net.cskb->pkt_type=PACKET_OTHERHOST;
skb906drivers/isdn/isdn_net.crawp = skb->data;
skb926drivers/isdn/isdn_net.cisdn_net_receive(struct device *ndev, struct sk_buff *skb)
skb933drivers/isdn/isdn_net.clp->transcount += skb->len;
skb947drivers/isdn/isdn_net.cskb->dev = ndev;
skb948drivers/isdn/isdn_net.cskb->pkt_type = PACKET_HOST;
skb949drivers/isdn/isdn_net.cskb->mac.raw = skb->data;
skb951drivers/isdn/isdn_net.cisdn_dumppkt("R:", skb->data, skb->len, 40);
skb956drivers/isdn/isdn_net.cskb->protocol = isdn_net_type_trans(skb,ndev);
skb960drivers/isdn/isdn_net.cskb->protocol = htons(ETH_P_IP);
skb964drivers/isdn/isdn_net.cskb_pull(skb, 2);
skb968drivers/isdn/isdn_net.cskb->protocol = *(unsigned short *)&(skb->data[0]);
skb969drivers/isdn/isdn_net.cskb_pull(skb, 2);
skb970drivers/isdn/isdn_net.cif (*(unsigned short *)skb->data == 0xFFFF)
skb971drivers/isdn/isdn_net.cskb->protocol = htons(ETH_P_802_3);
skb975drivers/isdn/isdn_net.cisdn_ppp_receive(lp->netdev, olp, skb);
skb981drivers/isdn/isdn_net.ckfree_skb(skb,FREE_READ);
skb984drivers/isdn/isdn_net.cnetif_rx(skb);
skb997drivers/isdn/isdn_net.cstruct sk_buff *skb;
skb1003drivers/isdn/isdn_net.cskb = dev_alloc_skb(len);
skb1004drivers/isdn/isdn_net.cif (skb == NULL) {
skb1008drivers/isdn/isdn_net.cmemcpy(skb_put(skb, len), buf, len);
skb1009drivers/isdn/isdn_net.cisdn_net_receive(&p->dev, skb);
skb1021drivers/isdn/isdn_net.cisdn_net_rcv_skb(int idx, struct sk_buff *skb) 
skb1029drivers/isdn/isdn_net.cisdn_net_receive(&p->dev, skb);
skb1037drivers/isdn/isdn_net.cmy_eth_header(struct sk_buff *skb, struct device *dev, unsigned short type,
skb1040drivers/isdn/isdn_net.cstruct ethhdr *eth = (struct ethhdr *)skb_push(skb,ETH_HLEN);
skb1084drivers/isdn/isdn_net.cisdn_net_header(struct sk_buff *skb, struct device *dev, unsigned short type,
skb1092drivers/isdn/isdn_net.clen = my_eth_header(skb, dev, type, daddr, saddr, plen);
skb1100drivers/isdn/isdn_net.c*((ushort*) skb_push(skb, 2)) = htons(type);
skb1104drivers/isdn/isdn_net.cskb_push(skb, 4);
skb1105drivers/isdn/isdn_net.cskb->data[0] = 0x0f;
skb1106drivers/isdn/isdn_net.cskb->data[1] = 0x00;
skb1107drivers/isdn/isdn_net.c*((ushort*)&skb->data[2]) = htons(type);
skb1130drivers/isdn/isdn_net.c*((unsigned long *)skb_push(skb, len)) = 0;
skb1141drivers/isdn/isdn_net.cstruct sk_buff *skb)
skb1164drivers/isdn/isdn_net.cret = arp_find((unsigned char *)&(eth->h_dest), dst, dev, dev->pa_addr,skb)? 1 : 0;
skb60drivers/isdn/isdn_ppp.cstruct sk_buff *skb, int proto);
skb67drivers/isdn/isdn_ppp.cstatic int isdn_ppp_fill_mpqueue(isdn_net_dev *, struct sk_buff **skb,
skb551drivers/isdn/isdn_ppp.cvoid isdn_ppp_receive(isdn_net_dev * net_dev, isdn_net_local * lp, struct sk_buff *skb)
skb554drivers/isdn/isdn_ppp.cprintk(KERN_DEBUG "recv, skb %d\n",skb->len);
skb557drivers/isdn/isdn_ppp.cif(skb->data[0] == 0xff && skb->data[1] == 0x03)
skb558drivers/isdn/isdn_ppp.cskb_pull(skb,2);
skb566drivers/isdn/isdn_ppp.cif (skb->data[0] & 0x1) {
skb567drivers/isdn/isdn_ppp.cproto = skb->data[0];
skb568drivers/isdn/isdn_ppp.cskb_pull(skb,1);  /* protocol ID is only 8 bit */
skb570drivers/isdn/isdn_ppp.cproto = ((int) skb->data[0] << 8) + skb->data[1];
skb571drivers/isdn/isdn_ppp.cskb_pull(skb,2);
skb576drivers/isdn/isdn_ppp.cu_char BEbyte = skb->data[0];
skb579drivers/isdn/isdn_ppp.c(int) skb->len, (int) skb->data[0], (int) skb->data[1], (int) skb->data[2], 
skb580drivers/isdn/isdn_ppp.c(int) skb->data[3], (int) skb->data[4], (int) skb->data[5]);
skb583drivers/isdn/isdn_ppp.csqno = ((int) skb->data[1] << 16) + ((int) skb->data[2] << 8) + (int) skb->data[3];
skb584drivers/isdn/isdn_ppp.cskb_pull(skb,4);
skb586drivers/isdn/isdn_ppp.csqno = (((int) skb->data[0] & 0xf) << 8) + (int) skb->data[1];
skb587drivers/isdn/isdn_ppp.cskb_pull(skb,2);
skb630drivers/isdn/isdn_ppp.cif ((sqno_end = isdn_ppp_fill_mpqueue(net_dev, &skb , BEbyte, &sqno, min_sqno)) < 0)
skb655drivers/isdn/isdn_ppp.cq->skb = skb;
skb684drivers/isdn/isdn_ppp.cisdn_ppp_push_higher(net_dev, lp, skb, -1);
skb690drivers/isdn/isdn_ppp.cisdn_ppp_push_higher(net_dev, lp, q->skb, -1);
skb699drivers/isdn/isdn_ppp.cisdn_ppp_push_higher(net_dev, lp, skb , proto);
skb702drivers/isdn/isdn_ppp.cisdn_ppp_push_higher(net_dev, lp, skb , -1);
skb706drivers/isdn/isdn_ppp.cstatic void isdn_ppp_push_higher(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb,int proto)
skb711drivers/isdn/isdn_ppp.cif (skb->data[0] & 0x01) {  /* is it odd? */
skb712drivers/isdn/isdn_ppp.cproto = (unsigned char) skb->data[0];
skb713drivers/isdn/isdn_ppp.cskb_pull(skb,1);  /* protocol ID is only 8 bit */
skb715drivers/isdn/isdn_ppp.cproto = ((int) (unsigned char) skb->data[0] << 8) + (unsigned char) skb->data[1];
skb716drivers/isdn/isdn_ppp.cskb_pull(skb,2);
skb721drivers/isdn/isdn_ppp.cprintk(KERN_DEBUG "push, skb %d %04x\n",skb->len,proto);
skb726drivers/isdn/isdn_ppp.cskb->dev = dev;
skb727drivers/isdn/isdn_ppp.cskb->mac.raw = skb->data;
skb728drivers/isdn/isdn_ppp.cskb->protocol = htons(ETH_P_IPX);
skb732drivers/isdn/isdn_ppp.cslhc_remember(ippp_table[net_dev->local.ppp_minor].slcomp, skb->data, skb->len);
skb735drivers/isdn/isdn_ppp.cskb->dev = dev;
skb736drivers/isdn/isdn_ppp.cskb->mac.raw = skb->data;
skb737drivers/isdn/isdn_ppp.cskb->protocol = htons(ETH_P_IP);
skb742drivers/isdn/isdn_ppp.cstruct sk_buff *skb_old = skb;
skb744drivers/isdn/isdn_ppp.cskb = dev_alloc_skb(skb_old->len + 40);
skb746drivers/isdn/isdn_ppp.cif (!skb) {
skb751drivers/isdn/isdn_ppp.cskb->dev = dev;
skb752drivers/isdn/isdn_ppp.cskb_put(skb,skb_old->len + 40);
skb753drivers/isdn/isdn_ppp.cmemcpy(skb->data, skb_old->data, skb_old->len);
skb754drivers/isdn/isdn_ppp.cskb->mac.raw = skb->data;
skb756drivers/isdn/isdn_ppp.cskb->data, skb_old->len);
skb757drivers/isdn/isdn_ppp.cskb_trim(skb, pkt_len);
skb759drivers/isdn/isdn_ppp.cskb->protocol = htons(ETH_P_IP);
skb768drivers/isdn/isdn_ppp.cskb_push(skb,4);
skb769drivers/isdn/isdn_ppp.cskb->data[0] = 0xff;
skb770drivers/isdn/isdn_ppp.cskb->data[1] = 0x03;
skb771drivers/isdn/isdn_ppp.cskb->data[2] = (proto>>8);
skb772drivers/isdn/isdn_ppp.cskb->data[3] = proto & 0xff;
skb773drivers/isdn/isdn_ppp.cisdn_ppp_fill_rq(skb->data, skb->len, lp->ppp_minor);  /* push data to pppd device */
skb774drivers/isdn/isdn_ppp.cdev_kfree_skb(skb,FREE_WRITE);
skb778drivers/isdn/isdn_ppp.cnetif_rx(skb);
skb790drivers/isdn/isdn_ppp.cint isdn_ppp_xmit(struct sk_buff *skb, struct device *dev)
skb802drivers/isdn/isdn_ppp.cif (*((unsigned long *)skb->data) != 0)
skb803drivers/isdn/isdn_ppp.creturn (isdn_net_send_skb(dev , lp , skb));
skb810drivers/isdn/isdn_ppp.cprintk(KERN_DEBUG  "xmit, skb %d\n",skb->len);
skb815drivers/isdn/isdn_ppp.cu_char *buf = skb->data;
skb826drivers/isdn/isdn_ppp.cpktlen = slhc_compress(ipts->slcomp, buf, skb->len-len, ipts->cbuf,
skb828drivers/isdn/isdn_ppp.cskb_trim(skb,pktlen+len);
skb829drivers/isdn/isdn_ppp.cif(buf != skb->data+len) { /* copied to new buffer ??? (btw: WHY must slhc copy it?? *sigh*)  */
skb830drivers/isdn/isdn_ppp.cmemcpy(skb->data+len,buf,pktlen);
skb832drivers/isdn/isdn_ppp.cif (skb->data[len] & SL_TYPE_COMPRESSED_TCP) {  /* cslip? style -> PPP */
skb834drivers/isdn/isdn_ppp.cskb->data[len] ^= SL_TYPE_COMPRESSED_TCP;
skb836drivers/isdn/isdn_ppp.cif (skb->data[len] >= SL_TYPE_UNCOMPRESSED_TCP)
skb838drivers/isdn/isdn_ppp.cskb->data[len] = (skb->data[len] & 0x0f) | 0x40;
skb844drivers/isdn/isdn_ppp.cprintk(KERN_DEBUG  "xmit, skb %d %04x\n",skb->len,proto);
skb856drivers/isdn/isdn_ppp.cskb->data[4] = MP_BEGIN_FRAG | MP_END_FRAG | (mp_seqno >> 8);  /* (B)egin & (E)ndbit .. */
skb857drivers/isdn/isdn_ppp.cskb->data[5] = mp_seqno & 0xff;
skb858drivers/isdn/isdn_ppp.cskb->data[6] = proto;  /* PID compression */
skb861drivers/isdn/isdn_ppp.cskb->data[4] = MP_BEGIN_FRAG | MP_END_FRAG;  /* (B)egin & (E)ndbit .. */
skb862drivers/isdn/isdn_ppp.cskb->data[5] = (mp_seqno >> 16) & 0xff;  /* sequence nubmer: 24bit */
skb863drivers/isdn/isdn_ppp.cskb->data[6] = (mp_seqno >> 8) & 0xff;
skb864drivers/isdn/isdn_ppp.cskb->data[7] = (mp_seqno >> 0) & 0xff;
skb865drivers/isdn/isdn_ppp.cskb->data[8] = proto;  /* PID compression */
skb870drivers/isdn/isdn_ppp.cskb->data[0] = 0xff;        /* All Stations */
skb871drivers/isdn/isdn_ppp.cskb->data[1] = 0x03;        /* Unumbered information */
skb872drivers/isdn/isdn_ppp.cskb->data[2] = proto >> 8;
skb873drivers/isdn/isdn_ppp.cskb->data[3] = proto & 0xff;
skb881drivers/isdn/isdn_ppp.creturn (isdn_net_send_skb(dev , lp , skb));
skb889drivers/isdn/isdn_ppp.cdev_kfree_skb(q->skb,FREE_WRITE);
skb955drivers/isdn/isdn_ppp.cstatic int isdn_ppp_fill_mpqueue(isdn_net_dev * dev, struct sk_buff ** skb, int BEbyte, int *sqnop, int min_sqno)
skb971drivers/isdn/isdn_ppp.cq1->skb = *skb;
skb1011drivers/isdn/isdn_ppp.cpktlen = -q1->skb->len;
skb1021drivers/isdn/isdn_ppp.cpktlen += q->skb->len;
skb1024drivers/isdn/isdn_ppp.cpktlen += q->skb->len;
skb1036drivers/isdn/isdn_ppp.cpktlen += q->skb->len;
skb1039drivers/isdn/isdn_ppp.cpktlen += q->skb->len;
skb1055drivers/isdn/isdn_ppp.c*skb = dev_alloc_skb(pktlen + 40); /* not needed: +40 for VJ compression .. */
skb1057drivers/isdn/isdn_ppp.cif (!(*skb)) {
skb1060drivers/isdn/isdn_ppp.cdev_kfree_skb(q->skb,FREE_WRITE);
skb1067drivers/isdn/isdn_ppp.cskb_put(*skb,pktlen);
skb1070drivers/isdn/isdn_ppp.cmemcpy((*skb)->data + cnt, q->skb->data, q->skb->len);
skb1071drivers/isdn/isdn_ppp.ccnt += q->skb->len;
skb1072drivers/isdn/isdn_ppp.cdev_kfree_skb(q->skb,FREE_WRITE);
skb1102drivers/isdn/isdn_ppp.cdev_kfree_skb(q->skb,FREE_WRITE);
skb1141drivers/isdn/isdn_ppp.cisdn_ppp_push_higher(net_dev, lp, ql->skb, -1);
skb121drivers/net/3c501.cstatic int  el_start_xmit(struct sk_buff *skb, struct device *dev);
skb376drivers/net/3c501.cstatic int el_start_xmit(struct sk_buff *skb, struct device *dev)
skb405drivers/net/3c501.cif (skb == NULL) 
skb432drivers/net/3c501.cint gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
skb433drivers/net/3c501.cunsigned char *buf = skb->data;
skb461drivers/net/3c501.coutsb(DATAPORT,buf,skb->len);  /* load buffer (usual thing each byte increments the pointer) */
skb481drivers/net/3c501.cdev_kfree_skb (skb, FREE_WRITE);
skb678drivers/net/3c501.cstruct sk_buff *skb;
skb698drivers/net/3c501.cskb = dev_alloc_skb(pkt_len+2);
skb705drivers/net/3c501.cif (skb == NULL) 
skb713drivers/net/3c501.cskb_reserve(skb,2);  /* Force 16 byte alignment */
skb714drivers/net/3c501.cskb->dev = dev;
skb720drivers/net/3c501.cinsb(DATAPORT, skb_put(skb,pkt_len), pkt_len);
skb721drivers/net/3c501.cskb->protocol=eth_type_trans(skb,dev);
skb722drivers/net/3c501.cnetif_rx(skb);
skb79drivers/net/3c503.cstatic void el2_block_input(struct device *dev, int count, struct sk_buff *skb,
skb546drivers/net/3c503.cel2_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
skb560drivers/net/3c503.cmemcpy_fromio(skb->data, dev->mem_start + ring_offset, semi_count);
skb562drivers/net/3c503.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
skb565drivers/net/3c503.ceth_io_copy_and_sum(skb, dev->mem_start + ring_offset, count, 0);
skb590drivers/net/3c503.cbuf =  (unsigned short int *) skb->data;
skb557drivers/net/3c505.cstruct sk_buff *skb;
skb572drivers/net/3c505.cskb = dev_alloc_skb(rlen+2);
skb583drivers/net/3c505.cif (skb == NULL) {
skb599drivers/net/3c505.cskb_reserve(skb,2);  /* 16 byte alignment */
skb600drivers/net/3c505.cskb->dev = dev;
skb605drivers/net/3c505.cptr = (unsigned short *)skb_put(skb,len);
skb614drivers/net/3c505.ckfree_skb(skb, FREE_WRITE);
skb623drivers/net/3c505.cskb->protocol=eth_type_trans(skb,dev);
skb624drivers/net/3c505.cnetif_rx(skb);
skb1005drivers/net/3c505.celp_start_xmit (struct sk_buff *skb, struct device *dev)
skb1012drivers/net/3c505.cif (skb == NULL) {
skb1020drivers/net/3c505.cif (skb->len <= 0)
skb1024drivers/net/3c505.cprintk("%s: request to send packet of length %d\n", dev->name, (int)skb->len);
skb1045drivers/net/3c505.cif (!send_packet(dev, skb->data, skb->len)) {
skb1051drivers/net/3c505.cprintk("%s: packet of length %d sent\n", dev->name, (int)skb->len);
skb1067drivers/net/3c505.cdev_kfree_skb(skb, FREE_WRITE);
skb282drivers/net/3c507.cstatic int  el16_send_packet(struct sk_buff *skb, struct device *dev);
skb451drivers/net/3c507.cel16_send_packet(struct sk_buff *skb, struct device *dev)
skb486drivers/net/3c507.cif (skb == NULL) {
skb495drivers/net/3c507.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb496drivers/net/3c507.cunsigned char *buf = skb->data;
skb506drivers/net/3c507.cdev_kfree_skb (skb, FREE_WRITE);
skb841drivers/net/3c507.cstruct sk_buff *skb;
skb844drivers/net/3c507.cskb = dev_alloc_skb(pkt_len+2);
skb845drivers/net/3c507.cif (skb == NULL) {
skb851drivers/net/3c507.cskb_reserve(skb,2);
skb852drivers/net/3c507.cskb->dev = dev;
skb855drivers/net/3c507.cmemcpy(skb_put(skb,pkt_len), data_frame + 5, pkt_len);
skb857drivers/net/3c507.cskb->protocol=eth_type_trans(skb,dev);
skb858drivers/net/3c507.cnetif_rx(skb);
skb117drivers/net/3c509.cstatic int el3_start_xmit(struct sk_buff *skb, struct device *dev);
skb397drivers/net/3c509.cstruct sk_buff * skb;
skb408drivers/net/3c509.cskb = lp->queue[lp->head];
skb413drivers/net/3c509.coutw(skb->len, ioaddr + TX_FIFO);
skb416drivers/net/3c509.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
skb419drivers/net/3c509.cdev_kfree_skb(skb, FREE_WRITE);
skb441drivers/net/3c509.cel3_start_xmit(struct sk_buff *skb, struct device *dev)
skb454drivers/net/3c509.clp->queue[tail] = skb;
skb474drivers/net/3c509.cdev_kfree_skb(skb, FREE_WRITE);
skb605drivers/net/3c509.cstruct sk_buff *skb;
skb607drivers/net/3c509.cskb = dev_alloc_skb(pkt_len+5);
skb611drivers/net/3c509.cif (skb != NULL) {
skb612drivers/net/3c509.cskb->dev = dev;
skb613drivers/net/3c509.cskb_reserve(skb,2);  /* Align IP on 16 byte boundaries */
skb616drivers/net/3c509.cinsl(ioaddr+RX_FIFO, skb_put(skb,pkt_len),
skb619drivers/net/3c509.cskb->protocol=eth_type_trans(skb,dev);
skb620drivers/net/3c509.cnetif_rx(skb);
skb238drivers/net/3c59x.cstatic int vortex_start_xmit(struct sk_buff *skb, struct device *dev);
skb636drivers/net/3c59x.cvortex_start_xmit(struct sk_buff *skb, struct device *dev)
skb663drivers/net/3c59x.cif (skb == NULL || skb->len <= 0) {
skb679drivers/net/3c59x.coutl(skb->len, ioaddr + TX_FIFO);
skb683drivers/net/3c59x.coutl((int)(skb->data), ioaddr + Wn7_MasterAddr);
skb684drivers/net/3c59x.coutw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
skb685drivers/net/3c59x.cvp->tx_skb = skb;
skb689drivers/net/3c59x.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
skb690drivers/net/3c59x.cdev_kfree_skb (skb, FREE_WRITE);
skb699drivers/net/3c59x.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
skb700drivers/net/3c59x.cdev_kfree_skb (skb, FREE_WRITE);
skb891drivers/net/3c59x.cstruct sk_buff *skb;
skb893drivers/net/3c59x.cskb = dev_alloc_skb(pkt_len + 5);
skb897drivers/net/3c59x.cif (skb != NULL) {
skb898drivers/net/3c59x.cskb->dev = dev;
skb899drivers/net/3c59x.cskb_reserve(skb, 2);  /* Align IP on 16 byte boundaries */
skb901drivers/net/3c59x.cinsl(ioaddr + RX_FIFO, skb_put(skb, pkt_len),
skb903drivers/net/3c59x.cskb->protocol = eth_type_trans(skb, dev);
skb904drivers/net/3c59x.cnetif_rx(skb);
skb140drivers/net/8390.cstatic int ei_start_xmit(struct sk_buff *skb, struct device *dev)
skb182drivers/net/8390.cif (skb == NULL) {
skb187drivers/net/8390.clength = skb->len;
skb188drivers/net/8390.cif (skb->len <= 0)
skb228drivers/net/8390.cei_block_output(dev, length, skb->data, output_page);
skb242drivers/net/8390.cei_block_output(dev, length, skb->data, ei_local->tx_start_page);
skb253drivers/net/8390.cdev_kfree_skb (skb, FREE_WRITE);
skb467drivers/net/8390.cstruct sk_buff *skb;
skb469drivers/net/8390.cskb = dev_alloc_skb(pkt_len+2);
skb470drivers/net/8390.cif (skb == NULL) {
skb477drivers/net/8390.cskb_reserve(skb,2);  /* IP headers on 16 byte boundaries */
skb478drivers/net/8390.cskb->dev = dev;
skb479drivers/net/8390.cskb_put(skb, pkt_len);  /* Make room */
skb480drivers/net/8390.cei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
skb481drivers/net/8390.cskb->protocol=eth_type_trans(skb,dev);
skb482drivers/net/8390.cnetif_rx(skb);
skb76drivers/net/ac3200.cstruct sk_buff *skb, int ring_offset);
skb269drivers/net/ac3200.cstatic void ac_block_input(struct device *dev, int count, struct sk_buff *skb,
skb277drivers/net/ac3200.cmemcpy_fromio(skb->data, xfer_start, semi_count);
skb279drivers/net/ac3200.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
skb282drivers/net/ac3200.ceth_io_copy_and_sum(skb, xfer_start, count, 0);
skb185drivers/net/apricot.cstatic int i596_start_xmit(struct sk_buff *skb, struct device *dev);
skb340drivers/net/apricot.cstruct sk_buff *skb = dev_alloc_skb(pkt_len);
skb344drivers/net/apricot.cif (skb == NULL)
skb351drivers/net/apricot.cskb->dev = dev;    
skb352drivers/net/apricot.cmemcpy(skb_put(skb,pkt_len), lp->scb.rfd->data, pkt_len);
skb354drivers/net/apricot.cskb->protocol=eth_type_trans(skb,dev);
skb355drivers/net/apricot.cnetif_rx(skb);
skb358drivers/net/apricot.cif (i596_debug > 4) print_eth(skb->data);
skb406drivers/net/apricot.cstruct sk_buff *skb = ((struct sk_buff *)(tx_cmd->tbd->data)) -1;
skb408drivers/net/apricot.cdev_kfree_skb(skb, FREE_WRITE);
skb569drivers/net/apricot.ci596_start_xmit(struct sk_buff *skb, struct device *dev)
skb607drivers/net/apricot.cif (skb == NULL) {
skb613drivers/net/apricot.cif (skb->len <= 0) return 0;
skb623drivers/net/apricot.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb632drivers/net/apricot.cdev_kfree_skb(skb, FREE_WRITE);
skb646drivers/net/apricot.ctx_cmd->tbd->data = skb->data;
skb648drivers/net/apricot.cif (i596_debug > 3) print_eth(skb->data);
skb804drivers/net/apricot.cstruct sk_buff *skb = ((struct sk_buff *)(tx_cmd->tbd->data)) -1;
skb806drivers/net/apricot.cdev_kfree_skb(skb, FREE_WRITE);
skb810drivers/net/apricot.cif (i596_debug >2) print_eth(skb->data);
skb526drivers/net/arcnet.cstruct sk_buff *skb;    /* packet data buffer             */
skb534drivers/net/arcnet.cstruct sk_buff *skb;    /* buffer from upper levels */
skb586drivers/net/arcnet.cstatic void arcnet_dump_skb(struct device *dev,struct sk_buff *skb,
skb589drivers/net/arcnet.c#  define arcnet_dump_skb(dev,skb,desc) ;
skb607drivers/net/arcnet.cstatic int arcnet_send_packet_bad(struct sk_buff *skb,struct device *dev);
skb608drivers/net/arcnet.cstatic int arcnetA_send_packet(struct sk_buff *skb, struct device *dev);
skb623drivers/net/arcnet.cint arcnetA_header(struct sk_buff *skb,struct device *dev,
skb626drivers/net/arcnet.cstruct sk_buff *skb);
skb627drivers/net/arcnet.cunsigned short arcnetA_type_trans(struct sk_buff *skb,struct device *dev);
skb632drivers/net/arcnet.cstatic int arcnetE_send_packet(struct sk_buff *skb, struct device *dev);
skb640drivers/net/arcnet.cstatic int arcnetS_send_packet(struct sk_buff *skb, struct device *dev);
skb643drivers/net/arcnet.cint arcnetS_header(struct sk_buff *skb,struct device *dev,
skb646drivers/net/arcnet.cstruct sk_buff *skb);
skb647drivers/net/arcnet.cunsigned short arcnetS_type_trans(struct sk_buff *skb,struct device *dev);
skb669drivers/net/arcnet.cvoid arcnet_dump_skb(struct device *dev,struct sk_buff *skb,char *desc)
skb677drivers/net/arcnet.cfor(i=0; i<skb->len; i++)
skb682drivers/net/arcnet.cprintk("%02X ",((u_char *)skb->data)[i]);
skb1458drivers/net/arcnet.carcnet_send_packet_bad(struct sk_buff *skb, struct device *dev)
skb1491drivers/net/arcnet.cstatus,tickssofar,lp->outgoing.skb,
skb1516drivers/net/arcnet.cif (lp->outgoing.skb)
skb1518drivers/net/arcnet.cdev_kfree_skb(lp->outgoing.skb,FREE_WRITE);
skb1521drivers/net/arcnet.clp->outgoing.skb=NULL;
skb1533drivers/net/arcnet.cif (skb == NULL) {
skb1574drivers/net/arcnet.carcnetA_send_packet(struct sk_buff *skb, struct device *dev)
skb1582drivers/net/arcnet.cbad=arcnet_send_packet_bad(skb,dev);
skb1591drivers/net/arcnet.cout->length = 1 < skb->len ? skb->len : 1;
skb1592drivers/net/arcnet.cout->hdr=(struct ClientData*)skb->data;
skb1593drivers/net/arcnet.cout->skb=skb;
skb1595drivers/net/arcnet.cBUGLVL(D_SKB) arcnet_dump_skb(dev,skb,"tx");
skb1612drivers/net/arcnet.c((char *)skb->data)+sizeof(struct ClientData),
skb1617drivers/net/arcnet.cdev_kfree_skb(out->skb,FREE_WRITE);
skb1618drivers/net/arcnet.cout->skb=NULL;
skb1631drivers/net/arcnet.cout->data=(u_char *)skb->data
skb1663drivers/net/arcnet.cif (out->skb)
skb1664drivers/net/arcnet.cdev_kfree_skb(out->skb,FREE_WRITE);
skb1665drivers/net/arcnet.cout->skb=NULL;
skb1987drivers/net/arcnet.cstatus,out->numsegs,out->segnum,out->skb);
skb2018drivers/net/arcnet.cif (!lp->outgoing.skb)
skb2046drivers/net/arcnet.cif (out->skb)
skb2047drivers/net/arcnet.cdev_kfree_skb(out->skb,FREE_WRITE);
skb2048drivers/net/arcnet.cout->skb=NULL;
skb2260drivers/net/arcnet.cstruct sk_buff *skb;
skb2289drivers/net/arcnet.cif (in->skb)  /* already assembling one! */
skb2294drivers/net/arcnet.ckfree_skb(in->skb,FREE_WRITE);
skb2297drivers/net/arcnet.cin->skb=NULL;
skb2302drivers/net/arcnet.cskb = alloc_skb(length, GFP_ATOMIC);
skb2303drivers/net/arcnet.cif (skb == NULL) {
skb2308drivers/net/arcnet.csoft=(struct ClientData *)skb->data;
skb2310drivers/net/arcnet.cskb->len = length;
skb2311drivers/net/arcnet.cskb->dev = dev;
skb2356drivers/net/arcnet.cBUGLVL(D_SKB) arcnet_dump_skb(dev,skb,"rx");
skb2358drivers/net/arcnet.cskb->protocol=arcnetA_type_trans(skb,dev);
skb2360drivers/net/arcnet.cnetif_rx(skb);
skb2386drivers/net/arcnet.cif (in->skb && in->sequence!=arcsoft->sequence)
skb2391drivers/net/arcnet.ckfree_skb(in->skb,FREE_WRITE);
skb2392drivers/net/arcnet.cin->skb=NULL;
skb2402drivers/net/arcnet.cif (in->skb)  /* already assembling one! */
skb2409drivers/net/arcnet.ckfree_skb(in->skb,FREE_WRITE);
skb2425drivers/net/arcnet.cin->skb=skb=alloc_skb(508*in->numpackets
skb2428drivers/net/arcnet.cif (skb == NULL) {
skb2437drivers/net/arcnet.cskb->free=1;
skb2439drivers/net/arcnet.csoft=(struct ClientData *)skb->data;
skb2441drivers/net/arcnet.cskb->len=sizeof(struct ClientData);
skb2442drivers/net/arcnet.cskb->dev=dev;
skb2456drivers/net/arcnet.cif (!in->skb)
skb2482drivers/net/arcnet.ckfree_skb(in->skb,FREE_WRITE);
skb2483drivers/net/arcnet.cin->skb=NULL;
skb2490drivers/net/arcnet.csoft=(struct ClientData *)in->skb->data;
skb2493drivers/net/arcnet.cskb=in->skb;
skb2495drivers/net/arcnet.cmemcpy(skb->data+skb->len,
skb2499drivers/net/arcnet.cskb->len+=length-sizeof(struct ClientData);
skb2507drivers/net/arcnet.cif (!skb || !in->skb)
skb2510drivers/net/arcnet.cskb,in->skb);
skb2514drivers/net/arcnet.cin->skb=NULL;
skb2517drivers/net/arcnet.cBUGLVL(D_SKB) arcnet_dump_skb(dev,skb,"rx");
skb2519drivers/net/arcnet.cskb->protocol=arcnetA_type_trans(skb,dev);
skb2521drivers/net/arcnet.cnetif_rx(skb);
skb2576drivers/net/arcnet.cint arcnetA_header(struct sk_buff *skb,struct device *dev,
skb2580drivers/net/arcnet.cskb_push(skb,dev->hard_header_len);
skb2651drivers/net/arcnet.cstruct sk_buff *skb)
skb2678drivers/net/arcnet.cstatus=arp_find(&(head->daddr), dst, dev, dev->pa_addr, skb)? 1 : 0;
skb2692drivers/net/arcnet.cunsigned short arcnetA_type_trans(struct sk_buff *skb,struct device *dev)
skb2698drivers/net/arcnet.cskb->mac.raw=skb->data;
skb2699drivers/net/arcnet.cskb_pull(skb,dev->hard_header_len);
skb2700drivers/net/arcnet.chead=(struct ClientData *)skb->mac.raw;
skb2703drivers/net/arcnet.cskb->pkt_type=PACKET_BROADCAST;
skb2708drivers/net/arcnet.cskb->pkt_type=PACKET_OTHERHOST;
skb2763drivers/net/arcnet.carcnetE_send_packet(struct sk_buff *skb, struct device *dev)
skb2770drivers/net/arcnet.cshort offset,length=skb->len+1;
skb2774drivers/net/arcnet.cbad=arcnet_send_packet_bad(skb,dev);
skb2789drivers/net/arcnet.cdev_kfree_skb(skb,FREE_WRITE);
skb2805drivers/net/arcnet.cif (((struct ethhdr*)(skb->data))->h_dest[0] == 0xFF)
skb2809drivers/net/arcnet.c((struct ethhdr*)(skb->data))->h_dest[5];
skb2837drivers/net/arcnet.cmemcpy(arcsoft,skb->data,skb->len);
skb2847drivers/net/arcnet.cdev_kfree_skb(skb,FREE_WRITE);
skb2874drivers/net/arcnet.cstruct sk_buff *skb;
skb2879drivers/net/arcnet.cskb = alloc_skb(length, GFP_ATOMIC);
skb2880drivers/net/arcnet.cif (skb == NULL) {
skb2886drivers/net/arcnet.cskb->len = length;
skb2887drivers/net/arcnet.cskb->dev = dev;
skb2889drivers/net/arcnet.cmemcpy(skb->data,(u_char *)arcsoft+1,length-1);
skb2891drivers/net/arcnet.cBUGLVL(D_SKB) arcnet_dump_skb(dev,skb,"rx");
skb2893drivers/net/arcnet.cskb->protocol=eth_type_trans(skb,dev);
skb2895drivers/net/arcnet.cnetif_rx(skb);
skb2934drivers/net/arcnet.carcnetS_send_packet(struct sk_buff *skb, struct device *dev)
skb2938drivers/net/arcnet.cstruct S_ClientData *hdr=(struct S_ClientData *)skb->data;
skb2942drivers/net/arcnet.cbad=arcnet_send_packet_bad(skb,dev);
skb2951drivers/net/arcnet.clength = 1 < skb->len ? skb->len : 1;
skb2953drivers/net/arcnet.cBUGLVL(D_SKB) arcnet_dump_skb(dev,skb,"tx");
skb2959drivers/net/arcnet.cskb->data+S_EXTRA_CLIENTDATA,
skb2961drivers/net/arcnet.cskb->data+sizeof(struct S_ClientData),
skb2966drivers/net/arcnet.cdev_kfree_skb(skb,FREE_WRITE);
skb2979drivers/net/arcnet.cdev_kfree_skb(skb,FREE_WRITE);
skb3003drivers/net/arcnet.cstruct sk_buff *skb;
skb3016drivers/net/arcnet.cskb = alloc_skb(length, GFP_ATOMIC);
skb3017drivers/net/arcnet.cif (skb == NULL) {
skb3022drivers/net/arcnet.csoft=(struct S_ClientData *)skb->data;
skb3023drivers/net/arcnet.cskb->len = length;
skb3033drivers/net/arcnet.cskb->dev = dev;  /* is already lp->sdev */
skb3035drivers/net/arcnet.cBUGLVL(D_SKB) arcnet_dump_skb(dev,skb,"rx");
skb3037drivers/net/arcnet.cskb->protocol=arcnetS_type_trans(skb,dev);
skb3039drivers/net/arcnet.cnetif_rx(skb);
skb3049drivers/net/arcnet.cint arcnetS_header(struct sk_buff *skb,struct device *dev,
skb3053drivers/net/arcnet.cskb_push(skb,dev->hard_header_len);
skb3106drivers/net/arcnet.cstruct sk_buff *skb)
skb3130drivers/net/arcnet.creturn arp_find(&(head->daddr), dst, dev, dev->pa_addr, skb)? 1 : 0;
skb3141drivers/net/arcnet.cunsigned short arcnetS_type_trans(struct sk_buff *skb,struct device *dev)
skb3147drivers/net/arcnet.cskb->mac.raw=skb->data;
skb3148drivers/net/arcnet.cskb_pull(skb,dev->hard_header_len);
skb3149drivers/net/arcnet.chead=(struct S_ClientData *)skb->mac.raw;
skb3152drivers/net/arcnet.cskb->pkt_type=PACKET_BROADCAST;
skb3157drivers/net/arcnet.cskb->pkt_type=PACKET_OTHERHOST;
skb119drivers/net/at1700.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb364drivers/net/at1700.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb398drivers/net/at1700.cif (skb == NULL) {
skb408drivers/net/at1700.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb409drivers/net/at1700.cunsigned char *buf = skb->data;
skb435drivers/net/at1700.cdev_kfree_skb (skb, FREE_WRITE);
skb520drivers/net/at1700.cstruct sk_buff *skb;
skb531drivers/net/at1700.cskb = dev_alloc_skb(pkt_len+3);
skb532drivers/net/at1700.cif (skb == NULL) {
skb541drivers/net/at1700.cskb->dev = dev;
skb542drivers/net/at1700.cskb_reserve(skb,2);
skb544drivers/net/at1700.cinsw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
skb545drivers/net/at1700.cskb->protocol=eth_type_trans(skb, dev);
skb546drivers/net/at1700.cnetif_rx(skb);
skb137drivers/net/atp.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb416drivers/net/atp.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb440drivers/net/atp.cif (skb == NULL) {
skb450drivers/net/atp.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb451drivers/net/atp.cunsigned char *buf = skb->data;
skb479drivers/net/atp.cdev_kfree_skb (skb, FREE_WRITE);
skb673drivers/net/atp.cstruct sk_buff *skb;
skb675drivers/net/atp.cskb = dev_alloc_skb(pkt_len);
skb676drivers/net/atp.cif (skb == NULL) {
skb681drivers/net/atp.cskb->dev = dev;
skb683drivers/net/atp.cread_block(ioaddr, pkt_len, skb_put(skb,pkt_len), dev->if_port);
skb686drivers/net/atp.cunsigned char *data = skb->data;
skb694drivers/net/atp.cskb->protocol=eth_type_trans(skb,dev);
skb695drivers/net/atp.cnetif_rx(skb);
skb454drivers/net/de4x5.cstruct sk_buff *skb[NUM_TX_DESC];       /* TX skb for freeing when sent */
skb505drivers/net/de4x5.cstruct sk_buff *skb;                /* Save the (re-ordered) skb's  */
skb538drivers/net/de4x5.cstatic int     de4x5_queue_pkt(struct sk_buff *skb, struct device *dev);
skb559drivers/net/de4x5.cstatic void    load_packet(struct device *dev, char *buf, u32 flags, struct sk_buff *skb);
skb576drivers/net/de4x5.cstatic void    de4x5_put_cache(struct device *dev, struct sk_buff *skb);
skb577drivers/net/de4x5.cstatic void    de4x5_putb_cache(struct device *dev, struct sk_buff *skb);
skb1039drivers/net/de4x5.cde4x5_queue_pkt(struct sk_buff *skb, struct device *dev)
skb1045drivers/net/de4x5.cif (skb == NULL) {
skb1051drivers/net/de4x5.cde4x5_put_cache(dev, skb);               /* Queue the buffer locally */
skb1066drivers/net/de4x5.cif (dev->tbusy || lp->skb[lp->tx_new]) {
skb1068drivers/net/de4x5.cde4x5_putb_cache(dev, skb);          /* Requeue the buffer */
skb1070drivers/net/de4x5.cde4x5_put_cache(dev, skb);
skb1073drivers/net/de4x5.cprintk("%s: transmit busy, lost media or stale skb found:\n  STS:%08x\n  tbusy:%ld\n  lostMedia:%d\n  IMR:%08x\n  OMR:%08x\n Stale skb: %s\n",dev->name, inl(DE4X5_STS), dev->tbusy, lp->lostMedia, inl(DE4X5_IMR), inl(DE4X5_OMR), (lp->skb[lp->tx_new] ? "YES" : "NO"));
skb1075drivers/net/de4x5.c} else if (skb->len > 0) {
skb1077drivers/net/de4x5.cif (lp->cache.skb && !dev->interrupt) {
skb1078drivers/net/de4x5.cde4x5_put_cache(dev, skb);
skb1079drivers/net/de4x5.cskb = de4x5_get_cache(dev);
skb1082drivers/net/de4x5.cwhile (skb && !dev->tbusy && !lp->skb[lp->tx_new]) {
skb1086drivers/net/de4x5.cload_packet(dev, skb->data, 
skb1087drivers/net/de4x5.cTD_IC | TD_LS | TD_FS | skb->len, skb);
skb1096drivers/net/de4x5.cskb = de4x5_get_cache(dev);
skb1100drivers/net/de4x5.cif (skb && (dev->tbusy || lp->skb[lp->tx_new])) {
skb1101drivers/net/de4x5.cde4x5_putb_cache(dev, skb);
skb1166drivers/net/de4x5.cwhile (lp->cache.skb && !dev->tbusy && lp->tx_enable) {
skb1204drivers/net/de4x5.cstruct sk_buff *skb;
skb1207drivers/net/de4x5.cif ((skb = dev_alloc_skb(pkt_len+2)) == NULL) {
skb1214drivers/net/de4x5.cskb->dev = dev;
skb1215drivers/net/de4x5.cskb_reserve(skb,2);        /* Align */
skb1218drivers/net/de4x5.cmemcpy(skb_put(skb,len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), len);
skb1219drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len-len), bus_to_virt(lp->rx_ring[0].buf), pkt_len - len);
skb1221drivers/net/de4x5.cmemcpy(skb_put(skb,pkt_len), bus_to_virt(lp->rx_ring[lp->rx_old].buf), pkt_len);
skb1225drivers/net/de4x5.cskb->protocol=eth_type_trans(skb,dev);
skb1226drivers/net/de4x5.cnetif_rx(skb);
skb1236drivers/net/de4x5.cbuf = skb->data;              /* Look at the dest addr */
skb1307drivers/net/de4x5.cif (lp->skb[entry] != NULL) {
skb1308drivers/net/de4x5.cdev_kfree_skb(lp->skb[entry], FREE_WRITE);
skb1309drivers/net/de4x5.clp->skb[entry] = NULL;
skb1396drivers/net/de4x5.cstatic void load_packet(struct device *dev, char *buf, u32 flags, struct sk_buff *skb)
skb1403drivers/net/de4x5.clp->skb[lp->tx_new] = skb;
skb2521drivers/net/de4x5.cif (lp->skb[i]) {
skb2522drivers/net/de4x5.cde4x5_putb_cache(dev, lp->skb[i]);
skb2523drivers/net/de4x5.clp->skb[i] = NULL;
skb2527drivers/net/de4x5.cif (lp->skb[i]) {
skb2528drivers/net/de4x5.cde4x5_putb_cache(dev, lp->skb[i]);
skb2529drivers/net/de4x5.clp->skb[i] = NULL;
skb2547drivers/net/de4x5.cstruct sk_buff *skb;
skb2558drivers/net/de4x5.cfor (i=0; TX_BUFFS_AVAIL && lp->cache.skb; i++) {
skb2559drivers/net/de4x5.cskb = de4x5_get_cache(dev);
skb2560drivers/net/de4x5.cload_packet(dev, skb->data, TD_IC | TD_LS | TD_FS | skb->len, skb);
skb2612drivers/net/de4x5.cstatic void de4x5_put_cache(struct device *dev, struct sk_buff *skb)
skb2617drivers/net/de4x5.cif (lp->cache.skb) {
skb2618drivers/net/de4x5.cfor (p=lp->cache.skb; p->next; p=p->next);
skb2619drivers/net/de4x5.cp->next = skb;
skb2621drivers/net/de4x5.clp->cache.skb = skb;
skb2623drivers/net/de4x5.cskb->next = NULL;
skb2628drivers/net/de4x5.cstatic void de4x5_putb_cache(struct device *dev, struct sk_buff *skb)
skb2631drivers/net/de4x5.cstruct sk_buff *p = lp->cache.skb;
skb2633drivers/net/de4x5.clp->cache.skb = skb;
skb2634drivers/net/de4x5.cskb->next = p;
skb2642drivers/net/de4x5.cstruct sk_buff *p = lp->cache.skb;
skb2645drivers/net/de4x5.clp->cache.skb = p->next;
skb247drivers/net/de600.cstatic int  de600_start_xmit(struct sk_buff *skb, struct device *dev);
skb397drivers/net/de600.cde600_start_xmit(struct sk_buff *skb, struct device *dev)
skb402drivers/net/de600.cbyte  *buffer = skb->data;
skb410drivers/net/de600.cif (skb == NULL) {
skb434drivers/net/de600.cPRINTK(("de600_start_xmit:len=%d, page %d/%d\n", skb->len, tx_fifo_in, free_tx_pages));
skb436drivers/net/de600.cif ((len = skb->len) < RUNT)
skb476drivers/net/de600.cif (skb->sk && (skb->sk->protocol == IPPROTO_TCP) &&
skb477drivers/net/de600.c(skb->sk->prot->rspace != &de600_rspace))
skb478drivers/net/de600.cskb->sk->prot->rspace = de600_rspace; /* Ugh! */
skb481drivers/net/de600.cdev_kfree_skb (skb, FREE_WRITE);
skb580drivers/net/de600.cstruct sk_buff  *skb;
skb605drivers/net/de600.cskb = dev_alloc_skb(size+2);
skb607drivers/net/de600.cif (skb == NULL) {
skb614drivers/net/de600.cskb->dev = dev;
skb615drivers/net/de600.cskb_reserve(skb,2);  /* Align */
skb618drivers/net/de600.cbuffer = skb_put(skb,size);
skb627drivers/net/de600.cskb->protocol=eth_type_trans(skb,dev);
skb629drivers/net/de600.cnetif_rx(skb);
skb511drivers/net/de620.cde620_start_xmit(struct sk_buff *skb, struct device *dev)
skb516drivers/net/de620.cbyte *buffer = skb->data;
skb525drivers/net/de620.cif (skb == NULL) {
skb550drivers/net/de620.cif ((len = skb->len) < RUNT)
skb560drivers/net/de620.c(int)skb->len, using_txbuf));
skb590drivers/net/de620.cdev_kfree_skb (skb, FREE_WRITE);
skb652drivers/net/de620.cstruct sk_buff *skb;
skb707drivers/net/de620.cskb = dev_alloc_skb(size+2);
skb708drivers/net/de620.cif (skb == NULL) { /* Yeah, but no place to put it... */
skb714drivers/net/de620.cskb_reserve(skb,2);  /* Align */
skb715drivers/net/de620.cskb->dev = dev;
skb716drivers/net/de620.cskb->free = 1;
skb718drivers/net/de620.cbuffer = skb_put(skb,size);
skb722drivers/net/de620.cskb->protocol=eth_type_trans(skb,dev);
skb723drivers/net/de620.cnetif_rx(skb); /* deliver it "upstairs" */
skb383drivers/net/depca.cstatic int    depca_start_xmit(struct sk_buff *skb, struct device *dev);
skb408drivers/net/depca.cstatic int    load_packet(struct device *dev, struct sk_buff *skb);
skb779drivers/net/depca.cdepca_start_xmit(struct sk_buff *skb, struct device *dev)
skb804drivers/net/depca.c} else if (skb == NULL) {
skb806drivers/net/depca.c} else if (skb->len > 0) {
skb813drivers/net/depca.cstatus = load_packet(dev, skb);
skb821drivers/net/depca.cdev_kfree_skb(skb, FREE_WRITE);
skb912drivers/net/depca.cstruct sk_buff *skb;
skb914drivers/net/depca.cskb = dev_alloc_skb(pkt_len+2);
skb915drivers/net/depca.cif (skb != NULL) {
skb917drivers/net/depca.cskb_reserve(skb,2);               /* 16 byte align the IP header */
skb918drivers/net/depca.cbuf = skb_put(skb,pkt_len);
skb919drivers/net/depca.cskb->dev = dev;
skb932drivers/net/depca.cskb->protocol=eth_type_trans(skb,dev);
skb933drivers/net/depca.cnetif_rx(skb);
skb1532drivers/net/depca.cstatic int load_packet(struct device *dev, struct sk_buff *skb)
skb1538drivers/net/depca.cend = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
skb1546drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, len);
skb1547drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[0], skb->data + len, skb->len - len);
skb1549drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, skb->len);
skb1553drivers/net/depca.clen = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
skb103drivers/net/dlci.cstatic int dlci_header(struct sk_buff *skb, struct device *dev, 
skb133drivers/net/dlci.cdest = skb_push(skb, hlen);
skb142drivers/net/dlci.cstatic void dlci_receive(struct sk_buff *skb, struct device *dev)
skb149drivers/net/dlci.chdr = (struct fradhdr *) skb->data;
skb152drivers/net/dlci.cskb->dev = dev;
skb179drivers/net/dlci.cskb->protocol = htons(hdr->PID);
skb185drivers/net/dlci.cskb->protocol = htons(ETH_P_IP);
skb205drivers/net/dlci.cskb->mac.raw = skb->data; 
skb206drivers/net/dlci.cskb_pull(skb, header);
skb207drivers/net/dlci.cnetif_rx(skb);
skb211drivers/net/dlci.cdev_kfree_skb(skb, FREE_WRITE);
skb214drivers/net/dlci.cstatic int dlci_transmit(struct sk_buff *skb, struct device *dev)
skb221drivers/net/dlci.cif (!skb || !dev)
skb233drivers/net/dlci.cret = dlp->slave->hard_start_xmit(skb, dlp->slave); 
skb56drivers/net/dummy.cstatic int dummy_xmit(struct sk_buff *skb, struct device *dev);
skb105drivers/net/dummy.cdummy_xmit(struct sk_buff *skb, struct device *dev)
skb111drivers/net/dummy.cif (skb == NULL || dev == NULL)
skb114drivers/net/dummy.cdev_kfree_skb(skb, FREE_WRITE);
skb102drivers/net/e2100.cstruct sk_buff *skb, int ring_offset);
skb318drivers/net/e2100.ce21_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
skb326drivers/net/e2100.ceth_io_copy_and_sum(skb, dev->mem_start + (ring_offset & 0xff), count, 0);
skb137drivers/net/eepro.cstatic int  eepro_send_packet(struct sk_buff *skb, struct device *dev);
skb595drivers/net/eepro.ceepro_send_packet(struct sk_buff *skb, struct device *dev)
skb633drivers/net/eepro.cif (skb == NULL) {
skb642drivers/net/eepro.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb643drivers/net/eepro.cunsigned char *buf = skb->data;
skb649drivers/net/eepro.cdev_kfree_skb (skb, FREE_WRITE);
skb1046drivers/net/eepro.cstruct sk_buff *skb;
skb1049drivers/net/eepro.cskb = dev_alloc_skb(rcv_size+2);
skb1050drivers/net/eepro.cif (skb == NULL) {
skb1055drivers/net/eepro.cskb->dev = dev;
skb1056drivers/net/eepro.cskb_reserve(skb,2);
skb1058drivers/net/eepro.cinsw(ioaddr+IO_PORT, skb_put(skb,rcv_size), (rcv_size + 1) >> 1);
skb1060drivers/net/eepro.cskb->protocol = eth_type_trans(skb,dev);  
skb1061drivers/net/eepro.cnetif_rx(skb);
skb620drivers/net/eexpress.cstruct sk_buff *skb;
skb622drivers/net/eexpress.cskb = dev_alloc_skb(pkt_len+16);
skb623drivers/net/eexpress.cif (skb == NULL) 
skb629drivers/net/eexpress.cskb->dev = dev;
skb630drivers/net/eexpress.cskb_reserve(skb, 2);
skb632drivers/net/eexpress.cinsw(ioaddr,skb_put(skb,pkt_len),(pkt_len+1)>>1);
skb633drivers/net/eexpress.cskb->protocol = eth_type_trans(skb,dev);
skb634drivers/net/eexpress.cnetif_rx(skb);
skb149drivers/net/eql.cstatic int eql_slave_xmit(struct sk_buff *skb, struct device *dev); /*  */
skb152drivers/net/eql.cstatic int eql_header(struct sk_buff *skb, struct device *dev, 
skb156drivers/net/eql.cunsigned long raddr, struct sk_buff *skb); /*  */
skb361drivers/net/eql.cstatic int eql_slave_xmit(struct sk_buff *skb, struct device *dev)
skb367drivers/net/eql.cif (skb == NULL)
skb380drivers/net/eql.cdev->name, eql_number_slaves (eql->queue), skb->len,
skb383drivers/net/eql.cdev_queue_xmit (skb, slave_dev, 1);
skb385drivers/net/eql.cslave->bytes_queued += skb->len; 
skb395drivers/net/eql.cdev_kfree_skb(skb, FREE_WRITE);
skb408drivers/net/eql.cstatic int  eql_header(struct sk_buff *skb, struct device *dev, 
skb417drivers/net/eql.cunsigned long raddr, struct sk_buff *skb)
skb327drivers/net/eth16i.cstatic int eth16i_tx(struct sk_buff *skb, struct device *dev);
skb859drivers/net/eth16i.cstatic int eth16i_tx(struct sk_buff *skb, struct device *dev)
skb918drivers/net/eth16i.cif(skb == NULL) {
skb932drivers/net/eth16i.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb933drivers/net/eth16i.cunsigned char *buf = skb->data;
skb973drivers/net/eth16i.cdev_kfree_skb(skb, FREE_WRITE);
skb1003drivers/net/eth16i.cstruct sk_buff *skb;
skb1016drivers/net/eth16i.cskb = dev_alloc_skb(pkt_len + 3);
skb1017drivers/net/eth16i.cif( skb == NULL ) {
skb1025drivers/net/eth16i.cskb->dev = dev;
skb1026drivers/net/eth16i.cskb_reserve(skb,2);
skb1034drivers/net/eth16i.cinsw(ioaddr + DATAPORT, skb_put(skb, pkt_len), (pkt_len + 1) >> 1);
skb1036drivers/net/eth16i.cunsigned char *buf = skb_put(skb, pkt_len);
skb1051drivers/net/eth16i.cskb->protocol=eth_type_trans(skb, dev);
skb1052drivers/net/eth16i.cnetif_rx(skb);
skb1059drivers/net/eth16i.cprintk(" %02x", skb->data[i]);
skb290drivers/net/ewrk3.cstatic int    ewrk3_queue_pkt(struct sk_buff *skb, struct device *dev);
skb722drivers/net/ewrk3.cewrk3_queue_pkt(struct sk_buff *skb, struct device *dev)
skb758drivers/net/ewrk3.c} else if (skb == NULL) {
skb760drivers/net/ewrk3.c} else if (skb->len > 0) {
skb808drivers/net/ewrk3.cu_char *p = skb->data;
skb811drivers/net/ewrk3.coutb((char)(skb->len & 0xff), EWRK3_DATA);
skb812drivers/net/ewrk3.coutb((char)((skb->len >> 8) & 0xff), EWRK3_DATA);
skb814drivers/net/ewrk3.cfor (i=0; i<skb->len; i++) {
skb821drivers/net/ewrk3.cwriteb((char)(skb->len & 0xff), (char *)buf);/* length (16 bit xfer)*/
skb824drivers/net/ewrk3.cwriteb((char)(((skb->len >> 8) & 0xff) | XCT), (char *)buf);
skb828drivers/net/ewrk3.cwriteb(0x00, (char *)(buf + skb->len));  /* Write the XCT flag */
skb829drivers/net/ewrk3.cmemcpy_toio(buf, skb->data, PRELOAD);/* Write PRELOAD bytes*/
skb831drivers/net/ewrk3.cmemcpy_toio(buf+PRELOAD, skb->data+PRELOAD, skb->len-PRELOAD);
skb832drivers/net/ewrk3.cwriteb(0xff, (char *)(buf + skb->len));  /* Write the XCT flag */
skb834drivers/net/ewrk3.cwriteb((char)((skb->len >> 8) & 0xff), (char *)buf);
skb838drivers/net/ewrk3.cmemcpy_toio((char *)buf, skb->data, skb->len);/* Write data bytes */
skb844drivers/net/ewrk3.cdev_kfree_skb (skb, FREE_WRITE);
skb1000drivers/net/ewrk3.cstruct sk_buff *skb;
skb1002drivers/net/ewrk3.cif ((skb = dev_alloc_skb(pkt_len+2)) != NULL) {
skb1004drivers/net/ewrk3.cskb->dev = dev;
skb1005drivers/net/ewrk3.cskb_reserve(skb,2);             /* Align to 16 bytes */
skb1006drivers/net/ewrk3.cp = skb_put(skb,pkt_len);
skb1021drivers/net/ewrk3.cskb->protocol=eth_type_trans(skb,dev);
skb1022drivers/net/ewrk3.cnetif_rx(skb);
skb1034drivers/net/ewrk3.cp = skb->data;                  /* Look at the dest addr */
skb112drivers/net/fmv18x.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb310drivers/net/fmv18x.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb351drivers/net/fmv18x.cif (skb == NULL) {
skb361drivers/net/fmv18x.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb362drivers/net/fmv18x.cunsigned char *buf = skb->data;
skb373drivers/net/fmv18x.c(unsigned long)skb->len);
skb399drivers/net/fmv18x.cdev_kfree_skb (skb, FREE_WRITE);
skb495drivers/net/fmv18x.cstruct sk_buff *skb;
skb504drivers/net/fmv18x.cskb = dev_alloc_skb(pkt_len+3);
skb505drivers/net/fmv18x.cif (skb == NULL) {
skb512drivers/net/fmv18x.cskb->dev = dev;
skb513drivers/net/fmv18x.cskb_reserve(skb,2);
skb515drivers/net/fmv18x.cinsw(ioaddr + DATAPORT, skb_put(skb,pkt_len), (pkt_len + 1) >> 1);
skb521drivers/net/fmv18x.cprintk(" %02x", skb->data[i]);
skb525drivers/net/fmv18x.cskb->protocol=eth_type_trans(skb, dev);
skb526drivers/net/fmv18x.cnetif_rx(skb);
skb102drivers/net/hp-plus.cstruct sk_buff *skb, int ring_offset);
skb108drivers/net/hp-plus.cstruct sk_buff *skb, int ring_offset);
skb340drivers/net/hp-plus.chpp_io_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
skb343drivers/net/hp-plus.cchar *buf = skb->data;
skb367drivers/net/hp-plus.chpp_mem_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
skb380drivers/net/hp-plus.cmemcpy_fromio(skb->data, dev->mem_start, count);
skb66drivers/net/hp.cstruct sk_buff *skb , int ring_offset);
skb276drivers/net/hp.chp_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
skb281drivers/net/hp.cchar *buf = skb->data;
skb193drivers/net/hp100.cstatic int hp100_start_xmit( struct sk_buff *skb, struct device *dev );
skb574drivers/net/hp100.cstatic int hp100_start_xmit( struct sk_buff *skb, struct device *dev )
skb595drivers/net/hp100.cif ( ( i = ( hp100_inl( TX_MEM_FREE ) & ~0x7fffffff ) ) < skb -> len + 16 )
skb639drivers/net/hp100.cif ( skb == NULL )
skb645drivers/net/hp100.cif ( skb -> len <= 0 ) return 0;
skb658drivers/net/hp100.cprintk( "hp100_start_xmit: irq_status = 0x%x, len = %d\n", val, (int)skb -> len );
skb660drivers/net/hp100.cok_flag = skb -> len >= HP100_MIN_PACKET_SIZE;
skb661drivers/net/hp100.ci = ok_flag ? skb -> len : HP100_MIN_PACKET_SIZE;
skb668drivers/net/hp100.cmemcpy( lp -> mem_ptr_virt, skb -> data, skb -> len );
skb670drivers/net/hp100.cmemset( lp -> mem_ptr_virt, 0, HP100_MIN_PACKET_SIZE - skb -> len );
skb674drivers/net/hp100.cmemcpy_toio( lp -> mem_ptr_phys, skb -> data, skb -> len );
skb676drivers/net/hp100.cmemset_io( lp -> mem_ptr_phys, 0, HP100_MIN_PACKET_SIZE - skb -> len );
skb681drivers/net/hp100.coutsl( ioaddr + HP100_REG_DATA32, skb -> data, ( skb -> len + 3 ) >> 2 );
skb683drivers/net/hp100.cfor ( i = ( skb -> len + 3 ) & ~3; i < HP100_MIN_PACKET_SIZE; i += 4 )
skb691drivers/net/hp100.cdev_kfree_skb( skb, FREE_WRITE );
skb710drivers/net/hp100.cstruct sk_buff *skb;
skb753drivers/net/hp100.cskb = dev_alloc_skb( pkt_len );
skb754drivers/net/hp100.cif ( skb == NULL )
skb765drivers/net/hp100.cskb -> dev = dev;
skb766drivers/net/hp100.cptr = (u_char *)skb_put( skb, pkt_len );
skb776drivers/net/hp100.cskb -> protocol = eth_type_trans( skb, dev );
skb777drivers/net/hp100.cnetif_rx( skb );
skb169drivers/net/ibmtr.cstatic int tok_send_packet(struct sk_buff *skb, struct device *dev);
skb1250drivers/net/ibmtr.cstruct sk_buff *skb;
skb1326drivers/net/ibmtr.cif (!(skb=dev_alloc_skb(arb_frame_len-lan_hdr_len+sizeof(struct trh_hdr)))) {
skb1334drivers/net/ibmtr.cskb_put(skb, arb_frame_len-lan_hdr_len+sizeof(struct trh_hdr));
skb1335drivers/net/ibmtr.cskb->dev=dev;
skb1337drivers/net/ibmtr.cdata=skb->data;
skb1376drivers/net/ibmtr.cskb->protocol=tr_type_trans(skb,dev);
skb1377drivers/net/ibmtr.cnetif_rx(skb);
skb1381drivers/net/ibmtr.cstatic int tok_send_packet(struct sk_buff *skb, struct device *dev) 
skb1403drivers/net/ibmtr.cif (skb==NULL) {
skb1412drivers/net/ibmtr.cti->current_skb=skb; 
skb276drivers/net/lance.cstatic int lance_start_xmit(struct sk_buff *skb, struct device *dev);
skb728drivers/net/lance.clance_start_xmit(struct sk_buff *skb, struct device *dev)
skb770drivers/net/lance.cif (skb == NULL) {
skb775drivers/net/lance.cif (skb->len <= 0)
skb810drivers/net/lance.c-(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
skb812drivers/net/lance.clp->tx_ring[entry].length = -skb->len;
skb818drivers/net/lance.cif ((int)(skb->data) + skb->len > 0x01000000) {
skb821drivers/net/lance.cdev->name, (int)(skb->data));
skb822drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
skb825drivers/net/lance.cdev_kfree_skb (skb, FREE_WRITE);
skb827drivers/net/lance.clp->tx_skbuff[entry] = skb;
skb828drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
skb1007drivers/net/lance.cstruct sk_buff *skb;
skb1016drivers/net/lance.cskb = dev_alloc_skb(pkt_len+2);
skb1017drivers/net/lance.cif (skb == NULL) 
skb1032drivers/net/lance.cskb->dev = dev;
skb1033drivers/net/lance.cskb_reserve(skb,2);  /* 16 byte align */
skb1034drivers/net/lance.cskb_put(skb,pkt_len);  /* Make room */
skb1035drivers/net/lance.ceth_copy_and_sum(skb,
skb1038drivers/net/lance.cskb->protocol=eth_type_trans(skb,dev);
skb1039drivers/net/lance.cnetif_rx(skb);
skb56drivers/net/loopback.cstatic int loopback_xmit(struct sk_buff *skb, struct device *dev)
skb61drivers/net/loopback.cif (skb == NULL || dev == NULL) 
skb69drivers/net/loopback.cif(skb->free==0)
skb71drivers/net/loopback.cstruct sk_buff *skb2=skb;
skb72drivers/net/loopback.cskb=skb_clone(skb, GFP_ATOMIC);    /* Clone the buffer */
skb73drivers/net/loopback.cif(skb==NULL)
skb78drivers/net/loopback.celse if(skb->sk)
skb84drivers/net/loopback.catomic_sub(skb->truesize, &skb->sk->wmem_alloc);
skb85drivers/net/loopback.cskb->sk->write_space(skb->sk);
skb88drivers/net/loopback.cskb->protocol=eth_type_trans(skb,dev);
skb89drivers/net/loopback.cskb->dev=dev;
skb91drivers/net/loopback.cskb->ip_summed = CHECKSUM_UNNECESSARY;
skb93drivers/net/loopback.cnetif_rx(skb);
skb95drivers/net/loopback.cskb_device_unlock(skb);
skb109drivers/net/ne.cstruct sk_buff *skb, int ring_offset);
skb498drivers/net/ne.cne_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
skb504drivers/net/ne.cchar *buf = skb->data;
skb127drivers/net/new_tunnel.cstatic int tunnel_xmit(struct sk_buff *skb, struct device *dev)
skb139drivers/net/new_tunnel.cif (skb == NULL || dev == NULL) {
skb166drivers/net/new_tunnel.ciph = (struct iphdr *) skb->data;
skb230drivers/net/new_tunnel.cprintk("Room left at head: %d\n", skb_headroom(skb));
skb231drivers/net/new_tunnel.cprintk("Room left at tail: %d\n", skb_tailroom(skb));
skb234drivers/net/new_tunnel.cif (skb_headroom(skb) >= max_headroom) {
skb235drivers/net/new_tunnel.cskb->h.iph = (struct iphdr *) skb_push(skb, tunnel_hlen);
skb239drivers/net/new_tunnel.cif ( !(new_skb = dev_alloc_skb(skb->len+max_headroom)) ) 
skb260drivers/net/new_tunnel.cnew_skb->ip_hdr = (struct iphdr *) skb_put(new_skb, skb->len);
skb261drivers/net/new_tunnel.cmemcpy(new_skb->ip_hdr, skb->data, skb->len);
skb263drivers/net/new_tunnel.cmemcpy(new_skb->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
skb269drivers/net/new_tunnel.ckfree_skb(skb, FREE_WRITE);
skb270drivers/net/new_tunnel.cskb = new_skb;
skb277drivers/net/new_tunnel.ciph       =  skb->h.iph;
skb279drivers/net/new_tunnel.ciph->tos    =  skb->ip_hdr->tos;
skb280drivers/net/new_tunnel.ciph->ttl    =  skb->ip_hdr->ttl;
skb286drivers/net/new_tunnel.ciph->tot_len    =  htons(skb->len);
skb289drivers/net/new_tunnel.cskb->ip_hdr     = skb->h.iph;
skb290drivers/net/new_tunnel.cskb->protocol    =  htons(ETH_P_IP);
skb302drivers/net/new_tunnel.cif (ip_forward(skb, dev, 0, target) == 1)
skb303drivers/net/new_tunnel.ckfree_skb(skb, FREE_WRITE);
skb895drivers/net/ni52.cstruct sk_buff *skb;
skb912drivers/net/ni52.cskb = (struct sk_buff *) dev_alloc_skb(totlen+2);
skb913drivers/net/ni52.cif(skb != NULL)
skb915drivers/net/ni52.cskb->dev = dev;
skb916drivers/net/ni52.cskb_reserve(skb,2);
skb917drivers/net/ni52.cskb_put(skb,totlen);
skb918drivers/net/ni52.ceth_copy_and_sum(skb,(char *) p->base+(unsigned long) rbd->buffer,totlen,0);
skb919drivers/net/ni52.cskb->protocol=eth_type_trans(skb,dev);
skb920drivers/net/ni52.cnetif_rx(skb);
skb1106drivers/net/ni52.cstatic int ni52_send_packet(struct sk_buff *skb, struct device *dev)
skb1153drivers/net/ni52.cif(skb == NULL)
skb1159drivers/net/ni52.cif (skb->len <= 0)
skb1161drivers/net/ni52.cif(skb->len > XMIT_BUFF_SIZE)
skb1163drivers/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);
skb1179drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
skb1180drivers/net/ni52.clen = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
skb1209drivers/net/ni52.cdev_kfree_skb(skb,FREE_WRITE);
skb1229drivers/net/ni52.cdev_kfree_skb(skb,FREE_WRITE);
skb1254drivers/net/ni52.cdev_kfree_skb(skb,FREE_WRITE);
skb124drivers/net/ni65.cstatic int  ni65_send_packet(struct sk_buff *skb, struct device *dev);
skb317drivers/net/ni65.cstruct sk_buff *skb;
skb318drivers/net/ni65.cif( !(skb = dev_alloc_skb(R_BUF_SIZE+2)) ) {
skb322drivers/net/ni65.cskb->dev = dev;
skb323drivers/net/ni65.cskb_reserve(skb,2);
skb324drivers/net/ni65.cskb_put(skb,R_BUF_SIZE);  /* grab the whole space .. (not necessary) */
skb325drivers/net/ni65.cif( (unsigned long) (skb->data + R_BUF_SIZE) > 0x1000000 ) {
skb329drivers/net/ni65.cp->recv_skb[i] = skb;
skb626drivers/net/ni65.cstruct sk_buff *skb = dev_alloc_skb(R_BUF_SIZE+2);
skb628drivers/net/ni65.cstruct sk_buff *skb = dev_alloc_skb(len+2);
skb630drivers/net/ni65.cif(skb)
skb632drivers/net/ni65.cskb_reserve(skb,2);
skb633drivers/net/ni65.cskb->dev = dev;
skb635drivers/net/ni65.cif( (unsigned long) (skb->data + R_BUF_SIZE) > 0x1000000) {
skb636drivers/net/ni65.cskb_put(skb,len);
skb637drivers/net/ni65.ceth_copy_and_sum(skb, (unsigned char *)(p->recv_skb[p->rmdnum]->data),len,0);
skb641drivers/net/ni65.cskb_put(skb,R_BUF_SIZE);
skb642drivers/net/ni65.cp->recv_skb[p->rmdnum] = skb;
skb643drivers/net/ni65.crmdp->u.buffer = (unsigned long) skb->data;
skb644drivers/net/ni65.cskb = skb1;
skb645drivers/net/ni65.cskb_trim(skb,len);
skb648drivers/net/ni65.cskb_put(skb,len);
skb649drivers/net/ni65.ceth_copy_and_sum(skb, (unsigned char *) p->recvbounce[p->rmdnum],len,0);
skb653drivers/net/ni65.cskb->protocol=eth_type_trans(skb,dev);
skb654drivers/net/ni65.cnetif_rx(skb);
skb676drivers/net/ni65.cstatic int ni65_send_packet(struct sk_buff *skb, struct device *dev)
skb692drivers/net/ni65.cif(skb == NULL) {
skb697drivers/net/ni65.cif (skb->len <= 0)
skb710drivers/net/ni65.cshort len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb715drivers/net/ni65.cif( (unsigned long) (skb->data + skb->len) > 0x1000000) {
skb718drivers/net/ni65.cmemcpy((char *) tmdp->u.buffer,(char *)skb->data,
skb719drivers/net/ni65.c(skb->len > T_BUF_SIZE) ? T_BUF_SIZE : skb->len);
skb720drivers/net/ni65.cdev_kfree_skb (skb, FREE_WRITE);
skb724drivers/net/ni65.ctmdp->u.buffer = (unsigned long) skb->data;
skb725drivers/net/ni65.cp->tmd_skb[p->tmdnum] = skb;
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;
skb554drivers/net/pi2.cskb = dev_alloc_skb(sksize);
skb555drivers/net/pi2.cif (skb == NULL) {
skb561drivers/net/pi2.cskb->dev = dev;
skb564drivers/net/pi2.ccfix=skb_put(skb,pkt_len);
skb569drivers/net/pi2.cskb->protocol=htons(ETH_P_AX25);
skb570drivers/net/pi2.cskb->mac.raw=skb->data;
skb571drivers/net/pi2.cIS_SKB(skb);
skb572drivers/net/pi2.cnetif_rx(skb);
skb585drivers/net/pi2.cstruct sk_buff *skb;
skb643drivers/net/pi2.cskb = dev_alloc_skb(sksize);
skb644drivers/net/pi2.cif (skb == NULL) {
skb650drivers/net/pi2.cskb->dev = dev;
skb653drivers/net/pi2.ccfix=skb_put(skb,pkt_len);
skb657drivers/net/pi2.cskb->protocol=ntohs(ETH_P_AX25);
skb658drivers/net/pi2.cskb->mac.raw=skb->data;
skb659drivers/net/pi2.cIS_SKB(skb);
skb660drivers/net/pi2.cnetif_rx(skb);
skb1077drivers/net/pi2.cstatic int pi_header(struct sk_buff *skb, struct device *dev, unsigned short type,
skb1080drivers/net/pi2.creturn ax25_encapsulate(skb, dev, type, daddr, saddr, len);
skb1085drivers/net/pi2.cstruct sk_buff *skb)
skb1087drivers/net/pi2.creturn ax25_rebuild_header(buff, dev, raddr, skb);
skb1493drivers/net/pi2.cstatic int pi_send_packet(struct sk_buff *skb, struct device *dev)
skb1500drivers/net/pi2.cif (skb == NULL) {
skb1504drivers/net/pi2.chardware_send_packet(lp, skb);
skb146drivers/net/plip.cunsigned long raddr, struct sk_buff *skb);
skb147drivers/net/plip.cstatic int plip_tx_packet(struct sk_buff *skb, struct device *dev);
skb197drivers/net/plip.cstruct sk_buff *skb;
skb212drivers/net/plip.cunsigned long raddr, struct sk_buff *skb);
skb415drivers/net/plip.cif (rcv->skb) {
skb416drivers/net/plip.crcv->skb->free = 1;
skb417drivers/net/plip.ckfree_skb(rcv->skb, FREE_READ);
skb418drivers/net/plip.crcv->skb = NULL;
skb421drivers/net/plip.cif (snd->skb) {
skb422drivers/net/plip.cdev_kfree_skb(snd->skb, FREE_WRITE);
skb423drivers/net/plip.csnd->skb = NULL;
skb543drivers/net/plip.crcv->skb = dev_alloc_skb(rcv->length.h);
skb544drivers/net/plip.cif (rcv->skb == NULL) {
skb548drivers/net/plip.cskb_put(rcv->skb,rcv->length.h);
skb549drivers/net/plip.crcv->skb->dev = dev;
skb555drivers/net/plip.clbuf = rcv->skb->data;
skb580drivers/net/plip.crcv->skb->protocol=eth_type_trans(rcv->skb, dev);
skb581drivers/net/plip.cnetif_rx(rcv->skb);
skb583drivers/net/plip.crcv->skb = NULL;
skb667drivers/net/plip.cif (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) {
skb670drivers/net/plip.csnd->skb = NULL;
skb742drivers/net/plip.cdev_kfree_skb(snd->skb, FREE_WRITE);
skb749drivers/net/plip.csnd->skb = NULL;
skb858drivers/net/plip.cstruct sk_buff *skb)
skb865drivers/net/plip.creturn nl->orig_rebuild_header(buff, dev, dst, skb);
skb880drivers/net/plip.cplip_tx_packet(struct sk_buff *skb, struct device *dev)
skb891drivers/net/plip.cif (skb == NULL) {
skb901drivers/net/plip.cif (skb->len > dev->mtu + dev->hard_header_len) {
skb902drivers/net/plip.cprintk("%s: packet too big, %d.\n", dev->name, (int)skb->len);
skb912drivers/net/plip.csnd->skb = skb;
skb913drivers/net/plip.csnd->length.h = skb->len;
skb959drivers/net/plip.cnl->rcv_data.skb = nl->snd_data.skb = NULL;
skb994drivers/net/plip.cif (snd->skb) {
skb995drivers/net/plip.cdev_kfree_skb(snd->skb, FREE_WRITE);
skb996drivers/net/plip.csnd->skb = NULL;
skb999drivers/net/plip.cif (rcv->skb) {
skb1000drivers/net/plip.crcv->skb->free = 1;
skb1001drivers/net/plip.ckfree_skb(rcv->skb, FREE_READ);
skb1002drivers/net/plip.crcv->skb = NULL;
skb89drivers/net/ppp.c#define skb_data(skb)       ((__u8 *) (skb)->data)
skb186drivers/net/ppp.cunsigned long raddr, struct sk_buff *skb);
skb1189drivers/net/ppp.csk_buff *skb = dev_alloc_skb (count);
skb1193drivers/net/ppp.cif (skb == NULL) {
skb1203drivers/net/ppp.cskb->dev      = ppp2dev (ppp);  /* We are the device */
skb1204drivers/net/ppp.cskb->protocol = proto;
skb1205drivers/net/ppp.cskb->mac.raw  = skb_data(skb);
skb1206drivers/net/ppp.cmemcpy (skb_put(skb,count), data, count);  /* move data */
skb1210drivers/net/ppp.cskb->free = 1;
skb1212drivers/net/ppp.cnetif_rx (skb);
skb3039drivers/net/ppp.cppp_dev_xmit (sk_buff *skb, struct device *dev)
skb3048drivers/net/ppp.cif (skb == NULL) {
skb3057drivers/net/ppp.cdev_kfree_skb (skb, FREE_WRITE);
skb3066drivers/net/ppp.cdev->name, skb);
skb3075drivers/net/ppp.cdev_kfree_skb (skb, FREE_WRITE);
skb3081drivers/net/ppp.clen   = skb->len;
skb3082drivers/net/ppp.cdata  = skb_data(skb);
skb3087drivers/net/ppp.cswitch (ntohs (skb->protocol)) {
skb3097drivers/net/ppp.cdev_kfree_skb (skb, FREE_WRITE);
skb3104drivers/net/ppp.cdev_kfree_skb (skb, FREE_WRITE);
skb3143drivers/net/ppp.cstatic int ppp_dev_header (sk_buff *skb, struct device *dev,
skb3152drivers/net/ppp.cunsigned long raddr, struct sk_buff *skb)
skb122drivers/net/pt.cstatic int pt_send_packet(struct sk_buff *skb, struct device *dev);
skb177drivers/net/pt.cstatic void hardware_send_packet(struct pt_local *lp, struct sk_buff *skb)
skb185drivers/net/pt.cptr = skb->data;
skb186drivers/net/pt.cif (ptr[0] != 0 && skb->len >= 2)
skb188drivers/net/pt.cprintk("Rx KISS... Control = %d, value = %d.\n", ptr[0], (skb->len > 1? ptr[1] : -1));
skb231drivers/net/pt.cskb_queue_tail(&lp->sndq, skb);
skb318drivers/net/pt.cstatic void free_p(struct sk_buff *skb)
skb320drivers/net/pt.cdev_kfree_skb(skb, FREE_WRITE);
skb339drivers/net/pt.cstatic int pt_header (struct sk_buff *skb, struct device *dev, unsigned short type,
skb342drivers/net/pt.creturn ax25_encapsulate(skb, dev, type, daddr, saddr, len);
skb348drivers/net/pt.cstruct sk_buff *skb)
skb350drivers/net/pt.creturn ax25_rebuild_header(buff, dev, raddr, skb);
skb972drivers/net/pt.cstatic int pt_send_packet(struct sk_buff *skb, struct device *dev)
skb982drivers/net/pt.cif (skb == NULL) {
skb986drivers/net/pt.chardware_send_packet(lp, skb);
skb1271drivers/net/pt.cstruct sk_buff *skb;
skb1392drivers/net/pt.cskb = dev_alloc_skb(sksize);
skb1393drivers/net/pt.cif (skb == NULL)
skb1400drivers/net/pt.cskb->dev = dev;
skb1403drivers/net/pt.ccfix=skb_put(skb,pkt_len);
skb1410drivers/net/pt.cskb->protocol = ntohs(ETH_P_AX25);
skb1411drivers/net/pt.cskb->mac.raw=skb->data;
skb1412drivers/net/pt.cIS_SKB(skb);
skb1413drivers/net/pt.cnetif_rx(skb);
skb1810drivers/net/pt.cstruct sk_buff *skb;
skb1815drivers/net/pt.cskb = dev_alloc_skb(2);
skb1816drivers/net/pt.cif (skb == NULL)
skb1821drivers/net/pt.cskb->dev = dev;
skb1822drivers/net/pt.ccfix = skb_put(skb, 2);
skb1825drivers/net/pt.cskb->protocol=htons(ETH_P_AX25);
skb1826drivers/net/pt.cskb->mac.raw=skb->data;
skb1827drivers/net/pt.cIS_SKB(skb);
skb1828drivers/net/pt.cnetif_rx(skb);
skb619drivers/net/sdla.cstatic int sdla_transmit(struct sk_buff *skb, struct device *dev)
skb633drivers/net/sdla.cif (skb == NULL) 
skb644drivers/net/sdla.cret = sdla_cmd(dev, SDLA_INFORMATION_WRITE, *(short *)(skb->dev->dev_addr), 0, skb->data, skb->len, NULL, NULL);
skb649drivers/net/sdla.cret = sdla_cmd(dev, SDLA_INFORMATION_WRITE, *(short *)(skb->dev->dev_addr), 0, NULL, skb->len, &addr, &size);
skb657drivers/net/sdla.csdla_write(dev, pbuf->buf_addr, skb->data, skb->len);
skb679drivers/net/sdla.cdev_kfree_skb(skb, FREE_WRITE);
skb691drivers/net/sdla.cstruct sk_buff    *skb;
skb707drivers/net/sdla.cskb = NULL;
skb738drivers/net/sdla.cskb = dev_alloc_skb(len);
skb739drivers/net/sdla.cif (skb == NULL) 
skb748drivers/net/sdla.csdla_read(dev, dev->mem_start + ((SDLA_502_RCV_BUF + SDLA_502_DATA_OFS) & 0x1FFF), skb_put(skb,len), len);
skb777drivers/net/sdla.cskb = dev_alloc_skb(len);
skb778drivers/net/sdla.cif (skb == NULL) 
skb791drivers/net/sdla.csdla_read(dev, addr, skb_put(skb, len), len);
skb795drivers/net/sdla.csdla_read(dev, pbufi->buf_base, skb_put(skb, split), split);
skb811drivers/net/sdla.c(*dlp->receive)(skb, master);
skb83drivers/net/seeq8005.cstatic int seeq8005_send_packet(struct sk_buff *skb, struct device *dev);
skb374drivers/net/seeq8005.cseeq8005_send_packet(struct sk_buff *skb, struct device *dev)
skb395drivers/net/seeq8005.cif (skb == NULL) {
skb405drivers/net/seeq8005.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb406drivers/net/seeq8005.cunsigned char *buf = skb->data;
skb411drivers/net/seeq8005.cdev_kfree_skb (skb, FREE_WRITE);
skb533drivers/net/seeq8005.cstruct sk_buff *skb;
skb536drivers/net/seeq8005.cskb = dev_alloc_skb(pkt_len);
skb537drivers/net/seeq8005.cif (skb == NULL) {
skb542drivers/net/seeq8005.cskb->dev = dev;
skb543drivers/net/seeq8005.cskb_reserve(skb, 2);  /* align data on 16 byte */
skb544drivers/net/seeq8005.cbuf = skb_put(skb,pkt_len);
skb557drivers/net/seeq8005.cskb->protocol=eth_type_trans(skb,dev);
skb558drivers/net/seeq8005.cnetif_rx(skb);
skb488drivers/net/sk_g16.cstatic int   SK_send_packet(struct sk_buff *skb, struct device *dev);
skb1191drivers/net/sk_g16.cstatic int SK_send_packet(struct sk_buff *skb, struct device *dev)
skb1222drivers/net/sk_g16.cif (skb == NULL)
skb1248drivers/net/sk_g16.cshort len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; 
skb1256drivers/net/sk_g16.cmemcpy((char *) (tmdp->u.buffer & 0x00ffffff), (char *)skb->data,
skb1257drivers/net/sk_g16.cskb->len);
skb1288drivers/net/sk_g16.cdev_kfree_skb(skb, FREE_WRITE);
skb1569drivers/net/sk_g16.cstruct sk_buff *skb;
skb1571drivers/net/sk_g16.cskb = dev_alloc_skb(len+2); /* allocate socket buffer */ 
skb1573drivers/net/sk_g16.cif (skb == NULL)                /* Could not get mem ? */
skb1591drivers/net/sk_g16.cskb->dev = dev;
skb1592drivers/net/sk_g16.cskb_reserve(skb,2);    /* Align IP header on 16 byte boundary */
skb1601drivers/net/sk_g16.cmemcpy(skb_put(skb,len), (unsigned char *) (rmdp->u.buffer & 0x00ffffff),
skb1612drivers/net/sk_g16.cskb->protocol=eth_type_trans(skb,dev);
skb1613drivers/net/sk_g16.cnetif_rx(skb);                 /* queue packet and mark it for processing */
skb102drivers/net/skeleton.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
skb344drivers/net/skeleton.cnet_send_packet(struct sk_buff *skb, struct device *dev)
skb369drivers/net/skeleton.cif (skb == NULL) {
skb380drivers/net/skeleton.cshort length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb381drivers/net/skeleton.cunsigned char *buf = skb->data;
skb386drivers/net/skeleton.cdev_kfree_skb (skb, FREE_WRITE);
skb459drivers/net/skeleton.cstruct sk_buff *skb;
skb461drivers/net/skeleton.cskb = dev_alloc_skb(pkt_len);
skb462drivers/net/skeleton.cif (skb == NULL) {
skb468drivers/net/skeleton.cskb->dev = dev;
skb471drivers/net/skeleton.cmemcpy(skb_put(skb,pkt_len), (void*)dev->rmem_start,
skb474drivers/net/skeleton.cinsw(ioaddr, skb->data, (pkt_len + 1) >> 1);
skb476drivers/net/skeleton.cnetif_rx(skb);
skb346drivers/net/slip.cstruct sk_buff *skb;
skb383drivers/net/slip.cskb = dev_alloc_skb(count);
skb384drivers/net/slip.cif (skb == NULL)  {
skb389drivers/net/slip.cskb->dev = sl->dev;
skb390drivers/net/slip.cmemcpy(skb_put(skb,count), sl->rbuff, count);
skb391drivers/net/slip.cskb->mac.raw=skb->data;
skb393drivers/net/slip.cskb->protocol=htons(ETH_P_AX25);
skb395drivers/net/slip.cskb->protocol=htons(ETH_P_IP);
skb396drivers/net/slip.cnetif_rx(skb);
skb486drivers/net/slip.csl_xmit(struct sk_buff *skb, struct device *dev)
skb525drivers/net/slip.cif (skb != NULL) {
skb527drivers/net/slip.csl_encaps(sl, skb->data, skb->len);
skb528drivers/net/slip.cdev_kfree_skb(skb, FREE_WRITE);
skb538drivers/net/slip.csl_header(struct sk_buff *skb, struct device *dev, unsigned short type,
skb546drivers/net/slip.creturn ax25_encapsulate(skb, dev, type, daddr, saddr, len);
skb557drivers/net/slip.cstruct sk_buff *skb)
skb564drivers/net/slip.creturn ax25_rebuild_header(buff, dev, raddr, skb);
skb73drivers/net/smc-ultra.cstruct sk_buff *skb, int ring_offset);
skb286drivers/net/smc-ultra.cultra_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
skb296drivers/net/smc-ultra.cmemcpy_fromio(skb->data, xfer_start, semi_count);
skb298drivers/net/smc-ultra.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
skb301drivers/net/smc-ultra.ceth_io_copy_and_sum(skb, xfer_start, count, 0);
skb224drivers/net/smc9194.cstatic int smc_send_packet(struct sk_buff *skb, struct device *dev);
skb313drivers/net/smc9194.cstatic int  smc_wait_to_send_packet( struct sk_buff * skb, struct device *dev );
skb547drivers/net/smc9194.cstatic int smc_wait_to_send_packet( struct sk_buff * skb, struct device * dev )
skb561drivers/net/smc9194.clp->saved_skb = skb;
skb563drivers/net/smc9194.clength = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb575drivers/net/smc9194.cdev_kfree_skb (skb, FREE_WRITE);
skb645drivers/net/smc9194.cstruct sk_buff *   skb = lp->saved_skb;
skb652drivers/net/smc9194.cif ( !skb ) {
skb656drivers/net/smc9194.clength = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
skb657drivers/net/smc9194.cbuf = skb->data;
skb664drivers/net/smc9194.ckfree(skb);
skb727drivers/net/smc9194.cdev_kfree_skb (skb, FREE_WRITE);
skb1224drivers/net/smc9194.cstatic int smc_send_packet(struct sk_buff *skb, struct device *dev)
skb1248drivers/net/smc9194.cif (skb == NULL) {
skb1257drivers/net/smc9194.cdev_kfree_skb (skb, FREE_WRITE);
skb1261drivers/net/smc9194.creturn smc_wait_to_send_packet( skb, dev );
skb1463drivers/net/smc9194.cstruct sk_buff  * skb;
skb1475drivers/net/smc9194.cskb = alloc_skb( packet_length + 5, GFP_ATOMIC );
skb1477drivers/net/smc9194.cskb = dev_alloc_skb( packet_length + 5); 
skb1480drivers/net/smc9194.cif ( skb == NULL ) {  
skb1492drivers/net/smc9194.cskb_reserve( skb, 2 );   /* 16 bit alignment */
skb1495drivers/net/smc9194.cskb->dev = dev;
skb1497drivers/net/smc9194.cskb->len = packet_length;
skb1498drivers/net/smc9194.cdata = skb->data;
skb1500drivers/net/smc9194.cdata = skb_put( skb, packet_length);
skb1529drivers/net/smc9194.cskb->protocol = eth_type_trans(skb, dev ); 
skb1531drivers/net/smc9194.cnetif_rx(skb);
skb339drivers/net/sunlance.cstruct sk_buff *skb;
skb356drivers/net/sunlance.cskb = dev_alloc_skb (pkt_len+2);
skb357drivers/net/sunlance.cif (skb == NULL){
skb365drivers/net/sunlance.cskb->dev = dev;
skb366drivers/net/sunlance.cskb_reserve (skb, 2);               /* 16 byte align */
skb367drivers/net/sunlance.cbuf = skb_put (skb, pkt_len);       /* make room */
skb369drivers/net/sunlance.cskb->protocol = eth_type_trans (skb,dev);
skb370drivers/net/sunlance.cnetif_rx (skb);
skb577drivers/net/sunlance.clance_start_xmit (struct sk_buff *skb, struct device *dev)
skb600drivers/net/sunlance.cif (skb == NULL){
skb606drivers/net/sunlance.cif (skb->len <= 0){
skb607drivers/net/sunlance.cprintk ("skb len is %ld\n", skb->len);
skb619drivers/net/sunlance.cskblen = skb->len;
skb632drivers/net/sunlance.cprintk ("%2.2x ", skb->data [i]);
skb641drivers/net/sunlance.cmemcpy ((char *)&ib->tx_buf [entry][0], skb->data, skblen);
skb657drivers/net/sunlance.cdev_kfree_skb (skb, FREE_WRITE);
skb156drivers/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 = dev_alloc_skb(pkt_len+2);
skb604drivers/net/tulip.cif (skb == NULL) {
skb619drivers/net/tulip.cskb->dev = dev;
skb620drivers/net/tulip.cskb_reserve(skb,2);  /* 16 byte align the data fields */
skb621drivers/net/tulip.cmemcpy(skb_put(skb,pkt_len), lp->rx_ring[entry].buffer1, pkt_len);
skb622drivers/net/tulip.cskb->protocol=eth_type_trans(skb,dev);
skb623drivers/net/tulip.cnetif_rx(skb);
skb1389drivers/net/wavelan.cwavelan_send_packet(struct sk_buff *skb, device *dev)
skb1430drivers/net/wavelan.cif (skb == (struct sk_buff *)0)
skb1444drivers/net/wavelan.clength = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
skb1445drivers/net/wavelan.cbuf = skb->data;
skb1452drivers/net/wavelan.cdev_kfree_skb(skb, FREE_WRITE);
skb1497drivers/net/wavelan.cstruct sk_buff  *skb;
skb1640drivers/net/wavelan.cif ((skb = dev_alloc_skb(sksize)) == (struct sk_buff *)0)
skb1647drivers/net/wavelan.cskb->dev = dev;
skb1649drivers/net/wavelan.cobram_read(ioaddr, rbd.rbd_bufl, skb_put(skb,pkt_len), pkt_len);
skb1665drivers/net/wavelan.cc = skb->data[i];
skb1667drivers/net/wavelan.cprintk(" %c", skb->data[i]);
skb1669drivers/net/wavelan.cprintk("%02x", skb->data[i]);
skb1678drivers/net/wavelan.cskb->protocol=eth_type_trans(skb,dev);
skb1679drivers/net/wavelan.cnetif_rx(skb);
skb55drivers/net/wd.cstruct sk_buff *skb, int ring_offset);
skb376drivers/net/wd.cwd_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
skb384drivers/net/wd.cmemcpy_fromio(skb->data, xfer_start, semi_count);
skb386drivers/net/wd.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
skb389drivers/net/wd.ceth_io_copy_and_sum(skb, xfer_start, count, 0);
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->data;
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 = dev_alloc_skb(pkt_len);
skb552drivers/net/znet.cif (skb == NULL) {
skb558drivers/net/znet.cskb->dev = dev;
skb562drivers/net/znet.cmemcpy(skb_put(skb,semi_cnt), zn.rx_cur, semi_cnt);
skb563drivers/net/znet.cmemcpy(skb_put(skb,pkt_len-semi_cnt), zn.rx_start,
skb566drivers/net/znet.cmemcpy(skb_put(skb,pkt_len), zn.rx_cur, pkt_len);
skb568drivers/net/znet.cunsigned int *packet = (unsigned int *) skb->data;
skb573drivers/net/znet.cskb->protocol=eth_type_trans(skb,dev);
skb574drivers/net/znet.cnetif_rx(skb);
skb228fs/nfs/nfsroot.cstatic int root_rarp_recv(struct sk_buff *skb, struct device *dev,
skb265fs/nfs/nfsroot.cstatic int root_rarp_recv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb267fs/nfs/nfsroot.cstruct arphdr *rarp = (struct arphdr *)skb->h.raw;
skb274fs/nfs/nfsroot.ckfree_skb(skb, FREE_READ);
skb280fs/nfs/nfsroot.ckfree_skb(skb, FREE_READ);
skb290fs/nfs/nfsroot.ckfree_skb(skb, FREE_READ);
skb305fs/nfs/nfsroot.ckfree_skb(skb, FREE_READ);
skb316fs/nfs/nfsroot.ckfree_skb(skb, FREE_READ);
skb331fs/nfs/nfsroot.ckfree_skb(skb, FREE_READ);
skb213include/asm-alpha/io.h#define eth_io_copy_and_sum(skb,src,len,unused)  memcpy_fromio((skb)->data,(src),(len))
skb141include/linux/atalk.hextern int aarp_send_ddp(struct device *dev,struct sk_buff *skb, struct at_addr *sa, void *hwaddr);
skb31include/linux/etherdevice.hextern int    eth_header(struct sk_buff *skb, struct device *dev,
skb35include/linux/etherdevice.hunsigned long dst, struct sk_buff *skb);
skb36include/linux/etherdevice.hextern unsigned short  eth_type_trans(struct sk_buff *skb, struct device *dev);
skb18include/linux/firewall.hstruct sk_buff *skb, void *phdr);
skb20include/linux/firewall.hstruct sk_buff *skb, void *phdr);
skb22include/linux/firewall.hstruct sk_buff *skb, void *phdr);
skb34include/linux/firewall.hextern int call_fw_firewall(int pf, struct sk_buff *skb, void *phdr);
skb35include/linux/firewall.hextern int call_in_firewall(int pf, struct sk_buff *skb, void *phdr);
skb36include/linux/firewall.hextern int call_out_firewall(int pf, struct sk_buff *skb, void *phdr);
skb136include/linux/if_frad.hvoid              (*receive)(struct sk_buff *skb, struct device *);
skb445include/linux/isdn.hstruct sk_buff *skb;
skb453include/linux/isdn.hstruct sk_buff *skb;
skb124include/linux/mroute.hextern void ipmr_forward(struct sk_buff *skb, int is_frag);
skb169include/linux/netdevice.hint        (*hard_start_xmit) (struct sk_buff *skb,
skb171include/linux/netdevice.hint        (*hard_header) (struct sk_buff *skb,
skb178include/linux/netdevice.hunsigned long raddr, struct sk_buff *skb);
skb232include/linux/netdevice.hextern void    dev_queue_xmit(struct sk_buff *skb, struct device *dev,
skb235include/linux/netdevice.hextern void    netif_rx(struct sk_buff *skb);
skb137include/linux/skbuff.hextern void      kfree_skb(struct sk_buff *skb, int rw);
skb149include/linux/skbuff.hextern void      kfree_skbmem(struct sk_buff *skb);
skb150include/linux/skbuff.hextern struct sk_buff *    skb_clone(struct sk_buff *skb, int priority);
skb151include/linux/skbuff.hextern struct sk_buff *    skb_copy(struct sk_buff *skb, int priority);
skb152include/linux/skbuff.hextern void      skb_device_lock(struct sk_buff *skb);
skb153include/linux/skbuff.hextern void      skb_device_unlock(struct sk_buff *skb);
skb154include/linux/skbuff.hextern void      dev_kfree_skb(struct sk_buff *skb, int mode);
skb155include/linux/skbuff.hextern int      skb_device_locked(struct sk_buff *skb);
skb156include/linux/skbuff.hextern unsigned char *    skb_put(struct sk_buff *skb, int len);
skb157include/linux/skbuff.hextern unsigned char *    skb_push(struct sk_buff *skb, int len);
skb158include/linux/skbuff.hextern unsigned char *    skb_pull(struct sk_buff *skb, int len);
skb159include/linux/skbuff.hextern int      skb_headroom(struct sk_buff *skb);
skb160include/linux/skbuff.hextern int      skb_tailroom(struct sk_buff *skb);
skb161include/linux/skbuff.hextern void      skb_reserve(struct sk_buff *skb, int len);
skb162include/linux/skbuff.hextern void       skb_trim(struct sk_buff *skb, int len);
skb193include/linux/skbuff.hextern int       skb_check(struct sk_buff *skb,int,int, char *);
skb194include/linux/skbuff.h#define IS_SKB(skb)    skb_check((skb), 0, __LINE__,__FILE__)
skb195include/linux/skbuff.h#define IS_SKB_HEAD(skb)  skb_check((skb), 1, __LINE__,__FILE__)
skb197include/linux/skbuff.h#define IS_SKB(skb)    
skb198include/linux/skbuff.h#define IS_SKB_HEAD(skb)  
skb360include/linux/skbuff.hextern __inline__ void __skb_unlink(struct sk_buff *skb, struct sk_buff_head *list)
skb365include/linux/skbuff.hnext = skb->next;
skb366include/linux/skbuff.hprev = skb->prev;
skb367include/linux/skbuff.hskb->next = NULL;
skb368include/linux/skbuff.hskb->prev = NULL;
skb369include/linux/skbuff.hskb->list = NULL;
skb381include/linux/skbuff.hextern __inline__ void skb_unlink(struct sk_buff *skb)
skb387include/linux/skbuff.hif(skb->list)
skb388include/linux/skbuff.h__skb_unlink(skb, skb->list);
skb396include/linux/skbuff.hextern __inline__ unsigned char *skb_put(struct sk_buff *skb, int len)
skb398include/linux/skbuff.hunsigned char *tmp=skb->tail;
skb399include/linux/skbuff.hskb->tail+=len;
skb400include/linux/skbuff.hskb->len+=len;
skb401include/linux/skbuff.hif(skb->tail>skb->end)
skb406include/linux/skbuff.hextern __inline__ unsigned char *skb_push(struct sk_buff *skb, int len)
skb408include/linux/skbuff.hskb->data-=len;
skb409include/linux/skbuff.hskb->len+=len;
skb410include/linux/skbuff.hif(skb->data<skb->head)
skb412include/linux/skbuff.hreturn skb->data;
skb415include/linux/skbuff.hextern __inline__ unsigned char * skb_pull(struct sk_buff *skb, int len)
skb417include/linux/skbuff.hif(len > skb->len)
skb419include/linux/skbuff.hskb->data+=len;
skb420include/linux/skbuff.hskb->len-=len;
skb421include/linux/skbuff.hreturn skb->data;
skb424include/linux/skbuff.hextern __inline__ int skb_headroom(struct sk_buff *skb)
skb426include/linux/skbuff.hreturn skb->data-skb->head;
skb429include/linux/skbuff.hextern __inline__ int skb_tailroom(struct sk_buff *skb)
skb431include/linux/skbuff.hreturn skb->end-skb->tail;
skb434include/linux/skbuff.hextern __inline__ void skb_reserve(struct sk_buff *skb, int len)
skb436include/linux/skbuff.hskb->data+=len;
skb437include/linux/skbuff.hskb->tail+=len;
skb440include/linux/skbuff.hextern __inline__ void skb_trim(struct sk_buff *skb, int len)
skb442include/linux/skbuff.hif(skb->len>len)
skb444include/linux/skbuff.hskb->len=len;
skb445include/linux/skbuff.hskb->tail=skb->data+len;
skb455include/linux/skbuff.hextern void      skb_free_datagram(struct sock * sk, struct sk_buff *skb);
skb31include/linux/trdevice.hextern int    tr_header(struct sk_buff *skb, struct device *dev,
skb35include/linux/trdevice.hunsigned long raddr, struct sk_buff *skb);
skb36include/linux/trdevice.hextern unsigned short  tr_type_trans(struct sk_buff *skb, struct device *dev);
skb6include/net/arp.hextern int  arp_rcv(struct sk_buff *skb, struct device *dev,
skb10include/net/arp.hstruct device *dev, u32 saddr, struct sk_buff *skb);
skb58include/net/ip.hstruct sk_buff  *skb;    /* complete received fragment    */
skb89include/net/ip.hextern int     ip_send(struct rtable *rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr);
skb90include/net/ip.hextern int     ip_build_header(struct sk_buff *skb,
skb96include/net/ip.hextern int    ip_rcv(struct sk_buff *skb, struct device *dev,
skb100include/net/ip.hstruct sk_buff * skb);
skb101include/net/ip.hextern int    ip_options_compile(struct options * opt, struct sk_buff * skb);
skb105include/net/ip.hstruct device *dev, struct sk_buff *skb,
skb129include/net/ip.hstruct sk_buff *ip_defrag(struct iphdr *iph, struct sk_buff *skb, struct device *dev);
skb130include/net/ip.hvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag);
skb136include/net/ip.hextern int ip_forward(struct sk_buff *skb, struct device *dev, int is_frag, __u32 target_addr);
skb142include/net/ip.hextern void ip_options_build(struct sk_buff *skb, struct options *opt, __u32 daddr, __u32 saddr, int is_frag);
skb143include/net/ip.hextern int ip_options_echo(struct options *dopt, struct options *sopt, __u32 daddr, __u32 saddr, struct sk_buff *skb);
skb144include/net/ip.hextern void ip_options_fragment(struct sk_buff *skb);
skb145include/net/ip.hextern int ip_options_compile(struct options *opt, struct sk_buff *skb);
skb1include/net/ipip.hextern int ipip_rcv(struct sk_buff *skb, struct device *dev, struct options *opt, 
skb50include/net/ipx.hextern int ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt);
skb11include/net/netlink.hextern int netlink_attach(int unit, int (*function)(struct sk_buff *skb));
skb12include/net/netlink.hextern int netlink_donothing(struct sk_buff *skb);
skb14include/net/netlink.hextern int netlink_post(int unit, struct sk_buff *skb);
skb31include/net/protocol.hint      (*handler)(struct sk_buff *skb, struct device *dev,
skb336include/net/sock.hint      (*build_header)(struct sk_buff *skb,
skb346include/net/sock.hstruct device *dev, struct sk_buff *skb,
skb464include/net/sock.hstruct sk_buff *skb);
skb466include/net/sock.hstruct sk_buff *skb);
skb477include/net/sock.hextern struct sk_buff     *sock_alloc_send_skb(struct sock *skb,
skb492include/net/sock.hextern __inline__ int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
skb494include/net/sock.hif (sk->rmem_alloc + skb->truesize >= sk->rcvbuf)
skb496include/net/sock.hatomic_add(skb->truesize, &sk->rmem_alloc);
skb497include/net/sock.hskb->sk=sk;
skb498include/net/sock.hskb_queue_tail(&sk->receive_queue,skb);
skb500include/net/sock.hsk->data_ready(sk,skb->len);
skb129include/net/tcp.hextern int  tcp_rcv(struct sk_buff *skb, struct device *dev,
skb142include/net/tcp.hunsigned long daddr, int len, struct sk_buff *skb);
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);
skb32net/802/p8022.cp8022_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb36net/802/p8022.cproto = find_8022_client(*(skb->h.raw));
skb38net/802/p8022.cskb->h.raw += 3;
skb39net/802/p8022.cskb_pull(skb,3);
skb40net/802/p8022.creturn proto->rcvfunc(skb, dev, pt);
skb43net/802/p8022.cskb->sk = NULL;
skb44net/802/p8022.ckfree_skb(skb, FREE_READ);
skb50net/802/p8022.cstruct sk_buff *skb, unsigned char *dest_node)
skb52net/802/p8022.cstruct device  *dev = skb->dev;
skb55net/802/p8022.crawp = skb_push(skb,3);
skb59net/802/p8022.cdev->hard_header(skb, dev, ETH_P_802_3, dest_node, NULL, skb->len);
skb9net/802/p8023.cstruct sk_buff *skb, unsigned char *dest_node)
skb11net/802/p8023.cstruct device  *dev = skb->dev;
skb13net/802/p8023.cdev->hard_header(skb, dev, ETH_P_802_3, dest_node, NULL, skb->len);
skb41net/802/psnap.cint snap_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb54net/802/psnap.cproto = find_snap_client(skb->h.raw);
skb61net/802/psnap.cskb->h.raw += 5;
skb62net/802/psnap.cskb_pull(skb,5);
skb65net/802/psnap.creturn proto->rcvfunc(skb, dev, &psnap_packet_type);
skb67net/802/psnap.cskb->sk = NULL;
skb68net/802/psnap.ckfree_skb(skb, FREE_READ);
skb76net/802/psnap.cstatic void snap_datalink_header(struct datalink_proto *dl, struct sk_buff *skb, unsigned char *dest_node)
skb78net/802/psnap.cmemcpy(skb_push(skb,5),dl->type,5);
skb79net/802/psnap.csnap_dl->datalink_header(snap_dl, skb, dest_node);
skb41net/802/tr.cint tr_header(struct sk_buff *skb, struct device *dev, unsigned short type,
skb45net/802/tr.cstruct trh_hdr *trh=(struct trh_hdr *)skb_push(skb,dev->hard_header_len);
skb72net/802/tr.cstruct sk_buff *skb) {
skb82net/802/tr.cif(arp_find(trh->daddr, dest, dev, dev->pa_addr, skb)) {
skb91net/802/tr.cunsigned short tr_type_trans(struct sk_buff *skb, struct device *dev) {
skb93net/802/tr.cstruct trh_hdr *trh=(struct trh_hdr *)skb->data;
skb94net/802/tr.cstruct trllc *trllc=(struct trllc *)(skb->data+sizeof(struct trh_hdr));
skb96net/802/tr.cskb->mac.raw = skb->data;
skb98net/802/tr.cskb_pull(skb,dev->hard_header_len);
skb106net/802/tr.cskb->pkt_type=PACKET_BROADCAST;
skb108net/802/tr.cskb->pkt_type=PACKET_MULTICAST;
skb114net/802/tr.cskb->pkt_type=PACKET_OTHERHOST;
skb88net/appletalk/aarp.cstruct sk_buff *skb;
skb90net/appletalk/aarp.cwhile((skb=skb_dequeue(&a->packet_queue))!=NULL)
skb91net/appletalk/aarp.ckfree_skb(skb, FREE_WRITE);
skb104net/appletalk/aarp.cstruct sk_buff *skb=alloc_skb(len, GFP_ATOMIC);
skb108net/appletalk/aarp.cif(skb==NULL || sat==NULL)
skb115net/appletalk/aarp.cskb_reserve(skb,dev->hard_header_len+aarp_dl->header_length);
skb116net/appletalk/aarp.ceah    =  (struct elapaarp *)skb_put(skb,sizeof(struct elapaarp));
skb117net/appletalk/aarp.cskb->arp  =  1;
skb118net/appletalk/aarp.cskb->free  =  1;
skb119net/appletalk/aarp.cskb->dev  =  a->dev;
skb147net/appletalk/aarp.caarp_dl->datalink_header(aarp_dl, skb, aarp_eth_multicast);  
skb153net/appletalk/aarp.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb165net/appletalk/aarp.cstruct sk_buff *skb=alloc_skb(len, GFP_ATOMIC);
skb168net/appletalk/aarp.cif(skb==NULL)
skb175net/appletalk/aarp.cskb_reserve(skb,dev->hard_header_len+aarp_dl->header_length);
skb176net/appletalk/aarp.ceah    =  (struct elapaarp *)skb_put(skb,sizeof(struct elapaarp));   
skb177net/appletalk/aarp.cskb->arp  =  1;
skb178net/appletalk/aarp.cskb->free  =  1;
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);
skb231net/appletalk/aarp.cif(skb==NULL)
skb238net/appletalk/aarp.cskb_reserve(skb,dev->hard_header_len+aarp_dl->header_length);
skb239net/appletalk/aarp.ceah    =  (struct elapaarp *)skb_put(skb,sizeof(struct elapaarp));
skb241net/appletalk/aarp.cskb->arp  =  1;
skb242net/appletalk/aarp.cskb->free  =  1;
skb243net/appletalk/aarp.cskb->dev  =  dev;
skb271net/appletalk/aarp.caarp_dl->datalink_header(aarp_dl, skb, aarp_eth_multicast);  
skb277net/appletalk/aarp.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb425net/appletalk/aarp.cint aarp_send_ddp(struct device *dev,struct sk_buff *skb, struct at_addr *sa, void *hwaddr)
skb439net/appletalk/aarp.cstruct ddpehdr *ddp=(struct ddpehdr *)skb->data;
skb450net/appletalk/aarp.cskb_pull(skb,sizeof(struct ddpehdr)-4);
skb456net/appletalk/aarp.c*((__u16 *)skb->data)=htons(skb->len);
skb464net/appletalk/aarp.cskb_push(skb,3);
skb465net/appletalk/aarp.cskb->data[0]=sa->s_node;
skb466net/appletalk/aarp.cskb->data[1]=at->s_node;
skb467net/appletalk/aarp.cskb->data[2]=ft;
skb469net/appletalk/aarp.cif(skb->sk==NULL)
skb470net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, SOPRI_NORMAL);
skb472net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
skb485net/appletalk/aarp.cskb->dev = dev;
skb486net/appletalk/aarp.cskb->protocol = htons(ETH_P_ATALK);
skb498net/appletalk/aarp.cddp_dl->datalink_header(ddp_dl, skb, ddp_eth_multicast);
skb499net/appletalk/aarp.cif(skb->sk==NULL)
skb500net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, SOPRI_NORMAL);
skb502net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
skb514net/appletalk/aarp.cddp_dl->datalink_header(ddp_dl, skb, a->hwaddr);
skb515net/appletalk/aarp.cif(skb->sk==NULL)
skb516net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, SOPRI_NORMAL);
skb518net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
skb534net/appletalk/aarp.cskb_queue_tail(&a->packet_queue, skb);
skb558net/appletalk/aarp.cskb_queue_tail(&a->packet_queue, skb);
skb600net/appletalk/aarp.cstruct sk_buff *skb;
skb619net/appletalk/aarp.cwhile((skb=skb_dequeue(&a->packet_queue))!=NULL)
skb622net/appletalk/aarp.cddp_dl->datalink_header(ddp_dl,skb,a->hwaddr);
skb623net/appletalk/aarp.cif(skb->sk==NULL)
skb624net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, SOPRI_NORMAL);
skb626net/appletalk/aarp.cdev_queue_xmit(skb, skb->dev, skb->sk->priority);
skb639net/appletalk/aarp.cstatic int aarp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb641net/appletalk/aarp.cstruct elapaarp *ea=(struct elapaarp *)skb->h.raw;
skb655net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb663net/appletalk/aarp.cif(!skb_pull(skb,sizeof(*ea)))
skb665net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb678net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb709net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb722net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb781net/appletalk/aarp.ckfree_skb(skb, FREE_READ);
skb211net/appletalk/ddp.cstruct sk_buff *skb;
skb214net/appletalk/ddp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
skb216net/appletalk/ddp.ckfree_skb(skb,FREE_READ);
skb1416net/appletalk/ddp.cstatic int atalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb1419net/appletalk/ddp.cstruct ddpehdr *ddp=(void *)skb->h.raw;
skb1425net/appletalk/ddp.cif(skb->len<sizeof(*ddp))
skb1427net/appletalk/ddp.ckfree_skb(skb,FREE_READ);
skb1444net/appletalk/ddp.coriglen = skb->len;
skb1446net/appletalk/ddp.cskb_trim(skb,min(skb->len,ddp->deh_len));
skb1454net/appletalk/ddp.cif(skb->len<sizeof(*ddp))
skb1456net/appletalk/ddp.ckfree_skb(skb,FREE_READ);
skb1468net/appletalk/ddp.ckfree_skb(skb,FREE_READ);
skb1474net/appletalk/ddp.cif(call_in_firewall(AF_APPLETALK, skb, ddp)!=FW_ACCEPT)
skb1476net/appletalk/ddp.ckfree_skb(skb, FREE_READ);
skb1497net/appletalk/ddp.cif (skb->pkt_type != PACKET_HOST || ddp->deh_dnet == 0) 
skb1499net/appletalk/ddp.ckfree_skb(skb, FREE_READ);
skb1508net/appletalk/ddp.cif(call_fw_firewall(AF_APPLETALK, skb, ddp)!=FW_ACCEPT)
skb1510net/appletalk/ddp.ckfree_skb(skb, FREE_READ);
skb1521net/appletalk/ddp.ckfree_skb(skb, FREE_READ);
skb1538net/appletalk/ddp.cskb_trim(skb,min(origlen, rt->dev->hard_header_len + 
skb1546net/appletalk/ddp.cskb->arp = 1;  /* Resolved */
skb1548net/appletalk/ddp.cif(aarp_send_ddp(rt->dev, skb, &ta, NULL)==-1)
skb1549net/appletalk/ddp.ckfree_skb(skb, FREE_READ);
skb1563net/appletalk/ddp.ckfree_skb(skb,FREE_READ);
skb1572net/appletalk/ddp.cskb->sk = sock;
skb1574net/appletalk/ddp.cif(sock_queue_rcv_skb(sock,skb)<0)
skb1576net/appletalk/ddp.cskb->sk=NULL;
skb1577net/appletalk/ddp.ckfree_skb(skb, FREE_WRITE);
skb1589net/appletalk/ddp.cstatic int ltalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb1597net/appletalk/ddp.cif(skb->mac.raw[2]==1)
skb1604net/appletalk/ddp.cif(ap==NULL || skb->len<sizeof(struct ddpshdr))
skb1606net/appletalk/ddp.ckfree_skb(skb, FREE_READ);
skb1615net/appletalk/ddp.cskb_push(skb, sizeof(*ddp)-4);
skb1616net/appletalk/ddp.cddp=(struct ddpehdr *)skb->data;
skb1628net/appletalk/ddp.cddp->deh_dnode=skb->mac.raw[0];  /* From physical header */
skb1629net/appletalk/ddp.cddp->deh_snode=skb->mac.raw[1];  /* From physical header */
skb1637net/appletalk/ddp.cddp->deh_len=skb->len;
skb1642net/appletalk/ddp.cskb->h.raw = skb->data;
skb1643net/appletalk/ddp.creturn atalk_rcv(skb,dev,pt);
skb1651net/appletalk/ddp.cstruct sk_buff *skb;
skb1724net/appletalk/ddp.cskb = sock_alloc_send_skb(sk, size, 0, 0 , &err);
skb1725net/appletalk/ddp.cif(skb==NULL)
skb1728net/appletalk/ddp.cskb->sk=sk;
skb1729net/appletalk/ddp.cskb->free=1;
skb1730net/appletalk/ddp.cskb->arp=1;
skb1731net/appletalk/ddp.cskb_reserve(skb,ddp_dl->header_length);
skb1732net/appletalk/ddp.cskb_reserve(skb,dev->hard_header_len);
skb1734net/appletalk/ddp.cskb->dev=dev;
skb1739net/appletalk/ddp.cddp=(struct ddpehdr *)skb_put(skb,sizeof(struct ddpehdr));
skb1760net/appletalk/ddp.cmemcpy_fromiovec(skb_put(skb,len),msg->msg_iov,len);
skb1769net/appletalk/ddp.cif(call_out_firewall(AF_APPLETALK, skb, ddp)!=FW_ACCEPT)
skb1771net/appletalk/ddp.ckfree_skb(skb, FREE_WRITE);
skb1786net/appletalk/ddp.cstruct sk_buff *skb2=skb_clone(skb, GFP_KERNEL);
skb1804net/appletalk/ddp.catomic_sub(skb->truesize, &sk->wmem_alloc);
skb1805net/appletalk/ddp.cddp_dl->datalink_header(ddp_dl, skb, dev->dev_addr);
skb1806net/appletalk/ddp.cskb->sk = NULL;
skb1807net/appletalk/ddp.cskb->mac.raw=skb->data;
skb1808net/appletalk/ddp.cskb->h.raw = skb->data + ddp_dl->header_length + dev->hard_header_len;
skb1809net/appletalk/ddp.cskb_pull(skb,dev->hard_header_len);
skb1810net/appletalk/ddp.cskb_pull(skb,ddp_dl->header_length);
skb1811net/appletalk/ddp.catalk_rcv(skb,dev,NULL);
skb1823net/appletalk/ddp.cif(aarp_send_ddp(dev,skb,&usat->sat_addr, NULL)==-1)
skb1824net/appletalk/ddp.ckfree_skb(skb, FREE_WRITE);
skb1839net/appletalk/ddp.cstruct sk_buff *skb;
skb1848net/appletalk/ddp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb1849net/appletalk/ddp.cif(skb==NULL)
skb1852net/appletalk/ddp.cddp = (struct ddpehdr *)(skb->h.raw);
skb1858net/appletalk/ddp.cskb_copy_datagram_iovec(skb,0,msg->msg_iov,copied);
skb1865net/appletalk/ddp.cskb_copy_datagram_iovec(skb,sizeof(*ddp),msg->msg_iov,copied);
skb1874net/appletalk/ddp.cskb_free_datagram(sk, skb);
skb1913net/appletalk/ddp.cstruct sk_buff *skb;
skb1915net/appletalk/ddp.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
skb1916net/appletalk/ddp.camount=skb->len-sizeof(struct ddpehdr);
skb370net/ax25/af_ax25.cstatic void ax25_send_to_raw(struct sock *sk, struct sk_buff *skb, int proto)
skb376net/ax25/af_ax25.cif ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
skb383net/ax25/af_ax25.csk->data_ready(sk, skb->len);
skb411net/ax25/af_ax25.cstruct sk_buff *skb;
skb423net/ax25/af_ax25.cwhile ((skb = skb_dequeue(&ax25->sk->receive_queue)) != NULL) {
skb424net/ax25/af_ax25.cif (skb->sk != ax25->sk) {      /* A pending connection */
skb425net/ax25/af_ax25.cskb->sk->dead = 1;  /* Queue the unaccepted socket for death */
skb426net/ax25/af_ax25.cax25_set_timer(skb->sk->ax25);
skb427net/ax25/af_ax25.cskb->sk->ax25->state = AX25_STATE_0;
skb430net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb755net/ax25/af_ax25.cint ax25_send_frame(struct sk_buff *skb, ax25_address *src, ax25_address *dest,
skb760net/ax25/af_ax25.cif (skb == NULL)
skb771net/ax25/af_ax25.cax25_output(ax25, skb);
skb810net/ax25/af_ax25.cax25_output(ax25, skb);
skb1501net/ax25/af_ax25.cstruct sk_buff *skb;
skb1522net/ax25/af_ax25.cif ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
skb1533net/ax25/af_ax25.c} while (skb == NULL);
skb1535net/ax25/af_ax25.cnewsk = skb->sk;
skb1540net/ax25/af_ax25.cskb->sk = NULL;
skb1541net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1583net/ax25/af_ax25.cstatic int ax25_rcv(struct sk_buff *skb, struct device *dev, ax25_address *dev_addr, struct packet_type *ptype)
skb1599net/ax25/af_ax25.cskb->h.raw = skb->data;
skb1602net/ax25/af_ax25.cif (call_in_firewall(PF_AX25, skb, skb->h.raw) != FW_ACCEPT) {
skb1603net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1612net/ax25/af_ax25.cif (ax25_parse_addr(skb->data, skb->len, &src, &dest, &dp, &type, &dama) == NULL) {
skb1613net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1646net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1652net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1658net/ax25/af_ax25.cbuild_ax25_addr(skb->data, &src, &dest, &dp, type, MODULUS);
skb1660net/ax25/af_ax25.cif (call_fw_firewall(PF_AX25, skb, skb->data) != FW_ACCEPT) {
skb1661net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1666net/ax25/af_ax25.cskb->arp = 1;
skb1667net/ax25/af_ax25.cax25_queue_xmit(skb, dev_out, SOPRI_NORMAL);
skb1669net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1678net/ax25/af_ax25.cskb_pull(skb, size_ax25_addr(&dp));
skb1690net/ax25/af_ax25.cif ((*skb->data & ~0x10) == LAPB_UI) {  /* UI frame - bypass LAPB processing */
skb1691net/ax25/af_ax25.cskb->h.raw = skb->data + 2;    /* skip control and pid */
skb1694net/ax25/af_ax25.cax25_send_to_raw(raw, skb, skb->data[1]);
skb1697net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1702net/ax25/af_ax25.cswitch (skb->data[1]) {
skb1706net/ax25/af_ax25.cskb_pull(skb,2);    /* drop PID/CTRL */
skb1708net/ax25/af_ax25.cip_rcv(skb, dev, ptype);  /* Note ptype here is the wrong one, fix me later */
skb1713net/ax25/af_ax25.cskb_pull(skb,2);
skb1714net/ax25/af_ax25.carp_rcv(skb, dev, ptype);  /* Note ptype here is wrong... */
skb1721net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1727net/ax25/af_ax25.cskb_pull(skb, 2);
skb1728net/ax25/af_ax25.cskb_queue_tail(&sk->receive_queue, skb);
skb1729net/ax25/af_ax25.cskb->sk = sk;
skb1730net/ax25/af_ax25.catomic_add(skb->truesize, &sk->rmem_alloc);
skb1732net/ax25/af_ax25.csk->data_ready(sk, skb->len);
skb1735net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1740net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);  /* Will scan SOCK_AX25 RAW sockets */
skb1753net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1768net/ax25/af_ax25.cif (ax25_process_rx_frame(ax25, skb, type, dama) == 0)
skb1769net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1778net/ax25/af_ax25.cif ((*skb->data & ~PF) != SABM && (*skb->data & ~PF) != SABME) {
skb1783net/ax25/af_ax25.cif ((*skb->data & ~PF) != DM && mine)
skb1786net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1798net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1804net/ax25/af_ax25.cskb_queue_head(&sk->receive_queue, skb);
skb1806net/ax25/af_ax25.cskb->sk     = make;
skb1814net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1822net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1834net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1846net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1861net/ax25/af_ax25.cif ((*skb->data & ~PF) == SABME) {
skb1885net/ax25/af_ax25.csk->data_ready(sk, skb->len );
skb1887net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);
skb1896net/ax25/af_ax25.cstatic int kiss_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *ptype)
skb1898net/ax25/af_ax25.cskb->sk = NULL;    /* Initially we don't know who its for */
skb1900net/ax25/af_ax25.cif ((*skb->data & 0x0F) != 0) {
skb1901net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);  /* Not a KISS data frame */
skb1905net/ax25/af_ax25.cskb_pull(skb, AX25_KISS_HEADER_LEN);  /* Remove the KISS byte */
skb1907net/ax25/af_ax25.creturn ax25_rcv(skb, dev, (ax25_address *)dev->dev_addr, ptype);
skb1914net/ax25/af_ax25.cstatic int bpq_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *ptype)
skb1919net/ax25/af_ax25.cskb->sk = NULL;    /* Initially we don't know who its for */
skb1922net/ax25/af_ax25.ckfree_skb(skb, FREE_READ);  /* We have no port callsign */
skb1926net/ax25/af_ax25.clen = skb->data[0] + skb->data[1] * 256 - 5;
skb1928net/ax25/af_ax25.cskb_pull(skb, 2);  /* Remove the length bytes */
skb1929net/ax25/af_ax25.cskb_trim(skb, len);  /* Set the length of the data */
skb1931net/ax25/af_ax25.creturn ax25_rcv(skb, dev, port_call, ptype);
skb1941net/ax25/af_ax25.cstruct sk_buff *skb;
skb2011net/ax25/af_ax25.cif ((skb = sock_alloc_send_skb(sk, size, 0, 0, &err)) == NULL)
skb2014net/ax25/af_ax25.cskb->sk   = sk;
skb2015net/ax25/af_ax25.cskb->free = 1;
skb2016net/ax25/af_ax25.cskb->arp  = 1;
skb2018net/ax25/af_ax25.cskb_reserve(skb, size - len);
skb2024net/ax25/af_ax25.cmemcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
skb2027net/ax25/af_ax25.casmptr  = skb_push(skb, 1);
skb2036net/ax25/af_ax25.ckfree_skb(skb, FREE_WRITE);
skb2040net/ax25/af_ax25.cax25_output(sk->ax25, skb);  /* Shove it onto the queue and kick */
skb2044net/ax25/af_ax25.casmptr = skb_push(skb, 1 + size_ax25_addr(dp));
skb2058net/ax25/af_ax25.cskb->h.raw = asmptr;
skb2061net/ax25/af_ax25.cprintk("base=%p pos=%p\n", skb->data, asmptr);
skb2066net/ax25/af_ax25.cax25_queue_xmit(skb, sk->ax25->device, SOPRI_NORMAL);
skb2078net/ax25/af_ax25.cstruct sk_buff *skb;
skb2097net/ax25/af_ax25.cif ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
skb2101net/ax25/af_ax25.clength = skb->len + (skb->data - skb->h.raw);
skb2104net/ax25/af_ax25.cskb_pull(skb, 1);    /* Remove PID */
skb2105net/ax25/af_ax25.clength     = skb->len;
skb2106net/ax25/af_ax25.cskb->h.raw = skb->data;
skb2110net/ax25/af_ax25.cskb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
skb2121net/ax25/af_ax25.cax25_parse_addr(skb->data, skb->len, NULL, &dest, &digi, NULL, &dama);
skb2145net/ax25/af_ax25.cskb_free_datagram(sk, skb);
skb2181net/ax25/af_ax25.cstruct sk_buff *skb;
skb2183net/ax25/af_ax25.cif ((skb = skb_peek(&sk->receive_queue)) != NULL)
skb2184net/ax25/af_ax25.camount = skb->len;
skb2441net/ax25/af_ax25.cvoid ax25_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
skb2447net/ax25/af_ax25.cif (call_out_firewall(PF_AX25, skb, skb->data) != FW_ACCEPT) {
skb2448net/ax25/af_ax25.ckfree_skb(skb, FREE_WRITE);
skb2453net/ax25/af_ax25.cskb->protocol = htons (ETH_P_AX25);
skb2460net/ax25/af_ax25.cif(skb_headroom(skb) < AX25_BPQ_HEADER_LEN) {
skb2462net/ax25/af_ax25.cskb->free = 1;
skb2463net/ax25/af_ax25.ckfree_skb(skb, FREE_WRITE);
skb2467net/ax25/af_ax25.csize = skb->len;
skb2469net/ax25/af_ax25.cptr = skb_push(skb, 2);
skb2474net/ax25/af_ax25.cdev->hard_header(skb, dev, ETH_P_BPQ, bcast_addr, NULL, 0);
skb2481net/ax25/af_ax25.cwas_locked = skb_device_locked(skb);
skb2482net/ax25/af_ax25.cdev_queue_xmit(skb, dev, pri);
skb2483net/ax25/af_ax25.cif (was_locked) skb_device_unlock(skb);
skb2489net/ax25/af_ax25.cptr = skb_push(skb, 1);
skb2498net/ax25/af_ax25.cwas_locked = skb_device_locked(skb);
skb2499net/ax25/af_ax25.cdev_queue_xmit(skb, dev, pri);
skb2500net/ax25/af_ax25.cif (was_locked) skb_device_unlock(skb);
skb2513net/ax25/af_ax25.cint ax25_encapsulate(struct sk_buff *skb, struct device *dev, unsigned short type, void *daddr,
skb2517net/ax25/af_ax25.cunsigned char *buff = skb_push(skb, AX25_HEADER_LEN);
skb2562net/ax25/af_ax25.cint ax25_rebuild_header(unsigned char *bp, struct device *dev, unsigned long dest, struct sk_buff *skb)
skb2566net/ax25/af_ax25.cif (arp_find(bp + 1, dest, dev, dev->pa_addr, skb))
skb2586net/ax25/af_ax25.cstruct sk_buff *ourskb=skb_clone(skb, GFP_ATOMIC);
skb2587net/ax25/af_ax25.cdev_kfree_skb(skb, FREE_WRITE);
skb2604net/ax25/af_ax25.cax25_dg_build_path(skb, (ax25_address *)(bp + 1), dev);
skb70net/ax25/ax25_in.cstatic int ax25_rx_fragment(ax25_cb *ax25, struct sk_buff *skb)
skb76net/ax25/ax25_in.cif (!(*skb->data & SEG_FIRST)) {
skb77net/ax25/ax25_in.cif ((ax25->fragno - 1) == (*skb->data & SEG_REM)) {
skb81net/ax25/ax25_in.cax25->fragno = *skb->data & SEG_REM;
skb82net/ax25/ax25_in.cskb_pull(skb, 1);  /* skip fragno */
skb83net/ax25/ax25_in.cax25->fraglen += skb->len;
skb84net/ax25/ax25_in.cskb_queue_tail(&ax25->frag_queue, skb);
skb94net/ax25/ax25_in.cskbn->dev  = skb->dev;
skb144net/ax25/ax25_in.cif (*skb->data & SEG_FIRST) {
skb145net/ax25/ax25_in.cax25->fragno = *skb->data & SEG_REM;
skb146net/ax25/ax25_in.cskb_pull(skb, 1);    /* skip fragno */
skb147net/ax25/ax25_in.cax25->fraglen = skb->len;
skb148net/ax25/ax25_in.cskb_queue_tail(&ax25->frag_queue, skb);
skb160net/ax25/ax25_in.cstatic int ax25_rx_iframe(ax25_cb *ax25, struct sk_buff *skb)
skb165net/ax25/ax25_in.cif (skb == NULL) return 0;
skb167net/ax25/ax25_in.cpid = *skb->data;
skb174net/ax25/ax25_in.cskb_pull(skb, 1);  /* Remove PID */
skb175net/ax25/ax25_in.cqueued = nr_route_frame(skb, ax25);
skb182net/ax25/ax25_in.cskb_pull(skb, 1);  /* Remove PID */
skb183net/ax25/ax25_in.cskb->h.raw = skb->data;
skb185net/ax25/ax25_in.cip_rcv(skb, ax25->device, NULL);  /* Wrong ptype */
skb192net/ax25/ax25_in.cskb_pull(skb, 1);  /* Remove PID */
skb193net/ax25/ax25_in.cqueued = ax25_rx_fragment(ax25, skb);
skb199net/ax25/ax25_in.cif (sock_queue_rcv_skb(ax25->sk, skb) == 0) {
skb216net/ax25/ax25_in.cstatic int ax25_state1_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int pf, int type, int dama)
skb292net/ax25/ax25_in.cstatic int ax25_state2_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int pf, int type)
skb372net/ax25/ax25_in.cstatic int ax25_state3_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int ns, int nr, int pf, int type, int dama)
skb504net/ax25/ax25_in.cqueued = ax25_rx_iframe(ax25, skb);
skb564net/ax25/ax25_in.cstatic int ax25_state4_machine(ax25_cb *ax25, struct sk_buff *skb, int frametype, int ns, int nr, int pf, int type, int dama)
skb750net/ax25/ax25_in.cqueued = ax25_rx_iframe(ax25, skb);
skb808net/ax25/ax25_in.cint ax25_process_rx_frame(ax25_cb *ax25, struct sk_buff *skb, int type, int dama)
skb823net/ax25/ax25_in.cframetype = ax25_decode(ax25, skb, &ns, &nr, &pf);
skb827net/ax25/ax25_in.cqueued = ax25_state1_machine(ax25, skb, frametype, pf, type, dama);
skb830net/ax25/ax25_in.cqueued = ax25_state2_machine(ax25, skb, frametype, pf, type);
skb833net/ax25/ax25_in.cqueued = ax25_state3_machine(ax25, skb, frametype, ns, nr, pf, type, dama);
skb836net/ax25/ax25_in.cqueued = ax25_state4_machine(ax25, skb, frametype, ns, nr, pf, type, dama);
skb60net/ax25/ax25_out.cvoid ax25_output(ax25_cb *ax25, struct sk_buff *skb)
skb76net/ax25/ax25_out.cif ((skb->len - 1) > mtu) {
skb77net/ax25/ax25_out.cswitch (*skb->data) {
skb89net/ax25/ax25_out.cskb_pull(skb, 1); /* skip PID */
skb94net/ax25/ax25_out.cfragno = skb->len / mtu;
skb95net/ax25/ax25_out.cif (skb->len % mtu == 0) fragno--;
skb97net/ax25/ax25_out.cfrontlen = skb_headroom(skb);  /* Address space + CTRL */
skb99net/ax25/ax25_out.cwhile (skb->len > 0) {
skb100net/ax25/ax25_out.cif (skb->sk != NULL) {
skb101net/ax25/ax25_out.cif ((skbn = sock_alloc_send_skb(skb->sk, mtu + 2 + frontlen, 0, 0, &err)) == NULL)
skb108net/ax25/ax25_out.cskbn->sk   = skb->sk;
skb112net/ax25/ax25_out.clen = (mtu > skb->len) ? skb->len : mtu;
skb117net/ax25/ax25_out.cmemcpy(skb_put(skbn, len), skb->data, len);
skb129net/ax25/ax25_out.cmemcpy(skb_put(skbn, len), skb->data, len);
skb134net/ax25/ax25_out.cskb_pull(skb, len);
skb138net/ax25/ax25_out.cskb->free = 1;
skb139net/ax25/ax25_out.ckfree_skb(skb, FREE_WRITE);
skb141net/ax25/ax25_out.cskb_queue_tail(&ax25->write_queue, skb);    /* Throw it on the queue */
skb154net/ax25/ax25_out.cstatic void ax25_send_iframe(ax25_cb *ax25, struct sk_buff *skb, int poll_bit)
skb158net/ax25/ax25_out.cif (skb == NULL)
skb162net/ax25/ax25_out.cframe = skb_push(skb, 1);
skb169net/ax25/ax25_out.cframe = skb_push(skb, 2);
skb177net/ax25/ax25_out.cax25_transmit_buffer(ax25, skb, C_COMMAND);  
skb182net/ax25/ax25_out.cstruct sk_buff *skb, *skbn;
skb206net/ax25/ax25_out.cskb  = skb_dequeue(&ax25->write_queue);
skb209net/ax25/ax25_out.cif ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL) {
skb210net/ax25/ax25_out.cskb_queue_head(&ax25->write_queue, skb);
skb232net/ax25/ax25_out.cskb_queue_tail(&ax25->ack_queue, skb);
skb236net/ax25/ax25_out.c} while (!last && (skb = skb_dequeue(&ax25->write_queue)) != NULL);
skb249net/ax25/ax25_out.cvoid ax25_transmit_buffer(ax25_cb *ax25, struct sk_buff *skb, int type)
skb264net/ax25/ax25_out.cif (skb_headroom(skb) < size_ax25_addr(ax25->digipeat)) {
skb266net/ax25/ax25_out.cskb->free = 1;
skb267net/ax25/ax25_out.ckfree_skb(skb, FREE_WRITE);
skb271net/ax25/ax25_out.cptr = skb_push(skb, size_ax25_addr(ax25->digipeat));
skb274net/ax25/ax25_out.cskb->arp = 1;
skb276net/ax25/ax25_out.cax25_queue_xmit(skb, ax25->device, SOPRI_NORMAL);
skb580net/ax25/ax25_route.cvoid ax25_dg_build_path(struct sk_buff *skb, ax25_address *addr, struct device *dev)
skb599net/ax25/ax25_route.cif (skb_headroom(skb) < len) {
skb604net/ax25/ax25_route.cmemcpy(&dest, skb->data + 1, AX25_ADDR_LEN);
skb605net/ax25/ax25_route.cmemcpy(&src,  skb->data + 8, AX25_ADDR_LEN);
skb608net/ax25/ax25_route.cbp = skb_push(skb, len);
skb63net/ax25/ax25_subr.cstruct sk_buff *skb;
skb65net/ax25/ax25_subr.cwhile ((skb = skb_dequeue(&ax25->write_queue)) != NULL) {
skb66net/ax25/ax25_subr.cskb->free = 1;
skb67net/ax25/ax25_subr.ckfree_skb(skb, FREE_WRITE);
skb70net/ax25/ax25_subr.cwhile ((skb = skb_dequeue(&ax25->ack_queue)) != NULL) {
skb71net/ax25/ax25_subr.cskb->free = 1;
skb72net/ax25/ax25_subr.ckfree_skb(skb, FREE_WRITE);
skb75net/ax25/ax25_subr.cwhile ((skb = skb_dequeue(&ax25->reseq_queue)) != NULL) {
skb76net/ax25/ax25_subr.ckfree_skb(skb, FREE_READ);
skb79net/ax25/ax25_subr.cwhile ((skb = skb_dequeue(&ax25->frag_queue)) != NULL) {
skb80net/ax25/ax25_subr.ckfree_skb(skb, FREE_READ);
skb91net/ax25/ax25_subr.cstruct sk_buff *skb;
skb98net/ax25/ax25_subr.cskb = skb_dequeue(&ax25->ack_queue);
skb99net/ax25/ax25_subr.cskb->free = 1;
skb100net/ax25/ax25_subr.ckfree_skb(skb, FREE_WRITE);
skb114net/ax25/ax25_subr.cstruct sk_buff *skb, *skb_prev = NULL;
skb121net/ax25/ax25_subr.cwhile ((skb = skb_dequeue(&ax25->ack_queue)) != NULL) {
skb123net/ax25/ax25_subr.cskb_queue_head(&ax25->write_queue, skb);
skb125net/ax25/ax25_subr.cskb_append(skb_prev, skb);
skb126net/ax25/ax25_subr.cskb_prev = skb;
skb152net/ax25/ax25_subr.cint ax25_decode(ax25_cb *ax25, struct sk_buff *skb, int *ns, int *nr, int *pf)
skb157net/ax25/ax25_subr.cframe = skb->data;
skb174net/ax25/ax25_subr.cskb_pull(skb, 1);
skb181net/ax25/ax25_subr.cskb_pull(skb, 2);
skb186net/ax25/ax25_subr.cskb_pull(skb, 2);
skb190net/ax25/ax25_subr.cskb_pull(skb, 1);
skb204net/ax25/ax25_subr.cstruct sk_buff *skb;
skb211net/ax25/ax25_subr.cif ((skb = alloc_skb(AX25_BPQ_HEADER_LEN + size_ax25_addr(ax25->digipeat) + 2, GFP_ATOMIC)) == NULL)
skb214net/ax25/ax25_subr.cskb_reserve(skb, AX25_BPQ_HEADER_LEN + size_ax25_addr(ax25->digipeat));
skb217net/ax25/ax25_subr.cskb->sk = ax25->sk;
skb218net/ax25/ax25_subr.catomic_add(skb->truesize, &ax25->sk->wmem_alloc);
skb223net/ax25/ax25_subr.cdptr = skb_put(skb, 1);
skb230net/ax25/ax25_subr.cdptr = skb_put(skb, 1);
skb234net/ax25/ax25_subr.cdptr = skb_put(skb, 2);
skb241net/ax25/ax25_subr.cskb->free = 1;
skb243net/ax25/ax25_subr.cax25_transmit_buffer(ax25, skb, type);
skb253net/ax25/ax25_subr.cstruct sk_buff *skb;
skb260net/ax25/ax25_subr.cif ((skb = alloc_skb(AX25_BPQ_HEADER_LEN + size_ax25_addr(digi) + 1, GFP_ATOMIC)) == NULL)
skb263net/ax25/ax25_subr.cskb_reserve(skb, AX25_BPQ_HEADER_LEN + size_ax25_addr(digi));
skb267net/ax25/ax25_subr.cdptr = skb_put(skb, 1);
skb268net/ax25/ax25_subr.cskb->sk = NULL;
skb276net/ax25/ax25_subr.cdptr  = skb_push(skb, size_ax25_addr(digi));
skb279net/ax25/ax25_subr.cskb->arp  = 1;
skb280net/ax25/ax25_subr.cskb->free = 1;
skb282net/ax25/ax25_subr.cax25_queue_xmit(skb, dev, SOPRI_NORMAL);
skb487net/ax25/ax25_subr.cstruct sk_buff *skb;
skb493net/ax25/ax25_subr.cif ((skb = alloc_skb(2, GFP_ATOMIC)) == NULL)
skb496net/ax25/ax25_subr.cskb->free = 1;
skb497net/ax25/ax25_subr.cskb->arp = 1;
skb500net/ax25/ax25_subr.cskb->sk = ax25->sk;
skb501net/ax25/ax25_subr.catomic_add(skb->truesize, &ax25->sk->wmem_alloc);
skb504net/ax25/ax25_subr.cskb->protocol = htons(ETH_P_AX25);
skb506net/ax25/ax25_subr.cp = skb_put(skb, 2);
skb511net/ax25/ax25_subr.cdev_queue_xmit(skb, ax25->device, SOPRI_NORMAL);
skb78net/core/datagram.cstruct sk_buff *skb;
skb118net/core/datagram.cskb=skb_peek(&sk->receive_queue);
skb119net/core/datagram.cif(skb!=NULL)
skb120net/core/datagram.cskb->users++;
skb122net/core/datagram.cif(skb==NULL)    /* shouldn't happen but .. */
skb124net/core/datagram.creturn skb;
skb126net/core/datagram.cskb = skb_dequeue(&sk->receive_queue);
skb127net/core/datagram.cif (!skb)  /* Avoid race if someone beats us to the data */
skb129net/core/datagram.cskb->users++;
skb130net/core/datagram.creturn skb;
skb138net/core/datagram.cvoid skb_free_datagram(struct sock * sk, struct sk_buff *skb)
skb144net/core/datagram.cskb->users--;
skb145net/core/datagram.cif(skb->users <= 0) {
skb148net/core/datagram.cif(!skb->next && !skb->prev)
skb149net/core/datagram.ckfree_skb(skb,FREE_READ);
skb159net/core/datagram.cvoid skb_copy_datagram(struct sk_buff *skb, int offset, char *to, int size)
skb161net/core/datagram.cmemcpy_tofs(to,skb->h.raw+offset,size);
skb169net/core/datagram.cvoid skb_copy_datagram_iovec(struct sk_buff *skb, int offset, struct iovec *to, int size)
skb171net/core/datagram.cmemcpy_toiovec(to,skb->h.raw+offset,size);
skb305net/core/dev.cstruct sk_buff *skb;
skb306net/core/dev.cwhile((skb=skb_dequeue(&dev->buffs[ct]))!=NULL)
skb307net/core/dev.cif(skb->free)
skb308net/core/dev.ckfree_skb(skb,FREE_WRITE);
skb338net/core/dev.cvoid dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
skb346net/core/dev.cif(pri>=0 && !skb_device_locked(skb))
skb347net/core/dev.cskb_device_lock(skb);  /* Shove a lock on the frame */
skb349net/core/dev.cIS_SKB(skb);
skb351net/core/dev.cskb->dev = dev;
skb378net/core/dev.cif (!skb->arp && dev->rebuild_header(skb->data, dev, skb->raddr, skb)) {
skb392net/core/dev.cskb->dev = dev = net_alias_main_dev(dev);
skb402net/core/dev.cdev_kfree_skb(skb, FREE_WRITE);
skb406net/core/dev.cskb_device_unlock(skb);    /* Buffer is on the device queue and can be freed safely */
skb407net/core/dev.c__skb_queue_tail(list, skb);
skb408net/core/dev.cskb = __skb_dequeue(list);
skb409net/core/dev.cskb_device_lock(skb);    /* New buffer needs locking down */
skb416net/core/dev.cskb->stamp=xtime;
skb423net/core/dev.c((struct sock *)ptype->data != skb->sk))
skb426net/core/dev.cif ((skb2 = skb_clone(skb, GFP_ATOMIC)) == NULL)
skb430net/core/dev.cptype->func(skb2, skb->dev, ptype);
skb436net/core/dev.cif (dev->hard_start_xmit(skb, dev) == 0) {
skb450net/core/dev.cskb_device_unlock(skb);
skb451net/core/dev.c__skb_queue_head(list,skb);
skb461net/core/dev.cvoid netif_rx(struct sk_buff *skb)
skb471net/core/dev.cskb->sk = NULL;
skb472net/core/dev.cskb->free = 1;
skb473net/core/dev.cif(skb->stamp.tv_sec==0)
skb474net/core/dev.cskb->stamp = xtime;
skb487net/core/dev.ckfree_skb(skb, FREE_READ);
skb495net/core/dev.cIS_SKB(skb);
skb497net/core/dev.cskb_queue_tail(&backlog,skb);
skb577net/core/dev.cstruct sk_buff * skb = backlog.next;
skb583net/core/dev.c__skb_unlink(skb, &backlog);
skb594net/core/dev.cskb->h.raw = skb->data;
skb600net/core/dev.ctype = skb->protocol;
skb612net/core/dev.cstruct sk_buff *skb2=skb_clone(skb, GFP_ATOMIC);
skb614net/core/dev.cpt_prev->func(skb2,skb->dev, pt_prev);
skb621net/core/dev.cif (ptype->type == type && (!ptype->dev || ptype->dev==skb->dev))
skb631net/core/dev.cskb2=skb_clone(skb, GFP_ATOMIC);
skb639net/core/dev.cpt_prev->func(skb2, skb->dev, pt_prev);
skb651net/core/dev.cpt_prev->func(skb, skb->dev, pt_prev);
skb657net/core/dev.ckfree_skb(skb, FREE_WRITE);
skb711net/core/dev.cstruct sk_buff *skb;
skb713net/core/dev.cskb = head->next;
skb714net/core/dev.c__skb_unlink(skb, head);
skb718net/core/dev.cskb_device_lock(skb);
skb724net/core/dev.cdev_queue_xmit(skb,dev,-i - 1);
skb96net/core/firewall.cint call_fw_firewall(int pf, struct sk_buff *skb, void *phdr)
skb102net/core/firewall.cint rc=fw->fw_forward(fw,pf,skb,phdr);
skb114net/core/firewall.cint call_in_firewall(int pf, struct sk_buff *skb, void *phdr)
skb120net/core/firewall.cint rc=fw->fw_input(fw,pf,skb,phdr);
skb128net/core/firewall.cint call_out_firewall(int pf, struct sk_buff *skb, void *phdr)
skb134net/core/firewall.cint rc=fw->fw_output(fw,pf,skb,phdr);
skb71net/core/net_alias.cstatic int net_alias_hard_start_xmit(struct sk_buff *skb, struct device *dev);
skb230net/core/net_alias.cnet_alias_hard_start_xmit(struct sk_buff *skb, struct device *dev)
skb233net/core/net_alias.cdev_kfree_skb(skb, FREE_WRITE);
skb86net/core/skbuff.cint skb_check(struct sk_buff *skb, int head, int line, char *file)
skb89net/core/skbuff.cif (skb->magic_debug_cookie != SK_HEAD_SKB) {
skb94net/core/skbuff.cif (!skb->next || !skb->prev) {
skb98net/core/skbuff.cif (skb->next->magic_debug_cookie != SK_HEAD_SKB
skb99net/core/skbuff.c&& skb->next->magic_debug_cookie != SK_GOOD_SKB) {
skb104net/core/skbuff.cif (skb->prev->magic_debug_cookie != SK_HEAD_SKB
skb105net/core/skbuff.c&& skb->prev->magic_debug_cookie != SK_GOOD_SKB) {
skb112net/core/skbuff.cstruct sk_buff *skb2 = skb->next;
skb114net/core/skbuff.cwhile (skb2 != skb && i < 5) {
skb126net/core/skbuff.cif (skb->next != NULL && skb->next->magic_debug_cookie != SK_HEAD_SKB
skb127net/core/skbuff.c&& skb->next->magic_debug_cookie != SK_GOOD_SKB) {
skb132net/core/skbuff.cif (skb->prev != NULL && skb->prev->magic_debug_cookie != SK_HEAD_SKB
skb133net/core/skbuff.c&& skb->prev->magic_debug_cookie != SK_GOOD_SKB) {
skb140net/core/skbuff.cif(skb->magic_debug_cookie==SK_FREED_SKB)
skb145net/core/skbuff.cskb,skb->truesize,skb->free);
skb148net/core/skbuff.cif(skb->magic_debug_cookie!=SK_GOOD_SKB)
skb152net/core/skbuff.cskb,skb->truesize,skb->free);
skb155net/core/skbuff.cif(skb->head>skb->data)
skb159net/core/skbuff.cskb,skb->head,skb->data);
skb162net/core/skbuff.cif(skb->tail>skb->end)
skb166net/core/skbuff.cskb,skb->tail,skb->end);
skb169net/core/skbuff.cif(skb->data>skb->tail)
skb173net/core/skbuff.cskb,skb->data,skb->tail);
skb176net/core/skbuff.cif(skb->tail-skb->data!=skb->len)
skb180net/core/skbuff.cskb,skb->data,skb->end,skb->len);
skb183net/core/skbuff.cif((unsigned long) skb->end > (unsigned long) skb)
skb187net/core/skbuff.cskb,skb->end);
skb465net/core/skbuff.cvoid skb_unlink(struct sk_buff *skb)
skb472net/core/skbuff.cIS_SKB(skb);
skb474net/core/skbuff.cif(skb->list)
skb476net/core/skbuff.cskb->list->qlen--;
skb477net/core/skbuff.cskb->next->prev = skb->prev;
skb478net/core/skbuff.cskb->prev->next = skb->next;
skb479net/core/skbuff.cskb->next = NULL;
skb480net/core/skbuff.cskb->prev = NULL;
skb481net/core/skbuff.cskb->list = NULL;
skb490net/core/skbuff.cvoid __skb_unlink(struct sk_buff *skb)
skb492net/core/skbuff.cIS_SKB(skb);
skb494net/core/skbuff.cif(skb->list)
skb496net/core/skbuff.cskb->list->qlen--;
skb497net/core/skbuff.cskb->next->prev = skb->prev;
skb498net/core/skbuff.cskb->prev->next = skb->next;
skb499net/core/skbuff.cskb->next = NULL;
skb500net/core/skbuff.cskb->prev = NULL;
skb501net/core/skbuff.cskb->list = NULL;
skb513net/core/skbuff.cunsigned char *skb_put(struct sk_buff *skb, int len)
skb515net/core/skbuff.cunsigned char *tmp=skb->tail;
skb516net/core/skbuff.cIS_SKB(skb);
skb517net/core/skbuff.cskb->tail+=len;
skb518net/core/skbuff.cskb->len+=len;
skb519net/core/skbuff.cIS_SKB(skb);
skb520net/core/skbuff.cif(skb->tail>skb->end)
skb525net/core/skbuff.cunsigned char *skb_push(struct sk_buff *skb, int len)
skb527net/core/skbuff.cIS_SKB(skb);
skb528net/core/skbuff.cskb->data-=len;
skb529net/core/skbuff.cskb->len+=len;
skb530net/core/skbuff.cIS_SKB(skb);
skb531net/core/skbuff.cif(skb->data<skb->head)
skb533net/core/skbuff.creturn skb->data;
skb536net/core/skbuff.cunsigned char * skb_pull(struct sk_buff *skb, int len)
skb538net/core/skbuff.cIS_SKB(skb);
skb539net/core/skbuff.cif(len>skb->len)
skb541net/core/skbuff.cskb->data+=len;
skb542net/core/skbuff.cskb->len-=len;
skb543net/core/skbuff.creturn skb->data;
skb546net/core/skbuff.cint skb_headroom(struct sk_buff *skb)
skb548net/core/skbuff.cIS_SKB(skb);
skb549net/core/skbuff.creturn skb->data-skb->head;
skb552net/core/skbuff.cint skb_tailroom(struct sk_buff *skb)
skb554net/core/skbuff.cIS_SKB(skb);
skb555net/core/skbuff.creturn skb->end-skb->tail;
skb558net/core/skbuff.cvoid skb_reserve(struct sk_buff *skb, int len)
skb560net/core/skbuff.cIS_SKB(skb);
skb561net/core/skbuff.cskb->data+=len;
skb562net/core/skbuff.cskb->tail+=len;
skb563net/core/skbuff.cif(skb->tail>skb->end)
skb565net/core/skbuff.cif(skb->data<skb->head)
skb567net/core/skbuff.cIS_SKB(skb);
skb570net/core/skbuff.cvoid skb_trim(struct sk_buff *skb, int len)
skb572net/core/skbuff.cIS_SKB(skb);
skb573net/core/skbuff.cif(skb->len>len)
skb575net/core/skbuff.cskb->len=len;
skb576net/core/skbuff.cskb->tail=skb->data+len;
skb589net/core/skbuff.cvoid kfree_skb(struct sk_buff *skb, int rw)
skb591net/core/skbuff.cif (skb == NULL)
skb598net/core/skbuff.cIS_SKB(skb);
skb600net/core/skbuff.cif (skb->lock)
skb602net/core/skbuff.cskb->free = 3;    /* Free when unlocked */
skb606net/core/skbuff.cif (skb->free == 2)
skb609net/core/skbuff.cif (skb->list)
skb613net/core/skbuff.cif(skb->destructor)
skb614net/core/skbuff.cskb->destructor(skb);
skb615net/core/skbuff.cif (skb->sk)
skb617net/core/skbuff.cstruct sock * sk = skb->sk;
skb621net/core/skbuff.csock_rfree(sk, skb);
skb623net/core/skbuff.csock_wfree(sk, skb);
skb629net/core/skbuff.catomic_sub(skb->truesize, &sk->rmem_alloc);
skb631net/core/skbuff.catomic_sub(skb->truesize, &sk->wmem_alloc);
skb635net/core/skbuff.ckfree_skbmem(skb);
skb639net/core/skbuff.ckfree_skbmem(skb);
skb648net/core/skbuff.cstruct sk_buff *skb;
skb676net/core/skbuff.cif(skb->magic_debug_cookie == SK_GOOD_SKB)
skb677net/core/skbuff.cprintk("Kernel kmalloc handed us an existing skb (%p)\n",skb);
skb688net/core/skbuff.cskb=(struct sk_buff *)(bptr+size)-1;
skb690net/core/skbuff.cskb->count = 1;    /* only one reference to this */
skb691net/core/skbuff.cskb->data_skb = NULL;  /* and we're our own data skb */
skb693net/core/skbuff.cskb->free = 2;  /* Invalid so we pick up forgetful users */
skb694net/core/skbuff.cskb->lock = 0;
skb695net/core/skbuff.cskb->pkt_type = PACKET_HOST;  /* Default type */
skb696net/core/skbuff.cskb->prev = skb->next = skb->link3 = NULL;
skb697net/core/skbuff.cskb->list = NULL;
skb698net/core/skbuff.cskb->sk = NULL;
skb699net/core/skbuff.cskb->truesize=size;
skb700net/core/skbuff.cskb->localroute=0;
skb701net/core/skbuff.cskb->stamp.tv_sec=0;  /* No idea about time */
skb702net/core/skbuff.cskb->localroute = 0;
skb703net/core/skbuff.cskb->ip_summed = 0;
skb704net/core/skbuff.cmemset(skb->proto_priv, 0, sizeof(skb->proto_priv));
skb707net/core/skbuff.cskb->magic_debug_cookie = SK_GOOD_SKB;
skb709net/core/skbuff.cskb->users = 0;
skb711net/core/skbuff.cskb->head=bptr;
skb712net/core/skbuff.cskb->data=bptr;
skb713net/core/skbuff.cskb->tail=bptr;
skb714net/core/skbuff.cskb->end=bptr+len;
skb715net/core/skbuff.cskb->len=0;
skb716net/core/skbuff.cskb->destructor=NULL;
skb717net/core/skbuff.creturn skb;
skb724net/core/skbuff.cstatic inline void __kfree_skbmem(struct sk_buff *skb)
skb727net/core/skbuff.cif (--skb->count <= 0) {
skb728net/core/skbuff.ckfree(skb->head);
skb733net/core/skbuff.cvoid kfree_skbmem(struct sk_buff *skb)
skb736net/core/skbuff.cvoid * addr = skb->head;
skb741net/core/skbuff.cif (--skb->count <= 0) {
skb743net/core/skbuff.cif (skb->data_skb) {
skb744net/core/skbuff.caddr = skb;
skb745net/core/skbuff.c__kfree_skbmem(skb->data_skb);
skb758net/core/skbuff.cstruct sk_buff *skb_clone(struct sk_buff *skb, int priority)
skb762net/core/skbuff.cIS_SKB(skb);
skb766net/core/skbuff.cmemcpy(n, skb, sizeof(*n));
skb768net/core/skbuff.cif (skb->data_skb)
skb769net/core/skbuff.cskb = skb->data_skb;
skb770net/core/skbuff.catomic_inc(&skb->count);
skb773net/core/skbuff.cn->data_skb = skb;
skb788net/core/skbuff.cstruct sk_buff *skb_copy(struct sk_buff *skb, int priority)
skb797net/core/skbuff.cIS_SKB(skb);
skb799net/core/skbuff.cn=alloc_skb(skb->truesize-sizeof(struct sk_buff),priority);
skb807net/core/skbuff.coffset=n->head-skb->head;
skb810net/core/skbuff.cskb_reserve(n,skb->data-skb->head);
skb812net/core/skbuff.cskb_put(n,skb->len);
skb814net/core/skbuff.cmemcpy(n->head,skb->head,skb->end-skb->head);
skb818net/core/skbuff.cn->when=skb->when;
skb819net/core/skbuff.cn->dev=skb->dev;
skb820net/core/skbuff.cn->h.raw=skb->h.raw+offset;
skb821net/core/skbuff.cn->mac.raw=skb->mac.raw+offset;
skb822net/core/skbuff.cn->ip_hdr=(struct iphdr *)(((char *)skb->ip_hdr)+offset);
skb823net/core/skbuff.cn->saddr=skb->saddr;
skb824net/core/skbuff.cn->daddr=skb->daddr;
skb825net/core/skbuff.cn->raddr=skb->raddr;
skb826net/core/skbuff.cn->seq=skb->seq;
skb827net/core/skbuff.cn->end_seq=skb->end_seq;
skb828net/core/skbuff.cn->ack_seq=skb->ack_seq;
skb829net/core/skbuff.cn->acked=skb->acked;
skb830net/core/skbuff.cmemcpy(n->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
skb831net/core/skbuff.cn->used=skb->used;
skb833net/core/skbuff.cn->arp=skb->arp;
skb837net/core/skbuff.cn->pkt_type=skb->pkt_type;
skb838net/core/skbuff.cn->stamp=skb->stamp;
skb848net/core/skbuff.cvoid skb_device_lock(struct sk_buff *skb)
skb850net/core/skbuff.cif(skb->lock)
skb854net/core/skbuff.cskb->lock++;
skb857net/core/skbuff.cvoid skb_device_unlock(struct sk_buff *skb)
skb859net/core/skbuff.cif(skb->lock==0)
skb861net/core/skbuff.cskb->lock--;
skb862net/core/skbuff.cif(skb->lock==0)
skb866net/core/skbuff.cvoid dev_kfree_skb(struct sk_buff *skb, int mode)
skb872net/core/skbuff.cif(skb->lock)
skb875net/core/skbuff.cskb->lock--;
skb877net/core/skbuff.cif (!skb->lock && (skb->free == 1 || skb->free == 3))
skb880net/core/skbuff.ckfree_skb(skb,mode);
skb888net/core/skbuff.cstruct sk_buff *skb;
skb890net/core/skbuff.cskb = alloc_skb(length+16, GFP_ATOMIC);
skb891net/core/skbuff.cif (skb)
skb892net/core/skbuff.cskb_reserve(skb,16);
skb893net/core/skbuff.creturn skb;
skb896net/core/skbuff.cint skb_device_locked(struct sk_buff *skb)
skb898net/core/skbuff.creturn skb->lock? 1 : 0;
skb331net/core/sock.cstruct sk_buff * skb = alloc_skb(size, priority);
skb332net/core/sock.cif (skb)
skb333net/core/sock.catomic_add(skb->truesize, &sk->wmem_alloc);
skb334net/core/sock.creturn skb;
skb345net/core/sock.cstruct sk_buff *skb = alloc_skb(size, priority);
skb346net/core/sock.cif (skb)
skb347net/core/sock.catomic_add(skb->truesize, &sk->rmem_alloc);
skb348net/core/sock.creturn skb;
skb387net/core/sock.cvoid sock_wfree(struct sock *sk, struct sk_buff *skb)
skb389net/core/sock.cint s=skb->truesize;
skb391net/core/sock.cIS_SKB(skb);
skb393net/core/sock.ckfree_skbmem(skb);
skb403net/core/sock.cvoid sock_rfree(struct sock *sk, struct sk_buff *skb)
skb405net/core/sock.cint s=skb->truesize;
skb407net/core/sock.cIS_SKB(skb);
skb409net/core/sock.ckfree_skbmem(skb);
skb422net/core/sock.cstruct sk_buff *skb;
skb444net/core/sock.cskb = sock_wmalloc(sk, size, 0, sk->allocation);
skb449net/core/sock.cskb = sock_wmalloc(sk, size, 0 , GFP_BUFFER);
skb450net/core/sock.cif(!skb)
skb451net/core/sock.cskb=sock_wmalloc(sk, fallback, 0, GFP_KERNEL);
skb458net/core/sock.cif(skb==NULL)
skb508net/core/sock.cwhile(skb==NULL);
skb510net/core/sock.creturn skb;
skb523net/core/sock.cstruct sk_buff * skb = sk->back_log.next;
skb524net/core/sock.c__skb_unlink(skb, &sk->back_log);
skb525net/core/sock.csk->prot->rcv(skb, skb->dev, (struct options*)skb->proto_priv,
skb526net/core/sock.cskb->saddr, skb->len, skb->daddr, 1,
skb90net/ethernet/eth.cint eth_header(struct sk_buff *skb, struct device *dev, unsigned short type,
skb93net/ethernet/eth.cstruct ethhdr *eth = (struct ethhdr *)skb_push(skb,ETH_HLEN);
skb141net/ethernet/eth.cstruct sk_buff *skb)
skb160net/ethernet/eth.creturn arp_find(eth->h_dest, dst, dev, dev->pa_addr, skb)? 1 : 0;
skb173net/ethernet/eth.cunsigned short eth_type_trans(struct sk_buff *skb, struct device *dev)
skb178net/ethernet/eth.cskb->mac.raw=skb->data;
skb179net/ethernet/eth.cskb_pull(skb,dev->hard_header_len);
skb180net/ethernet/eth.ceth= skb->mac.ethernet;
skb185net/ethernet/eth.cskb->pkt_type=PACKET_BROADCAST;
skb187net/ethernet/eth.cskb->pkt_type=PACKET_MULTICAST;
skb198net/ethernet/eth.cskb->pkt_type=PACKET_OTHERHOST;
skb204net/ethernet/eth.crawp = skb->data;
skb9net/ethernet/pe2.cstruct sk_buff *skb, unsigned char *dest_node)
skb11net/ethernet/pe2.cstruct device  *dev = skb->dev;
skb13net/ethernet/pe2.cskb->protocol = htons (ETH_P_IPX);
skb14net/ethernet/pe2.cdev->hard_header(skb, dev, ETH_P_IPX, dest_node, NULL, skb->len);
skb292net/ipv4/af_inet.cstruct sk_buff *skb;
skb310net/ipv4/af_inet.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL) 
skb312net/ipv4/af_inet.cIS_SKB(skb);
skb313net/ipv4/af_inet.ckfree_skb(skb, FREE_WRITE);
skb320net/ipv4/af_inet.cwhile((skb = skb_dequeue(&sk->write_queue)) != NULL) {
skb321net/ipv4/af_inet.cIS_SKB(skb);
skb322net/ipv4/af_inet.ckfree_skb(skb, FREE_WRITE);
skb329net/ipv4/af_inet.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) 
skb335net/ipv4/af_inet.cif (skb->sk != NULL && skb->sk != sk) 
skb337net/ipv4/af_inet.cIS_SKB(skb);
skb338net/ipv4/af_inet.cskb->sk->prot->close(skb->sk, 0);
skb340net/ipv4/af_inet.cIS_SKB(skb);
skb341net/ipv4/af_inet.ckfree_skb(skb, FREE_READ);
skb349net/ipv4/af_inet.cfor(skb = sk->send_head; skb != NULL; )
skb357net/ipv4/af_inet.cif (skb->next  && skb->prev) 
skb359net/ipv4/af_inet.cIS_SKB(skb);
skb360net/ipv4/af_inet.cskb_unlink(skb);
skb362net/ipv4/af_inet.cskb->dev = NULL;
skb363net/ipv4/af_inet.cskb2 = skb->link3;
skb364net/ipv4/af_inet.ckfree_skb(skb, FREE_WRITE);
skb365net/ipv4/af_inet.cskb = skb2;
skb374net/ipv4/af_inet.cwhile((skb=skb_dequeue(&sk->back_log))!=NULL) 
skb377net/ipv4/af_inet.cskb->sk = NULL;
skb378net/ipv4/af_inet.ckfree_skb(skb, FREE_READ);
skb138net/ipv4/arp.cstruct sk_buff_head    skb;      /* list of queued packets   */
skb311net/ipv4/arp.cstruct sk_buff *skb;
skb317net/ipv4/arp.cwhile ((skb = skb_dequeue(&entry->skb)) != NULL)
skb319net/ipv4/arp.cskb_device_lock(skb);
skb321net/ipv4/arp.cdev_kfree_skb(skb, FREE_WRITE);
skb539net/ipv4/arp.cskb_queue_head_init(&entry->skb);
skb818net/ipv4/arp.cstruct sk_buff *skb;
skb833net/ipv4/arp.cskb = alloc_skb(sizeof(struct arphdr)+ 2*(dev->addr_len+4)
skb835net/ipv4/arp.cif (skb == NULL)
skb840net/ipv4/arp.cskb_reserve(skb, dev->hard_header_len);
skb841net/ipv4/arp.carp = (struct arphdr *) skb_put(skb,sizeof(struct arphdr) + 2*(dev->addr_len+4));
skb842net/ipv4/arp.cskb->arp = 1;
skb843net/ipv4/arp.cskb->dev = dev;
skb844net/ipv4/arp.cskb->free = 1;
skb845net/ipv4/arp.cskb->protocol = htons (ETH_P_IP);
skb851net/ipv4/arp.cdev->hard_header(skb,dev,ptype,dest_hw?dest_hw:dev->broadcast,src_hw?src_hw:NULL,skb->len);
skb881net/ipv4/arp.cdev_queue_xmit(skb, dev, 0);
skb890net/ipv4/arp.cstruct sk_buff *skb;
skb912net/ipv4/arp.cwhile((skb = skb_dequeue(&entry->skb)) != NULL)
skb914net/ipv4/arp.cIS_SKB(skb);
skb915net/ipv4/arp.cskb_device_lock(skb);
skb917net/ipv4/arp.cif(!skb->dev->rebuild_header(skb->data,skb->dev,skb->raddr,skb))
skb919net/ipv4/arp.cskb->arp  = 1;
skb920net/ipv4/arp.cif(skb->sk==NULL)
skb921net/ipv4/arp.cdev_queue_xmit(skb, skb->dev, 0);
skb923net/ipv4/arp.cdev_queue_xmit(skb,skb->dev,skb->sk->priority);
skb963net/ipv4/arp.cint arp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb969net/ipv4/arp.cstruct arphdr *arp = (struct arphdr *)skb->h.raw;
skb990net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1010net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1019net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1028net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1036net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1043net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1065net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1091net/ipv4/arp.cif (tip != dev->pa_addr && net_alias_has(skb->dev)) 
skb1100net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1149net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1157net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1177net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1239net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1260net/ipv4/arp.centry->dev = skb->dev;
skb1262net/ipv4/arp.cskb_queue_head_init(&entry->skb);
skb1283net/ipv4/arp.ckfree_skb(skb, FREE_READ);
skb1396net/ipv4/arp.cu32 saddr, struct sk_buff *skb)
skb1403net/ipv4/arp.cif (skb)
skb1404net/ipv4/arp.cskb->arp = 1;
skb1427net/ipv4/arp.cif (skb != NULL)
skb1431net/ipv4/arp.cskb_queue_tail(&entry->skb, skb);
skb1432net/ipv4/arp.cskb_device_unlock(skb);
skb1445net/ipv4/arp.cif (skb->sk)
skb1447net/ipv4/arp.cskb->sk->err = EHOSTDOWN;
skb1448net/ipv4/arp.cskb->sk->error_report(skb->sk);
skb1451net/ipv4/arp.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, dev);
skb1453net/ipv4/arp.cdev_kfree_skb(skb, FREE_WRITE);
skb1467net/ipv4/arp.cif (skb)
skb1468net/ipv4/arp.cskb->arp = 1;
skb1492net/ipv4/arp.cskb_queue_head_init(&entry->skb);
skb1493net/ipv4/arp.cif (skb != NULL)
skb1495net/ipv4/arp.cskb_queue_tail(&entry->skb, skb);
skb1496net/ipv4/arp.cskb_device_unlock(skb);
skb1514net/ipv4/arp.celse if (skb != NULL)
skb1515net/ipv4/arp.cdev_kfree_skb(skb, FREE_WRITE);
skb1731net/ipv4/arp.cskb_queue_head_init(&entry->skb);
skb1807net/ipv4/arp.cstruct sk_buff * skb;
skb1826net/ipv4/arp.cwhile ((skb = skb_dequeue(&entry->skb)) != NULL)
skb1828net/ipv4/arp.cskb_device_lock(skb);
skb1830net/ipv4/arp.cskb_queue_tail(&entry1->skb, skb);
skb1831net/ipv4/arp.cskb_device_unlock(skb);
skb1976net/ipv4/arp.cskb_queue_head_init(&entry->skb);
skb152net/ipv4/icmp.cvoid (*handler)(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len);
skb340net/ipv4/icmp.cstatic void icmp_unreach(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
skb474net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb482net/ipv4/icmp.cstatic void icmp_redirect(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 source, __u32 daddr, int len)
skb541net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb552net/ipv4/icmp.cstatic void icmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
skb559net/ipv4/icmp.cif (ip_options_echo(&icmp_param.replyopts, NULL, daddr, saddr, skb)==0)
skb561net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb572net/ipv4/icmp.cstatic void icmp_timestamp(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
skb584net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb604net/ipv4/icmp.cif (ip_options_echo(&icmp_param.replyopts, NULL, daddr, saddr, skb)==0)
skb606net/ipv4/icmp.ckfree_skb(skb,FREE_READ);
skb622net/ipv4/icmp.cstatic void icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
skb633net/ipv4/icmp.cif (ip_options_echo(&icmp_param.replyopts, NULL, daddr, saddr, skb)==0)
skb636net/ipv4/icmp.ckfree_skb(skb, FREE_READ);  
skb639net/ipv4/icmp.cstatic void icmp_discard(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
skb641net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb648net/ipv4/icmp.cint icmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb652net/ipv4/icmp.cstruct icmphdr *icmph=(void *)skb->h.raw;
skb664net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb677net/ipv4/icmp.ckfree_skb(skb,FREE_READ);
skb695net/ipv4/icmp.ckfree_skb(skb, FREE_READ);
skb708net/ipv4/icmp.c(icmp_pointers[icmph->type].handler)(icmph,skb,skb->dev,saddr,daddr,len);
skb240net/ipv4/igmp.cstruct sk_buff *skb=alloc_skb(MAX_IGMP_SIZE, GFP_ATOMIC);
skb244net/ipv4/igmp.cif(skb==NULL)
skb246net/ipv4/igmp.ctmp=ip_build_header(skb, INADDR_ANY, address, &dev, IPPROTO_IGMP, NULL,
skb250net/ipv4/igmp.ckfree_skb(skb, FREE_WRITE);
skb253net/ipv4/igmp.cih=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
skb259net/ipv4/igmp.cip_queue_xmit(NULL,dev,skb,1);
skb429net/ipv4/igmp.cint igmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb448net/ipv4/igmp.cih=(struct igmphdr *)skb->h.raw;
skb450net/ipv4/igmp.cif(skb->len <sizeof(struct igmphdr) || skb->ip_hdr->ttl>1 || ip_compute_csum((void *)skb->h.raw,sizeof(struct igmphdr)))
skb452net/ipv4/igmp.ckfree_skb(skb, FREE_READ);
skb464net/ipv4/igmp.ckfree_skb(skb, FREE_READ);
skb474net/ipv4/igmp.ckfree_skb(skb, FREE_READ);
skb45net/ipv4/ip_forward.cstatic void ip_encap(struct sk_buff *skb, int len, struct device *out, __u32 daddr)
skb52net/ipv4/ip_forward.cstruct iphdr *iph=(struct iphdr *)skb_push(skb,sizeof(struct iphdr));
skb56net/ipv4/ip_forward.ciph->tos  =  skb->ip_hdr->tos;
skb57net/ipv4/ip_forward.ciph->ttl  =  skb->ip_hdr->ttl;
skb63net/ipv4/ip_forward.ciph->tot_len  =  htons(skb->len);
skb67net/ipv4/ip_forward.cskb->dev = out;
skb68net/ipv4/ip_forward.cskb->arp = 1;
skb69net/ipv4/ip_forward.cskb->raddr=daddr;
skb73net/ipv4/ip_forward.cif (out->hard_header && out->hard_header(skb, out, ETH_P_IP, NULL, NULL, len)<0)
skb74net/ipv4/ip_forward.cskb->arp=0;
skb86net/ipv4/ip_forward.cint ip_forward(struct sk_buff *skb, struct device *dev, int is_frag,
skb95net/ipv4/ip_forward.cstruct   options * opt  = (struct options*)skb->proto_priv;
skb101net/ipv4/ip_forward.cstruct sk_buff *skb_in = skb;  /* So we can remember if the masquerader did some swaps */
skb112net/ipv4/ip_forward.cfw_res=call_fw_firewall(PF_INET, skb, skb->h.iph);
skb118net/ipv4/ip_forward.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0, dev);
skb136net/ipv4/ip_forward.ciph = skb->h.iph;
skb153net/ipv4/ip_forward.cicmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, 0, dev);
skb174net/ipv4/ip_forward.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, 0, dev);
skb195net/ipv4/ip_forward.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_SR_FAILED, 0, dev);
skb214net/ipv4/ip_forward.cicmp_send(skb, ICMP_REDIRECT, ICMP_REDIR_HOST, raddr, dev);
skb223net/ipv4/ip_forward.cdev2=skb->dev;
skb224net/ipv4/ip_forward.craddr=skb->raddr;
skb245net/ipv4/ip_forward.cip_fw_masquerade(&skb, dev2);
skb247net/ipv4/ip_forward.cIS_SKB(skb);
skb249net/ipv4/ip_forward.cif (skb->len+encap > dev2->mtu && (ntohs(iph->frag_off) & IP_DF)) 
skb252net/ipv4/ip_forward.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(dev2->mtu), dev);
skb259net/ipv4/ip_forward.cif(skb_headroom(skb)-encap<dev2->hard_header_len)
skb261net/ipv4/ip_forward.cskb2 = alloc_skb(dev2->hard_header_len + skb->len + encap + 15, GFP_ATOMIC);
skb263net/ipv4/ip_forward.cif(skb_headroom(skb)<dev2->hard_header_len)
skb265net/ipv4/ip_forward.cskb2 = alloc_skb(dev2->hard_header_len + skb->len + 15, GFP_ATOMIC);
skb288net/ipv4/ip_forward.cskb_reserve(skb,(encap+dev->hard_header_len+15)&~15);  /* 16 byte aligned IP headers are good */
skb289net/ipv4/ip_forward.cip_encap(skb2,skb->len, dev2, raddr);
skb293net/ipv4/ip_forward.cip_send(rt,skb2,raddr,skb->len,dev2,dev2->pa_addr);
skb300net/ipv4/ip_forward.cptr = skb_put(skb2,skb->len);
skb307net/ipv4/ip_forward.cmemcpy(ptr, skb->h.raw, skb->len);
skb308net/ipv4/ip_forward.cmemcpy(skb2->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
skb317net/ipv4/ip_forward.cskb2 = skb;    
skb321net/ipv4/ip_forward.cip_encap(skb,skb->len, dev2, raddr);
skb325net/ipv4/ip_forward.cskb->arp=1;
skb326net/ipv4/ip_forward.cskb->raddr=raddr;
skb329net/ipv4/ip_forward.cmemcpy(skb_push(skb, dev2->hard_header_len), hh->hh_data, dev2->hard_header_len);
skb335net/ipv4/ip_forward.cskb->arp = 0;
skb340net/ipv4/ip_forward.cif(dev2->hard_header(skb, dev2, ETH_P_IP, NULL, NULL, skb->len)<0)
skb341net/ipv4/ip_forward.cskb->arp=0;
skb354net/ipv4/ip_forward.cif (skb != skb2)
skb460net/ipv4/ip_forward.cif(skb==skb2)
skb468net/ipv4/ip_forward.cif(skb!=skb_in)
skb54net/ipv4/ip_fragment.cextern __inline__ void frag_kfree_skb(struct sk_buff *skb, int type)
skb56net/ipv4/ip_fragment.catomic_sub(skb->truesize, &ip_frag_mem);
skb57net/ipv4/ip_fragment.ckfree_skb(skb,type);
skb79net/ipv4/ip_fragment.cstatic struct ipfrag *ip_frag_create(int offset, int end, struct sk_buff *skb, unsigned char *ptr)
skb96net/ipv4/ip_fragment.cfp->skb = skb;
skb105net/ipv4/ip_fragment.cip_frag_mem+=skb->truesize;
skb177net/ipv4/ip_fragment.cIS_SKB(fp->skb);
skb178net/ipv4/ip_fragment.cfrag_kfree_skb(fp->skb,FREE_READ);
skb210net/ipv4/ip_fragment.cicmp_send(qp->fragments->skb,ICMP_TIME_EXCEEDED,
skb241net/ipv4/ip_fragment.cstatic struct ipq *ip_create(struct sk_buff *skb, struct iphdr *iph, struct device *dev)
skb251net/ipv4/ip_fragment.cskb->dev = qp->dev;
skb331net/ipv4/ip_fragment.cstruct sk_buff *skb;
skb342net/ipv4/ip_fragment.cif ((skb = dev_alloc_skb(len)) == NULL)
skb351net/ipv4/ip_fragment.cskb_put(skb,len);
skb352net/ipv4/ip_fragment.cskb->h.raw = skb->data;
skb353net/ipv4/ip_fragment.cskb->free = 1;
skb356net/ipv4/ip_fragment.cptr = (unsigned char *) skb->h.raw;
skb366net/ipv4/ip_fragment.cif(count+fp->len > skb->len)
skb370net/ipv4/ip_fragment.cfrag_kfree_skb(skb,FREE_WRITE);
skb383net/ipv4/ip_fragment.ciph = skb->h.iph;
skb386net/ipv4/ip_fragment.cskb->ip_hdr = iph;
skb389net/ipv4/ip_fragment.creturn(skb);
skb397net/ipv4/ip_fragment.cstruct sk_buff *ip_defrag(struct iphdr *iph, struct sk_buff *skb, struct device *dev)
skb429net/ipv4/ip_fragment.creturn(skb);
skb462net/ipv4/ip_fragment.cif ((qp = ip_create(skb, iph, dev)) == NULL)
skb464net/ipv4/ip_fragment.cskb->sk = NULL;
skb465net/ipv4/ip_fragment.cfrag_kfree_skb(skb, FREE_READ);
skb481net/ipv4/ip_fragment.cptr = skb->data + ihl;
skb547net/ipv4/ip_fragment.cfrag_kfree_skb(tmp->skb,FREE_READ);
skb557net/ipv4/ip_fragment.ctfp = ip_frag_create(offset, end, skb, ptr);
skb565net/ipv4/ip_fragment.cskb->sk = NULL;
skb566net/ipv4/ip_fragment.cfrag_kfree_skb(skb, FREE_READ);
skb606net/ipv4/ip_fragment.cvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
skb619net/ipv4/ip_fragment.craw = skb->data;
skb622net/ipv4/ip_fragment.cskb->ip_hdr = iph;
skb624net/ipv4/ip_fragment.ciph = skb->ip_hdr;
skb657net/ipv4/ip_fragment.cicmp_send(skb,ICMP_DEST_UNREACH,ICMP_FRAG_NEEDED,dev->mtu, dev);
skb709net/ipv4/ip_fragment.cskb2->arp = skb->arp;
skb710net/ipv4/ip_fragment.cif(skb->free==0)
skb725net/ipv4/ip_fragment.cskb2->raddr = skb->raddr;  /* For rebuild_header - must be here */
skb755net/ipv4/ip_fragment.cip_options_fragment(skb);
skb616net/ipv4/ip_fw.cstatic struct sk_buff *revamp(struct sk_buff *skb, struct device *dev, struct ip_masq *ftp)
skb618net/ipv4/ip_fw.cstruct iphdr *iph = skb->h.iph;
skb657net/ipv4/ip_fw.cwhile (skb->len - ((unsigned char *)data - skb->h.raw) > 18)
skb694net/ipv4/ip_fw.creturn skb;
skb733net/ipv4/ip_fw.creturn skb;
skb757net/ipv4/ip_fw.cprintk("MASQUERADE: resizing needed for %d bytes (%ld)\n",diff, skb->len);
skb759net/ipv4/ip_fw.cskb2 = alloc_skb(MAX_HEADER + skb->len+diff, GFP_ATOMIC);
skb762net/ipv4/ip_fw.creturn skb;
skb764net/ipv4/ip_fw.cskb2->free = skb->free;
skb766net/ipv4/ip_fw.cskb_put(skb2,skb->len + diff);
skb767net/ipv4/ip_fw.cskb2->h.raw = skb2->data + (skb->h.raw - skb->data);
skb780net/ipv4/ip_fw.cmemcpy(skb2->data, skb->data, (p - (char *)skb->data));
skb781net/ipv4/ip_fw.cmemcpy(&skb2->data[(p - (char *)skb->data)], buf, strlen(buf));
skb782net/ipv4/ip_fw.cmemcpy(&skb2->data[(p - (char *)skb->data) + strlen(buf)], data,
skb783net/ipv4/ip_fw.cskb->len - (data-(char *)skb->data));
skb789net/ipv4/ip_fw.ciph->tot_len = htons(skb->len + diff);
skb796net/ipv4/ip_fw.ckfree_skb(skb, FREE_WRITE);
skb799net/ipv4/ip_fw.creturn skb;
skb814net/ipv4/ip_fw.cstruct sk_buff  *skb=*skb_ptr;
skb815net/ipv4/ip_fw.cstruct iphdr  *iph = skb->h.iph;
skb875net/ipv4/ip_fw.csize = skb->len - ((unsigned char *)portptr - skb->h.raw);
skb893net/ipv4/ip_fw.cskb = revamp(*skb_ptr, dev, ms);
skb894net/ipv4/ip_fw.c*skb_ptr = skb;
skb895net/ipv4/ip_fw.ciph = skb->h.iph;
skb897net/ipv4/ip_fw.csize = skb->len - ((unsigned char *)portptr-skb->h.raw);
skb911net/ipv4/ip_fw.cskb->csum = csum_partial((void *)(th + 1), size - sizeof(*th), 0);
skb912net/ipv4/ip_fw.ctcp_send_check(th,iph->saddr,iph->daddr,size,skb);
skb931net/ipv4/ip_fw.cint ip_fw_demasquerade(struct sk_buff *skb)
skb933net/ipv4/ip_fw.cstruct iphdr  *iph = skb->h.iph;
skb936net/ipv4/ip_fw.cstruct tcphdr   *th = (struct tcphdr *)(skb->h.raw+(iph->ihl<<2));
skb971net/ipv4/ip_fw.cint size = skb->len - ((unsigned char *)portptr - skb->h.raw);
skb1017net/ipv4/ip_fw.cskb->csum = csum_partial((void *)(((struct tcphdr *)portptr) + 1),
skb1019net/ipv4/ip_fw.ctcp_send_check((struct tcphdr *)portptr,iph->saddr,iph->daddr,size,skb);
skb1624net/ipv4/ip_fw.cint ipfw_input_check(struct firewall_ops *this, int pf, struct sk_buff *skb, void *phdr)
skb1626net/ipv4/ip_fw.creturn ip_fw_chk(phdr, skb->dev, ip_fw_in_chain, ip_fw_in_policy, 0);
skb1629net/ipv4/ip_fw.cint ipfw_output_check(struct firewall_ops *this, int pf, struct sk_buff *skb, void *phdr)
skb1631net/ipv4/ip_fw.creturn ip_fw_chk(phdr, skb->dev, ip_fw_out_chain, ip_fw_out_policy, 0);
skb1634net/ipv4/ip_fw.cint ipfw_forward_check(struct firewall_ops *this, int pf, struct sk_buff *skb, void *phdr)
skb1636net/ipv4/ip_fw.creturn ip_fw_chk(phdr, skb->dev, ip_fw_fwd_chain, ip_fw_fwd_policy, 0);
skb198net/ipv4/ip_input.cint ip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb200net/ipv4/ip_input.cstruct iphdr *iph = skb->h.iph;
skb223net/ipv4/ip_input.creturn ipv6_rcv(skb,dev,pt);
skb232net/ipv4/ip_input.cskb->ip_hdr = iph;
skb247net/ipv4/ip_input.cif (skb->len<sizeof(struct iphdr) || iph->ihl<5 || iph->version != 4 || ip_fast_csum((unsigned char *)iph, iph->ihl) !=0
skb248net/ipv4/ip_input.c|| skb->len < ntohs(iph->tot_len))
skb251net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb261net/ipv4/ip_input.cskb_trim(skb,ntohs(iph->tot_len));
skb270net/ipv4/ip_input.cif (iph->daddr != skb->dev->pa_addr && net_alias_has(skb->dev)) 
skb271net/ipv4/ip_input.cskb->dev = dev = net_alias_dev_rcv_sel32(skb->dev, AF_INET, iph->saddr, iph->daddr);
skb276net/ipv4/ip_input.cskb->ip_summed = 0;
skb277net/ipv4/ip_input.cif (ip_options_compile(NULL, skb))
skb279net/ipv4/ip_input.copt = (struct options*)skb->proto_priv;
skb283net/ipv4/ip_input.ckfree_skb(skb, FREE_READ);
skb304net/ipv4/ip_input.cif ((err=call_in_firewall(PF_INET, skb, iph))<FW_ACCEPT)
skb307net/ipv4/ip_input.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);
skb308net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb342net/ipv4/ip_input.cif ( iph->daddr == skb->dev->pa_addr || (brd = ip_chk_addr(iph->daddr)) != 0)
skb350net/ipv4/ip_input.cif (brd != IS_MYADDR || skb->pkt_type != PACKET_HOST) 
skb352net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb364net/ipv4/ip_input.cicmp_send(skb, ICMP_PARAMETERPROB, 0, opt->srr+2,
skb365net/ipv4/ip_input.cskb->dev);
skb366net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb380net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb390net/ipv4/ip_input.cif (ip_forward(skb, dev, is_frag, nexthop))
skb391net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb394net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb411net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb426net/ipv4/ip_input.cif (ip_fw_demasquerade(skb)) 
skb428net/ipv4/ip_input.cstruct iphdr *iph=skb->h.iph;
skb429net/ipv4/ip_input.cif (ip_forward(skb, dev, is_frag|IPFWD_MASQUERADED, iph->daddr))
skb430net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb442net/ipv4/ip_input.cskb=ip_defrag(iph,skb,dev);
skb443net/ipv4/ip_input.cif(skb==NULL)
skb445net/ipv4/ip_input.cskb->dev = dev;
skb446net/ipv4/ip_input.ciph=skb->h.iph;
skb453net/ipv4/ip_input.cskb->ip_hdr = iph;
skb454net/ipv4/ip_input.cskb->h.raw += iph->ihl*4;
skb489net/ipv4/ip_input.cskb1=skb_clone(skb, GFP_ATOMIC);
skb532net/ipv4/ip_input.cskb2 = skb_clone(skb, GFP_ATOMIC);
skb538net/ipv4/ip_input.cskb2 = skb;
skb571net/ipv4/ip_input.cipmr_forward(skb, is_frag);
skb574net/ipv4/ip_input.cstruct sk_buff *skb2=skb_clone(skb, GFP_ATOMIC);
skb585net/ipv4/ip_input.craw_rcv(raw_sk, skb, dev, iph->saddr, daddr);
skb589net/ipv4/ip_input.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, 0, dev);  
skb590net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb604net/ipv4/ip_input.cif(skb->pkt_type!=PACKET_HOST || brd==IS_BROADCAST)
skb606net/ipv4/ip_input.ckfree_skb(skb,FREE_WRITE);
skb617net/ipv4/ip_input.cicmp_send(skb, ICMP_PARAMETERPROB, 0, 16, skb->dev);
skb618net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb621net/ipv4/ip_input.cif (ip_forward(skb, dev, is_frag, iph->daddr))
skb622net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb627net/ipv4/ip_input.ckfree_skb(skb, FREE_WRITE);
skb29net/ipv4/ip_options.cvoid ip_options_build(struct sk_buff * skb, struct options * opt,
skb33net/ipv4/ip_options.cunsigned char * iph = (unsigned char*)skb->ip_hdr;
skb35net/ipv4/ip_options.cmemcpy(skb->proto_priv, opt, sizeof(struct options));
skb37net/ipv4/ip_options.copt = (struct options*)skb->proto_priv;
skb75net/ipv4/ip_options.cstruct sk_buff * skb) 
skb86net/ipv4/ip_options.csopt = (struct options*)skb->proto_priv;
skb95net/ipv4/ip_options.c(unsigned char *)skb->ip_hdr);
skb194net/ipv4/ip_options.cvoid ip_options_fragment(struct sk_buff * skb) 
skb196net/ipv4/ip_options.cunsigned char * optptr = (unsigned char*)skb->ip_hdr;
skb197net/ipv4/ip_options.cstruct options * opt = (struct options*)skb->proto_priv;
skb234net/ipv4/ip_options.cint ip_options_compile(struct options * opt, struct sk_buff * skb)
skb244net/ipv4/ip_options.copt = (struct options*)skb->proto_priv;
skb246net/ipv4/ip_options.ciph = (unsigned char*)skb->ip_hdr;
skb253net/ipv4/ip_options.coptptr = opt->is_data ? opt->__data : (unsigned char*)&skb->ip_hdr[1];
skb302net/ipv4/ip_options.cif (!skb) 
skb339net/ipv4/ip_options.cif (skb) 
skb341net/ipv4/ip_options.cmemcpy(&optptr[optptr[2]-1], &skb->dev->pa_addr, 4);
skb378net/ipv4/ip_options.cif (skb) 
skb390net/ipv4/ip_options.cif (skb) 
skb392net/ipv4/ip_options.cmemcpy(&optptr[ts->ptr-1], &skb->dev->pa_addr, 4);
skb411net/ipv4/ip_options.cif (skb)
skb441net/ipv4/ip_options.cif (skb) 
skb451net/ipv4/ip_options.cif (!skb) 
skb466net/ipv4/ip_options.cif (skb) 
skb468net/ipv4/ip_options.cicmp_send(skb, ICMP_PARAMETERPROB, 0, pp_ptr-iph, skb->dev);
skb469net/ipv4/ip_options.ckfree_skb(skb, FREE_READ);
skb67net/ipv4/ip_output.cstatic void ip_loopback(struct device *old_dev, struct sk_buff *skb)
skb70net/ipv4/ip_output.cint len=ntohs(skb->ip_hdr->tot_len);
skb79net/ipv4/ip_output.cnewskb->saddr=skb->saddr;
skb80net/ipv4/ip_output.cnewskb->daddr=skb->daddr;
skb81net/ipv4/ip_output.cnewskb->raddr=skb->raddr;
skb85net/ipv4/ip_output.cnewskb->pkt_type=skb->pkt_type;
skb90net/ipv4/ip_output.cip_send(NULL,newskb, skb->ip_hdr->daddr, len, dev, skb->ip_hdr->saddr);
skb95net/ipv4/ip_output.cmemcpy(newskb->proto_priv, skb->proto_priv, sizeof(skb->proto_priv));
skb100net/ipv4/ip_output.cmemcpy(newskb->ip_hdr,skb->ip_hdr,len);
skb114net/ipv4/ip_output.cint ip_send(struct rtable * rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr)
skb118net/ipv4/ip_output.cskb->dev = dev;
skb119net/ipv4/ip_output.cskb->arp = 1;
skb120net/ipv4/ip_output.cskb->protocol = htons(ETH_P_IP);
skb127net/ipv4/ip_output.cskb_reserve(skb,(dev->hard_header_len+15)&~15);  /* 16 byte aligned IP headers are good */
skb130net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
skb136net/ipv4/ip_output.cskb->arp = 0;
skb137net/ipv4/ip_output.cskb->raddr = daddr;
skb140net/ipv4/ip_output.cmac = dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, len);
skb144net/ipv4/ip_output.cskb->arp = 0;
skb145net/ipv4/ip_output.cskb->raddr = daddr;  /* next routing address */
skb151net/ipv4/ip_output.cstatic int ip_send_room(struct rtable * rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr)
skb155net/ipv4/ip_output.cskb->dev = dev;
skb156net/ipv4/ip_output.cskb->arp = 1;
skb157net/ipv4/ip_output.cskb->protocol = htons(ETH_P_IP);
skb160net/ipv4/ip_output.cskb_reserve(skb,MAX_HEADER);
skb163net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
skb169net/ipv4/ip_output.cskb->arp = 0;
skb170net/ipv4/ip_output.cskb->raddr = daddr;
skb173net/ipv4/ip_output.cmac = dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, len);
skb177net/ipv4/ip_output.cskb->arp = 0;
skb178net/ipv4/ip_output.cskb->raddr = daddr;  /* next routing address */
skb192net/ipv4/ip_output.cint ip_build_header(struct sk_buff *skb, __u32 saddr, __u32 daddr,
skb211net/ipv4/ip_output.cif(MULTICAST(daddr) && *dev==NULL && skb->sk && *skb->sk->ip_mc_name)
skb212net/ipv4/ip_output.c*dev=dev_get(skb->sk->ip_mc_name);
skb216net/ipv4/ip_output.crt = ip_check_route(rp, daddr, skb->localroute);
skb225net/ipv4/ip_output.crt = ip_rt_route(daddr, skb->localroute);
skb263net/ipv4/ip_output.ctmp = ip_send_room(rt, skb, raddr, len, *dev, saddr);
skb265net/ipv4/ip_output.ctmp = ip_send(rt, skb, raddr, len, *dev, saddr);
skb273net/ipv4/ip_output.cskb->dev = *dev;
skb274net/ipv4/ip_output.cskb->saddr = saddr;
skb293net/ipv4/ip_output.ciph=(struct iphdr *)skb_put(skb,sizeof(struct iphdr) + opt->optlen);
skb295net/ipv4/ip_output.ciph=(struct iphdr *)skb_put(skb,sizeof(struct iphdr));
skb305net/ipv4/ip_output.cskb->ip_hdr   = iph;
skb310net/ipv4/ip_output.cip_options_build(skb, opt, final_daddr, (*dev)->pa_addr, 0);
skb335net/ipv4/ip_output.cstruct sk_buff *skb, int free)
skb347net/ipv4/ip_output.cIS_SKB(skb);
skb354net/ipv4/ip_output.cskb->dev = dev;
skb355net/ipv4/ip_output.cskb->when = jiffies;
skb365net/ipv4/ip_output.ciph = skb->ip_hdr;
skb366net/ipv4/ip_output.ciph->tot_len = htons(skb->len-(((unsigned char *)iph)-skb->data));
skb369net/ipv4/ip_output.cif(call_out_firewall(PF_INET, skb, iph) < FW_ACCEPT)
skb387net/ipv4/ip_output.cskb->free = free;
skb397net/ipv4/ip_output.cip_fragment(sk,skb,dev,0);
skb398net/ipv4/ip_output.cIS_SKB(skb);
skb399net/ipv4/ip_output.ckfree_skb(skb,FREE_WRITE);
skb417net/ipv4/ip_output.cif (skb->next != NULL)
skb420net/ipv4/ip_output.cskb_unlink(skb);
skb441net/ipv4/ip_output.cif (skb->link3 != NULL)
skb444net/ipv4/ip_output.cskb->link3 = NULL;
skb448net/ipv4/ip_output.csk->send_tail = skb;
skb449net/ipv4/ip_output.csk->send_head = skb;
skb453net/ipv4/ip_output.csk->send_tail->link3 = skb;
skb454net/ipv4/ip_output.csk->send_tail = skb;
skb463net/ipv4/ip_output.cskb->sk = sk;
skb486net/ipv4/ip_output.cip_loopback(dev,skb);
skb495net/ipv4/ip_output.cip_loopback(dev,skb);
skb504net/ipv4/ip_output.cif(skb->ip_hdr->ttl==0)
skb506net/ipv4/ip_output.ckfree_skb(skb, FREE_READ);
skb512net/ipv4/ip_output.cip_loopback(dev,skb);
skb523net/ipv4/ip_output.cdev_queue_xmit(skb, dev, sk->priority);
skb527net/ipv4/ip_output.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb536net/ipv4/ip_output.ckfree_skb(skb, FREE_WRITE);
skb649net/ipv4/ip_output.cstruct sk_buff *skb=sock_alloc_send_skb(sk, length+15+dev->hard_header_len,0, noblock, &error);
skb650net/ipv4/ip_output.cif(skb==NULL)
skb655net/ipv4/ip_output.cskb->dev=dev;
skb656net/ipv4/ip_output.cskb->protocol = htons(ETH_P_IP);
skb657net/ipv4/ip_output.cskb->free=1;
skb658net/ipv4/ip_output.cskb->when=jiffies;
skb659net/ipv4/ip_output.cskb->sk=sk;
skb660net/ipv4/ip_output.cskb->arp=0;
skb661net/ipv4/ip_output.cskb->saddr=saddr;
skb662net/ipv4/ip_output.cskb->raddr = raddr;
skb663net/ipv4/ip_output.cskb_reserve(skb,(dev->hard_header_len+15)&~15);
skb666net/ipv4/ip_output.cskb->arp=1;
skb667net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),hh->hh_data,dev->hard_header_len);
skb670net/ipv4/ip_output.cskb->arp = 0;
skb678net/ipv4/ip_output.cif(dev->hard_header(skb,dev,ETH_P_IP,NULL,NULL,0)>0)
skb679net/ipv4/ip_output.cskb->arp=1;
skb682net/ipv4/ip_output.cskb->arp=1;
skb683net/ipv4/ip_output.cskb->ip_hdr=iph=(struct iphdr *)skb_put(skb,length);
skb700net/ipv4/ip_output.cip_options_build(skb, opt,
skb711net/ipv4/ip_output.cif(call_out_firewall(PF_INET, skb, iph)< FW_ACCEPT)
skb713net/ipv4/ip_output.ckfree_skb(skb, FREE_WRITE);
skb721net/ipv4/ip_output.cdev_queue_xmit(skb,dev,sk->priority);
skb725net/ipv4/ip_output.ckfree_skb(skb, FREE_WRITE);
skb800net/ipv4/ip_output.cstruct sk_buff * skb;
skb808net/ipv4/ip_output.cskb = sock_alloc_send_skb(sk, fraglen+15, 0, noblock, &error);
skb809net/ipv4/ip_output.cif (skb == NULL)
skb822net/ipv4/ip_output.cskb->dev = dev;
skb823net/ipv4/ip_output.cskb->protocol = htons(ETH_P_IP);
skb824net/ipv4/ip_output.cskb->when = jiffies;
skb825net/ipv4/ip_output.cskb->free = 1; /* dubious, this one */
skb826net/ipv4/ip_output.cskb->sk = sk;
skb827net/ipv4/ip_output.cskb->arp = 0;
skb828net/ipv4/ip_output.cskb->saddr = saddr;
skb829net/ipv4/ip_output.cskb->raddr = raddr;
skb830net/ipv4/ip_output.cskb_reserve(skb,(dev->hard_header_len+15)&~15);
skb831net/ipv4/ip_output.cdata = skb_put(skb, fraglen-dev->hard_header_len);
skb842net/ipv4/ip_output.cskb->arp=1;
skb843net/ipv4/ip_output.cmemcpy(skb_push(skb,dev->hard_header_len),hh->hh_data,dev->hard_header_len);
skb846net/ipv4/ip_output.cskb->arp = 0;
skb854net/ipv4/ip_output.cif(dev->hard_header(skb, dev, ETH_P_IP, 
skb856net/ipv4/ip_output.cskb->arp=1;
skb863net/ipv4/ip_output.cskb->ip_hdr = iph = (struct iphdr *)data;
skb876net/ipv4/ip_output.cip_options_build(skb, opt,
skb915net/ipv4/ip_output.cif(!offset && call_out_firewall(PF_INET, skb, iph) < FW_ACCEPT)
skb917net/ipv4/ip_output.ckfree_skb(skb, FREE_WRITE);
skb946net/ipv4/ip_output.cif(skb->daddr==IGMP_ALL_HOSTS || (dev->flags&IFF_ALLMULTI))
skb947net/ipv4/ip_output.cip_loopback(dev,skb);
skb955net/ipv4/ip_output.cip_loopback(dev,skb);
skb968net/ipv4/ip_output.cif(skb->ip_hdr->ttl==0)
skb969net/ipv4/ip_output.ckfree_skb(skb, FREE_READ);
skb980net/ipv4/ip_output.cip_loopback(dev,skb);
skb988net/ipv4/ip_output.cdev_queue_xmit(skb, dev, sk->priority);
skb999net/ipv4/ip_output.ckfree_skb(skb, FREE_WRITE);
skb1038net/ipv4/ip_output.cstruct sk_buff *skb=alloc_skb(sizeof(struct netlink_rtinfo), GFP_ATOMIC);
skb1041net/ipv4/ip_output.cif(skb==NULL)
skb1043net/ipv4/ip_output.cskb->free=1;
skb1044net/ipv4/ip_output.cnrt=(struct netlink_rtinfo *)skb_put(skb, sizeof(struct netlink_rtinfo));
skb1058net/ipv4/ip_output.cnetlink_post(NETLINK_ROUTE, skb);
skb52net/ipv4/ipip.cint ipip_rcv(struct sk_buff *skb, struct device *dev, struct options *opt, 
skb68net/ipv4/ipip.cskb_pull(skb, ((struct iphdr *)skb->data)->ihl<<2);
skb74net/ipv4/ipip.cskb->h.iph=(struct iphdr *)skb->data;
skb75net/ipv4/ipip.cskb->ip_hdr=(struct iphdr *)skb->data;
skb76net/ipv4/ipip.cmemset(skb->proto_priv, 0, sizeof(struct options));
skb77net/ipv4/ipip.cif (skb->ip_hdr->ihl > 5) 
skb79net/ipv4/ipip.cif (ip_options_compile(NULL, skb))
skb88net/ipv4/ipip.cif((err=call_in_firewall(PF_INET, skb, skb->ip_hdr))<FW_ACCEPT)
skb91net/ipv4/ipip.cicmp_send(skb,ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0 , dev);
skb92net/ipv4/ipip.ckfree_skb(skb, FREE_READ);
skb108net/ipv4/ipip.cif(ip_forward(skb, dev, 0, daddr))
skb109net/ipv4/ipip.ckfree_skb(skb, FREE_READ);
skb99net/ipv4/ipmr.cstruct sk_buff *skb;
skb140net/ipv4/ipmr.cwhile((skb=skb_dequeue(&cache->mfc_unresolved)))
skb141net/ipv4/ipmr.ckfree_skb(skb, FREE_WRITE);
skb216net/ipv4/ipmr.cstruct sk_buff *skb;
skb244net/ipv4/ipmr.cwhile((skb=skb_dequeue(&cache->mfc_unresolved)))
skb245net/ipv4/ipmr.cipmr_forward(skb, skb->protocol);
skb255net/ipv4/ipmr.cstruct sk_buff *skb=alloc_skb(128, GFP_ATOMIC);
skb258net/ipv4/ipmr.cif(!skb)
skb261net/ipv4/ipmr.cskb->free=1;
skb267net/ipv4/ipmr.cskb->ip_hdr=(struct iphdr *)skb_put(skb,ihl);
skb268net/ipv4/ipmr.cskb->h.iph=skb->ip_hdr;
skb269net/ipv4/ipmr.cmemcpy(skb->data,pkt->data,ihl);
skb270net/ipv4/ipmr.cskb->ip_hdr->protocol = 0;      /* Flag to the kernel this is a route add */
skb276net/ipv4/ipmr.cigmp=(struct igmphdr *)skb_put(skb,sizeof(struct igmphdr));
skb279net/ipv4/ipmr.cskb->ip_hdr->tot_len=htons(skb->len);      /* Fix the length */
skb284net/ipv4/ipmr.cif(sock_queue_rcv_skb(mroute_socket,skb)<0)
skb286net/ipv4/ipmr.cskb->sk=NULL;
skb287net/ipv4/ipmr.ckfree_skb(skb, FREE_READ);
skb296net/ipv4/ipmr.cstatic void ipmr_cache_unresolved(struct mfc_cache *cache, vifi_t vifi, struct sk_buff *skb, int is_frag)
skb305net/ipv4/ipmr.ckfree_skb(skb, FREE_WRITE);
skb312net/ipv4/ipmr.ccache->mfc_origin=skb->ip_hdr->saddr;
skb313net/ipv4/ipmr.ccache->mfc_mcastgrp=skb->ip_hdr->daddr;
skb330net/ipv4/ipmr.cipmr_cache_report(skb);
skb337net/ipv4/ipmr.ckfree_skb(skb, FREE_WRITE);
skb345net/ipv4/ipmr.cskb->protocol=is_frag;
skb346net/ipv4/ipmr.cskb_queue_tail(&cache->mfc_unresolved,skb);
skb702net/ipv4/ipmr.cstatic void ipmr_queue_xmit(struct sk_buff *skb, struct vif_device *vif, struct device *in_dev, int frag)
skb705net/ipv4/ipmr.c__u32 raddr=skb->raddr;
skb712net/ipv4/ipmr.cvif->bytes_out+=skb->len;
skb713net/ipv4/ipmr.cskb->dev=vif->dev;
skb714net/ipv4/ipmr.cskb->raddr=skb->h.iph->daddr;
skb719net/ipv4/ipmr.cif(vif->dev==NULL || ip_forward(skb, in_dev, frag|IPFWD_MULTICASTING|tunnel, raddr)==-1)
skb720net/ipv4/ipmr.ckfree_skb(skb, FREE_WRITE);
skb727net/ipv4/ipmr.cvoid ipmr_forward(struct sk_buff *skb, int is_frag)
skb732net/ipv4/ipmr.cint vif=ipmr_vifi_find(skb->dev);
skb735net/ipv4/ipmr.ckfree_skb(skb, FREE_WRITE);
skb740net/ipv4/ipmr.cvif_table[vif].bytes_in+=skb->len;
skb742net/ipv4/ipmr.ccache=ipmr_cache_find(skb->ip_hdr->saddr,skb->ip_hdr->daddr);
skb749net/ipv4/ipmr.cipmr_cache_unresolved(cache,vif,skb, is_frag);
skb761net/ipv4/ipmr.cif(skb->ip_hdr->ttl > cache->mfc_ttls[ct] && cache->mfc_ttls[ct]>0)
skb769net/ipv4/ipmr.cskb2=skb_copy(skb, GFP_ATOMIC);
skb773net/ipv4/ipmr.cipmr_queue_xmit(skb2, &vif_table[psend], skb->dev, is_frag);
skb781net/ipv4/ipmr.ckfree_skb(skb, FREE_WRITE);
skb784net/ipv4/ipmr.cipmr_queue_xmit(skb, &vif_table[psend], skb->dev, is_frag);
skb79net/ipv4/packet.cint packet_rcv(struct sk_buff *skb, struct device *dev,  struct packet_type *pt)
skb95net/ipv4/packet.cskb_push(skb,skb->data-skb->mac.raw);
skb101net/ipv4/packet.cskb->dev = dev;
skb108net/ipv4/packet.cif(sock_queue_rcv_skb(sk,skb)<0)
skb110net/ipv4/packet.cskb->sk = NULL;
skb111net/ipv4/packet.ckfree_skb(skb, FREE_READ);
skb130net/ipv4/packet.cstruct sk_buff *skb;
skb175net/ipv4/packet.cskb = sock_wmalloc(sk, len, 0, GFP_KERNEL);
skb183net/ipv4/packet.cif (skb == NULL) 
skb192net/ipv4/packet.cskb->sk = sk;
skb193net/ipv4/packet.cskb->free = 1;
skb194net/ipv4/packet.cmemcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
skb195net/ipv4/packet.cskb->arp = 1;    /* No ARP needs doing on this (complete) frame */
skb196net/ipv4/packet.cskb->protocol = proto;
skb203net/ipv4/packet.cdev_queue_xmit(skb, dev, sk->priority);
skb205net/ipv4/packet.ckfree_skb(skb, FREE_WRITE);
skb404net/ipv4/packet.cstruct sk_buff *skb;
skb432net/ipv4/packet.cskb=skb_recv_datagram(sk,flags,noblock,&err);
skb440net/ipv4/packet.cif(skb==NULL)
skb448net/ipv4/packet.ccopied = min(len, skb->len);
skb450net/ipv4/packet.cmemcpy_toiovec(msg->msg_iov, skb->data, copied);  /* We can't use skb_copy_datagram here */
skb451net/ipv4/packet.csk->stamp=skb->stamp;
skb459net/ipv4/packet.csaddr->spkt_family = skb->dev->type;
skb460net/ipv4/packet.cstrncpy(saddr->spkt_device,skb->dev->name, 15);
skb461net/ipv4/packet.csaddr->spkt_protocol = skb->protocol;
skb469net/ipv4/packet.cskb_free_datagram(sk, skb);
skb194net/ipv4/rarp.cstatic int rarp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb199net/ipv4/rarp.cstruct arphdr *rarp = (struct arphdr *) skb->data;
skb200net/ipv4/rarp.cunsigned char *rarp_ptr = skb_pull(skb,sizeof(struct arphdr));
skb212net/ipv4/rarp.ckfree_skb(skb, FREE_READ);
skb221net/ipv4/rarp.ckfree_skb(skb, FREE_READ);
skb239net/ipv4/rarp.ckfree_skb(skb, FREE_READ);
skb275net/ipv4/rarp.ckfree_skb(skb, FREE_READ);
skb119net/ipv4/raw.cint raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr)
skb122net/ipv4/raw.cskb->sk = sk;
skb123net/ipv4/raw.cskb_trim(skb,ntohs(skb->ip_hdr->tot_len));
skb125net/ipv4/raw.cskb->h.raw = (unsigned char *) skb->ip_hdr;
skb126net/ipv4/raw.cskb->dev = dev;
skb127net/ipv4/raw.cskb->saddr = daddr;
skb128net/ipv4/raw.cskb->daddr = saddr;
skb137net/ipv4/raw.cskb->ip_hdr->tot_len=ntohs(skb->ip_hdr->tot_len-4*skb->ip_hdr->ihl);
skb142net/ipv4/raw.cif(sock_queue_rcv_skb(sk,skb)<0)
skb145net/ipv4/raw.cskb->sk=NULL;
skb146net/ipv4/raw.ckfree_skb(skb, FREE_READ);
skb318net/ipv4/raw.cstruct sk_buff *skb;
skb331net/ipv4/raw.cskb=skb_recv_datagram(sk,flags,noblock,&err);
skb332net/ipv4/raw.cif(skb==NULL)
skb335net/ipv4/raw.ccopied = min(len, skb->len);
skb337net/ipv4/raw.cskb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
skb338net/ipv4/raw.csk->stamp=skb->stamp;
skb344net/ipv4/raw.csin->sin_addr.s_addr = skb->daddr;
skb346net/ipv4/raw.cskb_free_datagram(sk, skb);
skb460net/ipv4/tcp.cstruct sk_buff *skb;
skb464net/ipv4/tcp.cskb=tcp_find_established(s);
skb465net/ipv4/tcp.cif(skb!=NULL)
skb466net/ipv4/tcp.cskb_unlink(skb);  /* Take it off the queue */
skb468net/ipv4/tcp.creturn skb;
skb479net/ipv4/tcp.cstruct sk_buff *skb;
skb481net/ipv4/tcp.cwhile ((skb = skb_dequeue(&sk->receive_queue)) != NULL) 
skb483net/ipv4/tcp.ctcp_close(skb->sk, 0);
skb484net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb603net/ipv4/tcp.cstruct sk_buff *skb;
skb612net/ipv4/tcp.cif (sk == NULL || (skb = skb_peek(&sk->receive_queue)) == NULL)
skb629net/ipv4/tcp.cif (before(counted, skb->seq))     /* Found a hole so stops here */
skb631net/ipv4/tcp.csum = skb->len - (counted - skb->seq);  /* Length - header but start from where we are up to (avoid overlaps) */
skb632net/ipv4/tcp.cif (skb->h.th->syn)
skb637net/ipv4/tcp.cif (skb->h.th->syn) 
skb657net/ipv4/tcp.cif (skb->h.th->urg)
skb659net/ipv4/tcp.cif (amount && skb->h.th->psh) break;
skb660net/ipv4/tcp.cskb = skb->next;
skb662net/ipv4/tcp.cwhile(skb != (struct sk_buff *)&sk->receive_queue);
skb806net/ipv4/tcp.cunsigned long daddr, int len, struct sk_buff *skb)
skb813net/ipv4/tcp.ccsum_partial((char *)th,sizeof(*th),skb->csum));
skb899net/ipv4/tcp.cstruct sk_buff *skb;
skb997net/ipv4/tcp.cif ((skb = tcp_dequeue_partial(sk)) != NULL) 
skb1001net/ipv4/tcp.ctcp_size = skb->tail - (unsigned char *)(skb->h.th + 1);
skb1013net/ipv4/tcp.cmemcpy_fromfs(skb_put(skb,copy), from, copy);
skb1014net/ipv4/tcp.cskb->csum = csum_partial(skb->tail - tcp_size, tcp_size, 0);
skb1022net/ipv4/tcp.ctcp_send_skb(sk, skb);
skb1024net/ipv4/tcp.ctcp_enqueue_partial(skb, sk);
skb1058net/ipv4/tcp.cskb = sock_wmalloc(sk, sk->mtu + 128 + prot->max_header + 15, 0, GFP_KERNEL);
skb1059net/ipv4/tcp.csend_tmp = skb;
skb1063net/ipv4/tcp.cskb = sock_wmalloc(sk, copy + prot->max_header + 15 , 0, GFP_KERNEL);
skb1070net/ipv4/tcp.cif (skb == NULL) 
skb1091net/ipv4/tcp.cskb->sk = sk;
skb1092net/ipv4/tcp.cskb->free = 0;
skb1093net/ipv4/tcp.cskb->localroute = sk->localroute|(flags&MSG_DONTROUTE);
skb1100net/ipv4/tcp.ctmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
skb1101net/ipv4/tcp.cIPPROTO_TCP, sk->opt, skb->truesize,sk->ip_tos,sk->ip_ttl,&sk->ip_route_cache);
skb1104net/ipv4/tcp.csock_wfree(sk, skb);
skb1110net/ipv4/tcp.cskb->ip_hdr->frag_off |= htons(IP_DF);
skb1112net/ipv4/tcp.cskb->dev = dev;
skb1113net/ipv4/tcp.cskb->h.th =(struct tcphdr *)skb_put(skb,sizeof(struct tcphdr));
skb1114net/ipv4/tcp.ctmp = tcp_build_header(skb->h.th, sk, seglen-copy);
skb1117net/ipv4/tcp.csock_wfree(sk, skb);
skb1125net/ipv4/tcp.cskb->h.th->urg = 1;
skb1126net/ipv4/tcp.cskb->h.th->urg_ptr = ntohs(copy);
skb1129net/ipv4/tcp.cskb->csum = csum_partial_copy_fromuser(from,
skb1130net/ipv4/tcp.cskb_put(skb,copy), copy, 0);
skb1136net/ipv4/tcp.cskb->free = 0;
skb1144net/ipv4/tcp.ctcp_send_skb(sk, skb);
skb1353net/ipv4/tcp.cstatic inline void tcp_eat_skb(struct sock *sk, struct sk_buff * skb)
skb1355net/ipv4/tcp.cskb->sk = sk;
skb1356net/ipv4/tcp.c__skb_unlink(skb, &sk->receive_queue);
skb1357net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb1369net/ipv4/tcp.cstruct sk_buff *skb;
skb1375net/ipv4/tcp.cwhile ((skb=skb_peek(&sk->receive_queue)) != NULL) {
skb1376net/ipv4/tcp.cif (!skb->used || skb->users)
skb1378net/ipv4/tcp.ctcp_eat_skb(sk, skb);
skb1431net/ipv4/tcp.cstruct sk_buff * skb;
skb1447net/ipv4/tcp.cskb = skb_peek(&sk->receive_queue);
skb1450net/ipv4/tcp.cif (!skb)
skb1452net/ipv4/tcp.cif (before(*seq, skb->seq))
skb1454net/ipv4/tcp.coffset = *seq - skb->seq;
skb1455net/ipv4/tcp.cif (skb->h.th->syn)
skb1457net/ipv4/tcp.cif (offset < skb->len)
skb1459net/ipv4/tcp.cif (skb->h.th->fin)
skb1462net/ipv4/tcp.cskb->used = 1;
skb1463net/ipv4/tcp.cskb = skb->next;
skb1465net/ipv4/tcp.cwhile (skb != (struct sk_buff *)&sk->receive_queue);
skb1521net/ipv4/tcp.cskb->users++;
skb1527net/ipv4/tcp.cused = skb->len - offset;
skb1566net/ipv4/tcp.cmemcpy_toiovec(msg->msg_iov,((unsigned char *)skb->h.th) +
skb1567net/ipv4/tcp.cskb->h.th->doff*4 + offset, used);
skb1577net/ipv4/tcp.cskb->users --;
skb1581net/ipv4/tcp.cif (used + offset < skb->len)
skb1588net/ipv4/tcp.cif (skb->h.th->fin)
skb1592net/ipv4/tcp.cskb->used = 1;
skb1593net/ipv4/tcp.cif (!skb->users)
skb1594net/ipv4/tcp.ctcp_eat_skb(sk, skb);    
skb1606net/ipv4/tcp.cskb->used = 1;
skb1765net/ipv4/tcp.cstruct sk_buff *skb;
skb1797net/ipv4/tcp.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
skb1798net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb1851net/ipv4/tcp.cstruct sk_buff *skb;
skb1868net/ipv4/tcp.cwhile((skb = tcp_dequeue_established(sk)) == NULL) 
skb1894net/ipv4/tcp.cnewsk = skb->sk;
skb1896net/ipv4/tcp.ckfree_skb(skb, FREE_READ);
skb209net/ipv4/tcp_input.cstatic int tcp_reset(struct sock *sk, struct sk_buff *skb)
skb240net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb317net/ipv4/tcp_input.cstatic void tcp_conn_request(struct sock *sk, struct sk_buff *skb,
skb324net/ipv4/tcp_input.cth = skb->h.th;
skb337net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb352net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb369net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb383net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb386net/ipv4/tcp_input.cif (ip_options_echo(sk->opt, opt, daddr, saddr, skb)) 
skb391net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb424net/ipv4/tcp_input.cnewsk->acked_seq = skb->seq+1;
skb425net/ipv4/tcp_input.cnewsk->lastwin_seq = skb->seq+1;
skb427net/ipv4/tcp_input.cnewsk->copied_seq = skb->seq+1;
skb428net/ipv4/tcp_input.cnewsk->fin_seq = skb->seq;
skb445net/ipv4/tcp_input.cnewsk->dummy_th.source = skb->h.th->dest;
skb446net/ipv4/tcp_input.cnewsk->dummy_th.dest = skb->h.th->source;
skb457net/ipv4/tcp_input.cnewsk->acked_seq = skb->seq + 1;
skb458net/ipv4/tcp_input.cnewsk->copied_seq = skb->seq + 1;
skb466net/ipv4/tcp_input.cnewsk->ip_tos=skb->ip_hdr->tos;
skb515net/ipv4/tcp_input.ctcp_options(newsk,skb->h.th);
skb518net/ipv4/tcp_input.ctcp_send_synack(newsk, sk, skb);
skb534net/ipv4/tcp_input.cstruct sk_buff *skb;
skb549net/ipv4/tcp_input.cskb = skb2;
skb550net/ipv4/tcp_input.cskb2 = skb->link3;
skb551net/ipv4/tcp_input.cskb->link3 = NULL;
skb552net/ipv4/tcp_input.cif (after(skb->end_seq, window_seq)) 
skb557net/ipv4/tcp_input.cif (skb->next != NULL) 
skb559net/ipv4/tcp_input.cskb_unlink(skb);        
skb563net/ipv4/tcp_input.cskb_queue_head(&sk->write_queue,skb);
skb565net/ipv4/tcp_input.cskb_append(wskb,skb);
skb566net/ipv4/tcp_input.cwskb = skb;
skb572net/ipv4/tcp_input.csk->send_head = skb;
skb573net/ipv4/tcp_input.csk->send_tail = skb;
skb577net/ipv4/tcp_input.csk->send_tail->link3 = skb;
skb578net/ipv4/tcp_input.csk->send_tail = skb;
skb580net/ipv4/tcp_input.cskb->link3 = NULL;
skb1108net/ipv4/tcp_input.cstatic int tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
skb1110net/ipv4/tcp_input.csk->fin_seq = skb->end_seq;
skb1190net/ipv4/tcp_input.cstatic inline u32 tcp_queue_ack(struct sk_buff * skb, struct sock * sk)
skb1196net/ipv4/tcp_input.cskb->acked = 1;
skb1197net/ipv4/tcp_input.cif (skb->h.th->fin)
skb1198net/ipv4/tcp_input.ctcp_fin(skb,sk,skb->h.th);
skb1199net/ipv4/tcp_input.creturn skb->end_seq;
skb1207net/ipv4/tcp_input.cstatic void tcp_queue(struct sk_buff * skb, struct sock * sk,
skb1220net/ipv4/tcp_input.cif (!after(next->seq, skb->seq))
skb1228net/ipv4/tcp_input.c__skb_append(next, skb, list);
skb1229net/ipv4/tcp_input.cnext = skb->next;
skb1235net/ipv4/tcp_input.cif (!after(skb->seq, ack_seq) && after(skb->end_seq, ack_seq)) {
skb1236net/ipv4/tcp_input.cack_seq = tcp_queue_ack(skb, sk);
skb1293net/ipv4/tcp_input.cstatic int tcp_data(struct sk_buff *skb, struct sock *sk, 
skb1299net/ipv4/tcp_input.cth = skb->h.th;
skb1300net/ipv4/tcp_input.cskb_pull(skb,th->doff*4);
skb1301net/ipv4/tcp_input.cskb_trim(skb,len-(th->doff*4));
skb1308net/ipv4/tcp_input.csk->bytes_rcv += skb->len;
skb1310net/ipv4/tcp_input.cif (skb->len == 0 && !th->fin) 
skb1318net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1337net/ipv4/tcp_input.cif(skb->len)  /* We don't care if it's just an ack or
skb1340net/ipv4/tcp_input.cnew_seq = skb->seq + skb->len + th->syn;  /* Right edge of _data_ part of frame */
skb1363net/ipv4/tcp_input.ctcp_send_reset(sk->saddr, sk->daddr, skb->h.th,
skb1364net/ipv4/tcp_input.csk->prot, NULL, skb->dev, sk->ip_tos, sk->ip_ttl);
skb1370net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1379net/ipv4/tcp_input.ctcp_queue(skb, sk, th, saddr);
skb1386net/ipv4/tcp_input.cif (!skb->acked) 
skb1510net/ipv4/tcp_input.cint tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb1524net/ipv4/tcp_input.cth = skb->h.th;
skb1525net/ipv4/tcp_input.csk = skb->sk;
skb1528net/ipv4/tcp_input.cif (skb->pkt_type!=PACKET_HOST)
skb1535net/ipv4/tcp_input.cskb_pull(skb, skb->h.raw-skb->data);
skb1540net/ipv4/tcp_input.cswitch (skb->ip_summed) 
skb1543net/ipv4/tcp_input.cskb->csum = csum_partial((char *)th, len, 0);
skb1545net/ipv4/tcp_input.cif (tcp_check(th, len, saddr, daddr, skb->csum))
skb1553net/ipv4/tcp_input.cskb->sk = sk;
skb1554net/ipv4/tcp_input.cskb->seq = ntohl(th->seq);
skb1555net/ipv4/tcp_input.cskb->end_seq = skb->seq + th->syn + th->fin + len - th->doff*4;
skb1556net/ipv4/tcp_input.cskb->ack_seq = ntohl(th->ack_seq);
skb1558net/ipv4/tcp_input.cskb->acked = 0;
skb1559net/ipv4/tcp_input.cskb->used = 0;
skb1560net/ipv4/tcp_input.cskb->free = 1;
skb1561net/ipv4/tcp_input.cskb->saddr = daddr;
skb1562net/ipv4/tcp_input.cskb->daddr = saddr;
skb1569net/ipv4/tcp_input.c__skb_queue_tail(&sk->back_log, skb);
skb1597net/ipv4/tcp_input.cskb->sk=sk;
skb1598net/ipv4/tcp_input.catomic_add(skb->truesize, &sk->rmem_alloc);
skb1632net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1640net/ipv4/tcp_input.ctcp_conn_request(sk, skb, daddr, saddr, opt, dev, tcp_init_seq());
skb1661net/ipv4/tcp_input.cif (sk->state == TCP_SYN_RECV && th->syn && skb->seq+1 == sk->acked_seq)
skb1663net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1679net/ipv4/tcp_input.cif(!tcp_ack(sk,th,skb->ack_seq,len))
skb1686net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1690net/ipv4/tcp_input.creturn tcp_reset(sk,skb);
skb1698net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1706net/ipv4/tcp_input.csk->acked_seq = skb->seq+1;
skb1707net/ipv4/tcp_input.csk->lastwin_seq = skb->seq+1;
skb1708net/ipv4/tcp_input.csk->fin_seq = skb->seq;
skb1737net/ipv4/tcp_input.creturn tcp_reset(sk,skb);
skb1747net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1770net/ipv4/tcp_input.cafter(skb->seq, sk->acked_seq) && !th->rst)
skb1776net/ipv4/tcp_input.catomic_sub(skb->truesize, &sk->rmem_alloc);
skb1777net/ipv4/tcp_input.cskb->sk = NULL;
skb1785net/ipv4/tcp_input.cskb->sk = sk;
skb1786net/ipv4/tcp_input.catomic_add(skb->truesize, &sk->rmem_alloc);
skb1787net/ipv4/tcp_input.ctcp_conn_request(sk, skb, daddr, saddr,opt, dev,seq+128000);
skb1790net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1802net/ipv4/tcp_input.cif (!tcp_sequence(sk, skb->seq, skb->end_seq-th->syn))
skb1805net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1810net/ipv4/tcp_input.creturn tcp_reset(sk,skb);
skb1818net/ipv4/tcp_input.ctcp_send_reset(daddr,saddr,th, &tcp_prot, opt, dev, skb->ip_hdr->tos, 255);
skb1819net/ipv4/tcp_input.creturn tcp_reset(sk,skb);  
skb1829net/ipv4/tcp_input.cif(th->ack && !tcp_ack(sk,th,skb->ack_seq,len))
skb1839net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1858net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1874net/ipv4/tcp_input.cif(tcp_data(skb,sk, saddr, len))
skb1875net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb1887net/ipv4/tcp_input.ctcp_send_reset(daddr, saddr, th, &tcp_prot, opt,dev,skb->ip_hdr->tos,255);
skb1893net/ipv4/tcp_input.cskb->sk = NULL;
skb1894net/ipv4/tcp_input.ckfree_skb(skb, FREE_READ);
skb31net/ipv4/tcp_output.cvoid tcp_send_skb(struct sock *sk, struct sk_buff *skb)
skb34net/ipv4/tcp_output.cstruct tcphdr * th = skb->h.th;
skb40net/ipv4/tcp_output.csize = skb->len - ((unsigned char *) th - skb->data);
skb46net/ipv4/tcp_output.cif (size < sizeof(struct tcphdr) || size > skb->len) 
skb49net/ipv4/tcp_output.cskb, skb->data, th, skb->len);
skb50net/ipv4/tcp_output.ckfree_skb(skb, FREE_WRITE);
skb65net/ipv4/tcp_output.ckfree_skb(skb,FREE_WRITE);
skb75net/ipv4/tcp_output.cskb->seq = ntohl(th->seq);
skb76net/ipv4/tcp_output.cskb->end_seq = skb->seq + size - 4*th->doff;
skb86net/ipv4/tcp_output.cif (after(skb->end_seq, sk->window_seq) ||
skb93net/ipv4/tcp_output.cif (skb->next != NULL) 
skb96net/ipv4/tcp_output.cskb_unlink(skb);
skb98net/ipv4/tcp_output.cskb_queue_tail(&sk->write_queue, skb);
skb113net/ipv4/tcp_output.ctcp_send_check(th, sk->saddr, sk->daddr, size, skb);
skb123net/ipv4/tcp_output.csk->prot->queue_xmit(sk, skb->dev, skb, 0);
skb150net/ipv4/tcp_output.cstruct sk_buff * skb;
skb155net/ipv4/tcp_output.cskb = sk->partial;
skb156net/ipv4/tcp_output.cif (skb) {
skb161net/ipv4/tcp_output.creturn skb;
skb170net/ipv4/tcp_output.cstruct sk_buff *skb;
skb174net/ipv4/tcp_output.cwhile ((skb = tcp_dequeue_partial(sk)) != NULL)
skb175net/ipv4/tcp_output.ctcp_send_skb(sk, skb);
skb182net/ipv4/tcp_output.cvoid tcp_enqueue_partial(struct sk_buff * skb, struct sock * sk)
skb192net/ipv4/tcp_output.csk->partial = skb;
skb214net/ipv4/tcp_output.cstruct sk_buff *skb;
skb232net/ipv4/tcp_output.cwhile((skb = skb_peek(&sk->write_queue)) != NULL &&
skb233net/ipv4/tcp_output.c!after(skb->end_seq, sk->window_seq) &&
skb236net/ipv4/tcp_output.c!after(skb->end_seq, sk->rcv_ack_seq))
skb239net/ipv4/tcp_output.cIS_SKB(skb);
skb240net/ipv4/tcp_output.cskb_unlink(skb);
skb246net/ipv4/tcp_output.cif (before(skb->end_seq, sk->rcv_ack_seq +1)) 
skb254net/ipv4/tcp_output.ckfree_skb(skb, FREE_WRITE);
skb270net/ipv4/tcp_output.ciph = skb->ip_hdr;
skb272net/ipv4/tcp_output.csize = skb->len - (((unsigned char *) th) - skb->data);
skb284net/ipv4/tcp_output.ctcp_send_check(th, sk->saddr, sk->daddr, size, skb);
skb286net/ipv4/tcp_output.csk->sent_seq = skb->end_seq;
skb292net/ipv4/tcp_output.csk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
skb315net/ipv4/tcp_output.cstruct sk_buff * skb;
skb322net/ipv4/tcp_output.cskb = sk->send_head;
skb324net/ipv4/tcp_output.cwhile (skb != NULL)
skb330net/ipv4/tcp_output.cdev = skb->dev;
skb331net/ipv4/tcp_output.cIS_SKB(skb);
skb332net/ipv4/tcp_output.cskb->when = jiffies;
skb344net/ipv4/tcp_output.cif (skb_device_locked(skb))
skb351net/ipv4/tcp_output.cskb_pull(skb,((unsigned char *)skb->ip_hdr)-skb->data);
skb362net/ipv4/tcp_output.ciph = (struct iphdr *)skb->data;
skb378net/ipv4/tcp_output.cstruct options *  opt = (struct options*)skb->proto_priv;
skb379net/ipv4/tcp_output.crt = ip_check_route(&sk->ip_route_cache, opt->srr?opt->faddr:iph->daddr, skb->localroute);
skb391net/ipv4/tcp_output.cif(skb->sk)
skb393net/ipv4/tcp_output.cskb->sk->err_soft=ENETUNREACH;
skb394net/ipv4/tcp_output.cskb->sk->error_report(skb->sk);
skb400net/ipv4/tcp_output.cskb->raddr=rt->rt_gateway;
skb401net/ipv4/tcp_output.cskb->dev=dev;
skb402net/ipv4/tcp_output.cskb->arp=1;
skb405net/ipv4/tcp_output.cmemcpy(skb_push(skb,dev->hard_header_len),rt->rt_hh->hh_data,dev->hard_header_len);
skb408net/ipv4/tcp_output.cskb->arp = 0;
skb416net/ipv4/tcp_output.cif(dev->hard_header(skb, dev, ETH_P_IP, NULL, NULL, skb->len)<0)
skb417net/ipv4/tcp_output.cskb->arp=0;
skb435net/ipv4/tcp_output.ctcp_send_check(th, sk->saddr, sk->daddr, size, skb);
skb451net/ipv4/tcp_output.cif (sk && !skb_device_locked(skb))
skb454net/ipv4/tcp_output.cskb_unlink(skb);
skb457net/ipv4/tcp_output.cdev_queue_xmit(skb, dev, sk->priority);
skb485net/ipv4/tcp_output.cskb = skb->link3;
skb662net/ipv4/tcp_output.cvoid tcp_send_synack(struct sock * newsk, struct sock * sk, struct sk_buff * skb)
skb675net/ipv4/tcp_output.ckfree_skb(skb, FREE_READ);
skb700net/ipv4/tcp_output.cskb->sk = sk;
skb701net/ipv4/tcp_output.ckfree_skb(skb, FREE_READ);
skb708net/ipv4/tcp_output.cmemcpy(t1, skb->h.th, sizeof(*t1));
skb714net/ipv4/tcp_output.ct1->dest = skb->h.th->source;
skb735net/ipv4/tcp_output.cskb->sk = newsk;
skb741net/ipv4/tcp_output.catomic_sub(skb->truesize, &sk->rmem_alloc);
skb742net/ipv4/tcp_output.catomic_add(skb->truesize, &newsk->rmem_alloc);
skb744net/ipv4/tcp_output.cskb_queue_tail(&sk->receive_queue,skb);
skb860net/ipv4/tcp_output.cstruct sk_buff *buff,*skb;
skb884net/ipv4/tcp_output.c(skb=skb_peek(&sk->write_queue)))
skb910net/ipv4/tcp_output.ciph = (struct iphdr *)skb->ip_hdr;
skb179net/ipv4/tcp_timer.cstruct sk_buff *skb;
skb184net/ipv4/tcp_timer.cskb = sk->send_head;
skb185net/ipv4/tcp_timer.cif (!skb) {
skb196net/ipv4/tcp_timer.cif (jiffies < skb->when + sk->rto) 
skb200net/ipv4/tcp_timer.ctcp_reset_xmit_timer (sk, TIME_WRITE, skb->when + sk->rto - jiffies);
skb138net/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);
skb465net/ipv4/udp.cstruct sk_buff *skb;
skb470net/ipv4/udp.cskb = skb_peek(&sk->receive_queue);
skb471net/ipv4/udp.cif (skb != NULL) {
skb477net/ipv4/udp.camount = skb->len-sizeof(struct udphdr);
skb504net/ipv4/udp.cstruct sk_buff *skb;
skb520net/ipv4/udp.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb521net/ipv4/udp.cif(skb==NULL)
skb524net/ipv4/udp.ctruesize = skb->len - sizeof(struct udphdr);
skb531net/ipv4/udp.cskb_copy_datagram_iovec(skb,sizeof(struct udphdr),msg->msg_iov,copied);
skb532net/ipv4/udp.csk->stamp=skb->stamp;
skb538net/ipv4/udp.csin->sin_port = skb->h.uh->source;
skb539net/ipv4/udp.csin->sin_addr.s_addr = skb->daddr;
skb542net/ipv4/udp.cskb_free_datagram(sk, skb);
skb591net/ipv4/udp.cint udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
skb607net/ipv4/udp.cuh = (struct udphdr *) skb->h.uh;
skb621net/ipv4/udp.ckfree_skb(skb, FREE_WRITE);
skb633net/ipv4/udp.c( (skb->ip_summed == CHECKSUM_HW) && udp_check(uh, len, saddr, daddr, skb->csum ) ) ||
skb634net/ipv4/udp.c( (skb->ip_summed == CHECKSUM_NONE) && udp_check(uh, len, saddr, daddr,csum_partial((char*)uh, len, 0)))
skb650net/ipv4/udp.ckfree_skb(skb, FREE_WRITE);
skb674net/ipv4/udp.cskb1=skb_clone(skb,GFP_ATOMIC);
skb676net/ipv4/udp.cskb1=skb;
skb684net/ipv4/udp.ckfree_skb(skb, FREE_READ);
skb705net/ipv4/udp.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0, dev);
skb711net/ipv4/udp.cskb->sk = NULL;
skb712net/ipv4/udp.ckfree_skb(skb, FREE_WRITE);
skb715net/ipv4/udp.creturn udp_deliver(sk,uh,skb,dev, saddr, daddr, len);
skb718net/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)
skb720net/ipv4/udp.cskb->sk = sk;
skb721net/ipv4/udp.cskb->dev = dev;
skb722net/ipv4/udp.cskb_trim(skb,len);
skb728net/ipv4/udp.cskb->daddr = saddr;
skb729net/ipv4/udp.cskb->saddr = daddr;
skb739net/ipv4/udp.cif (sock_queue_rcv_skb(sk,skb)<0) 
skb744net/ipv4/udp.cskb->sk = NULL;
skb745net/ipv4/udp.ckfree_skb(skb, FREE_WRITE);
skb187net/ipx/af_ipx.cstruct sk_buff  *skb;
skb190net/ipx/af_ipx.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL) {
skb191net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb360net/ipx/af_ipx.cstatic int ipxitf_def_skb_handler(struct sock *sock, struct sk_buff *skb)
skb364net/ipx/af_ipx.cif((retval = sock_queue_rcv_skb(sock, skb))<0) 
skb370net/ipx/af_ipx.ckfree_skb(skb,FREE_WRITE);
skb381net/ipx/af_ipx.cipxitf_demux_socket(ipx_interface *intrfc, struct sk_buff *skb, int copy) 
skb383net/ipx/af_ipx.cipx_packet  *ipx = (ipx_packet *)(skb->h.raw);
skb403net/ipx/af_ipx.cskb1 = skb_clone(skb, GFP_ATOMIC);
skb415net/ipx/af_ipx.cskb1 = skb;
skb437net/ipx/af_ipx.ckfree_skb(skb, FREE_WRITE);
skb445net/ipx/af_ipx.cipxitf_demux_socket(ipx_interface *intrfc, struct sk_buff *skb, int copy) 
skb447net/ipx/af_ipx.cipx_packet  *ipx = (ipx_packet *)(skb->h.raw);
skb490net/ipx/af_ipx.ckfree_skb(skb,FREE_WRITE);
skb504net/ipx/af_ipx.cskb1 = skb_clone(skb, GFP_ATOMIC);
skb510net/ipx/af_ipx.cskb1 = skb;
skb543net/ipx/af_ipx.cipxitf_adjust_skbuff(ipx_interface *intrfc, struct sk_buff *skb)
skb546net/ipx/af_ipx.cint  in_offset = skb->h.raw - skb->head;
skb552net/ipx/af_ipx.cskb->arp = skb->free = 1;
skb553net/ipx/af_ipx.creturn skb;
skb557net/ipx/af_ipx.clen = skb->len + out_offset;
skb561net/ipx/af_ipx.cskb2->h.raw=skb_put(skb2,skb->len);
skb564net/ipx/af_ipx.cmemcpy(skb2->h.raw, skb->h.raw, skb->len);
skb566net/ipx/af_ipx.ckfree_skb(skb, FREE_WRITE);
skb570net/ipx/af_ipx.cstatic int ipxitf_send(ipx_interface *intrfc, struct sk_buff *skb, char *node)
skb572net/ipx/af_ipx.cipx_packet  *ipx = (ipx_packet *)(skb->h.raw);
skb604net/ipx/af_ipx.cif(skb->sk)
skb606net/ipx/af_ipx.catomic_sub(skb->truesize, &skb->sk->wmem_alloc);
skb607net/ipx/af_ipx.cskb->sk=NULL;
skb612net/ipx/af_ipx.creturn ipxitf_demux_socket(intrfc, skb, 0);
skb619net/ipx/af_ipx.cif (!send_to_wire && skb->sk)
skb621net/ipx/af_ipx.catomic_sub(skb->truesize, &skb->sk->wmem_alloc);
skb622net/ipx/af_ipx.cskb->sk=NULL;
skb624net/ipx/af_ipx.cipxitf_demux_socket(intrfc, skb, send_to_wire);
skb652net/ipx/af_ipx.ckfree_skb(skb,FREE_WRITE);
skb670net/ipx/af_ipx.cskb = ipxitf_adjust_skbuff(intrfc, skb);
skb671net/ipx/af_ipx.cif (skb == NULL) 
skb675net/ipx/af_ipx.cskb->dev = dev;
skb676net/ipx/af_ipx.cskb->protocol = htons(ETH_P_IPX);
skb677net/ipx/af_ipx.cdl->datalink_header(dl, skb, dest_node);
skb683net/ipx/af_ipx.cdump_pkt("IPX snd:", (ipx_packet *)skb->h.raw);
skb684net/ipx/af_ipx.cdump_data("ETH hdr:", skb->data, skb->h.raw - skb->data);
skb691net/ipx/af_ipx.cdev_queue_xmit(skb, dev, SOPRI_NORMAL);
skb706net/ipx/af_ipx.cstatic int ipxitf_rcv(ipx_interface *intrfc, struct sk_buff *skb)
skb708net/ipx/af_ipx.cipx_packet  *ipx = (ipx_packet *) (skb->h.raw);
skb716net/ipx/af_ipx.cif (call_in_firewall(PF_IPX, skb, ipx)!=FW_ACCEPT)
skb718net/ipx/af_ipx.ckfree_skb(skb, FREE_READ);
skb760net/ipx/af_ipx.cif (call_fw_firewall(PF_IPX, skb, ipx)!=FW_ACCEPT)
skb762net/ipx/af_ipx.ckfree_skb(skb, FREE_READ);
skb767net/ipx/af_ipx.cif ((skb->pkt_type != PACKET_BROADCAST) &&
skb768net/ipx/af_ipx.c(skb->pkt_type != PACKET_MULTICAST))
skb769net/ipx/af_ipx.creturn ipxrtr_route_skb(skb);
skb771net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb779net/ipx/af_ipx.creturn ipxitf_demux_socket(intrfc, skb, 0);
skb783net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb1172net/ipx/af_ipx.cstruct sk_buff *skb;
skb1199net/ipx/af_ipx.cskb=sock_alloc_send_skb(sk, size, 0, 0, &err);
skb1200net/ipx/af_ipx.cif(skb==NULL)
skb1203net/ipx/af_ipx.cskb_reserve(skb,ipx_offset);
skb1204net/ipx/af_ipx.cskb->free=1;
skb1205net/ipx/af_ipx.cskb->arp=1;
skb1206net/ipx/af_ipx.cskb->sk=sk;
skb1209net/ipx/af_ipx.cipx=(ipx_packet *)skb_put(skb,sizeof(ipx_packet));
skb1214net/ipx/af_ipx.cskb->h.raw = (unsigned char *)ipx;
skb1237net/ipx/af_ipx.cmemcpy_fromiovec(skb_put(skb,len),iov,len);
skb1240net/ipx/af_ipx.cif(call_out_firewall(PF_IPX, skb, ipx)!=FW_ACCEPT)
skb1242net/ipx/af_ipx.ckfree_skb(skb, FREE_WRITE);
skb1247net/ipx/af_ipx.creturn ipxitf_send(intrfc, skb, (rt && rt->ir_routed) ? 
skb1252net/ipx/af_ipx.cipxrtr_route_skb(struct sk_buff *skb)
skb1254net/ipx/af_ipx.cipx_packet  *ipx = (ipx_packet *) (skb->h.raw);
skb1261net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb1265net/ipx/af_ipx.c(void)ipxitf_send(i, skb, (r->ir_routed) ? 
skb1950net/ipx/af_ipx.cint ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
skb1957net/ipx/af_ipx.cipx=(ipx_packet *)skb->h.raw;
skb1963net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb1969net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb1982net/ipx/af_ipx.ckfree_skb(skb,FREE_READ);
skb1987net/ipx/af_ipx.creturn ipxitf_rcv(intrfc, skb);
skb2051net/ipx/af_ipx.cstruct sk_buff *skb;
skb2061net/ipx/af_ipx.cskb=skb_recv_datagram(sk,flags,noblock,&er);
skb2062net/ipx/af_ipx.cif(skb==NULL)
skb2068net/ipx/af_ipx.cipx = (ipx_packet *)(skb->h.raw);
skb2071net/ipx/af_ipx.cskb_copy_datagram_iovec(skb,sizeof(struct ipx_packet),msg->msg_iov,copied);
skb2081net/ipx/af_ipx.cskb_free_datagram(sk, skb);
skb2116net/ipx/af_ipx.cstruct sk_buff *skb;
skb2118net/ipx/af_ipx.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
skb2119net/ipx/af_ipx.camount=skb->len-sizeof(struct ipx_packet);
skb33net/netlink.cstatic int (*netlink_handler[MAX_LINKS])(struct sk_buff *skb);
skb49net/netlink.cstatic int netlink_err(struct sk_buff *skb)
skb51net/netlink.ckfree_skb(skb, FREE_READ);
skb60net/netlink.cint netlink_donothing(struct sk_buff *skb)
skb62net/netlink.ckfree_skb(skb, FREE_READ);
skb73net/netlink.cstruct sk_buff *skb;
skb74net/netlink.cskb=alloc_skb(count, GFP_KERNEL);
skb75net/netlink.cskb->free=1;
skb76net/netlink.cmemcpy_fromfs(skb_put(skb,count),buf, count);
skb77net/netlink.creturn (netlink_handler[minor])(skb);
skb87net/netlink.cstruct sk_buff *skb;
skb89net/netlink.cwhile((skb=skb_dequeue(&skb_queue_rd[minor]))==NULL)
skb103net/netlink.crdq_size[minor]-=skb->len;
skb105net/netlink.cif(skb->len<count)
skb106net/netlink.ccount=skb->len;
skb107net/netlink.cmemcpy_tofs(buf,skb->data,count);
skb108net/netlink.ckfree_skb(skb, FREE_READ);
skb177net/netlink.cint netlink_attach(int unit, int (*function)(struct sk_buff *skb))
skb194net/netlink.cint netlink_post(int unit, struct sk_buff *skb)
skb202net/netlink.cif(rdq_size[unit]+skb->len>MAX_QBYTES)
skb206net/netlink.cskb_queue_tail(&skb_queue_rd[unit], skb);
skb207net/netlink.crdq_size[unit]+=skb->len;
skb240net/netrom/af_netrom.cstruct sk_buff *skb;
skb251net/netrom/af_netrom.cwhile ((skb = skb_dequeue(&sk->receive_queue)) != NULL) {
skb252net/netrom/af_netrom.cif (skb->sk != sk) {      /* A pending connection */
skb253net/netrom/af_netrom.cskb->sk->dead = 1;  /* Queue the unaccepted socket for death */
skb254net/netrom/af_netrom.cnr_set_timer(skb->sk);
skb255net/netrom/af_netrom.cskb->sk->nr->state = NR_STATE_0;
skb258net/netrom/af_netrom.ckfree_skb(skb, FREE_READ);
skb814net/netrom/af_netrom.cstruct sk_buff *skb;
skb835net/netrom/af_netrom.cif ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
skb846net/netrom/af_netrom.c} while (skb == NULL);
skb848net/netrom/af_netrom.cnewsk = skb->sk;
skb853net/netrom/af_netrom.cskb->sk = NULL;
skb854net/netrom/af_netrom.ckfree_skb(skb, FREE_READ);
skb887net/netrom/af_netrom.cint nr_rx_frame(struct sk_buff *skb, struct device *dev)
skb896net/netrom/af_netrom.cskb->sk = NULL;    /* Initially we don't know who its for */
skb902net/netrom/af_netrom.csrc  = (ax25_address *)(skb->data + 0);
skb903net/netrom/af_netrom.cdest = (ax25_address *)(skb->data + 7);
skb905net/netrom/af_netrom.ccircuit_index = skb->data[15];
skb906net/netrom/af_netrom.ccircuit_id    = skb->data[16];
skb907net/netrom/af_netrom.cframetype     = skb->data[19];
skb914net/netrom/af_netrom.cskb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
skb915net/netrom/af_netrom.cskb->h.raw = skb->data;
skb917net/netrom/af_netrom.creturn nr_rx_ip(skb, dev);
skb927net/netrom/af_netrom.cskb->h.raw = skb->data;
skb929net/netrom/af_netrom.cif ((frametype & 0x0F) == NR_CONNACK && skb->len == 22)
skb934net/netrom/af_netrom.creturn nr_process_rx_frame(sk, skb);
skb942net/netrom/af_netrom.cuser = (ax25_address *)(skb->data + 21);
skb945net/netrom/af_netrom.cnr_transmit_dm(skb);
skb949net/netrom/af_netrom.cwindow = skb->data[20];
skb951net/netrom/af_netrom.cskb->sk             = make;
skb972net/netrom/af_netrom.cif (skb->len == 37) {
skb973net/netrom/af_netrom.ctimeout = skb->data[36] * 256 + skb->data[35];
skb994net/netrom/af_netrom.cskb_queue_head(&sk->receive_queue, skb);
skb999net/netrom/af_netrom.csk->data_ready(sk, skb->len);
skb1010net/netrom/af_netrom.cstruct sk_buff *skb;
skb1050net/netrom/af_netrom.cif ((skb = sock_alloc_send_skb(sk, size, 0, 0, &err)) == NULL)
skb1053net/netrom/af_netrom.cskb->sk   = sk;
skb1054net/netrom/af_netrom.cskb->free = 1;
skb1055net/netrom/af_netrom.cskb->arp  = 1;
skb1057net/netrom/af_netrom.cskb_reserve(skb, size - len);
skb1063net/netrom/af_netrom.casmptr = skb_push(skb, NR_TRANSPORT_LEN);
skb1083net/netrom/af_netrom.cskb->h.raw = skb_put(skb, len);
skb1085net/netrom/af_netrom.casmptr = skb->h.raw;
skb1097net/netrom/af_netrom.ckfree_skb(skb, FREE_WRITE);
skb1101net/netrom/af_netrom.cnr_output(sk, skb);  /* Shove it onto the queue */
skb1113net/netrom/af_netrom.cstruct sk_buff *skb;
skb1130net/netrom/af_netrom.cif ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
skb1134net/netrom/af_netrom.cskb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
skb1135net/netrom/af_netrom.cskb->h.raw = skb->data;
skb1138net/netrom/af_netrom.ccopied = (size < skb->len) ? size : skb->len;
skb1139net/netrom/af_netrom.cskb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
skb1145net/netrom/af_netrom.cmemcpy(&addr.sax25_call, skb->data + 7, AX25_ADDR_LEN);
skb1152net/netrom/af_netrom.cskb_free_datagram(sk, skb);
skb1186net/netrom/af_netrom.cstruct sk_buff *skb;
skb1188net/netrom/af_netrom.cif ((skb = skb_peek(&sk->receive_queue)) != NULL)
skb1189net/netrom/af_netrom.camount = skb->len - 20;
skb54net/netrom/nr_dev.cint nr_rx_ip(struct sk_buff *skb, struct device *dev)
skb64net/netrom/nr_dev.cskb->protocol = htons(ETH_P_IP);
skb67net/netrom/nr_dev.cskb->dev = dev;
skb69net/netrom/nr_dev.cskb->h.raw = skb->data;
skb70net/netrom/nr_dev.cip_rcv(skb, skb->dev, NULL);
skb75net/netrom/nr_dev.cstatic int nr_header(struct sk_buff *skb, struct device *dev, unsigned short type,
skb78net/netrom/nr_dev.cunsigned char *buff = skb_push(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
skb108net/netrom/nr_dev.cunsigned long raddr, struct sk_buff *skb)
skb113net/netrom/nr_dev.cskb_device_unlock(skb);
skb116net/netrom/nr_dev.cskb->free = 1;
skb117net/netrom/nr_dev.ckfree_skb(skb, FREE_WRITE);
skb130net/netrom/nr_dev.cif (!nr_route_frame(skb, NULL)) {
skb131net/netrom/nr_dev.cskb->free = 1;
skb132net/netrom/nr_dev.ckfree_skb(skb, FREE_WRITE);
skb165net/netrom/nr_dev.cstatic int nr_xmit(struct sk_buff *skb, struct device *dev)
skb169net/netrom/nr_dev.cif (skb == NULL || dev == NULL)
skb189net/netrom/nr_dev.cdev_kfree_skb(skb, FREE_WRITE);
skb53net/netrom/nr_in.cstatic int nr_queue_rx_frame(struct sock *sk, struct sk_buff *skb, int more)
skb55net/netrom/nr_in.cstruct sk_buff *skbo, *skbn = skb;
skb58net/netrom/nr_in.csk->nr->fraglen += skb->len;
skb59net/netrom/nr_in.cskb_queue_tail(&sk->nr->frag_queue, skb);
skb64net/netrom/nr_in.csk->nr->fraglen += skb->len;
skb65net/netrom/nr_in.cskb_queue_tail(&sk->nr->frag_queue, skb);
skb97net/netrom/nr_in.cstatic int nr_state1_machine(struct sock *sk, struct sk_buff *skb, int frametype)
skb103net/netrom/nr_in.csk->window         = skb->data[20];
skb104net/netrom/nr_in.csk->nr->your_index = skb->data[17];
skb105net/netrom/nr_in.csk->nr->your_id    = skb->data[18];
skb143net/netrom/nr_in.cstatic int nr_state2_machine(struct sock *sk, struct sk_buff *skb, int frametype)
skb171net/netrom/nr_in.cstatic int nr_state3_machine(struct sock *sk, struct sk_buff *skb, int frametype)
skb179net/netrom/nr_in.cnr = skb->data[18];
skb180net/netrom/nr_in.cns = skb->data[17];
skb263net/netrom/nr_in.cskb_queue_head(&sk->nr->reseq_queue, skb);
skb310net/netrom/nr_in.cint nr_process_rx_frame(struct sock *sk, struct sk_buff *skb)
skb325net/netrom/nr_in.cframetype = skb->data[19];
skb330net/netrom/nr_in.cqueued = nr_state1_machine(sk, skb, frametype);
skb333net/netrom/nr_in.cqueued = nr_state2_machine(sk, skb, frametype);
skb336net/netrom/nr_in.cqueued = nr_state3_machine(sk, skb, frametype);
skb49net/netrom/nr_out.cvoid nr_output(struct sock *sk, struct sk_buff *skb)
skb57net/netrom/nr_out.cif (skb->len - NR_TRANSPORT_LEN > mtu) {
skb59net/netrom/nr_out.cmemcpy(transport, skb->data, NR_TRANSPORT_LEN);
skb60net/netrom/nr_out.cskb_pull(skb, NR_TRANSPORT_LEN);
skb62net/netrom/nr_out.cfrontlen = skb_headroom(skb);
skb64net/netrom/nr_out.cwhile (skb->len > 0) {
skb74net/netrom/nr_out.clen = (mtu > skb->len) ? skb->len : mtu;
skb77net/netrom/nr_out.cmemcpy(skb_put(skbn, len), skb->data, len);
skb78net/netrom/nr_out.cskb_pull(skb, len);
skb84net/netrom/nr_out.cif (skb->len > 0)
skb90net/netrom/nr_out.cskb->free = 1;
skb91net/netrom/nr_out.ckfree_skb(skb, FREE_WRITE);
skb93net/netrom/nr_out.cskb_queue_tail(&sk->write_queue, skb);    /* Throw it on the queue */
skb104net/netrom/nr_out.cstatic void nr_send_iframe(struct sock *sk, struct sk_buff *skb)
skb106net/netrom/nr_out.cif (skb == NULL)
skb109net/netrom/nr_out.cskb->data[2] = sk->nr->vs;
skb110net/netrom/nr_out.cskb->data[3] = sk->nr->vr;
skb113net/netrom/nr_out.cskb->data[4] |= NR_CHOKE_FLAG;
skb115net/netrom/nr_out.cnr_transmit_buffer(sk, skb);  
skb120net/netrom/nr_out.cstruct sk_buff *skb, *skbn;
skb122net/netrom/nr_out.cif ((skb = skb_peek(&sk->nr->ack_queue)) == NULL)
skb125net/netrom/nr_out.cif ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL)
skb143net/netrom/nr_out.cstruct sk_buff *skb, *skbn;
skb166net/netrom/nr_out.cskb  = skb_dequeue(&sk->write_queue);
skb169net/netrom/nr_out.cif ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL) {
skb170net/netrom/nr_out.cskb_queue_head(&sk->write_queue, skb);
skb187net/netrom/nr_out.cskb_queue_tail(&sk->nr->ack_queue, skb);
skb189net/netrom/nr_out.c} while (!last && (skb = skb_dequeue(&sk->write_queue)) != NULL);
skb202net/netrom/nr_out.cvoid nr_transmit_buffer(struct sock *sk, struct sk_buff *skb)
skb209net/netrom/nr_out.cdptr = skb_push(skb, NR_NETWORK_LEN);
skb225net/netrom/nr_out.cskb->arp = 1;
skb227net/netrom/nr_out.cif (!nr_route_frame(skb, NULL)) {
skb228net/netrom/nr_out.ckfree_skb(skb, FREE_WRITE);
skb649net/netrom/nr_route.cint nr_route_frame(struct sk_buff *skb, ax25_cb *ax25)
skb659net/netrom/nr_route.cif(ax25 && call_in_firewall(PF_NETROM, skb, skb->data)!=FW_ACCEPT)
skb661net/netrom/nr_route.cif(!ax25 && call_out_firewall(PF_NETROM, skb, skb->data)!=FW_ACCEPT)
skb664net/netrom/nr_route.cnr_src  = (ax25_address *)(skb->data + 0);
skb665net/netrom/nr_route.cnr_dest = (ax25_address *)(skb->data + 7);
skb671net/netrom/nr_route.creturn nr_rx_frame(skb, dev);
skb677net/netrom/nr_route.cif (--skb->data[14] == 0)
skb698net/netrom/nr_route.cif(ax25 && call_fw_firewall(PF_NETROM, skb, skb->data)!=FW_ACCEPT)
skb702net/netrom/nr_route.cdptr  = skb_push(skb, 1);
skb705net/netrom/nr_route.cax25_send_frame(skb, (ax25_address *)dev->dev_addr, &nr_neigh->callsign, nr_neigh->digipeat, nr_neigh->dev);
skb49net/netrom/nr_subr.cstruct sk_buff *skb;
skb51net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->write_queue)) != NULL) {
skb52net/netrom/nr_subr.cskb->sk   = sk;
skb53net/netrom/nr_subr.cskb->free = 1;
skb54net/netrom/nr_subr.ckfree_skb(skb, FREE_WRITE);
skb57net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->ack_queue)) != NULL) {
skb58net/netrom/nr_subr.cskb->sk   = sk;
skb59net/netrom/nr_subr.cskb->free = 1;
skb60net/netrom/nr_subr.ckfree_skb(skb, FREE_WRITE);
skb63net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->reseq_queue)) != NULL) {
skb64net/netrom/nr_subr.ckfree_skb(skb, FREE_READ);
skb67net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->frag_queue)) != NULL) {
skb68net/netrom/nr_subr.ckfree_skb(skb, FREE_READ);
skb79net/netrom/nr_subr.cstruct sk_buff *skb;
skb86net/netrom/nr_subr.cskb = skb_dequeue(&sk->nr->ack_queue);
skb87net/netrom/nr_subr.cskb->sk   = sk;
skb88net/netrom/nr_subr.cskb->free = 1;
skb89net/netrom/nr_subr.ckfree_skb(skb, FREE_WRITE);
skb102net/netrom/nr_subr.cstruct sk_buff *skb, *skb_prev = NULL;
skb104net/netrom/nr_subr.cwhile ((skb = skb_dequeue(&sk->nr->ack_queue)) != NULL) {
skb106net/netrom/nr_subr.cskb_queue_head(&sk->write_queue, skb);
skb108net/netrom/nr_subr.cskb_append(skb_prev, skb);
skb109net/netrom/nr_subr.cskb_prev = skb;
skb153net/netrom/nr_subr.cstruct sk_buff *skb;
skb175net/netrom/nr_subr.cif ((skb = alloc_skb(len, GFP_ATOMIC)) == NULL)
skb181net/netrom/nr_subr.cskb_reserve(skb, AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + NR_NETWORK_LEN);
skb183net/netrom/nr_subr.cdptr = skb_put(skb, skb_tailroom(skb));
skb237net/netrom/nr_subr.cskb->free = 1;
skb239net/netrom/nr_subr.cnr_transmit_buffer(sk, skb);
skb246net/netrom/nr_subr.cvoid nr_transmit_dm(struct sk_buff *skb)
skb261net/netrom/nr_subr.cmemcpy(dptr, skb->data + 7, AX25_ADDR_LEN);
skb267net/netrom/nr_subr.cmemcpy(dptr, skb->data + 0, AX25_ADDR_LEN);
skb275net/netrom/nr_subr.c*dptr++ = skb->data[15];
skb276net/netrom/nr_subr.c*dptr++ = skb->data[16];
skb174net/unix/af_unix.cstruct sk_buff *skb;
skb178net/unix/af_unix.cwhile((skb=skb_dequeue(&sk->receive_queue))!=NULL)
skb182net/unix/af_unix.cunix_socket *osk=skb->sk;
skb184net/unix/af_unix.ckfree_skb(skb, FREE_WRITE);  /* Now surplus - free the skb first before the socket */
skb191net/unix/af_unix.ckfree_skb(skb,FREE_WRITE);
skb463net/unix/af_unix.cstruct sk_buff *skb;
skb519net/unix/af_unix.cskb=sock_alloc_send_skb(sk, 0, 0, 0, &err); /* Marker object */
skb520net/unix/af_unix.cif(skb==NULL)
skb522net/unix/af_unix.cskb->sk=sk;        /* So they know it is us */
skb523net/unix/af_unix.cskb->free=1;
skb529net/unix/af_unix.ckfree_skb(skb, FREE_WRITE);
skb534net/unix/af_unix.ckfree_skb(skb, FREE_WRITE);
skb540net/unix/af_unix.cskb_queue_tail(&other->receive_queue,skb);
skb591net/unix/af_unix.cunix_socket *ska,*skb;  
skb594net/unix/af_unix.cskb=b->data;
skb598net/unix/af_unix.cskb->protinfo.af_unix.locks++;
skb599net/unix/af_unix.cska->protinfo.af_unix.other=skb;
skb600net/unix/af_unix.cskb->protinfo.af_unix.other=ska;
skb602net/unix/af_unix.cskb->state=TCP_ESTABLISHED;
skb610net/unix/af_unix.cstruct sk_buff *skb;
skb633net/unix/af_unix.cskb=skb_dequeue(&sk->receive_queue);
skb634net/unix/af_unix.cif(skb==NULL)
skb650net/unix/af_unix.cwhile(skb==NULL);
skb651net/unix/af_unix.ctsk=skb->sk;
skb652net/unix/af_unix.ckfree_skb(skb, FREE_WRITE);  /* The buffer is just used as a tag */
skb804net/unix/af_unix.cstatic void unix_detach_fds(struct sk_buff *skb, struct cmsghdr *cmsg)
skb826net/unix/af_unix.cmemcpy(&fdnum,skb->h.filp,sizeof(int));
skb827net/unix/af_unix.cfp=(struct file **)(skb->h.filp+sizeof(int));
skb858net/unix/af_unix.ckfree(skb->h.filp);
skb859net/unix/af_unix.cskb->h.filp=NULL;
skb862net/unix/af_unix.cskb->destructor = NULL;
skb865net/unix/af_unix.cstatic void unix_destruct_fds(struct sk_buff *skb)
skb867net/unix/af_unix.cunix_detach_fds(skb,NULL);
skb873net/unix/af_unix.cstatic void unix_attach_fds(int fpnum,struct file **fp,struct sk_buff *skb)
skb876net/unix/af_unix.cskb->h.filp=kmalloc(sizeof(int)+fpnum*sizeof(struct file *), 
skb879net/unix/af_unix.cmemcpy(skb->h.filp,&fpnum,sizeof(int));
skb881net/unix/af_unix.cmemcpy(skb->h.filp+sizeof(int),fp,fpnum*sizeof(struct file *));
skb882net/unix/af_unix.cskb->destructor = unix_destruct_fds;
skb895net/unix/af_unix.cstruct sk_buff *skb;
skb986net/unix/af_unix.cskb=sock_alloc_send_skb(sk,size,limit,nonblock, &err);
skb988net/unix/af_unix.cif(skb==NULL)
skb998net/unix/af_unix.csize=skb_tailroom(skb);    /* If we dropped back on a limit then our skb is smaller */
skb1000net/unix/af_unix.cskb->sk=sk;
skb1001net/unix/af_unix.cskb->free=1;
skb1005net/unix/af_unix.cunix_attach_fds(fpnum,fp,skb);
skb1009net/unix/af_unix.cskb->h.filp=NULL;
skb1011net/unix/af_unix.cmemcpy_fromiovec(skb_put(skb,size),msg->msg_iov, size);
skb1023net/unix/af_unix.ckfree_skb(skb, FREE_WRITE);
skb1037net/unix/af_unix.ckfree_skb(skb, FREE_WRITE);
skb1044net/unix/af_unix.cskb_queue_tail(&other->receive_queue, skb);
skb1072net/unix/af_unix.cstruct sk_buff *skb;
skb1124net/unix/af_unix.cskb=skb_dequeue(&sk->receive_queue);
skb1125net/unix/af_unix.cif(skb==NULL)
skb1143net/unix/af_unix.cif(skb->sk->protinfo.af_unix.name)
skb1145net/unix/af_unix.cmemcpy(sunaddr->sun_path, skb->sk->protinfo.af_unix.name, 108);
skb1154net/unix/af_unix.cnum=min(skb->len,len-done);
skb1155net/unix/af_unix.cmemcpy_tofs(sp, skb->data, num);
skb1157net/unix/af_unix.cif (skb->h.filp!=NULL)
skb1158net/unix/af_unix.cunix_detach_fds(skb,cm);
skb1164net/unix/af_unix.cskb_pull(skb, num);
skb1166net/unix/af_unix.cif (skb->len) {
skb1167net/unix/af_unix.cskb_queue_head(&sk->receive_queue, skb);
skb1170net/unix/af_unix.ckfree_skb(skb, FREE_WRITE);
skb1236net/unix/af_unix.cstruct sk_buff *skb;
skb1240net/unix/af_unix.cif((skb=skb_peek(&sk->receive_queue))!=NULL)
skb1241net/unix/af_unix.camount=skb->len;
skb196net/unix/garbage.cstruct sk_buff *skb;
skb198net/unix/garbage.cskb=skb_peek(&x->receive_queue);
skb204net/unix/garbage.cwhile(skb && skb != (struct sk_buff *)&x->receive_queue)
skb209net/unix/garbage.cif(skb->h.filp)
skb214net/unix/garbage.cint nfd=*(int *)skb->h.filp;
skb215net/unix/garbage.cstruct file **fp=(struct file **)(skb->h.filp+sizeof(int));
skb235net/unix/garbage.cskb=skb->next;