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 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, see <http://www.gnu.org/licenses/>. 14 */ 15 16 #include "qemu/osdep.h" 17 18 #include <sys/signalfd.h> 19 #include <linux/unistd.h> 20 #include <linux/audit.h> 21 #ifdef CONFIG_INOTIFY 22 #include <sys/inotify.h> 23 #endif 24 #include <linux/netlink.h> 25 #ifdef CONFIG_RTNETLINK 26 #include <linux/rtnetlink.h> 27 #include <linux/if_bridge.h> 28 #endif 29 #include "qemu.h" 30 #include "fd-trans.h" 31 32 enum { 33 QEMU_IFLA_BR_UNSPEC, 34 QEMU_IFLA_BR_FORWARD_DELAY, 35 QEMU_IFLA_BR_HELLO_TIME, 36 QEMU_IFLA_BR_MAX_AGE, 37 QEMU_IFLA_BR_AGEING_TIME, 38 QEMU_IFLA_BR_STP_STATE, 39 QEMU_IFLA_BR_PRIORITY, 40 QEMU_IFLA_BR_VLAN_FILTERING, 41 QEMU_IFLA_BR_VLAN_PROTOCOL, 42 QEMU_IFLA_BR_GROUP_FWD_MASK, 43 QEMU_IFLA_BR_ROOT_ID, 44 QEMU_IFLA_BR_BRIDGE_ID, 45 QEMU_IFLA_BR_ROOT_PORT, 46 QEMU_IFLA_BR_ROOT_PATH_COST, 47 QEMU_IFLA_BR_TOPOLOGY_CHANGE, 48 QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED, 49 QEMU_IFLA_BR_HELLO_TIMER, 50 QEMU_IFLA_BR_TCN_TIMER, 51 QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER, 52 QEMU_IFLA_BR_GC_TIMER, 53 QEMU_IFLA_BR_GROUP_ADDR, 54 QEMU_IFLA_BR_FDB_FLUSH, 55 QEMU_IFLA_BR_MCAST_ROUTER, 56 QEMU_IFLA_BR_MCAST_SNOOPING, 57 QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR, 58 QEMU_IFLA_BR_MCAST_QUERIER, 59 QEMU_IFLA_BR_MCAST_HASH_ELASTICITY, 60 QEMU_IFLA_BR_MCAST_HASH_MAX, 61 QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT, 62 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT, 63 QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL, 64 QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL, 65 QEMU_IFLA_BR_MCAST_QUERIER_INTVL, 66 QEMU_IFLA_BR_MCAST_QUERY_INTVL, 67 QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL, 68 QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL, 69 QEMU_IFLA_BR_NF_CALL_IPTABLES, 70 QEMU_IFLA_BR_NF_CALL_IP6TABLES, 71 QEMU_IFLA_BR_NF_CALL_ARPTABLES, 72 QEMU_IFLA_BR_VLAN_DEFAULT_PVID, 73 QEMU_IFLA_BR_PAD, 74 QEMU_IFLA_BR_VLAN_STATS_ENABLED, 75 QEMU_IFLA_BR_MCAST_STATS_ENABLED, 76 QEMU_IFLA_BR_MCAST_IGMP_VERSION, 77 QEMU_IFLA_BR_MCAST_MLD_VERSION, 78 QEMU___IFLA_BR_MAX, 79 }; 80 81 enum { 82 QEMU_IFLA_UNSPEC, 83 QEMU_IFLA_ADDRESS, 84 QEMU_IFLA_BROADCAST, 85 QEMU_IFLA_IFNAME, 86 QEMU_IFLA_MTU, 87 QEMU_IFLA_LINK, 88 QEMU_IFLA_QDISC, 89 QEMU_IFLA_STATS, 90 QEMU_IFLA_COST, 91 QEMU_IFLA_PRIORITY, 92 QEMU_IFLA_MASTER, 93 QEMU_IFLA_WIRELESS, 94 QEMU_IFLA_PROTINFO, 95 QEMU_IFLA_TXQLEN, 96 QEMU_IFLA_MAP, 97 QEMU_IFLA_WEIGHT, 98 QEMU_IFLA_OPERSTATE, 99 QEMU_IFLA_LINKMODE, 100 QEMU_IFLA_LINKINFO, 101 QEMU_IFLA_NET_NS_PID, 102 QEMU_IFLA_IFALIAS, 103 QEMU_IFLA_NUM_VF, 104 QEMU_IFLA_VFINFO_LIST, 105 QEMU_IFLA_STATS64, 106 QEMU_IFLA_VF_PORTS, 107 QEMU_IFLA_PORT_SELF, 108 QEMU_IFLA_AF_SPEC, 109 QEMU_IFLA_GROUP, 110 QEMU_IFLA_NET_NS_FD, 111 QEMU_IFLA_EXT_MASK, 112 QEMU_IFLA_PROMISCUITY, 113 QEMU_IFLA_NUM_TX_QUEUES, 114 QEMU_IFLA_NUM_RX_QUEUES, 115 QEMU_IFLA_CARRIER, 116 QEMU_IFLA_PHYS_PORT_ID, 117 QEMU_IFLA_CARRIER_CHANGES, 118 QEMU_IFLA_PHYS_SWITCH_ID, 119 QEMU_IFLA_LINK_NETNSID, 120 QEMU_IFLA_PHYS_PORT_NAME, 121 QEMU_IFLA_PROTO_DOWN, 122 QEMU_IFLA_GSO_MAX_SEGS, 123 QEMU_IFLA_GSO_MAX_SIZE, 124 QEMU_IFLA_PAD, 125 QEMU_IFLA_XDP, 126 QEMU_IFLA_EVENT, 127 QEMU_IFLA_NEW_NETNSID, 128 QEMU_IFLA_IF_NETNSID, 129 QEMU_IFLA_CARRIER_UP_COUNT, 130 QEMU_IFLA_CARRIER_DOWN_COUNT, 131 QEMU_IFLA_NEW_IFINDEX, 132 QEMU___IFLA_MAX 133 }; 134 135 enum { 136 QEMU_IFLA_BRPORT_UNSPEC, 137 QEMU_IFLA_BRPORT_STATE, 138 QEMU_IFLA_BRPORT_PRIORITY, 139 QEMU_IFLA_BRPORT_COST, 140 QEMU_IFLA_BRPORT_MODE, 141 QEMU_IFLA_BRPORT_GUARD, 142 QEMU_IFLA_BRPORT_PROTECT, 143 QEMU_IFLA_BRPORT_FAST_LEAVE, 144 QEMU_IFLA_BRPORT_LEARNING, 145 QEMU_IFLA_BRPORT_UNICAST_FLOOD, 146 QEMU_IFLA_BRPORT_PROXYARP, 147 QEMU_IFLA_BRPORT_LEARNING_SYNC, 148 QEMU_IFLA_BRPORT_PROXYARP_WIFI, 149 QEMU_IFLA_BRPORT_ROOT_ID, 150 QEMU_IFLA_BRPORT_BRIDGE_ID, 151 QEMU_IFLA_BRPORT_DESIGNATED_PORT, 152 QEMU_IFLA_BRPORT_DESIGNATED_COST, 153 QEMU_IFLA_BRPORT_ID, 154 QEMU_IFLA_BRPORT_NO, 155 QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK, 156 QEMU_IFLA_BRPORT_CONFIG_PENDING, 157 QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER, 158 QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER, 159 QEMU_IFLA_BRPORT_HOLD_TIMER, 160 QEMU_IFLA_BRPORT_FLUSH, 161 QEMU_IFLA_BRPORT_MULTICAST_ROUTER, 162 QEMU_IFLA_BRPORT_PAD, 163 QEMU_IFLA_BRPORT_MCAST_FLOOD, 164 QEMU_IFLA_BRPORT_MCAST_TO_UCAST, 165 QEMU_IFLA_BRPORT_VLAN_TUNNEL, 166 QEMU_IFLA_BRPORT_BCAST_FLOOD, 167 QEMU_IFLA_BRPORT_GROUP_FWD_MASK, 168 QEMU_IFLA_BRPORT_NEIGH_SUPPRESS, 169 QEMU___IFLA_BRPORT_MAX 170 }; 171 172 enum { 173 QEMU_IFLA_TUN_UNSPEC, 174 QEMU_IFLA_TUN_OWNER, 175 QEMU_IFLA_TUN_GROUP, 176 QEMU_IFLA_TUN_TYPE, 177 QEMU_IFLA_TUN_PI, 178 QEMU_IFLA_TUN_VNET_HDR, 179 QEMU_IFLA_TUN_PERSIST, 180 QEMU_IFLA_TUN_MULTI_QUEUE, 181 QEMU_IFLA_TUN_NUM_QUEUES, 182 QEMU_IFLA_TUN_NUM_DISABLED_QUEUES, 183 QEMU___IFLA_TUN_MAX, 184 }; 185 186 enum { 187 QEMU_IFLA_INFO_UNSPEC, 188 QEMU_IFLA_INFO_KIND, 189 QEMU_IFLA_INFO_DATA, 190 QEMU_IFLA_INFO_XSTATS, 191 QEMU_IFLA_INFO_SLAVE_KIND, 192 QEMU_IFLA_INFO_SLAVE_DATA, 193 QEMU___IFLA_INFO_MAX, 194 }; 195 196 enum { 197 QEMU_IFLA_INET_UNSPEC, 198 QEMU_IFLA_INET_CONF, 199 QEMU___IFLA_INET_MAX, 200 }; 201 202 enum { 203 QEMU_IFLA_INET6_UNSPEC, 204 QEMU_IFLA_INET6_FLAGS, 205 QEMU_IFLA_INET6_CONF, 206 QEMU_IFLA_INET6_STATS, 207 QEMU_IFLA_INET6_MCAST, 208 QEMU_IFLA_INET6_CACHEINFO, 209 QEMU_IFLA_INET6_ICMP6STATS, 210 QEMU_IFLA_INET6_TOKEN, 211 QEMU_IFLA_INET6_ADDR_GEN_MODE, 212 QEMU___IFLA_INET6_MAX 213 }; 214 215 enum { 216 QEMU_IFLA_XDP_UNSPEC, 217 QEMU_IFLA_XDP_FD, 218 QEMU_IFLA_XDP_ATTACHED, 219 QEMU_IFLA_XDP_FLAGS, 220 QEMU_IFLA_XDP_PROG_ID, 221 QEMU___IFLA_XDP_MAX, 222 }; 223 224 enum { 225 QEMU_RTA_UNSPEC, 226 QEMU_RTA_DST, 227 QEMU_RTA_SRC, 228 QEMU_RTA_IIF, 229 QEMU_RTA_OIF, 230 QEMU_RTA_GATEWAY, 231 QEMU_RTA_PRIORITY, 232 QEMU_RTA_PREFSRC, 233 QEMU_RTA_METRICS, 234 QEMU_RTA_MULTIPATH, 235 QEMU_RTA_PROTOINFO, /* no longer used */ 236 QEMU_RTA_FLOW, 237 QEMU_RTA_CACHEINFO, 238 QEMU_RTA_SESSION, /* no longer used */ 239 QEMU_RTA_MP_ALGO, /* no longer used */ 240 QEMU_RTA_TABLE, 241 QEMU_RTA_MARK, 242 QEMU_RTA_MFC_STATS, 243 QEMU_RTA_VIA, 244 QEMU_RTA_NEWDST, 245 QEMU_RTA_PREF, 246 QEMU_RTA_ENCAP_TYPE, 247 QEMU_RTA_ENCAP, 248 QEMU_RTA_EXPIRES, 249 QEMU_RTA_PAD, 250 QEMU_RTA_UID, 251 QEMU_RTA_TTL_PROPAGATE, 252 QEMU_RTA_IP_PROTO, 253 QEMU_RTA_SPORT, 254 QEMU_RTA_DPORT, 255 QEMU___RTA_MAX 256 }; 257 258 TargetFdTrans **target_fd_trans; 259 unsigned int target_fd_max; 260 261 static void tswap_nlmsghdr(struct nlmsghdr *nlh) 262 { 263 nlh->nlmsg_len = tswap32(nlh->nlmsg_len); 264 nlh->nlmsg_type = tswap16(nlh->nlmsg_type); 265 nlh->nlmsg_flags = tswap16(nlh->nlmsg_flags); 266 nlh->nlmsg_seq = tswap32(nlh->nlmsg_seq); 267 nlh->nlmsg_pid = tswap32(nlh->nlmsg_pid); 268 } 269 270 static abi_long host_to_target_for_each_nlmsg(struct nlmsghdr *nlh, 271 size_t len, 272 abi_long (*host_to_target_nlmsg) 273 (struct nlmsghdr *)) 274 { 275 uint32_t nlmsg_len; 276 abi_long ret; 277 278 while (len > sizeof(struct nlmsghdr)) { 279 280 nlmsg_len = nlh->nlmsg_len; 281 if (nlmsg_len < sizeof(struct nlmsghdr) || 282 nlmsg_len > len) { 283 break; 284 } 285 286 switch (nlh->nlmsg_type) { 287 case NLMSG_DONE: 288 tswap_nlmsghdr(nlh); 289 return 0; 290 case NLMSG_NOOP: 291 break; 292 case NLMSG_ERROR: 293 { 294 struct nlmsgerr *e = NLMSG_DATA(nlh); 295 e->error = tswap32(e->error); 296 tswap_nlmsghdr(&e->msg); 297 tswap_nlmsghdr(nlh); 298 return 0; 299 } 300 default: 301 ret = host_to_target_nlmsg(nlh); 302 if (ret < 0) { 303 tswap_nlmsghdr(nlh); 304 return ret; 305 } 306 break; 307 } 308 tswap_nlmsghdr(nlh); 309 len -= NLMSG_ALIGN(nlmsg_len); 310 nlh = (struct nlmsghdr *)(((char*)nlh) + NLMSG_ALIGN(nlmsg_len)); 311 } 312 return 0; 313 } 314 315 static abi_long target_to_host_for_each_nlmsg(struct nlmsghdr *nlh, 316 size_t len, 317 abi_long (*target_to_host_nlmsg) 318 (struct nlmsghdr *)) 319 { 320 int ret; 321 322 while (len > sizeof(struct nlmsghdr)) { 323 if (tswap32(nlh->nlmsg_len) < sizeof(struct nlmsghdr) || 324 tswap32(nlh->nlmsg_len) > len) { 325 break; 326 } 327 tswap_nlmsghdr(nlh); 328 switch (nlh->nlmsg_type) { 329 case NLMSG_DONE: 330 return 0; 331 case NLMSG_NOOP: 332 break; 333 case NLMSG_ERROR: 334 { 335 struct nlmsgerr *e = NLMSG_DATA(nlh); 336 e->error = tswap32(e->error); 337 tswap_nlmsghdr(&e->msg); 338 return 0; 339 } 340 default: 341 ret = target_to_host_nlmsg(nlh); 342 if (ret < 0) { 343 return ret; 344 } 345 } 346 len -= NLMSG_ALIGN(nlh->nlmsg_len); 347 nlh = (struct nlmsghdr *)(((char *)nlh) + NLMSG_ALIGN(nlh->nlmsg_len)); 348 } 349 return 0; 350 } 351 352 #ifdef CONFIG_RTNETLINK 353 static abi_long host_to_target_for_each_nlattr(struct nlattr *nlattr, 354 size_t len, void *context, 355 abi_long (*host_to_target_nlattr) 356 (struct nlattr *, 357 void *context)) 358 { 359 unsigned short nla_len; 360 abi_long ret; 361 362 while (len > sizeof(struct nlattr)) { 363 nla_len = nlattr->nla_len; 364 if (nla_len < sizeof(struct nlattr) || 365 nla_len > len) { 366 break; 367 } 368 ret = host_to_target_nlattr(nlattr, context); 369 nlattr->nla_len = tswap16(nlattr->nla_len); 370 nlattr->nla_type = tswap16(nlattr->nla_type); 371 if (ret < 0) { 372 return ret; 373 } 374 len -= NLA_ALIGN(nla_len); 375 nlattr = (struct nlattr *)(((char *)nlattr) + NLA_ALIGN(nla_len)); 376 } 377 return 0; 378 } 379 380 static abi_long host_to_target_for_each_rtattr(struct rtattr *rtattr, 381 size_t len, 382 abi_long (*host_to_target_rtattr) 383 (struct rtattr *)) 384 { 385 unsigned short rta_len; 386 abi_long ret; 387 388 while (len > sizeof(struct rtattr)) { 389 rta_len = rtattr->rta_len; 390 if (rta_len < sizeof(struct rtattr) || 391 rta_len > len) { 392 break; 393 } 394 ret = host_to_target_rtattr(rtattr); 395 rtattr->rta_len = tswap16(rtattr->rta_len); 396 rtattr->rta_type = tswap16(rtattr->rta_type); 397 if (ret < 0) { 398 return ret; 399 } 400 len -= RTA_ALIGN(rta_len); 401 rtattr = (struct rtattr *)(((char *)rtattr) + RTA_ALIGN(rta_len)); 402 } 403 return 0; 404 } 405 406 #define NLA_DATA(nla) ((void *)((char *)(nla)) + NLA_HDRLEN) 407 408 static abi_long host_to_target_data_bridge_nlattr(struct nlattr *nlattr, 409 void *context) 410 { 411 uint16_t *u16; 412 uint32_t *u32; 413 uint64_t *u64; 414 415 switch (nlattr->nla_type) { 416 /* no data */ 417 case QEMU_IFLA_BR_FDB_FLUSH: 418 break; 419 /* binary */ 420 case QEMU_IFLA_BR_GROUP_ADDR: 421 break; 422 /* uint8_t */ 423 case QEMU_IFLA_BR_VLAN_FILTERING: 424 case QEMU_IFLA_BR_TOPOLOGY_CHANGE: 425 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_DETECTED: 426 case QEMU_IFLA_BR_MCAST_ROUTER: 427 case QEMU_IFLA_BR_MCAST_SNOOPING: 428 case QEMU_IFLA_BR_MCAST_QUERY_USE_IFADDR: 429 case QEMU_IFLA_BR_MCAST_QUERIER: 430 case QEMU_IFLA_BR_NF_CALL_IPTABLES: 431 case QEMU_IFLA_BR_NF_CALL_IP6TABLES: 432 case QEMU_IFLA_BR_NF_CALL_ARPTABLES: 433 case QEMU_IFLA_BR_VLAN_STATS_ENABLED: 434 case QEMU_IFLA_BR_MCAST_STATS_ENABLED: 435 case QEMU_IFLA_BR_MCAST_IGMP_VERSION: 436 case QEMU_IFLA_BR_MCAST_MLD_VERSION: 437 break; 438 /* uint16_t */ 439 case QEMU_IFLA_BR_PRIORITY: 440 case QEMU_IFLA_BR_VLAN_PROTOCOL: 441 case QEMU_IFLA_BR_GROUP_FWD_MASK: 442 case QEMU_IFLA_BR_ROOT_PORT: 443 case QEMU_IFLA_BR_VLAN_DEFAULT_PVID: 444 u16 = NLA_DATA(nlattr); 445 *u16 = tswap16(*u16); 446 break; 447 /* uint32_t */ 448 case QEMU_IFLA_BR_FORWARD_DELAY: 449 case QEMU_IFLA_BR_HELLO_TIME: 450 case QEMU_IFLA_BR_MAX_AGE: 451 case QEMU_IFLA_BR_AGEING_TIME: 452 case QEMU_IFLA_BR_STP_STATE: 453 case QEMU_IFLA_BR_ROOT_PATH_COST: 454 case QEMU_IFLA_BR_MCAST_HASH_ELASTICITY: 455 case QEMU_IFLA_BR_MCAST_HASH_MAX: 456 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_CNT: 457 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_CNT: 458 u32 = NLA_DATA(nlattr); 459 *u32 = tswap32(*u32); 460 break; 461 /* uint64_t */ 462 case QEMU_IFLA_BR_HELLO_TIMER: 463 case QEMU_IFLA_BR_TCN_TIMER: 464 case QEMU_IFLA_BR_GC_TIMER: 465 case QEMU_IFLA_BR_TOPOLOGY_CHANGE_TIMER: 466 case QEMU_IFLA_BR_MCAST_LAST_MEMBER_INTVL: 467 case QEMU_IFLA_BR_MCAST_MEMBERSHIP_INTVL: 468 case QEMU_IFLA_BR_MCAST_QUERIER_INTVL: 469 case QEMU_IFLA_BR_MCAST_QUERY_INTVL: 470 case QEMU_IFLA_BR_MCAST_QUERY_RESPONSE_INTVL: 471 case QEMU_IFLA_BR_MCAST_STARTUP_QUERY_INTVL: 472 u64 = NLA_DATA(nlattr); 473 *u64 = tswap64(*u64); 474 break; 475 /* ifla_bridge_id: uin8_t[] */ 476 case QEMU_IFLA_BR_ROOT_ID: 477 case QEMU_IFLA_BR_BRIDGE_ID: 478 break; 479 default: 480 gemu_log("Unknown QEMU_IFLA_BR type %d\n", nlattr->nla_type); 481 break; 482 } 483 return 0; 484 } 485 486 static abi_long host_to_target_slave_data_bridge_nlattr(struct nlattr *nlattr, 487 void *context) 488 { 489 uint16_t *u16; 490 uint32_t *u32; 491 uint64_t *u64; 492 493 switch (nlattr->nla_type) { 494 /* uint8_t */ 495 case QEMU_IFLA_BRPORT_STATE: 496 case QEMU_IFLA_BRPORT_MODE: 497 case QEMU_IFLA_BRPORT_GUARD: 498 case QEMU_IFLA_BRPORT_PROTECT: 499 case QEMU_IFLA_BRPORT_FAST_LEAVE: 500 case QEMU_IFLA_BRPORT_LEARNING: 501 case QEMU_IFLA_BRPORT_UNICAST_FLOOD: 502 case QEMU_IFLA_BRPORT_PROXYARP: 503 case QEMU_IFLA_BRPORT_LEARNING_SYNC: 504 case QEMU_IFLA_BRPORT_PROXYARP_WIFI: 505 case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK: 506 case QEMU_IFLA_BRPORT_CONFIG_PENDING: 507 case QEMU_IFLA_BRPORT_MULTICAST_ROUTER: 508 case QEMU_IFLA_BRPORT_MCAST_FLOOD: 509 case QEMU_IFLA_BRPORT_MCAST_TO_UCAST: 510 case QEMU_IFLA_BRPORT_VLAN_TUNNEL: 511 case QEMU_IFLA_BRPORT_BCAST_FLOOD: 512 case QEMU_IFLA_BRPORT_NEIGH_SUPPRESS: 513 break; 514 /* uint16_t */ 515 case QEMU_IFLA_BRPORT_PRIORITY: 516 case QEMU_IFLA_BRPORT_DESIGNATED_PORT: 517 case QEMU_IFLA_BRPORT_DESIGNATED_COST: 518 case QEMU_IFLA_BRPORT_ID: 519 case QEMU_IFLA_BRPORT_NO: 520 case QEMU_IFLA_BRPORT_GROUP_FWD_MASK: 521 u16 = NLA_DATA(nlattr); 522 *u16 = tswap16(*u16); 523 break; 524 /* uin32_t */ 525 case QEMU_IFLA_BRPORT_COST: 526 u32 = NLA_DATA(nlattr); 527 *u32 = tswap32(*u32); 528 break; 529 /* uint64_t */ 530 case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER: 531 case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER: 532 case QEMU_IFLA_BRPORT_HOLD_TIMER: 533 u64 = NLA_DATA(nlattr); 534 *u64 = tswap64(*u64); 535 break; 536 /* ifla_bridge_id: uint8_t[] */ 537 case QEMU_IFLA_BRPORT_ROOT_ID: 538 case QEMU_IFLA_BRPORT_BRIDGE_ID: 539 break; 540 default: 541 gemu_log("Unknown QEMU_IFLA_BRPORT type %d\n", nlattr->nla_type); 542 break; 543 } 544 return 0; 545 } 546 547 static abi_long host_to_target_data_tun_nlattr(struct nlattr *nlattr, 548 void *context) 549 { 550 uint32_t *u32; 551 552 switch (nlattr->nla_type) { 553 /* uint8_t */ 554 case QEMU_IFLA_TUN_TYPE: 555 case QEMU_IFLA_TUN_PI: 556 case QEMU_IFLA_TUN_VNET_HDR: 557 case QEMU_IFLA_TUN_PERSIST: 558 case QEMU_IFLA_TUN_MULTI_QUEUE: 559 break; 560 /* uint32_t */ 561 case QEMU_IFLA_TUN_NUM_QUEUES: 562 case QEMU_IFLA_TUN_NUM_DISABLED_QUEUES: 563 case QEMU_IFLA_TUN_OWNER: 564 case QEMU_IFLA_TUN_GROUP: 565 u32 = NLA_DATA(nlattr); 566 *u32 = tswap32(*u32); 567 break; 568 default: 569 gemu_log("Unknown QEMU_IFLA_TUN type %d\n", nlattr->nla_type); 570 break; 571 } 572 return 0; 573 } 574 575 struct linkinfo_context { 576 int len; 577 char *name; 578 int slave_len; 579 char *slave_name; 580 }; 581 582 static abi_long host_to_target_data_linkinfo_nlattr(struct nlattr *nlattr, 583 void *context) 584 { 585 struct linkinfo_context *li_context = context; 586 587 switch (nlattr->nla_type) { 588 /* string */ 589 case QEMU_IFLA_INFO_KIND: 590 li_context->name = NLA_DATA(nlattr); 591 li_context->len = nlattr->nla_len - NLA_HDRLEN; 592 break; 593 case QEMU_IFLA_INFO_SLAVE_KIND: 594 li_context->slave_name = NLA_DATA(nlattr); 595 li_context->slave_len = nlattr->nla_len - NLA_HDRLEN; 596 break; 597 /* stats */ 598 case QEMU_IFLA_INFO_XSTATS: 599 /* FIXME: only used by CAN */ 600 break; 601 /* nested */ 602 case QEMU_IFLA_INFO_DATA: 603 if (strncmp(li_context->name, "bridge", 604 li_context->len) == 0) { 605 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), 606 nlattr->nla_len, 607 NULL, 608 host_to_target_data_bridge_nlattr); 609 } else if (strncmp(li_context->name, "tun", 610 li_context->len) == 0) { 611 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), 612 nlattr->nla_len, 613 NULL, 614 host_to_target_data_tun_nlattr); 615 } else { 616 gemu_log("Unknown QEMU_IFLA_INFO_KIND %s\n", li_context->name); 617 } 618 break; 619 case QEMU_IFLA_INFO_SLAVE_DATA: 620 if (strncmp(li_context->slave_name, "bridge", 621 li_context->slave_len) == 0) { 622 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), 623 nlattr->nla_len, 624 NULL, 625 host_to_target_slave_data_bridge_nlattr); 626 } else { 627 gemu_log("Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n", 628 li_context->slave_name); 629 } 630 break; 631 default: 632 gemu_log("Unknown host QEMU_IFLA_INFO type: %d\n", nlattr->nla_type); 633 break; 634 } 635 636 return 0; 637 } 638 639 static abi_long host_to_target_data_inet_nlattr(struct nlattr *nlattr, 640 void *context) 641 { 642 uint32_t *u32; 643 int i; 644 645 switch (nlattr->nla_type) { 646 case QEMU_IFLA_INET_CONF: 647 u32 = NLA_DATA(nlattr); 648 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32); 649 i++) { 650 u32[i] = tswap32(u32[i]); 651 } 652 break; 653 default: 654 gemu_log("Unknown host AF_INET type: %d\n", nlattr->nla_type); 655 } 656 return 0; 657 } 658 659 static abi_long host_to_target_data_inet6_nlattr(struct nlattr *nlattr, 660 void *context) 661 { 662 uint32_t *u32; 663 uint64_t *u64; 664 struct ifla_cacheinfo *ci; 665 int i; 666 667 switch (nlattr->nla_type) { 668 /* binaries */ 669 case QEMU_IFLA_INET6_TOKEN: 670 break; 671 /* uint8_t */ 672 case QEMU_IFLA_INET6_ADDR_GEN_MODE: 673 break; 674 /* uint32_t */ 675 case QEMU_IFLA_INET6_FLAGS: 676 u32 = NLA_DATA(nlattr); 677 *u32 = tswap32(*u32); 678 break; 679 /* uint32_t[] */ 680 case QEMU_IFLA_INET6_CONF: 681 u32 = NLA_DATA(nlattr); 682 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32); 683 i++) { 684 u32[i] = tswap32(u32[i]); 685 } 686 break; 687 /* ifla_cacheinfo */ 688 case QEMU_IFLA_INET6_CACHEINFO: 689 ci = NLA_DATA(nlattr); 690 ci->max_reasm_len = tswap32(ci->max_reasm_len); 691 ci->tstamp = tswap32(ci->tstamp); 692 ci->reachable_time = tswap32(ci->reachable_time); 693 ci->retrans_time = tswap32(ci->retrans_time); 694 break; 695 /* uint64_t[] */ 696 case QEMU_IFLA_INET6_STATS: 697 case QEMU_IFLA_INET6_ICMP6STATS: 698 u64 = NLA_DATA(nlattr); 699 for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u64); 700 i++) { 701 u64[i] = tswap64(u64[i]); 702 } 703 break; 704 default: 705 gemu_log("Unknown host AF_INET6 type: %d\n", nlattr->nla_type); 706 } 707 return 0; 708 } 709 710 static abi_long host_to_target_data_spec_nlattr(struct nlattr *nlattr, 711 void *context) 712 { 713 switch (nlattr->nla_type) { 714 case AF_INET: 715 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len, 716 NULL, 717 host_to_target_data_inet_nlattr); 718 case AF_INET6: 719 return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len, 720 NULL, 721 host_to_target_data_inet6_nlattr); 722 default: 723 gemu_log("Unknown host AF_SPEC type: %d\n", nlattr->nla_type); 724 break; 725 } 726 return 0; 727 } 728 729 static abi_long host_to_target_data_xdp_nlattr(struct nlattr *nlattr, 730 void *context) 731 { 732 uint32_t *u32; 733 734 switch (nlattr->nla_type) { 735 /* uint8_t */ 736 case QEMU_IFLA_XDP_ATTACHED: 737 break; 738 /* uint32_t */ 739 case QEMU_IFLA_XDP_PROG_ID: 740 u32 = NLA_DATA(nlattr); 741 *u32 = tswap32(*u32); 742 break; 743 default: 744 gemu_log("Unknown host XDP type: %d\n", nlattr->nla_type); 745 break; 746 } 747 return 0; 748 } 749 750 static abi_long host_to_target_data_link_rtattr(struct rtattr *rtattr) 751 { 752 uint32_t *u32; 753 struct rtnl_link_stats *st; 754 struct rtnl_link_stats64 *st64; 755 struct rtnl_link_ifmap *map; 756 struct linkinfo_context li_context; 757 758 switch (rtattr->rta_type) { 759 /* binary stream */ 760 case QEMU_IFLA_ADDRESS: 761 case QEMU_IFLA_BROADCAST: 762 /* string */ 763 case QEMU_IFLA_IFNAME: 764 case QEMU_IFLA_QDISC: 765 break; 766 /* uin8_t */ 767 case QEMU_IFLA_OPERSTATE: 768 case QEMU_IFLA_LINKMODE: 769 case QEMU_IFLA_CARRIER: 770 case QEMU_IFLA_PROTO_DOWN: 771 break; 772 /* uint32_t */ 773 case QEMU_IFLA_MTU: 774 case QEMU_IFLA_LINK: 775 case QEMU_IFLA_WEIGHT: 776 case QEMU_IFLA_TXQLEN: 777 case QEMU_IFLA_CARRIER_CHANGES: 778 case QEMU_IFLA_NUM_RX_QUEUES: 779 case QEMU_IFLA_NUM_TX_QUEUES: 780 case QEMU_IFLA_PROMISCUITY: 781 case QEMU_IFLA_EXT_MASK: 782 case QEMU_IFLA_LINK_NETNSID: 783 case QEMU_IFLA_GROUP: 784 case QEMU_IFLA_MASTER: 785 case QEMU_IFLA_NUM_VF: 786 case QEMU_IFLA_GSO_MAX_SEGS: 787 case QEMU_IFLA_GSO_MAX_SIZE: 788 case QEMU_IFLA_CARRIER_UP_COUNT: 789 case QEMU_IFLA_CARRIER_DOWN_COUNT: 790 u32 = RTA_DATA(rtattr); 791 *u32 = tswap32(*u32); 792 break; 793 /* struct rtnl_link_stats */ 794 case QEMU_IFLA_STATS: 795 st = RTA_DATA(rtattr); 796 st->rx_packets = tswap32(st->rx_packets); 797 st->tx_packets = tswap32(st->tx_packets); 798 st->rx_bytes = tswap32(st->rx_bytes); 799 st->tx_bytes = tswap32(st->tx_bytes); 800 st->rx_errors = tswap32(st->rx_errors); 801 st->tx_errors = tswap32(st->tx_errors); 802 st->rx_dropped = tswap32(st->rx_dropped); 803 st->tx_dropped = tswap32(st->tx_dropped); 804 st->multicast = tswap32(st->multicast); 805 st->collisions = tswap32(st->collisions); 806 807 /* detailed rx_errors: */ 808 st->rx_length_errors = tswap32(st->rx_length_errors); 809 st->rx_over_errors = tswap32(st->rx_over_errors); 810 st->rx_crc_errors = tswap32(st->rx_crc_errors); 811 st->rx_frame_errors = tswap32(st->rx_frame_errors); 812 st->rx_fifo_errors = tswap32(st->rx_fifo_errors); 813 st->rx_missed_errors = tswap32(st->rx_missed_errors); 814 815 /* detailed tx_errors */ 816 st->tx_aborted_errors = tswap32(st->tx_aborted_errors); 817 st->tx_carrier_errors = tswap32(st->tx_carrier_errors); 818 st->tx_fifo_errors = tswap32(st->tx_fifo_errors); 819 st->tx_heartbeat_errors = tswap32(st->tx_heartbeat_errors); 820 st->tx_window_errors = tswap32(st->tx_window_errors); 821 822 /* for cslip etc */ 823 st->rx_compressed = tswap32(st->rx_compressed); 824 st->tx_compressed = tswap32(st->tx_compressed); 825 break; 826 /* struct rtnl_link_stats64 */ 827 case QEMU_IFLA_STATS64: 828 st64 = RTA_DATA(rtattr); 829 st64->rx_packets = tswap64(st64->rx_packets); 830 st64->tx_packets = tswap64(st64->tx_packets); 831 st64->rx_bytes = tswap64(st64->rx_bytes); 832 st64->tx_bytes = tswap64(st64->tx_bytes); 833 st64->rx_errors = tswap64(st64->rx_errors); 834 st64->tx_errors = tswap64(st64->tx_errors); 835 st64->rx_dropped = tswap64(st64->rx_dropped); 836 st64->tx_dropped = tswap64(st64->tx_dropped); 837 st64->multicast = tswap64(st64->multicast); 838 st64->collisions = tswap64(st64->collisions); 839 840 /* detailed rx_errors: */ 841 st64->rx_length_errors = tswap64(st64->rx_length_errors); 842 st64->rx_over_errors = tswap64(st64->rx_over_errors); 843 st64->rx_crc_errors = tswap64(st64->rx_crc_errors); 844 st64->rx_frame_errors = tswap64(st64->rx_frame_errors); 845 st64->rx_fifo_errors = tswap64(st64->rx_fifo_errors); 846 st64->rx_missed_errors = tswap64(st64->rx_missed_errors); 847 848 /* detailed tx_errors */ 849 st64->tx_aborted_errors = tswap64(st64->tx_aborted_errors); 850 st64->tx_carrier_errors = tswap64(st64->tx_carrier_errors); 851 st64->tx_fifo_errors = tswap64(st64->tx_fifo_errors); 852 st64->tx_heartbeat_errors = tswap64(st64->tx_heartbeat_errors); 853 st64->tx_window_errors = tswap64(st64->tx_window_errors); 854 855 /* for cslip etc */ 856 st64->rx_compressed = tswap64(st64->rx_compressed); 857 st64->tx_compressed = tswap64(st64->tx_compressed); 858 break; 859 /* struct rtnl_link_ifmap */ 860 case QEMU_IFLA_MAP: 861 map = RTA_DATA(rtattr); 862 map->mem_start = tswap64(map->mem_start); 863 map->mem_end = tswap64(map->mem_end); 864 map->base_addr = tswap64(map->base_addr); 865 map->irq = tswap16(map->irq); 866 break; 867 /* nested */ 868 case QEMU_IFLA_LINKINFO: 869 memset(&li_context, 0, sizeof(li_context)); 870 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len, 871 &li_context, 872 host_to_target_data_linkinfo_nlattr); 873 case QEMU_IFLA_AF_SPEC: 874 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len, 875 NULL, 876 host_to_target_data_spec_nlattr); 877 case QEMU_IFLA_XDP: 878 return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len, 879 NULL, 880 host_to_target_data_xdp_nlattr); 881 default: 882 gemu_log("Unknown host QEMU_IFLA type: %d\n", rtattr->rta_type); 883 break; 884 } 885 return 0; 886 } 887 888 static abi_long host_to_target_data_addr_rtattr(struct rtattr *rtattr) 889 { 890 uint32_t *u32; 891 struct ifa_cacheinfo *ci; 892 893 switch (rtattr->rta_type) { 894 /* binary: depends on family type */ 895 case IFA_ADDRESS: 896 case IFA_LOCAL: 897 break; 898 /* string */ 899 case IFA_LABEL: 900 break; 901 /* u32 */ 902 case IFA_FLAGS: 903 case IFA_BROADCAST: 904 u32 = RTA_DATA(rtattr); 905 *u32 = tswap32(*u32); 906 break; 907 /* struct ifa_cacheinfo */ 908 case IFA_CACHEINFO: 909 ci = RTA_DATA(rtattr); 910 ci->ifa_prefered = tswap32(ci->ifa_prefered); 911 ci->ifa_valid = tswap32(ci->ifa_valid); 912 ci->cstamp = tswap32(ci->cstamp); 913 ci->tstamp = tswap32(ci->tstamp); 914 break; 915 default: 916 gemu_log("Unknown host IFA type: %d\n", rtattr->rta_type); 917 break; 918 } 919 return 0; 920 } 921 922 static abi_long host_to_target_data_route_rtattr(struct rtattr *rtattr) 923 { 924 uint32_t *u32; 925 struct rta_cacheinfo *ci; 926 927 switch (rtattr->rta_type) { 928 /* binary: depends on family type */ 929 case QEMU_RTA_GATEWAY: 930 case QEMU_RTA_DST: 931 case QEMU_RTA_PREFSRC: 932 break; 933 /* u8 */ 934 case QEMU_RTA_PREF: 935 break; 936 /* u32 */ 937 case QEMU_RTA_PRIORITY: 938 case QEMU_RTA_TABLE: 939 case QEMU_RTA_OIF: 940 u32 = RTA_DATA(rtattr); 941 *u32 = tswap32(*u32); 942 break; 943 /* struct rta_cacheinfo */ 944 case QEMU_RTA_CACHEINFO: 945 ci = RTA_DATA(rtattr); 946 ci->rta_clntref = tswap32(ci->rta_clntref); 947 ci->rta_lastuse = tswap32(ci->rta_lastuse); 948 ci->rta_expires = tswap32(ci->rta_expires); 949 ci->rta_error = tswap32(ci->rta_error); 950 ci->rta_used = tswap32(ci->rta_used); 951 #if defined(RTNETLINK_HAVE_PEERINFO) 952 ci->rta_id = tswap32(ci->rta_id); 953 ci->rta_ts = tswap32(ci->rta_ts); 954 ci->rta_tsage = tswap32(ci->rta_tsage); 955 #endif 956 break; 957 default: 958 gemu_log("Unknown host RTA type: %d\n", rtattr->rta_type); 959 break; 960 } 961 return 0; 962 } 963 964 static abi_long host_to_target_link_rtattr(struct rtattr *rtattr, 965 uint32_t rtattr_len) 966 { 967 return host_to_target_for_each_rtattr(rtattr, rtattr_len, 968 host_to_target_data_link_rtattr); 969 } 970 971 static abi_long host_to_target_addr_rtattr(struct rtattr *rtattr, 972 uint32_t rtattr_len) 973 { 974 return host_to_target_for_each_rtattr(rtattr, rtattr_len, 975 host_to_target_data_addr_rtattr); 976 } 977 978 static abi_long host_to_target_route_rtattr(struct rtattr *rtattr, 979 uint32_t rtattr_len) 980 { 981 return host_to_target_for_each_rtattr(rtattr, rtattr_len, 982 host_to_target_data_route_rtattr); 983 } 984 985 static abi_long host_to_target_data_route(struct nlmsghdr *nlh) 986 { 987 uint32_t nlmsg_len; 988 struct ifinfomsg *ifi; 989 struct ifaddrmsg *ifa; 990 struct rtmsg *rtm; 991 992 nlmsg_len = nlh->nlmsg_len; 993 switch (nlh->nlmsg_type) { 994 case RTM_NEWLINK: 995 case RTM_DELLINK: 996 case RTM_GETLINK: 997 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) { 998 ifi = NLMSG_DATA(nlh); 999 ifi->ifi_type = tswap16(ifi->ifi_type); 1000 ifi->ifi_index = tswap32(ifi->ifi_index); 1001 ifi->ifi_flags = tswap32(ifi->ifi_flags); 1002 ifi->ifi_change = tswap32(ifi->ifi_change); 1003 host_to_target_link_rtattr(IFLA_RTA(ifi), 1004 nlmsg_len - NLMSG_LENGTH(sizeof(*ifi))); 1005 } 1006 break; 1007 case RTM_NEWADDR: 1008 case RTM_DELADDR: 1009 case RTM_GETADDR: 1010 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) { 1011 ifa = NLMSG_DATA(nlh); 1012 ifa->ifa_index = tswap32(ifa->ifa_index); 1013 host_to_target_addr_rtattr(IFA_RTA(ifa), 1014 nlmsg_len - NLMSG_LENGTH(sizeof(*ifa))); 1015 } 1016 break; 1017 case RTM_NEWROUTE: 1018 case RTM_DELROUTE: 1019 case RTM_GETROUTE: 1020 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) { 1021 rtm = NLMSG_DATA(nlh); 1022 rtm->rtm_flags = tswap32(rtm->rtm_flags); 1023 host_to_target_route_rtattr(RTM_RTA(rtm), 1024 nlmsg_len - NLMSG_LENGTH(sizeof(*rtm))); 1025 } 1026 break; 1027 default: 1028 return -TARGET_EINVAL; 1029 } 1030 return 0; 1031 } 1032 1033 static inline abi_long host_to_target_nlmsg_route(struct nlmsghdr *nlh, 1034 size_t len) 1035 { 1036 return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_route); 1037 } 1038 1039 static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr, 1040 size_t len, 1041 abi_long (*target_to_host_rtattr) 1042 (struct rtattr *)) 1043 { 1044 abi_long ret; 1045 1046 while (len >= sizeof(struct rtattr)) { 1047 if (tswap16(rtattr->rta_len) < sizeof(struct rtattr) || 1048 tswap16(rtattr->rta_len) > len) { 1049 break; 1050 } 1051 rtattr->rta_len = tswap16(rtattr->rta_len); 1052 rtattr->rta_type = tswap16(rtattr->rta_type); 1053 ret = target_to_host_rtattr(rtattr); 1054 if (ret < 0) { 1055 return ret; 1056 } 1057 len -= RTA_ALIGN(rtattr->rta_len); 1058 rtattr = (struct rtattr *)(((char *)rtattr) + 1059 RTA_ALIGN(rtattr->rta_len)); 1060 } 1061 return 0; 1062 } 1063 1064 static abi_long target_to_host_data_link_rtattr(struct rtattr *rtattr) 1065 { 1066 switch (rtattr->rta_type) { 1067 default: 1068 gemu_log("Unknown target QEMU_IFLA type: %d\n", rtattr->rta_type); 1069 break; 1070 } 1071 return 0; 1072 } 1073 1074 static abi_long target_to_host_data_addr_rtattr(struct rtattr *rtattr) 1075 { 1076 switch (rtattr->rta_type) { 1077 /* binary: depends on family type */ 1078 case IFA_LOCAL: 1079 case IFA_ADDRESS: 1080 break; 1081 default: 1082 gemu_log("Unknown target IFA type: %d\n", rtattr->rta_type); 1083 break; 1084 } 1085 return 0; 1086 } 1087 1088 static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr) 1089 { 1090 uint32_t *u32; 1091 switch (rtattr->rta_type) { 1092 /* binary: depends on family type */ 1093 case QEMU_RTA_DST: 1094 case QEMU_RTA_SRC: 1095 case QEMU_RTA_GATEWAY: 1096 break; 1097 /* u32 */ 1098 case QEMU_RTA_PRIORITY: 1099 case QEMU_RTA_OIF: 1100 u32 = RTA_DATA(rtattr); 1101 *u32 = tswap32(*u32); 1102 break; 1103 default: 1104 gemu_log("Unknown target RTA type: %d\n", rtattr->rta_type); 1105 break; 1106 } 1107 return 0; 1108 } 1109 1110 static void target_to_host_link_rtattr(struct rtattr *rtattr, 1111 uint32_t rtattr_len) 1112 { 1113 target_to_host_for_each_rtattr(rtattr, rtattr_len, 1114 target_to_host_data_link_rtattr); 1115 } 1116 1117 static void target_to_host_addr_rtattr(struct rtattr *rtattr, 1118 uint32_t rtattr_len) 1119 { 1120 target_to_host_for_each_rtattr(rtattr, rtattr_len, 1121 target_to_host_data_addr_rtattr); 1122 } 1123 1124 static void target_to_host_route_rtattr(struct rtattr *rtattr, 1125 uint32_t rtattr_len) 1126 { 1127 target_to_host_for_each_rtattr(rtattr, rtattr_len, 1128 target_to_host_data_route_rtattr); 1129 } 1130 1131 static abi_long target_to_host_data_route(struct nlmsghdr *nlh) 1132 { 1133 struct ifinfomsg *ifi; 1134 struct ifaddrmsg *ifa; 1135 struct rtmsg *rtm; 1136 1137 switch (nlh->nlmsg_type) { 1138 case RTM_GETLINK: 1139 break; 1140 case RTM_NEWLINK: 1141 case RTM_DELLINK: 1142 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) { 1143 ifi = NLMSG_DATA(nlh); 1144 ifi->ifi_type = tswap16(ifi->ifi_type); 1145 ifi->ifi_index = tswap32(ifi->ifi_index); 1146 ifi->ifi_flags = tswap32(ifi->ifi_flags); 1147 ifi->ifi_change = tswap32(ifi->ifi_change); 1148 target_to_host_link_rtattr(IFLA_RTA(ifi), nlh->nlmsg_len - 1149 NLMSG_LENGTH(sizeof(*ifi))); 1150 } 1151 break; 1152 case RTM_GETADDR: 1153 case RTM_NEWADDR: 1154 case RTM_DELADDR: 1155 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) { 1156 ifa = NLMSG_DATA(nlh); 1157 ifa->ifa_index = tswap32(ifa->ifa_index); 1158 target_to_host_addr_rtattr(IFA_RTA(ifa), nlh->nlmsg_len - 1159 NLMSG_LENGTH(sizeof(*ifa))); 1160 } 1161 break; 1162 case RTM_GETROUTE: 1163 break; 1164 case RTM_NEWROUTE: 1165 case RTM_DELROUTE: 1166 if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) { 1167 rtm = NLMSG_DATA(nlh); 1168 rtm->rtm_flags = tswap32(rtm->rtm_flags); 1169 target_to_host_route_rtattr(RTM_RTA(rtm), nlh->nlmsg_len - 1170 NLMSG_LENGTH(sizeof(*rtm))); 1171 } 1172 break; 1173 default: 1174 return -TARGET_EOPNOTSUPP; 1175 } 1176 return 0; 1177 } 1178 1179 static abi_long target_to_host_nlmsg_route(struct nlmsghdr *nlh, size_t len) 1180 { 1181 return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_route); 1182 } 1183 #endif /* CONFIG_RTNETLINK */ 1184 1185 static abi_long host_to_target_data_audit(struct nlmsghdr *nlh) 1186 { 1187 switch (nlh->nlmsg_type) { 1188 default: 1189 gemu_log("Unknown host audit message type %d\n", 1190 nlh->nlmsg_type); 1191 return -TARGET_EINVAL; 1192 } 1193 return 0; 1194 } 1195 1196 static inline abi_long host_to_target_nlmsg_audit(struct nlmsghdr *nlh, 1197 size_t len) 1198 { 1199 return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_audit); 1200 } 1201 1202 static abi_long target_to_host_data_audit(struct nlmsghdr *nlh) 1203 { 1204 switch (nlh->nlmsg_type) { 1205 case AUDIT_USER: 1206 case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG: 1207 case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2: 1208 break; 1209 default: 1210 gemu_log("Unknown target audit message type %d\n", 1211 nlh->nlmsg_type); 1212 return -TARGET_EINVAL; 1213 } 1214 1215 return 0; 1216 } 1217 1218 static abi_long target_to_host_nlmsg_audit(struct nlmsghdr *nlh, size_t len) 1219 { 1220 return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_audit); 1221 } 1222 1223 static abi_long packet_target_to_host_sockaddr(void *host_addr, 1224 abi_ulong target_addr, 1225 socklen_t len) 1226 { 1227 struct sockaddr *addr = host_addr; 1228 struct target_sockaddr *target_saddr; 1229 1230 target_saddr = lock_user(VERIFY_READ, target_addr, len, 1); 1231 if (!target_saddr) { 1232 return -TARGET_EFAULT; 1233 } 1234 1235 memcpy(addr, target_saddr, len); 1236 addr->sa_family = tswap16(target_saddr->sa_family); 1237 /* spkt_protocol is big-endian */ 1238 1239 unlock_user(target_saddr, target_addr, 0); 1240 return 0; 1241 } 1242 1243 TargetFdTrans target_packet_trans = { 1244 .target_to_host_addr = packet_target_to_host_sockaddr, 1245 }; 1246 1247 #ifdef CONFIG_RTNETLINK 1248 static abi_long netlink_route_target_to_host(void *buf, size_t len) 1249 { 1250 abi_long ret; 1251 1252 ret = target_to_host_nlmsg_route(buf, len); 1253 if (ret < 0) { 1254 return ret; 1255 } 1256 1257 return len; 1258 } 1259 1260 static abi_long netlink_route_host_to_target(void *buf, size_t len) 1261 { 1262 abi_long ret; 1263 1264 ret = host_to_target_nlmsg_route(buf, len); 1265 if (ret < 0) { 1266 return ret; 1267 } 1268 1269 return len; 1270 } 1271 1272 TargetFdTrans target_netlink_route_trans = { 1273 .target_to_host_data = netlink_route_target_to_host, 1274 .host_to_target_data = netlink_route_host_to_target, 1275 }; 1276 #endif /* CONFIG_RTNETLINK */ 1277 1278 static abi_long netlink_audit_target_to_host(void *buf, size_t len) 1279 { 1280 abi_long ret; 1281 1282 ret = target_to_host_nlmsg_audit(buf, len); 1283 if (ret < 0) { 1284 return ret; 1285 } 1286 1287 return len; 1288 } 1289 1290 static abi_long netlink_audit_host_to_target(void *buf, size_t len) 1291 { 1292 abi_long ret; 1293 1294 ret = host_to_target_nlmsg_audit(buf, len); 1295 if (ret < 0) { 1296 return ret; 1297 } 1298 1299 return len; 1300 } 1301 1302 TargetFdTrans target_netlink_audit_trans = { 1303 .target_to_host_data = netlink_audit_target_to_host, 1304 .host_to_target_data = netlink_audit_host_to_target, 1305 }; 1306 1307 /* signalfd siginfo conversion */ 1308 1309 static void 1310 host_to_target_signalfd_siginfo(struct signalfd_siginfo *tinfo, 1311 const struct signalfd_siginfo *info) 1312 { 1313 int sig = host_to_target_signal(info->ssi_signo); 1314 1315 /* linux/signalfd.h defines a ssi_addr_lsb 1316 * not defined in sys/signalfd.h but used by some kernels 1317 */ 1318 1319 #ifdef BUS_MCEERR_AO 1320 if (tinfo->ssi_signo == SIGBUS && 1321 (tinfo->ssi_code == BUS_MCEERR_AR || 1322 tinfo->ssi_code == BUS_MCEERR_AO)) { 1323 uint16_t *ssi_addr_lsb = (uint16_t *)(&info->ssi_addr + 1); 1324 uint16_t *tssi_addr_lsb = (uint16_t *)(&tinfo->ssi_addr + 1); 1325 *tssi_addr_lsb = tswap16(*ssi_addr_lsb); 1326 } 1327 #endif 1328 1329 tinfo->ssi_signo = tswap32(sig); 1330 tinfo->ssi_errno = tswap32(tinfo->ssi_errno); 1331 tinfo->ssi_code = tswap32(info->ssi_code); 1332 tinfo->ssi_pid = tswap32(info->ssi_pid); 1333 tinfo->ssi_uid = tswap32(info->ssi_uid); 1334 tinfo->ssi_fd = tswap32(info->ssi_fd); 1335 tinfo->ssi_tid = tswap32(info->ssi_tid); 1336 tinfo->ssi_band = tswap32(info->ssi_band); 1337 tinfo->ssi_overrun = tswap32(info->ssi_overrun); 1338 tinfo->ssi_trapno = tswap32(info->ssi_trapno); 1339 tinfo->ssi_status = tswap32(info->ssi_status); 1340 tinfo->ssi_int = tswap32(info->ssi_int); 1341 tinfo->ssi_ptr = tswap64(info->ssi_ptr); 1342 tinfo->ssi_utime = tswap64(info->ssi_utime); 1343 tinfo->ssi_stime = tswap64(info->ssi_stime); 1344 tinfo->ssi_addr = tswap64(info->ssi_addr); 1345 } 1346 1347 static abi_long host_to_target_data_signalfd(void *buf, size_t len) 1348 { 1349 int i; 1350 1351 for (i = 0; i < len; i += sizeof(struct signalfd_siginfo)) { 1352 host_to_target_signalfd_siginfo(buf + i, buf + i); 1353 } 1354 1355 return len; 1356 } 1357 1358 TargetFdTrans target_signalfd_trans = { 1359 .host_to_target_data = host_to_target_data_signalfd, 1360 }; 1361 1362 static abi_long swap_data_eventfd(void *buf, size_t len) 1363 { 1364 uint64_t *counter = buf; 1365 int i; 1366 1367 if (len < sizeof(uint64_t)) { 1368 return -EINVAL; 1369 } 1370 1371 for (i = 0; i < len; i += sizeof(uint64_t)) { 1372 *counter = tswap64(*counter); 1373 counter++; 1374 } 1375 1376 return len; 1377 } 1378 1379 TargetFdTrans target_eventfd_trans = { 1380 .host_to_target_data = swap_data_eventfd, 1381 .target_to_host_data = swap_data_eventfd, 1382 }; 1383 1384 #if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \ 1385 (defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \ 1386 defined(__NR_inotify_init1)) 1387 static abi_long host_to_target_data_inotify(void *buf, size_t len) 1388 { 1389 struct inotify_event *ev; 1390 int i; 1391 uint32_t name_len; 1392 1393 for (i = 0; i < len; i += sizeof(struct inotify_event) + name_len) { 1394 ev = (struct inotify_event *)((char *)buf + i); 1395 name_len = ev->len; 1396 1397 ev->wd = tswap32(ev->wd); 1398 ev->mask = tswap32(ev->mask); 1399 ev->cookie = tswap32(ev->cookie); 1400 ev->len = tswap32(name_len); 1401 } 1402 1403 return len; 1404 } 1405 1406 TargetFdTrans target_inotify_trans = { 1407 .host_to_target_data = host_to_target_data_inotify, 1408 }; 1409 #endif 1410