Linux Audio

Check our new training course

Loading...
v3.15
 
  1#include <linux/kmod.h>
  2#include <linux/netdevice.h>
  3#include <linux/etherdevice.h>
  4#include <linux/rtnetlink.h>
  5#include <linux/net_tstamp.h>
  6#include <linux/wireless.h>
  7#include <net/wext.h>
  8
  9/*
 10 *	Map an interface index to its name (SIOCGIFNAME)
 11 */
 12
 13/*
 14 *	We need this ioctl for efficient implementation of the
 15 *	if_indextoname() function required by the IPv6 API.  Without
 16 *	it, we would have to search all the interfaces to find a
 17 *	match.  --pb
 18 */
 19
 20static int dev_ifname(struct net *net, struct ifreq __user *arg)
 21{
 22	struct ifreq ifr;
 23	int error;
 24
 25	/*
 26	 *	Fetch the caller's info block.
 27	 */
 28
 29	if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
 30		return -EFAULT;
 31
 32	error = netdev_get_name(net, ifr.ifr_name, ifr.ifr_ifindex);
 33	if (error)
 34		return error;
 35
 36	if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
 37		return -EFAULT;
 38	return 0;
 39}
 40
 41static gifconf_func_t *gifconf_list[NPROTO];
 42
 43/**
 44 *	register_gifconf	-	register a SIOCGIF handler
 45 *	@family: Address family
 46 *	@gifconf: Function handler
 47 *
 48 *	Register protocol dependent address dumping routines. The handler
 49 *	that is passed must not be freed or reused until it has been replaced
 50 *	by another handler.
 51 */
 52int register_gifconf(unsigned int family, gifconf_func_t *gifconf)
 53{
 54	if (family >= NPROTO)
 55		return -EINVAL;
 56	gifconf_list[family] = gifconf;
 57	return 0;
 58}
 59EXPORT_SYMBOL(register_gifconf);
 60
 61/*
 62 *	Perform a SIOCGIFCONF call. This structure will change
 63 *	size eventually, and there is nothing I can do about it.
 64 *	Thus we will need a 'compatibility mode'.
 65 */
 66
 67static int dev_ifconf(struct net *net, char __user *arg)
 68{
 69	struct ifconf ifc;
 70	struct net_device *dev;
 71	char __user *pos;
 72	int len;
 73	int total;
 74	int i;
 75
 76	/*
 77	 *	Fetch the caller's info block.
 78	 */
 79
 80	if (copy_from_user(&ifc, arg, sizeof(struct ifconf)))
 81		return -EFAULT;
 82
 83	pos = ifc.ifc_buf;
 84	len = ifc.ifc_len;
 85
 86	/*
 87	 *	Loop over the interfaces, and write an info block for each.
 88	 */
 89
 90	total = 0;
 91	for_each_netdev(net, dev) {
 92		for (i = 0; i < NPROTO; i++) {
 93			if (gifconf_list[i]) {
 94				int done;
 95				if (!pos)
 96					done = gifconf_list[i](dev, NULL, 0);
 97				else
 98					done = gifconf_list[i](dev, pos + total,
 99							       len - total);
100				if (done < 0)
101					return -EFAULT;
102				total += done;
103			}
104		}
105	}
106
107	/*
108	 *	All done.  Write the updated control block back to the caller.
109	 */
110	ifc.ifc_len = total;
111
112	/*
113	 * 	Both BSD and Solaris return 0 here, so we do too.
114	 */
115	return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0;
116}
117
118/*
119 *	Perform the SIOCxIFxxx calls, inside rcu_read_lock()
120 */
121static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
122{
123	int err;
124	struct net_device *dev = dev_get_by_name_rcu(net, ifr->ifr_name);
125
126	if (!dev)
127		return -ENODEV;
128
129	switch (cmd) {
130	case SIOCGIFFLAGS:	/* Get interface flags */
131		ifr->ifr_flags = (short) dev_get_flags(dev);
132		return 0;
133
134	case SIOCGIFMETRIC:	/* Get the metric on the interface
135				   (currently unused) */
136		ifr->ifr_metric = 0;
137		return 0;
138
139	case SIOCGIFMTU:	/* Get the MTU of a device */
140		ifr->ifr_mtu = dev->mtu;
141		return 0;
142
143	case SIOCGIFHWADDR:
144		if (!dev->addr_len)
145			memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data);
 
146		else
147			memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
148			       min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
 
149		ifr->ifr_hwaddr.sa_family = dev->type;
150		return 0;
151
152	case SIOCGIFSLAVE:
153		err = -EINVAL;
154		break;
155
156	case SIOCGIFMAP:
157		ifr->ifr_map.mem_start = dev->mem_start;
158		ifr->ifr_map.mem_end   = dev->mem_end;
159		ifr->ifr_map.base_addr = dev->base_addr;
160		ifr->ifr_map.irq       = dev->irq;
161		ifr->ifr_map.dma       = dev->dma;
162		ifr->ifr_map.port      = dev->if_port;
163		return 0;
164
165	case SIOCGIFINDEX:
166		ifr->ifr_ifindex = dev->ifindex;
167		return 0;
168
169	case SIOCGIFTXQLEN:
170		ifr->ifr_qlen = dev->tx_queue_len;
171		return 0;
172
173	default:
174		/* dev_ioctl() should ensure this case
175		 * is never reached
176		 */
177		WARN_ON(1);
178		err = -ENOTTY;
179		break;
180
181	}
182	return err;
183}
184
185static int net_hwtstamp_validate(struct ifreq *ifr)
186{
187	struct hwtstamp_config cfg;
188	enum hwtstamp_tx_types tx_type;
189	enum hwtstamp_rx_filters rx_filter;
190	int tx_type_valid = 0;
191	int rx_filter_valid = 0;
192
193	if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
194		return -EFAULT;
195
196	if (cfg.flags) /* reserved for future extensions */
197		return -EINVAL;
198
199	tx_type = cfg.tx_type;
200	rx_filter = cfg.rx_filter;
201
202	switch (tx_type) {
203	case HWTSTAMP_TX_OFF:
204	case HWTSTAMP_TX_ON:
205	case HWTSTAMP_TX_ONESTEP_SYNC:
206		tx_type_valid = 1;
207		break;
208	}
209
210	switch (rx_filter) {
211	case HWTSTAMP_FILTER_NONE:
212	case HWTSTAMP_FILTER_ALL:
213	case HWTSTAMP_FILTER_SOME:
214	case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
215	case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
216	case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
217	case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
218	case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
219	case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
220	case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
221	case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
222	case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
223	case HWTSTAMP_FILTER_PTP_V2_EVENT:
224	case HWTSTAMP_FILTER_PTP_V2_SYNC:
225	case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
 
226		rx_filter_valid = 1;
227		break;
228	}
229
230	if (!tx_type_valid || !rx_filter_valid)
231		return -ERANGE;
232
233	return 0;
234}
235
236/*
237 *	Perform the SIOCxIFxxx calls, inside rtnl_lock()
238 */
239static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
240{
241	int err;
242	struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
243	const struct net_device_ops *ops;
244
245	if (!dev)
246		return -ENODEV;
247
248	ops = dev->netdev_ops;
249
250	switch (cmd) {
251	case SIOCSIFFLAGS:	/* Set interface flags */
252		return dev_change_flags(dev, ifr->ifr_flags);
253
254	case SIOCSIFMETRIC:	/* Set the metric on the interface
255				   (currently unused) */
256		return -EOPNOTSUPP;
257
258	case SIOCSIFMTU:	/* Set the MTU of a device */
259		return dev_set_mtu(dev, ifr->ifr_mtu);
260
261	case SIOCSIFHWADDR:
 
 
262		return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
263
264	case SIOCSIFHWBROADCAST:
265		if (ifr->ifr_hwaddr.sa_family != dev->type)
266			return -EINVAL;
267		memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
268		       min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len));
 
269		call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
270		return 0;
271
272	case SIOCSIFMAP:
273		if (ops->ndo_set_config) {
274			if (!netif_device_present(dev))
275				return -ENODEV;
276			return ops->ndo_set_config(dev, &ifr->ifr_map);
277		}
278		return -EOPNOTSUPP;
279
280	case SIOCADDMULTI:
281		if (!ops->ndo_set_rx_mode ||
282		    ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
283			return -EINVAL;
284		if (!netif_device_present(dev))
285			return -ENODEV;
286		return dev_mc_add_global(dev, ifr->ifr_hwaddr.sa_data);
287
288	case SIOCDELMULTI:
289		if (!ops->ndo_set_rx_mode ||
290		    ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
291			return -EINVAL;
292		if (!netif_device_present(dev))
293			return -ENODEV;
294		return dev_mc_del_global(dev, ifr->ifr_hwaddr.sa_data);
295
296	case SIOCSIFTXQLEN:
297		if (ifr->ifr_qlen < 0)
298			return -EINVAL;
299		dev->tx_queue_len = ifr->ifr_qlen;
 
 
 
 
 
 
 
 
 
 
 
300		return 0;
301
302	case SIOCSIFNAME:
303		ifr->ifr_newname[IFNAMSIZ-1] = '\0';
304		return dev_change_name(dev, ifr->ifr_newname);
305
306	case SIOCSHWTSTAMP:
307		err = net_hwtstamp_validate(ifr);
308		if (err)
309			return err;
310		/* fall through */
311
312	/*
313	 *	Unknown or private ioctl
314	 */
315	default:
316		if ((cmd >= SIOCDEVPRIVATE &&
317		    cmd <= SIOCDEVPRIVATE + 15) ||
318		    cmd == SIOCBONDENSLAVE ||
319		    cmd == SIOCBONDRELEASE ||
320		    cmd == SIOCBONDSETHWADDR ||
321		    cmd == SIOCBONDSLAVEINFOQUERY ||
322		    cmd == SIOCBONDINFOQUERY ||
323		    cmd == SIOCBONDCHANGEACTIVE ||
324		    cmd == SIOCGMIIPHY ||
325		    cmd == SIOCGMIIREG ||
326		    cmd == SIOCSMIIREG ||
327		    cmd == SIOCBRADDIF ||
328		    cmd == SIOCBRDELIF ||
329		    cmd == SIOCSHWTSTAMP ||
330		    cmd == SIOCGHWTSTAMP ||
331		    cmd == SIOCWANDEV) {
332			err = -EOPNOTSUPP;
333			if (ops->ndo_do_ioctl) {
334				if (netif_device_present(dev))
335					err = ops->ndo_do_ioctl(dev, ifr, cmd);
336				else
337					err = -ENODEV;
338			}
339		} else
340			err = -EINVAL;
341
342	}
343	return err;
344}
345
346/**
347 *	dev_load 	- load a network module
348 *	@net: the applicable net namespace
349 *	@name: name of interface
350 *
351 *	If a network interface is not present and the process has suitable
352 *	privileges this function loads the module. If module loading is not
353 *	available in this kernel then it becomes a nop.
354 */
355
356void dev_load(struct net *net, const char *name)
357{
358	struct net_device *dev;
359	int no_module;
360
361	rcu_read_lock();
362	dev = dev_get_by_name_rcu(net, name);
363	rcu_read_unlock();
364
365	no_module = !dev;
366	if (no_module && capable(CAP_NET_ADMIN))
367		no_module = request_module("netdev-%s", name);
368	if (no_module && capable(CAP_SYS_MODULE)) {
369		if (!request_module("%s", name))
370			pr_warn("Loading kernel module for a network device with CAP_SYS_MODULE (deprecated).  Use CAP_NET_ADMIN and alias netdev-%s instead.\n",
371				name);
372	}
373}
374EXPORT_SYMBOL(dev_load);
375
376/*
377 *	This function handles all "interface"-type I/O control requests. The actual
378 *	'doing' part of this is dev_ifsioc above.
379 */
380
381/**
382 *	dev_ioctl	-	network device ioctl
383 *	@net: the applicable net namespace
384 *	@cmd: command to issue
385 *	@arg: pointer to a struct ifreq in user space
386 *
387 *	Issue ioctl functions to devices. This is normally called by the
388 *	user space syscall interfaces but can sometimes be useful for
389 *	other purposes. The return value is the return from the syscall if
390 *	positive or a negative errno code on error.
391 */
392
393int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)
394{
395	struct ifreq ifr;
396	int ret;
397	char *colon;
398
399	/* One special case: SIOCGIFCONF takes ifconf argument
400	   and requires shared lock, because it sleeps writing
401	   to user space.
402	 */
403
404	if (cmd == SIOCGIFCONF) {
405		rtnl_lock();
406		ret = dev_ifconf(net, (char __user *) arg);
407		rtnl_unlock();
408		return ret;
409	}
410	if (cmd == SIOCGIFNAME)
411		return dev_ifname(net, (struct ifreq __user *)arg);
412
413	if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
414		return -EFAULT;
415
416	ifr.ifr_name[IFNAMSIZ-1] = 0;
417
418	colon = strchr(ifr.ifr_name, ':');
419	if (colon)
420		*colon = 0;
421
422	/*
423	 *	See which interface the caller is talking about.
424	 */
425
426	switch (cmd) {
427	/*
428	 *	These ioctl calls:
429	 *	- can be done by all.
430	 *	- atomic and do not require locking.
431	 *	- return a value
432	 */
433	case SIOCGIFFLAGS:
434	case SIOCGIFMETRIC:
435	case SIOCGIFMTU:
436	case SIOCGIFHWADDR:
437	case SIOCGIFSLAVE:
438	case SIOCGIFMAP:
439	case SIOCGIFINDEX:
440	case SIOCGIFTXQLEN:
441		dev_load(net, ifr.ifr_name);
442		rcu_read_lock();
443		ret = dev_ifsioc_locked(net, &ifr, cmd);
444		rcu_read_unlock();
445		if (!ret) {
446			if (colon)
447				*colon = ':';
448			if (copy_to_user(arg, &ifr,
449					 sizeof(struct ifreq)))
450				ret = -EFAULT;
451		}
452		return ret;
453
454	case SIOCETHTOOL:
455		dev_load(net, ifr.ifr_name);
456		rtnl_lock();
457		ret = dev_ethtool(net, &ifr);
458		rtnl_unlock();
459		if (!ret) {
460			if (colon)
461				*colon = ':';
462			if (copy_to_user(arg, &ifr,
463					 sizeof(struct ifreq)))
464				ret = -EFAULT;
465		}
466		return ret;
467
468	/*
469	 *	These ioctl calls:
470	 *	- require superuser power.
471	 *	- require strict serialization.
472	 *	- return a value
473	 */
474	case SIOCGMIIPHY:
475	case SIOCGMIIREG:
476	case SIOCSIFNAME:
 
477		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
478			return -EPERM;
479		dev_load(net, ifr.ifr_name);
480		rtnl_lock();
481		ret = dev_ifsioc(net, &ifr, cmd);
482		rtnl_unlock();
483		if (!ret) {
484			if (colon)
485				*colon = ':';
486			if (copy_to_user(arg, &ifr,
487					 sizeof(struct ifreq)))
488				ret = -EFAULT;
489		}
490		return ret;
491
492	/*
493	 *	These ioctl calls:
494	 *	- require superuser power.
495	 *	- require strict serialization.
496	 *	- do not return a value
497	 */
498	case SIOCSIFMAP:
499	case SIOCSIFTXQLEN:
500		if (!capable(CAP_NET_ADMIN))
501			return -EPERM;
502		/* fall through */
503	/*
504	 *	These ioctl calls:
505	 *	- require local superuser power.
506	 *	- require strict serialization.
507	 *	- do not return a value
508	 */
509	case SIOCSIFFLAGS:
510	case SIOCSIFMETRIC:
511	case SIOCSIFMTU:
512	case SIOCSIFHWADDR:
513	case SIOCSIFSLAVE:
514	case SIOCADDMULTI:
515	case SIOCDELMULTI:
516	case SIOCSIFHWBROADCAST:
517	case SIOCSMIIREG:
518	case SIOCBONDENSLAVE:
519	case SIOCBONDRELEASE:
520	case SIOCBONDSETHWADDR:
521	case SIOCBONDCHANGEACTIVE:
522	case SIOCBRADDIF:
523	case SIOCBRDELIF:
524	case SIOCSHWTSTAMP:
525		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
526			return -EPERM;
527		/* fall through */
528	case SIOCBONDSLAVEINFOQUERY:
529	case SIOCBONDINFOQUERY:
530		dev_load(net, ifr.ifr_name);
531		rtnl_lock();
532		ret = dev_ifsioc(net, &ifr, cmd);
533		rtnl_unlock();
 
 
534		return ret;
535
536	case SIOCGIFMEM:
537		/* Get the per device memory space. We can add this but
538		 * currently do not support it */
539	case SIOCSIFMEM:
540		/* Set the per device memory buffer space.
541		 * Not applicable in our case */
542	case SIOCSIFLINK:
543		return -ENOTTY;
544
545	/*
546	 *	Unknown or private ioctl.
547	 */
548	default:
549		if (cmd == SIOCWANDEV ||
550		    cmd == SIOCGHWTSTAMP ||
551		    (cmd >= SIOCDEVPRIVATE &&
552		     cmd <= SIOCDEVPRIVATE + 15)) {
553			dev_load(net, ifr.ifr_name);
554			rtnl_lock();
555			ret = dev_ifsioc(net, &ifr, cmd);
556			rtnl_unlock();
557			if (!ret && copy_to_user(arg, &ifr,
558						 sizeof(struct ifreq)))
559				ret = -EFAULT;
560			return ret;
561		}
562		/* Take care of Wireless Extensions */
563		if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)
564			return wext_handle_ioctl(net, &ifr, cmd, arg);
565		return -ENOTTY;
566	}
567}
v4.17
  1// SPDX-License-Identifier: GPL-2.0
  2#include <linux/kmod.h>
  3#include <linux/netdevice.h>
  4#include <linux/etherdevice.h>
  5#include <linux/rtnetlink.h>
  6#include <linux/net_tstamp.h>
  7#include <linux/wireless.h>
  8#include <net/wext.h>
  9
 10/*
 11 *	Map an interface index to its name (SIOCGIFNAME)
 12 */
 13
 14/*
 15 *	We need this ioctl for efficient implementation of the
 16 *	if_indextoname() function required by the IPv6 API.  Without
 17 *	it, we would have to search all the interfaces to find a
 18 *	match.  --pb
 19 */
 20
 21static int dev_ifname(struct net *net, struct ifreq *ifr)
 22{
 23	ifr->ifr_name[IFNAMSIZ-1] = 0;
 24	return netdev_get_name(net, ifr->ifr_name, ifr->ifr_ifindex);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 25}
 26
 27static gifconf_func_t *gifconf_list[NPROTO];
 28
 29/**
 30 *	register_gifconf	-	register a SIOCGIF handler
 31 *	@family: Address family
 32 *	@gifconf: Function handler
 33 *
 34 *	Register protocol dependent address dumping routines. The handler
 35 *	that is passed must not be freed or reused until it has been replaced
 36 *	by another handler.
 37 */
 38int register_gifconf(unsigned int family, gifconf_func_t *gifconf)
 39{
 40	if (family >= NPROTO)
 41		return -EINVAL;
 42	gifconf_list[family] = gifconf;
 43	return 0;
 44}
 45EXPORT_SYMBOL(register_gifconf);
 46
 47/*
 48 *	Perform a SIOCGIFCONF call. This structure will change
 49 *	size eventually, and there is nothing I can do about it.
 50 *	Thus we will need a 'compatibility mode'.
 51 */
 52
 53int dev_ifconf(struct net *net, struct ifconf *ifc, int size)
 54{
 
 55	struct net_device *dev;
 56	char __user *pos;
 57	int len;
 58	int total;
 59	int i;
 60
 61	/*
 62	 *	Fetch the caller's info block.
 63	 */
 64
 65	pos = ifc->ifc_buf;
 66	len = ifc->ifc_len;
 
 
 
 67
 68	/*
 69	 *	Loop over the interfaces, and write an info block for each.
 70	 */
 71
 72	total = 0;
 73	for_each_netdev(net, dev) {
 74		for (i = 0; i < NPROTO; i++) {
 75			if (gifconf_list[i]) {
 76				int done;
 77				if (!pos)
 78					done = gifconf_list[i](dev, NULL, 0, size);
 79				else
 80					done = gifconf_list[i](dev, pos + total,
 81							       len - total, size);
 82				if (done < 0)
 83					return -EFAULT;
 84				total += done;
 85			}
 86		}
 87	}
 88
 89	/*
 90	 *	All done.  Write the updated control block back to the caller.
 91	 */
 92	ifc->ifc_len = total;
 93
 94	/*
 95	 * 	Both BSD and Solaris return 0 here, so we do too.
 96	 */
 97	return 0;
 98}
 99
100/*
101 *	Perform the SIOCxIFxxx calls, inside rcu_read_lock()
102 */
103static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
104{
105	int err;
106	struct net_device *dev = dev_get_by_name_rcu(net, ifr->ifr_name);
107
108	if (!dev)
109		return -ENODEV;
110
111	switch (cmd) {
112	case SIOCGIFFLAGS:	/* Get interface flags */
113		ifr->ifr_flags = (short) dev_get_flags(dev);
114		return 0;
115
116	case SIOCGIFMETRIC:	/* Get the metric on the interface
117				   (currently unused) */
118		ifr->ifr_metric = 0;
119		return 0;
120
121	case SIOCGIFMTU:	/* Get the MTU of a device */
122		ifr->ifr_mtu = dev->mtu;
123		return 0;
124
125	case SIOCGIFHWADDR:
126		if (!dev->addr_len)
127			memset(ifr->ifr_hwaddr.sa_data, 0,
128			       sizeof(ifr->ifr_hwaddr.sa_data));
129		else
130			memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr,
131			       min(sizeof(ifr->ifr_hwaddr.sa_data),
132				   (size_t)dev->addr_len));
133		ifr->ifr_hwaddr.sa_family = dev->type;
134		return 0;
135
136	case SIOCGIFSLAVE:
137		err = -EINVAL;
138		break;
139
140	case SIOCGIFMAP:
141		ifr->ifr_map.mem_start = dev->mem_start;
142		ifr->ifr_map.mem_end   = dev->mem_end;
143		ifr->ifr_map.base_addr = dev->base_addr;
144		ifr->ifr_map.irq       = dev->irq;
145		ifr->ifr_map.dma       = dev->dma;
146		ifr->ifr_map.port      = dev->if_port;
147		return 0;
148
149	case SIOCGIFINDEX:
150		ifr->ifr_ifindex = dev->ifindex;
151		return 0;
152
153	case SIOCGIFTXQLEN:
154		ifr->ifr_qlen = dev->tx_queue_len;
155		return 0;
156
157	default:
158		/* dev_ioctl() should ensure this case
159		 * is never reached
160		 */
161		WARN_ON(1);
162		err = -ENOTTY;
163		break;
164
165	}
166	return err;
167}
168
169static int net_hwtstamp_validate(struct ifreq *ifr)
170{
171	struct hwtstamp_config cfg;
172	enum hwtstamp_tx_types tx_type;
173	enum hwtstamp_rx_filters rx_filter;
174	int tx_type_valid = 0;
175	int rx_filter_valid = 0;
176
177	if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
178		return -EFAULT;
179
180	if (cfg.flags) /* reserved for future extensions */
181		return -EINVAL;
182
183	tx_type = cfg.tx_type;
184	rx_filter = cfg.rx_filter;
185
186	switch (tx_type) {
187	case HWTSTAMP_TX_OFF:
188	case HWTSTAMP_TX_ON:
189	case HWTSTAMP_TX_ONESTEP_SYNC:
190		tx_type_valid = 1;
191		break;
192	}
193
194	switch (rx_filter) {
195	case HWTSTAMP_FILTER_NONE:
196	case HWTSTAMP_FILTER_ALL:
197	case HWTSTAMP_FILTER_SOME:
198	case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
199	case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
200	case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
201	case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
202	case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
203	case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
204	case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
205	case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
206	case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
207	case HWTSTAMP_FILTER_PTP_V2_EVENT:
208	case HWTSTAMP_FILTER_PTP_V2_SYNC:
209	case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
210	case HWTSTAMP_FILTER_NTP_ALL:
211		rx_filter_valid = 1;
212		break;
213	}
214
215	if (!tx_type_valid || !rx_filter_valid)
216		return -ERANGE;
217
218	return 0;
219}
220
221/*
222 *	Perform the SIOCxIFxxx calls, inside rtnl_lock()
223 */
224static int dev_ifsioc(struct net *net, struct ifreq *ifr, unsigned int cmd)
225{
226	int err;
227	struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
228	const struct net_device_ops *ops;
229
230	if (!dev)
231		return -ENODEV;
232
233	ops = dev->netdev_ops;
234
235	switch (cmd) {
236	case SIOCSIFFLAGS:	/* Set interface flags */
237		return dev_change_flags(dev, ifr->ifr_flags);
238
239	case SIOCSIFMETRIC:	/* Set the metric on the interface
240				   (currently unused) */
241		return -EOPNOTSUPP;
242
243	case SIOCSIFMTU:	/* Set the MTU of a device */
244		return dev_set_mtu(dev, ifr->ifr_mtu);
245
246	case SIOCSIFHWADDR:
247		if (dev->addr_len > sizeof(struct sockaddr))
248			return -EINVAL;
249		return dev_set_mac_address(dev, &ifr->ifr_hwaddr);
250
251	case SIOCSIFHWBROADCAST:
252		if (ifr->ifr_hwaddr.sa_family != dev->type)
253			return -EINVAL;
254		memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
255		       min(sizeof(ifr->ifr_hwaddr.sa_data),
256			   (size_t)dev->addr_len));
257		call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
258		return 0;
259
260	case SIOCSIFMAP:
261		if (ops->ndo_set_config) {
262			if (!netif_device_present(dev))
263				return -ENODEV;
264			return ops->ndo_set_config(dev, &ifr->ifr_map);
265		}
266		return -EOPNOTSUPP;
267
268	case SIOCADDMULTI:
269		if (!ops->ndo_set_rx_mode ||
270		    ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
271			return -EINVAL;
272		if (!netif_device_present(dev))
273			return -ENODEV;
274		return dev_mc_add_global(dev, ifr->ifr_hwaddr.sa_data);
275
276	case SIOCDELMULTI:
277		if (!ops->ndo_set_rx_mode ||
278		    ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
279			return -EINVAL;
280		if (!netif_device_present(dev))
281			return -ENODEV;
282		return dev_mc_del_global(dev, ifr->ifr_hwaddr.sa_data);
283
284	case SIOCSIFTXQLEN:
285		if (ifr->ifr_qlen < 0)
286			return -EINVAL;
287		if (dev->tx_queue_len ^ ifr->ifr_qlen) {
288			unsigned int orig_len = dev->tx_queue_len;
289
290			dev->tx_queue_len = ifr->ifr_qlen;
291			err = call_netdevice_notifiers(
292					NETDEV_CHANGE_TX_QUEUE_LEN, dev);
293			err = notifier_to_errno(err);
294			if (err) {
295				dev->tx_queue_len = orig_len;
296				return err;
297			}
298		}
299		return 0;
300
301	case SIOCSIFNAME:
302		ifr->ifr_newname[IFNAMSIZ-1] = '\0';
303		return dev_change_name(dev, ifr->ifr_newname);
304
305	case SIOCSHWTSTAMP:
306		err = net_hwtstamp_validate(ifr);
307		if (err)
308			return err;
309		/* fall through */
310
311	/*
312	 *	Unknown or private ioctl
313	 */
314	default:
315		if ((cmd >= SIOCDEVPRIVATE &&
316		    cmd <= SIOCDEVPRIVATE + 15) ||
317		    cmd == SIOCBONDENSLAVE ||
318		    cmd == SIOCBONDRELEASE ||
319		    cmd == SIOCBONDSETHWADDR ||
320		    cmd == SIOCBONDSLAVEINFOQUERY ||
321		    cmd == SIOCBONDINFOQUERY ||
322		    cmd == SIOCBONDCHANGEACTIVE ||
323		    cmd == SIOCGMIIPHY ||
324		    cmd == SIOCGMIIREG ||
325		    cmd == SIOCSMIIREG ||
326		    cmd == SIOCBRADDIF ||
327		    cmd == SIOCBRDELIF ||
328		    cmd == SIOCSHWTSTAMP ||
329		    cmd == SIOCGHWTSTAMP ||
330		    cmd == SIOCWANDEV) {
331			err = -EOPNOTSUPP;
332			if (ops->ndo_do_ioctl) {
333				if (netif_device_present(dev))
334					err = ops->ndo_do_ioctl(dev, ifr, cmd);
335				else
336					err = -ENODEV;
337			}
338		} else
339			err = -EINVAL;
340
341	}
342	return err;
343}
344
345/**
346 *	dev_load 	- load a network module
347 *	@net: the applicable net namespace
348 *	@name: name of interface
349 *
350 *	If a network interface is not present and the process has suitable
351 *	privileges this function loads the module. If module loading is not
352 *	available in this kernel then it becomes a nop.
353 */
354
355void dev_load(struct net *net, const char *name)
356{
357	struct net_device *dev;
358	int no_module;
359
360	rcu_read_lock();
361	dev = dev_get_by_name_rcu(net, name);
362	rcu_read_unlock();
363
364	no_module = !dev;
365	if (no_module && capable(CAP_NET_ADMIN))
366		no_module = request_module("netdev-%s", name);
367	if (no_module && capable(CAP_SYS_MODULE))
368		request_module("%s", name);
 
 
 
369}
370EXPORT_SYMBOL(dev_load);
371
372/*
373 *	This function handles all "interface"-type I/O control requests. The actual
374 *	'doing' part of this is dev_ifsioc above.
375 */
376
377/**
378 *	dev_ioctl	-	network device ioctl
379 *	@net: the applicable net namespace
380 *	@cmd: command to issue
381 *	@arg: pointer to a struct ifreq in user space
382 *
383 *	Issue ioctl functions to devices. This is normally called by the
384 *	user space syscall interfaces but can sometimes be useful for
385 *	other purposes. The return value is the return from the syscall if
386 *	positive or a negative errno code on error.
387 */
388
389int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr, bool *need_copyout)
390{
 
391	int ret;
392	char *colon;
393
394	if (need_copyout)
395		*need_copyout = true;
 
 
 
 
 
 
 
 
 
396	if (cmd == SIOCGIFNAME)
397		return dev_ifname(net, ifr);
 
 
 
398
399	ifr->ifr_name[IFNAMSIZ-1] = 0;
400
401	colon = strchr(ifr->ifr_name, ':');
402	if (colon)
403		*colon = 0;
404
405	/*
406	 *	See which interface the caller is talking about.
407	 */
408
409	switch (cmd) {
410	/*
411	 *	These ioctl calls:
412	 *	- can be done by all.
413	 *	- atomic and do not require locking.
414	 *	- return a value
415	 */
416	case SIOCGIFFLAGS:
417	case SIOCGIFMETRIC:
418	case SIOCGIFMTU:
419	case SIOCGIFHWADDR:
420	case SIOCGIFSLAVE:
421	case SIOCGIFMAP:
422	case SIOCGIFINDEX:
423	case SIOCGIFTXQLEN:
424		dev_load(net, ifr->ifr_name);
425		rcu_read_lock();
426		ret = dev_ifsioc_locked(net, ifr, cmd);
427		rcu_read_unlock();
428		if (colon)
429			*colon = ':';
 
 
 
 
 
430		return ret;
431
432	case SIOCETHTOOL:
433		dev_load(net, ifr->ifr_name);
434		rtnl_lock();
435		ret = dev_ethtool(net, ifr);
436		rtnl_unlock();
437		if (colon)
438			*colon = ':';
 
 
 
 
 
439		return ret;
440
441	/*
442	 *	These ioctl calls:
443	 *	- require superuser power.
444	 *	- require strict serialization.
445	 *	- return a value
446	 */
447	case SIOCGMIIPHY:
448	case SIOCGMIIREG:
449	case SIOCSIFNAME:
450		dev_load(net, ifr->ifr_name);
451		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
452			return -EPERM;
 
453		rtnl_lock();
454		ret = dev_ifsioc(net, ifr, cmd);
455		rtnl_unlock();
456		if (colon)
457			*colon = ':';
 
 
 
 
 
458		return ret;
459
460	/*
461	 *	These ioctl calls:
462	 *	- require superuser power.
463	 *	- require strict serialization.
464	 *	- do not return a value
465	 */
466	case SIOCSIFMAP:
467	case SIOCSIFTXQLEN:
468		if (!capable(CAP_NET_ADMIN))
469			return -EPERM;
470		/* fall through */
471	/*
472	 *	These ioctl calls:
473	 *	- require local superuser power.
474	 *	- require strict serialization.
475	 *	- do not return a value
476	 */
477	case SIOCSIFFLAGS:
478	case SIOCSIFMETRIC:
479	case SIOCSIFMTU:
480	case SIOCSIFHWADDR:
481	case SIOCSIFSLAVE:
482	case SIOCADDMULTI:
483	case SIOCDELMULTI:
484	case SIOCSIFHWBROADCAST:
485	case SIOCSMIIREG:
486	case SIOCBONDENSLAVE:
487	case SIOCBONDRELEASE:
488	case SIOCBONDSETHWADDR:
489	case SIOCBONDCHANGEACTIVE:
490	case SIOCBRADDIF:
491	case SIOCBRDELIF:
492	case SIOCSHWTSTAMP:
493		if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
494			return -EPERM;
495		/* fall through */
496	case SIOCBONDSLAVEINFOQUERY:
497	case SIOCBONDINFOQUERY:
498		dev_load(net, ifr->ifr_name);
499		rtnl_lock();
500		ret = dev_ifsioc(net, ifr, cmd);
501		rtnl_unlock();
502		if (need_copyout)
503			*need_copyout = false;
504		return ret;
505
506	case SIOCGIFMEM:
507		/* Get the per device memory space. We can add this but
508		 * currently do not support it */
509	case SIOCSIFMEM:
510		/* Set the per device memory buffer space.
511		 * Not applicable in our case */
512	case SIOCSIFLINK:
513		return -ENOTTY;
514
515	/*
516	 *	Unknown or private ioctl.
517	 */
518	default:
519		if (cmd == SIOCWANDEV ||
520		    cmd == SIOCGHWTSTAMP ||
521		    (cmd >= SIOCDEVPRIVATE &&
522		     cmd <= SIOCDEVPRIVATE + 15)) {
523			dev_load(net, ifr->ifr_name);
524			rtnl_lock();
525			ret = dev_ifsioc(net, ifr, cmd);
526			rtnl_unlock();
 
 
 
527			return ret;
528		}
 
 
 
529		return -ENOTTY;
530	}
531}