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