linux-user/fd-trans.c

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