Line data Source code
1 : /*
2 : * Netlink helper functions for driver wrappers
3 : * Copyright (c) 2002-2014, Jouni Malinen <j@w1.fi>
4 : *
5 : * This software may be distributed under the terms of the BSD license.
6 : * See README for more details.
7 : */
8 :
9 : #include "includes.h"
10 :
11 : #include "common.h"
12 : #include "eloop.h"
13 : #include "priv_netlink.h"
14 : #include "netlink.h"
15 :
16 :
17 : struct netlink_data {
18 : struct netlink_config *cfg;
19 : int sock;
20 : };
21 :
22 :
23 162519 : static void netlink_receive_link(struct netlink_data *netlink,
24 : void (*cb)(void *ctx, struct ifinfomsg *ifi,
25 : u8 *buf, size_t len),
26 : struct nlmsghdr *h)
27 : {
28 162519 : if (cb == NULL || NLMSG_PAYLOAD(h, 0) < sizeof(struct ifinfomsg))
29 162519 : return;
30 162519 : cb(netlink->cfg->ctx, NLMSG_DATA(h),
31 : (u8 *) NLMSG_DATA(h) + NLMSG_ALIGN(sizeof(struct ifinfomsg)),
32 162519 : NLMSG_PAYLOAD(h, sizeof(struct ifinfomsg)));
33 : }
34 :
35 :
36 120033 : static void netlink_receive(int sock, void *eloop_ctx, void *sock_ctx)
37 : {
38 120033 : struct netlink_data *netlink = eloop_ctx;
39 : char buf[8192];
40 : int left;
41 : struct sockaddr_nl from;
42 : socklen_t fromlen;
43 : struct nlmsghdr *h;
44 120033 : int max_events = 10;
45 :
46 : try_again:
47 282523 : fromlen = sizeof(from);
48 282523 : left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT,
49 : (struct sockaddr *) &from, &fromlen);
50 282523 : if (left < 0) {
51 119936 : if (errno != EINTR && errno != EAGAIN)
52 0 : wpa_printf(MSG_INFO, "netlink: recvfrom failed: %s",
53 0 : strerror(errno));
54 239969 : return;
55 : }
56 :
57 162587 : h = (struct nlmsghdr *) buf;
58 487761 : while (NLMSG_OK(h, left)) {
59 162587 : switch (h->nlmsg_type) {
60 : case RTM_NEWLINK:
61 160886 : netlink_receive_link(netlink, netlink->cfg->newlink_cb,
62 : h);
63 160886 : break;
64 : case RTM_DELLINK:
65 1633 : netlink_receive_link(netlink, netlink->cfg->dellink_cb,
66 : h);
67 1633 : break;
68 : }
69 :
70 162587 : h = NLMSG_NEXT(h, left);
71 : }
72 :
73 162587 : if (left > 0) {
74 0 : wpa_printf(MSG_DEBUG, "netlink: %d extra bytes in the end of "
75 : "netlink message", left);
76 : }
77 :
78 162587 : if (--max_events > 0) {
79 : /*
80 : * Try to receive all events in one eloop call in order to
81 : * limit race condition on cases where AssocInfo event, Assoc
82 : * event, and EAPOL frames are received more or less at the
83 : * same time. We want to process the event messages first
84 : * before starting EAPOL processing.
85 : */
86 162490 : goto try_again;
87 : }
88 : }
89 :
90 :
91 55 : struct netlink_data * netlink_init(struct netlink_config *cfg)
92 : {
93 : struct netlink_data *netlink;
94 : struct sockaddr_nl local;
95 :
96 55 : netlink = os_zalloc(sizeof(*netlink));
97 55 : if (netlink == NULL)
98 0 : return NULL;
99 :
100 55 : netlink->sock = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
101 55 : if (netlink->sock < 0) {
102 0 : wpa_printf(MSG_ERROR, "netlink: Failed to open netlink "
103 0 : "socket: %s", strerror(errno));
104 0 : netlink_deinit(netlink);
105 0 : return NULL;
106 : }
107 :
108 55 : os_memset(&local, 0, sizeof(local));
109 55 : local.nl_family = AF_NETLINK;
110 55 : local.nl_groups = RTMGRP_LINK;
111 55 : if (bind(netlink->sock, (struct sockaddr *) &local, sizeof(local)) < 0)
112 : {
113 0 : wpa_printf(MSG_ERROR, "netlink: Failed to bind netlink "
114 0 : "socket: %s", strerror(errno));
115 0 : netlink_deinit(netlink);
116 0 : return NULL;
117 : }
118 :
119 55 : eloop_register_read_sock(netlink->sock, netlink_receive, netlink,
120 : NULL);
121 :
122 55 : netlink->cfg = cfg;
123 :
124 55 : return netlink;
125 : }
126 :
127 :
128 55 : void netlink_deinit(struct netlink_data *netlink)
129 : {
130 55 : if (netlink == NULL)
131 55 : return;
132 55 : if (netlink->sock >= 0) {
133 55 : eloop_unregister_read_sock(netlink->sock);
134 55 : close(netlink->sock);
135 : }
136 55 : os_free(netlink->cfg);
137 55 : os_free(netlink);
138 : }
139 :
140 :
141 22971 : static const char * linkmode_str(int mode)
142 : {
143 22971 : switch (mode) {
144 : case -1:
145 20251 : return "no change";
146 : case 0:
147 2187 : return "kernel-control";
148 : case 1:
149 533 : return "userspace-control";
150 : }
151 0 : return "?";
152 : }
153 :
154 :
155 22971 : static const char * operstate_str(int state)
156 : {
157 22971 : switch (state) {
158 : case -1:
159 0 : return "no change";
160 : case IF_OPER_DORMANT:
161 15353 : return "IF_OPER_DORMANT";
162 : case IF_OPER_UP:
163 7618 : return "IF_OPER_UP";
164 : }
165 0 : return "?";
166 : }
167 :
168 :
169 22971 : int netlink_send_oper_ifla(struct netlink_data *netlink, int ifindex,
170 : int linkmode, int operstate)
171 : {
172 : struct {
173 : struct nlmsghdr hdr;
174 : struct ifinfomsg ifinfo;
175 : char opts[16];
176 : } req;
177 : struct rtattr *rta;
178 : static int nl_seq;
179 : ssize_t ret;
180 :
181 22971 : os_memset(&req, 0, sizeof(req));
182 :
183 22971 : req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg));
184 22971 : req.hdr.nlmsg_type = RTM_SETLINK;
185 22971 : req.hdr.nlmsg_flags = NLM_F_REQUEST;
186 22971 : req.hdr.nlmsg_seq = ++nl_seq;
187 22971 : req.hdr.nlmsg_pid = 0;
188 :
189 22971 : req.ifinfo.ifi_family = AF_UNSPEC;
190 22971 : req.ifinfo.ifi_type = 0;
191 22971 : req.ifinfo.ifi_index = ifindex;
192 22971 : req.ifinfo.ifi_flags = 0;
193 22971 : req.ifinfo.ifi_change = 0;
194 :
195 22971 : if (linkmode != -1) {
196 2720 : rta = aliasing_hide_typecast(
197 : ((char *) &req + NLMSG_ALIGN(req.hdr.nlmsg_len)),
198 : struct rtattr);
199 2720 : rta->rta_type = IFLA_LINKMODE;
200 2720 : rta->rta_len = RTA_LENGTH(sizeof(char));
201 2720 : *((char *) RTA_DATA(rta)) = linkmode;
202 2720 : req.hdr.nlmsg_len += RTA_SPACE(sizeof(char));
203 : }
204 22971 : if (operstate != -1) {
205 22971 : rta = aliasing_hide_typecast(
206 : ((char *) &req + NLMSG_ALIGN(req.hdr.nlmsg_len)),
207 : struct rtattr);
208 22971 : rta->rta_type = IFLA_OPERSTATE;
209 22971 : rta->rta_len = RTA_LENGTH(sizeof(char));
210 22971 : *((char *) RTA_DATA(rta)) = operstate;
211 22971 : req.hdr.nlmsg_len += RTA_SPACE(sizeof(char));
212 : }
213 :
214 22971 : wpa_printf(MSG_DEBUG, "netlink: Operstate: ifindex=%d linkmode=%d (%s), operstate=%d (%s)",
215 : ifindex, linkmode, linkmode_str(linkmode),
216 : operstate, operstate_str(operstate));
217 :
218 22971 : ret = send(netlink->sock, &req, req.hdr.nlmsg_len, 0);
219 22971 : if (ret < 0) {
220 0 : wpa_printf(MSG_DEBUG, "netlink: Sending operstate IFLA "
221 : "failed: %s (assume operstate is not supported)",
222 0 : strerror(errno));
223 : }
224 :
225 22971 : return ret < 0 ? -1 : 0;
226 : }
|
