net/netrom/nr_dev.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * Copyright Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
   8  */
   9 #include <linux/module.h>
  10 #include <linux/proc_fs.h>
  11 #include <linux/kernel.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/fs.h>
  14 #include <linux/types.h>
  15 #include <linux/sysctl.h>
  16 #include <linux/string.h>
  17 #include <linux/socket.h>
  18 #include <linux/errno.h>
  19 #include <linux/fcntl.h>
  20 #include <linux/in.h>
  21 #include <linux/if_ether.h>     /* For the statistics structure. */
  22 #include <linux/slab.h>
  23 #include <linux/uaccess.h>
  24
  25 #include <asm/io.h>
  26
  27 #include <linux/inet.h>
  28 #include <linux/netdevice.h>
  29 #include <linux/etherdevice.h>
  30 #include <linux/if_arp.h>
  31 #include <linux/skbuff.h>
  32
  33 #include <net/ip.h>
  34 #include <net/arp.h>
  35
  36 #include <net/ax25.h>
  37 #include <net/netrom.h>
  38
  39 /*
  40  *      Only allow IP over NET/ROM frames through if the netrom device is up.
  41  */
  42
  43 int nr_rx_ip(struct sk_buff *skb, struct net_device *dev)
  44 {
  45         struct net_device_stats *stats = &dev->stats;
  46
  47         if (!netif_running(dev)) {
  48                 stats->rx_dropped++;
  49                 return 0;
  50         }
  51
  52         stats->rx_packets++;
  53         stats->rx_bytes += skb->len;
  54
  55         skb->protocol = htons(ETH_P_IP);
  56
  57         /* Spoof incoming device */
  58         skb->dev      = dev;
  59         skb->mac_header = skb->network_header;
  60         skb_reset_network_header(skb);
  61         skb->pkt_type = PACKET_HOST;
  62
  63         netif_rx(skb);
  64
  65         return 1;
  66 }
  67
  68 static int nr_header(struct sk_buff *skb, struct net_device *dev,
  69                      unsigned short type,
  70                      const void *daddr, const void *saddr, unsigned int len)
  71 {
  72         unsigned char *buff = skb_push(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
  73
  74         memcpy(buff, (saddr != NULL) ? saddr : dev->dev_addr, dev->addr_len);
  75         buff[6] &= ~AX25_CBIT;
  76         buff[6] &= ~AX25_EBIT;
  77         buff[6] |= AX25_SSSID_SPARE;
  78         buff    += AX25_ADDR_LEN;
  79
  80         if (daddr != NULL)
  81                 memcpy(buff, daddr, dev->addr_len);
  82         buff[6] &= ~AX25_CBIT;
  83         buff[6] |= AX25_EBIT;
  84         buff[6] |= AX25_SSSID_SPARE;
  85         buff    += AX25_ADDR_LEN;
  86
  87         *buff++ = sysctl_netrom_network_ttl_initialiser;
  88
  89         *buff++ = NR_PROTO_IP;
  90         *buff++ = NR_PROTO_IP;
  91         *buff++ = 0;
  92         *buff++ = 0;
  93         *buff++ = NR_PROTOEXT;
  94
  95         if (daddr != NULL)
  96                 return 37;
  97
  98         return -37;
  99 }
 100
 101 static int __must_check nr_set_mac_address(struct net_device *dev, void *addr)
 102 {
 103         struct sockaddr *sa = addr;
 104         int err;
 105
 106         if (!memcmp(dev->dev_addr, sa->sa_data, dev->addr_len))
 107                 return 0;
 108
 109         if (dev->flags & IFF_UP) {
 110                 err = ax25_listen_register((ax25_address *)sa->sa_data, NULL);
 111                 if (err)
 112                         return err;
 113
 114                 ax25_listen_release((ax25_address *)dev->dev_addr, NULL);
 115         }
 116
 117         memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
 118
 119         return 0;
 120 }
 121
 122 static int nr_open(struct net_device *dev)
 123 {
 124         int err;
 125
 126         err = ax25_listen_register((ax25_address *)dev->dev_addr, NULL);
 127         if (err)
 128                 return err;
 129
 130         netif_start_queue(dev);
 131
 132         return 0;
 133 }
 134
 135 static int nr_close(struct net_device *dev)
 136 {
 137         ax25_listen_release((ax25_address *)dev->dev_addr, NULL);
 138         netif_stop_queue(dev);
 139         return 0;
 140 }
 141
 142 static netdev_tx_t nr_xmit(struct sk_buff *skb, struct net_device *dev)
 143 {
 144         struct net_device_stats *stats = &dev->stats;
 145         unsigned int len = skb->len;
 146
 147         if (!nr_route_frame(skb, NULL)) {
 148                 kfree_skb(skb);
 149                 stats->tx_errors++;
 150                 return NETDEV_TX_OK;
 151         }
 152
 153         stats->tx_packets++;
 154         stats->tx_bytes += len;
 155
 156         return NETDEV_TX_OK;
 157 }
 158
 159 static const struct header_ops nr_header_ops = {
 160         .create = nr_header,
 161 };
 162
 163 static const struct net_device_ops nr_netdev_ops = {
 164         .ndo_open               = nr_open,
 165         .ndo_stop               = nr_close,
 166         .ndo_start_xmit         = nr_xmit,
 167         .ndo_set_mac_address    = nr_set_mac_address,
 168 };
 169
 170 void nr_setup(struct net_device *dev)
 171 {
 172         dev->mtu                = NR_MAX_PACKET_SIZE;
 173         dev->netdev_ops         = &nr_netdev_ops;
 174         dev->header_ops         = &nr_header_ops;
 175         dev->hard_header_len    = NR_NETWORK_LEN + NR_TRANSPORT_LEN;
 176         dev->addr_len           = AX25_ADDR_LEN;
 177         dev->type               = ARPHRD_NETROM;
 178
 179         /* New-style flags. */
 180         dev->flags              = IFF_NOARP;
 181 }