469 lines
15 KiB
C
Executable File
469 lines
15 KiB
C
Executable File
#ifndef LINUX_COMPATIBILITY_H
|
|
#define LINUX_COMPATIBILITY_H
|
|
|
|
/*
|
|
* Definition and macro
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
#include <linux/version.h>
|
|
#include <linux/in.h>
|
|
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 31)
|
|
#include <linux/mdio.h>
|
|
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 0)
|
|
#include <uapi/linux/mdio.h>
|
|
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0) */
|
|
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,31) */
|
|
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0)
|
|
#define NETIF_F_CSUM_MASK NETIF_F_ALL_CSUM
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)
|
|
#define skb_vlan_tag_present(__skb) vlan_tx_tag_present(__skb)
|
|
#define skb_vlan_tag_get(__skb) vlan_tx_tag_get(__skb)
|
|
#define skb_vlan_tag_get_id(__skb) vlan_tx_tag_get_id(__skb)
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 19, 0)
|
|
#define napi_alloc_skb(napi, length) netdev_alloc_skb_ip_align(netdev, length)
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 14, 0)
|
|
#define ether_addr_copy(dst, src) memcpy(dst, src, ETH_ALEN)
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 13, 0)
|
|
#define BIT(nr) (1UL << (nr))
|
|
#define BIT_ULL(nr) (1ULL << (nr))
|
|
#define BITS_PER_BYTE 8
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 10, 0)
|
|
#define NETIF_F_HW_VLAN_CTAG_RX NETIF_F_HW_VLAN_RX
|
|
#define NETIF_F_HW_VLAN_CTAG_TX NETIF_F_HW_VLAN_TX
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 8, 0)
|
|
#define USB_DEVICE_INTERFACE_CLASS(vend, prod, iclass) \
|
|
USB_DEVICE_AND_INTERFACE_INFO(vend, prod, iclass, 0xff, 0)
|
|
|
|
static inline __sum16 tcp_v6_check(int len,
|
|
const struct in6_addr *saddr,
|
|
const struct in6_addr *daddr,
|
|
__wsum base)
|
|
{
|
|
return csum_ipv6_magic(saddr, daddr, len, IPPROTO_TCP, base);
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 6, 0)
|
|
#define eth_random_addr(addr) random_ether_addr(addr)
|
|
#define MDIO_EEE_100TX MDIO_AN_EEE_ADV_100TX /* 100TX EEE cap */
|
|
#define MDIO_EEE_1000T MDIO_AN_EEE_ADV_1000T /* 1000T EEE cap */
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 4, 0)
|
|
#define ETH_MDIO_SUPPORTS_C22 MDIO_SUPPORTS_C22
|
|
|
|
static inline void eth_hw_addr_random(struct net_device *dev)
|
|
{
|
|
random_ether_addr(dev->dev_addr);
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 3, 0)
|
|
#define module_usb_driver(__driver) \
|
|
static int __init __driver##_init(void) \
|
|
{ \
|
|
return usb_register(&(__driver)); \
|
|
} \
|
|
module_init(__driver##_init); \
|
|
static void __exit __driver##_exit(void) \
|
|
{ \
|
|
usb_deregister(&(__driver)); \
|
|
} \
|
|
module_exit(__driver##_exit);
|
|
|
|
#define netdev_features_t u32
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 2, 0)
|
|
#define PMSG_IS_AUTO(msg) (((msg).event & PM_EVENT_AUTO) != 0)
|
|
|
|
static inline struct page *skb_frag_page(const skb_frag_t *frag)
|
|
{
|
|
return frag->page;
|
|
}
|
|
|
|
static inline void *skb_frag_address(const skb_frag_t *frag)
|
|
{
|
|
return page_address(skb_frag_page(frag)) + frag->page_offset;
|
|
}
|
|
|
|
static inline unsigned int skb_frag_size(const skb_frag_t *frag)
|
|
{
|
|
return frag->size;
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 1, 0)
|
|
#define ndo_set_rx_mode ndo_set_multicast_list
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 39)
|
|
#define NETIF_F_RXCSUM (1 << 29) /* Receive checksumming offload */
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 38)
|
|
#define MDIO_AN_EEE_ADV 60 /* EEE advertisement */
|
|
#define MDIO_AN_EEE_ADV_100TX 0x0002 /* Advertise 100TX EEE cap */
|
|
#define MDIO_AN_EEE_ADV_1000T 0x0004 /* Advertise 1000T EEE cap */
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 37)
|
|
#define skb_checksum_none_assert(skb_ptr) ((skb_ptr)->ip_summed = CHECKSUM_NONE)
|
|
|
|
static inline __be16 vlan_get_protocol(const struct sk_buff *skb)
|
|
{
|
|
__be16 protocol = 0;
|
|
|
|
if (vlan_tx_tag_present(skb) ||
|
|
skb->protocol != cpu_to_be16(ETH_P_8021Q))
|
|
protocol = skb->protocol;
|
|
else {
|
|
__be16 proto, *protop;
|
|
protop = skb_header_pointer(skb, offsetof(struct vlan_ethhdr,
|
|
h_vlan_encapsulated_proto), sizeof(proto), &proto);
|
|
if (likely(protop))
|
|
protocol = *protop;
|
|
}
|
|
return protocol;
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 36)
|
|
#define skb_tx_timestamp(skb)
|
|
|
|
#define queue_delayed_work(long_wq, work, delay) schedule_delayed_work(work, delay)
|
|
|
|
static inline void usleep_range(unsigned long min, unsigned long max)
|
|
{
|
|
unsigned long ms = min / 1000;
|
|
|
|
if (ms)
|
|
mdelay(ms);
|
|
|
|
udelay(min % 1000);
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
|
|
static inline bool pci_dev_run_wake(struct pci_dev *dev)
|
|
{
|
|
return 1;
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 34)
|
|
#define netdev_mc_count(netdev) ((netdev)->mc_count)
|
|
#define netdev_mc_empty(netdev) (netdev_mc_count(netdev) == 0)
|
|
|
|
#define netif_printk(priv, type, level, netdev, fmt, args...) \
|
|
do { \
|
|
if (netif_msg_##type(priv)) \
|
|
printk(level "%s: " fmt, (netdev)->name, ##args); \
|
|
} while (0)
|
|
|
|
#define netif_emerg(priv, type, netdev, fmt, args...) \
|
|
netif_printk(priv, type, KERN_EMERG, netdev, fmt, ##args)
|
|
#define netif_alert(priv, type, netdev, fmt, args...) \
|
|
netif_printk(priv, type, KERN_ALERT, netdev, fmt, ##args)
|
|
#define netif_crit(priv, type, netdev, fmt, args...) \
|
|
netif_printk(priv, type, KERN_CRIT, netdev, fmt, ##args)
|
|
#define netif_err(priv, type, netdev, fmt, args...) \
|
|
netif_printk(priv, type, KERN_ERR, netdev, fmt, ##args)
|
|
#define netif_warn(priv, type, netdev, fmt, args...) \
|
|
netif_printk(priv, type, KERN_WARNING, netdev, fmt, ##args)
|
|
#define netif_notice(priv, type, netdev, fmt, args...) \
|
|
netif_printk(priv, type, KERN_NOTICE, netdev, fmt, ##args)
|
|
#define netif_info(priv, type, netdev, fmt, args...) \
|
|
netif_printk(priv, type, KERN_INFO, (netdev), fmt, ##args)
|
|
|
|
static inline int usb_enable_autosuspend(struct usb_device *udev)
|
|
{ return 0; }
|
|
static inline int usb_disable_autosuspend(struct usb_device *udev)
|
|
{ return 0; }
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 33)
|
|
#define get_sset_count get_stats_count
|
|
|
|
static inline struct sk_buff *netdev_alloc_skb_ip_align(struct net_device *dev,
|
|
unsigned int length)
|
|
{
|
|
struct sk_buff *skb = netdev_alloc_skb(dev, length + NET_IP_ALIGN);
|
|
|
|
if (NET_IP_ALIGN && skb)
|
|
skb_reserve(skb, NET_IP_ALIGN);
|
|
return skb;
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 32)
|
|
#define pm_request_resume(para)
|
|
#define pm_runtime_set_suspended(para)
|
|
#define pm_schedule_suspend(para1, para2)
|
|
#define pm_runtime_get_sync(para)
|
|
#define pm_runtime_put_sync(para)
|
|
#define pm_runtime_put_noidle(para)
|
|
#define pm_runtime_idle(para)
|
|
#define pm_runtime_set_active(para)
|
|
#define pm_runtime_enable(para)
|
|
#define pm_runtime_disable(para)
|
|
typedef int netdev_tx_t;
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31)
|
|
#define USB_SPEED_SUPER (USB_SPEED_VARIABLE + 1)
|
|
#define MDIO_MMD_AN 7 /* Auto-Negotiation */
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 29)
|
|
#define napi_gro_receive(napi, skb) netif_receive_skb(skb)
|
|
#define vlan_gro_receive(napi, grp, vlan_tci, skb) \
|
|
vlan_hwaccel_receive_skb(skb, grp, vlan_tci)
|
|
|
|
static inline void usb_autopm_put_interface_async(struct usb_interface *intf)
|
|
{
|
|
struct usb_device *udev = interface_to_usbdev(intf);
|
|
int status = 0;
|
|
|
|
if (intf->condition == USB_INTERFACE_UNBOUND) {
|
|
status = -ENODEV;
|
|
} else {
|
|
udev->last_busy = jiffies;
|
|
--intf->pm_usage_cnt;
|
|
if (udev->autosuspend_disabled || udev->autosuspend_delay < 0)
|
|
status = -EPERM;
|
|
}
|
|
}
|
|
|
|
static inline int usb_autopm_get_interface_async(struct usb_interface *intf)
|
|
{
|
|
struct usb_device *udev = interface_to_usbdev(intf);
|
|
int status = 0;
|
|
|
|
if (intf->condition == USB_INTERFACE_UNBOUND)
|
|
status = -ENODEV;
|
|
else if (udev->autoresume_disabled)
|
|
status = -EPERM;
|
|
else
|
|
++intf->pm_usage_cnt;
|
|
return status;
|
|
}
|
|
|
|
static inline int eth_change_mtu(struct net_device *dev, int new_mtu)
|
|
{
|
|
if (new_mtu < 68 || new_mtu > ETH_DATA_LEN)
|
|
return -EINVAL;
|
|
dev->mtu = new_mtu;
|
|
return 0;
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 28)
|
|
static inline void __skb_queue_splice(const struct sk_buff_head *list,
|
|
struct sk_buff *prev,
|
|
struct sk_buff *next)
|
|
{
|
|
struct sk_buff *first = list->next;
|
|
struct sk_buff *last = list->prev;
|
|
|
|
first->prev = prev;
|
|
prev->next = first;
|
|
|
|
last->next = next;
|
|
next->prev = last;
|
|
}
|
|
|
|
static inline void skb_queue_splice(const struct sk_buff_head *list,
|
|
struct sk_buff_head *head)
|
|
{
|
|
if (!skb_queue_empty(list)) {
|
|
__skb_queue_splice(list, (struct sk_buff *) head, head->next);
|
|
head->qlen += list->qlen;
|
|
}
|
|
}
|
|
|
|
static inline void __skb_queue_head_init(struct sk_buff_head *list)
|
|
{
|
|
list->prev = list->next = (struct sk_buff *)list;
|
|
list->qlen = 0;
|
|
}
|
|
|
|
static inline void skb_queue_splice_init(struct sk_buff_head *list,
|
|
struct sk_buff_head *head)
|
|
{
|
|
if (!skb_queue_empty(list)) {
|
|
__skb_queue_splice(list, (struct sk_buff *) head, head->next);
|
|
head->qlen += list->qlen;
|
|
__skb_queue_head_init(list);
|
|
}
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
|
|
#define PM_EVENT_AUTO 0x0400
|
|
|
|
static inline void __list_splice2(const struct list_head *list,
|
|
struct list_head *prev,
|
|
struct list_head *next)
|
|
{
|
|
struct list_head *first = list->next;
|
|
struct list_head *last = list->prev;
|
|
|
|
first->prev = prev;
|
|
prev->next = first;
|
|
|
|
last->next = next;
|
|
next->prev = last;
|
|
}
|
|
|
|
static inline void list_splice_tail(struct list_head *list,
|
|
struct list_head *head)
|
|
{
|
|
if (!list_empty(list))
|
|
__list_splice2(list, head->prev, head);
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
|
|
struct napi_struct {
|
|
struct list_head poll_list;
|
|
unsigned long state;
|
|
int weight;
|
|
int (*poll)(struct napi_struct *, int);
|
|
#ifdef CONFIG_NETPOLL
|
|
spinlock_t poll_lock;
|
|
int poll_owner;
|
|
struct net_device *dev;
|
|
struct list_head dev_list;
|
|
#endif
|
|
};
|
|
|
|
#define napi_enable(napi_ptr) netif_poll_enable(container_of(napi_ptr, struct r8152, napi)->netdev)
|
|
#define napi_disable(napi_ptr) netif_poll_disable(container_of(napi_ptr, struct r8152, napi)->netdev)
|
|
#define napi_schedule(napi_ptr) netif_rx_schedule(container_of(napi_ptr, struct r8152, napi)->netdev)
|
|
#define napi_complete(napi_ptr) netif_rx_complete(container_of(napi_ptr, struct r8152, napi)->netdev)
|
|
#define netif_napi_add(ndev, napi_ptr, function, weight_t) \
|
|
ndev->poll = function; \
|
|
ndev->weight = weight_t;
|
|
typedef unsigned long uintptr_t;
|
|
#define DMA_BIT_MASK(value) \
|
|
(value < 64 ? ((1ULL << value) - 1) : 0xFFFFFFFFFFFFFFFFULL)
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 23)
|
|
#define NETIF_F_IPV6_CSUM 16
|
|
#define cancel_delayed_work_sync cancel_delayed_work
|
|
|
|
static inline int skb_cow_head(struct sk_buff *skb, unsigned int headroom)
|
|
{
|
|
int delta = 0;
|
|
|
|
if (headroom > skb_headroom(skb))
|
|
delta = headroom - skb_headroom(skb);
|
|
|
|
if (delta || skb_header_cloned(skb))
|
|
return pskb_expand_head(skb, ALIGN(delta, NET_SKB_PAD),
|
|
0, GFP_ATOMIC);
|
|
return 0;
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 22)
|
|
#define ip_hdr(skb_ptr) ((skb_ptr)->nh.iph)
|
|
#define ipv6hdr(skb_ptr) ((skb_ptr)->nh.ipv6h)
|
|
|
|
static inline void skb_copy_from_linear_data(const struct sk_buff *skb,
|
|
void *to,
|
|
const unsigned int len)
|
|
{
|
|
memcpy(to, skb->data, len);
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 21)
|
|
#define vlan_group_set_device(vlgrp, vid, value) \
|
|
do { if (vlgrp) \
|
|
(vlgrp)->vlan_devices[vid] = value; } while (0)
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 20)
|
|
#define delayed_work work_struct
|
|
#define INIT_DELAYED_WORK(a, b) INIT_WORK(a, b, tp)
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)
|
|
#define CHECKSUM_PARTIAL CHECKSUM_HW
|
|
|
|
static inline void *kmemdup(const void *src, size_t len, gfp_t gfp)
|
|
{
|
|
void *p;
|
|
|
|
p = kmalloc_track_caller(len, gfp);
|
|
if (p)
|
|
memcpy(p, src, len);
|
|
return p;
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 18)
|
|
#define skb_is_gso(skb_ptr) skb_shinfo(skb_ptr)->tso_size
|
|
#define netdev_alloc_skb(dev, len) dev_alloc_skb(len)
|
|
#define IRQF_SHARED SA_SHIRQ
|
|
|
|
static inline struct sk_buff *skb_gso_segment(struct sk_buff *skb, int features)
|
|
{
|
|
return NULL;
|
|
}
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 16)
|
|
#ifndef __LINUX_MUTEX_H
|
|
#define mutex semaphore
|
|
#define mutex_lock down
|
|
#define mutex_unlock up
|
|
#define mutex_trylock down_trylock
|
|
#define mutex_lock_interruptible down_interruptible
|
|
#define mutex_init init_MUTEX
|
|
#endif
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 14)
|
|
#define ADVERTISED_Pause (1 << 13)
|
|
#define ADVERTISED_Asym_Pause (1 << 14)
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 12)
|
|
#define skb_header_cloned(skb) skb_cloned(skb)
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24) */
|
|
static inline void netif_napi_del(struct napi_struct *napi)
|
|
{
|
|
#ifdef CONFIG_NETPOLL
|
|
list_del(&napi->dev_list);
|
|
#endif
|
|
}
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,27) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,28) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,31) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,32) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,3,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,4,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,6,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,8,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,13,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,14,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,19,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(4,0,0) */
|
|
#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(4,5,0) */
|
|
|
|
#ifndef FALSE
|
|
#define TRUE 1
|
|
#define FALSE 0
|
|
#endif
|
|
|
|
enum rtl_cmd {
|
|
RTLTOOL_PLA_OCP_READ_DWORD = 0,
|
|
RTLTOOL_PLA_OCP_WRITE_DWORD,
|
|
RTLTOOL_USB_OCP_READ_DWORD,
|
|
RTLTOOL_USB_OCP_WRITE_DWORD,
|
|
RTLTOOL_PLA_OCP_READ,
|
|
RTLTOOL_PLA_OCP_WRITE,
|
|
RTLTOOL_USB_OCP_READ,
|
|
RTLTOOL_USB_OCP_WRITE,
|
|
RTLTOOL_USB_INFO,
|
|
RTL_ENABLE_USB_DIAG,
|
|
RTL_DISABLE_USB_DIAG,
|
|
|
|
RTLTOOL_INVALID
|
|
};
|
|
|
|
struct usb_device_info {
|
|
__u16 idVendor;
|
|
__u16 idProduct;
|
|
__u16 bcdDevice;
|
|
__u8 dev_addr[8];
|
|
char devpath[16];
|
|
};
|
|
|
|
struct rtltool_cmd {
|
|
__u32 cmd;
|
|
__u32 offset;
|
|
__u32 byteen;
|
|
__u32 data;
|
|
void *buf;
|
|
struct usb_device_info nic_info;
|
|
struct sockaddr ifru_addr;
|
|
struct sockaddr ifru_netmask;
|
|
struct sockaddr ifru_hwaddr;
|
|
};
|
|
|
|
#endif /* LINUX_COMPATIBILITY_H */
|