1 // SPDX-License-Identifier: GPL-2.0-only
3 * Generic HDLC support routines for Linux
6 * Copyright (C) 2000 - 2006 Krzysztof Halasa <khc@pm.waw.pl>
9 #include <linux/errno.h>
10 #include <linux/hdlc.h>
11 #include <linux/if_arp.h>
12 #include <linux/inetdevice.h>
13 #include <linux/init.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/pkt_sched.h>
17 #include <linux/poll.h>
18 #include <linux/rtnetlink.h>
19 #include <linux/skbuff.h>
21 #undef DEBUG_HARD_HEADER
23 #define CISCO_MULTICAST 0x8F /* Cisco multicast address */
24 #define CISCO_UNICAST 0x0F /* Cisco unicast address */
25 #define CISCO_KEEPALIVE 0x8035 /* Cisco keepalive protocol */
26 #define CISCO_SYS_INFO 0x2000 /* Cisco interface/system info */
27 #define CISCO_ADDR_REQ 0 /* Cisco address request */
28 #define CISCO_ADDR_REPLY 1 /* Cisco address reply */
29 #define CISCO_KEEPALIVE_REQ 2 /* Cisco keepalive request */
40 __be32 type; /* code */
43 __be16 rel; /* reliability */
46 #define CISCO_PACKET_LEN 18
47 #define CISCO_BIG_PACKET_LEN 20
53 struct timer_list timer;
54 struct net_device *dev;
56 unsigned long last_poll;
58 u32 txseq; /* TX sequence number, 0 = none */
59 u32 rxseq; /* RX sequence number */
63 static int cisco_ioctl(struct net_device *dev, struct ifreq *ifr);
66 static inline struct cisco_state* state(hdlc_device *hdlc)
68 return (struct cisco_state *)hdlc->state;
72 static int cisco_hard_header(struct sk_buff *skb, struct net_device *dev,
73 u16 type, const void *daddr, const void *saddr,
76 struct hdlc_header *data;
77 #ifdef DEBUG_HARD_HEADER
78 printk(KERN_DEBUG "%s: cisco_hard_header called\n", dev->name);
81 skb_push(skb, sizeof(struct hdlc_header));
82 data = (struct hdlc_header*)skb->data;
83 if (type == CISCO_KEEPALIVE)
84 data->address = CISCO_MULTICAST;
86 data->address = CISCO_UNICAST;
88 data->protocol = htons(type);
90 return sizeof(struct hdlc_header);
95 static void cisco_keepalive_send(struct net_device *dev, u32 type,
96 __be32 par1, __be32 par2)
99 struct cisco_packet *data;
101 skb = dev_alloc_skb(sizeof(struct hdlc_header) +
102 sizeof(struct cisco_packet));
104 netdev_warn(dev, "Memory squeeze on cisco_keepalive_send()\n");
108 cisco_hard_header(skb, dev, CISCO_KEEPALIVE, NULL, NULL, 0);
109 data = (struct cisco_packet*)(skb->data + 4);
111 data->type = htonl(type);
114 data->rel = cpu_to_be16(0xFFFF);
115 /* we will need do_div here if 1000 % HZ != 0 */
116 data->time = htonl((jiffies - INITIAL_JIFFIES) * (1000 / HZ));
118 skb_put(skb, sizeof(struct cisco_packet));
119 skb->priority = TC_PRIO_CONTROL;
121 skb_reset_network_header(skb);
128 static __be16 cisco_type_trans(struct sk_buff *skb, struct net_device *dev)
130 struct hdlc_header *data = (struct hdlc_header*)skb->data;
132 if (skb->len < sizeof(struct hdlc_header))
133 return cpu_to_be16(ETH_P_HDLC);
135 if (data->address != CISCO_MULTICAST &&
136 data->address != CISCO_UNICAST)
137 return cpu_to_be16(ETH_P_HDLC);
139 switch (data->protocol) {
140 case cpu_to_be16(ETH_P_IP):
141 case cpu_to_be16(ETH_P_IPX):
142 case cpu_to_be16(ETH_P_IPV6):
143 skb_pull(skb, sizeof(struct hdlc_header));
144 return data->protocol;
146 return cpu_to_be16(ETH_P_HDLC);
151 static int cisco_rx(struct sk_buff *skb)
153 struct net_device *dev = skb->dev;
154 hdlc_device *hdlc = dev_to_hdlc(dev);
155 struct cisco_state *st = state(hdlc);
156 struct hdlc_header *data = (struct hdlc_header*)skb->data;
157 struct cisco_packet *cisco_data;
158 struct in_device *in_dev;
162 if (skb->len < sizeof(struct hdlc_header))
165 if (data->address != CISCO_MULTICAST &&
166 data->address != CISCO_UNICAST)
169 switch (ntohs(data->protocol)) {
171 /* Packet is not needed, drop it. */
172 dev_kfree_skb_any(skb);
173 return NET_RX_SUCCESS;
175 case CISCO_KEEPALIVE:
176 if ((skb->len != sizeof(struct hdlc_header) +
178 (skb->len != sizeof(struct hdlc_header) +
179 CISCO_BIG_PACKET_LEN)) {
180 netdev_info(dev, "Invalid length of Cisco control packet (%d bytes)\n",
185 cisco_data = (struct cisco_packet*)(skb->data + sizeof
186 (struct hdlc_header));
188 switch (ntohl (cisco_data->type)) {
189 case CISCO_ADDR_REQ: /* Stolen from syncppp.c :-) */
191 in_dev = __in_dev_get_rcu(dev);
193 mask = ~cpu_to_be32(0); /* is the mask correct? */
195 if (in_dev != NULL) {
196 const struct in_ifaddr *ifa;
198 in_dev_for_each_ifa_rcu(ifa, in_dev) {
199 if (strcmp(dev->name,
200 ifa->ifa_label) == 0) {
201 addr = ifa->ifa_local;
202 mask = ifa->ifa_mask;
207 cisco_keepalive_send(dev, CISCO_ADDR_REPLY,
211 dev_kfree_skb_any(skb);
212 return NET_RX_SUCCESS;
214 case CISCO_ADDR_REPLY:
215 netdev_info(dev, "Unexpected Cisco IP address reply\n");
218 case CISCO_KEEPALIVE_REQ:
219 spin_lock(&st->lock);
220 st->rxseq = ntohl(cisco_data->par1);
221 ack = ntohl(cisco_data->par2);
222 if (ack && (ack == st->txseq ||
223 /* our current REQ may be in transit */
224 ack == st->txseq - 1)) {
225 st->last_poll = jiffies;
227 u32 sec, min, hrs, days;
228 sec = ntohl(cisco_data->time) / 1000;
229 min = sec / 60; sec -= min * 60;
230 hrs = min / 60; min -= hrs * 60;
231 days = hrs / 24; hrs -= days * 24;
232 netdev_info(dev, "Link up (peer uptime %ud%uh%um%us)\n",
233 days, hrs, min, sec);
234 netif_dormant_off(dev);
238 spin_unlock(&st->lock);
240 dev_kfree_skb_any(skb);
241 return NET_RX_SUCCESS;
242 } /* switch (keepalive type) */
243 } /* switch (protocol) */
245 netdev_info(dev, "Unsupported protocol %x\n", ntohs(data->protocol));
246 dev_kfree_skb_any(skb);
250 dev->stats.rx_errors++; /* Mark error */
251 dev_kfree_skb_any(skb);
257 static void cisco_timer(struct timer_list *t)
259 struct cisco_state *st = from_timer(st, t, timer);
260 struct net_device *dev = st->dev;
262 spin_lock(&st->lock);
264 time_after(jiffies, st->last_poll + st->settings.timeout * HZ)) {
266 netdev_info(dev, "Link down\n");
267 netif_dormant_on(dev);
270 cisco_keepalive_send(dev, CISCO_KEEPALIVE_REQ, htonl(++st->txseq),
272 spin_unlock(&st->lock);
274 st->timer.expires = jiffies + st->settings.interval * HZ;
275 add_timer(&st->timer);
280 static void cisco_start(struct net_device *dev)
282 hdlc_device *hdlc = dev_to_hdlc(dev);
283 struct cisco_state *st = state(hdlc);
286 spin_lock_irqsave(&st->lock, flags);
287 st->up = st->txseq = st->rxseq = 0;
288 spin_unlock_irqrestore(&st->lock, flags);
291 timer_setup(&st->timer, cisco_timer, 0);
292 st->timer.expires = jiffies + HZ; /* First poll after 1 s */
293 add_timer(&st->timer);
298 static void cisco_stop(struct net_device *dev)
300 hdlc_device *hdlc = dev_to_hdlc(dev);
301 struct cisco_state *st = state(hdlc);
304 del_timer_sync(&st->timer);
306 spin_lock_irqsave(&st->lock, flags);
307 netif_dormant_on(dev);
308 st->up = st->txseq = 0;
309 spin_unlock_irqrestore(&st->lock, flags);
313 static struct hdlc_proto proto = {
314 .start = cisco_start,
316 .type_trans = cisco_type_trans,
317 .ioctl = cisco_ioctl,
318 .netif_rx = cisco_rx,
319 .module = THIS_MODULE,
322 static const struct header_ops cisco_header_ops = {
323 .create = cisco_hard_header,
326 static int cisco_ioctl(struct net_device *dev, struct ifreq *ifr)
328 cisco_proto __user *cisco_s = ifr->ifr_settings.ifs_ifsu.cisco;
329 const size_t size = sizeof(cisco_proto);
330 cisco_proto new_settings;
331 hdlc_device *hdlc = dev_to_hdlc(dev);
334 switch (ifr->ifr_settings.type) {
336 if (dev_to_hdlc(dev)->proto != &proto)
338 ifr->ifr_settings.type = IF_PROTO_CISCO;
339 if (ifr->ifr_settings.size < size) {
340 ifr->ifr_settings.size = size; /* data size wanted */
343 if (copy_to_user(cisco_s, &state(hdlc)->settings, size))
348 if (!capable(CAP_NET_ADMIN))
351 if (dev->flags & IFF_UP)
354 if (copy_from_user(&new_settings, cisco_s, size))
357 if (new_settings.interval < 1 ||
358 new_settings.timeout < 2)
361 result = hdlc->attach(dev, ENCODING_NRZ,PARITY_CRC16_PR1_CCITT);
365 result = attach_hdlc_protocol(dev, &proto,
366 sizeof(struct cisco_state));
370 memcpy(&state(hdlc)->settings, &new_settings, size);
371 spin_lock_init(&state(hdlc)->lock);
372 dev->header_ops = &cisco_header_ops;
373 dev->type = ARPHRD_CISCO;
374 call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, dev);
375 netif_dormant_on(dev);
383 static int __init mod_init(void)
385 register_hdlc_protocol(&proto);
391 static void __exit mod_exit(void)
393 unregister_hdlc_protocol(&proto);
397 module_init(mod_init);
398 module_exit(mod_exit);
400 MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>");
401 MODULE_DESCRIPTION("Cisco HDLC protocol support for generic HDLC");
402 MODULE_LICENSE("GPL v2");