linux-user/fd-trans.c

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