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