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         gemu_log("Unknown QEMU_IFLA_BR type %d\n", nlattr->nla_type);
 518         break;
 519     }
 520     return 0;
 521 }
 522
 523 static abi_long host_to_target_slave_data_bridge_nlattr(struct nlattr *nlattr,
 524                                                         void *context)
 525 {
 526     uint16_t *u16;
 527     uint32_t *u32;
 528     uint64_t *u64;
 529
 530     switch (nlattr->nla_type) {
 531     /* uint8_t */
 532     case QEMU_IFLA_BRPORT_STATE:
 533     case QEMU_IFLA_BRPORT_MODE:
 534     case QEMU_IFLA_BRPORT_GUARD:
 535     case QEMU_IFLA_BRPORT_PROTECT:
 536     case QEMU_IFLA_BRPORT_FAST_LEAVE:
 537     case QEMU_IFLA_BRPORT_LEARNING:
 538     case QEMU_IFLA_BRPORT_UNICAST_FLOOD:
 539     case QEMU_IFLA_BRPORT_PROXYARP:
 540     case QEMU_IFLA_BRPORT_LEARNING_SYNC:
 541     case QEMU_IFLA_BRPORT_PROXYARP_WIFI:
 542     case QEMU_IFLA_BRPORT_TOPOLOGY_CHANGE_ACK:
 543     case QEMU_IFLA_BRPORT_CONFIG_PENDING:
 544     case QEMU_IFLA_BRPORT_MULTICAST_ROUTER:
 545     case QEMU_IFLA_BRPORT_MCAST_FLOOD:
 546     case QEMU_IFLA_BRPORT_MCAST_TO_UCAST:
 547     case QEMU_IFLA_BRPORT_VLAN_TUNNEL:
 548     case QEMU_IFLA_BRPORT_BCAST_FLOOD:
 549     case QEMU_IFLA_BRPORT_NEIGH_SUPPRESS:
 550     case QEMU_IFLA_BRPORT_ISOLATED:
 551         break;
 552     /* uint16_t */
 553     case QEMU_IFLA_BRPORT_PRIORITY:
 554     case QEMU_IFLA_BRPORT_DESIGNATED_PORT:
 555     case QEMU_IFLA_BRPORT_DESIGNATED_COST:
 556     case QEMU_IFLA_BRPORT_ID:
 557     case QEMU_IFLA_BRPORT_NO:
 558     case QEMU_IFLA_BRPORT_GROUP_FWD_MASK:
 559         u16 = NLA_DATA(nlattr);
 560         *u16 = tswap16(*u16);
 561         break;
 562     /* uin32_t */
 563     case QEMU_IFLA_BRPORT_COST:
 564     case QEMU_IFLA_BRPORT_BACKUP_PORT:
 565         u32 = NLA_DATA(nlattr);
 566         *u32 = tswap32(*u32);
 567         break;
 568     /* uint64_t */
 569     case QEMU_IFLA_BRPORT_MESSAGE_AGE_TIMER:
 570     case QEMU_IFLA_BRPORT_FORWARD_DELAY_TIMER:
 571     case QEMU_IFLA_BRPORT_HOLD_TIMER:
 572         u64 = NLA_DATA(nlattr);
 573         *u64 = tswap64(*u64);
 574         break;
 575     /* ifla_bridge_id: uint8_t[] */
 576     case QEMU_IFLA_BRPORT_ROOT_ID:
 577     case QEMU_IFLA_BRPORT_BRIDGE_ID:
 578         break;
 579     default:
 580         gemu_log("Unknown QEMU_IFLA_BRPORT type %d\n", nlattr->nla_type);
 581         break;
 582     }
 583     return 0;
 584 }
 585
 586 static abi_long host_to_target_data_tun_nlattr(struct nlattr *nlattr,
 587                                                   void *context)
 588 {
 589     uint32_t *u32;
 590
 591     switch (nlattr->nla_type) {
 592     /* uint8_t */
 593     case QEMU_IFLA_TUN_TYPE:
 594     case QEMU_IFLA_TUN_PI:
 595     case QEMU_IFLA_TUN_VNET_HDR:
 596     case QEMU_IFLA_TUN_PERSIST:
 597     case QEMU_IFLA_TUN_MULTI_QUEUE:
 598         break;
 599     /* uint32_t */
 600     case QEMU_IFLA_TUN_NUM_QUEUES:
 601     case QEMU_IFLA_TUN_NUM_DISABLED_QUEUES:
 602     case QEMU_IFLA_TUN_OWNER:
 603     case QEMU_IFLA_TUN_GROUP:
 604         u32 = NLA_DATA(nlattr);
 605         *u32 = tswap32(*u32);
 606         break;
 607     default:
 608         gemu_log("Unknown QEMU_IFLA_TUN type %d\n", nlattr->nla_type);
 609         break;
 610     }
 611     return 0;
 612 }
 613
 614 struct linkinfo_context {
 615     int len;
 616     char *name;
 617     int slave_len;
 618     char *slave_name;
 619 };
 620
 621 static abi_long host_to_target_data_linkinfo_nlattr(struct nlattr *nlattr,
 622                                                     void *context)
 623 {
 624     struct linkinfo_context *li_context = context;
 625
 626     switch (nlattr->nla_type) {
 627     /* string */
 628     case QEMU_IFLA_INFO_KIND:
 629         li_context->name = NLA_DATA(nlattr);
 630         li_context->len = nlattr->nla_len - NLA_HDRLEN;
 631         break;
 632     case QEMU_IFLA_INFO_SLAVE_KIND:
 633         li_context->slave_name = NLA_DATA(nlattr);
 634         li_context->slave_len = nlattr->nla_len - NLA_HDRLEN;
 635         break;
 636     /* stats */
 637     case QEMU_IFLA_INFO_XSTATS:
 638         /* FIXME: only used by CAN */
 639         break;
 640     /* nested */
 641     case QEMU_IFLA_INFO_DATA:
 642         if (strncmp(li_context->name, "bridge",
 643                     li_context->len) == 0) {
 644             return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
 645                                                   nlattr->nla_len,
 646                                                   NULL,
 647                                              host_to_target_data_bridge_nlattr);
 648         } else if (strncmp(li_context->name, "tun",
 649                     li_context->len) == 0) {
 650             return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
 651                                                   nlattr->nla_len,
 652                                                   NULL,
 653                                                 host_to_target_data_tun_nlattr);
 654         } else {
 655             gemu_log("Unknown QEMU_IFLA_INFO_KIND %s\n", li_context->name);
 656         }
 657         break;
 658     case QEMU_IFLA_INFO_SLAVE_DATA:
 659         if (strncmp(li_context->slave_name, "bridge",
 660                     li_context->slave_len) == 0) {
 661             return host_to_target_for_each_nlattr(NLA_DATA(nlattr),
 662                                                   nlattr->nla_len,
 663                                                   NULL,
 664                                        host_to_target_slave_data_bridge_nlattr);
 665         } else {
 666             gemu_log("Unknown QEMU_IFLA_INFO_SLAVE_KIND %s\n",
 667                      li_context->slave_name);
 668         }
 669         break;
 670     default:
 671         gemu_log("Unknown host QEMU_IFLA_INFO type: %d\n", nlattr->nla_type);
 672         break;
 673     }
 674
 675     return 0;
 676 }
 677
 678 static abi_long host_to_target_data_inet_nlattr(struct nlattr *nlattr,
 679                                                 void *context)
 680 {
 681     uint32_t *u32;
 682     int i;
 683
 684     switch (nlattr->nla_type) {
 685     case QEMU_IFLA_INET_CONF:
 686         u32 = NLA_DATA(nlattr);
 687         for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
 688              i++) {
 689             u32[i] = tswap32(u32[i]);
 690         }
 691         break;
 692     default:
 693         gemu_log("Unknown host AF_INET type: %d\n", nlattr->nla_type);
 694     }
 695     return 0;
 696 }
 697
 698 static abi_long host_to_target_data_inet6_nlattr(struct nlattr *nlattr,
 699                                                 void *context)
 700 {
 701     uint32_t *u32;
 702     uint64_t *u64;
 703     struct ifla_cacheinfo *ci;
 704     int i;
 705
 706     switch (nlattr->nla_type) {
 707     /* binaries */
 708     case QEMU_IFLA_INET6_TOKEN:
 709         break;
 710     /* uint8_t */
 711     case QEMU_IFLA_INET6_ADDR_GEN_MODE:
 712         break;
 713     /* uint32_t */
 714     case QEMU_IFLA_INET6_FLAGS:
 715         u32 = NLA_DATA(nlattr);
 716         *u32 = tswap32(*u32);
 717         break;
 718     /* uint32_t[] */
 719     case QEMU_IFLA_INET6_CONF:
 720         u32 = NLA_DATA(nlattr);
 721         for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u32);
 722              i++) {
 723             u32[i] = tswap32(u32[i]);
 724         }
 725         break;
 726     /* ifla_cacheinfo */
 727     case QEMU_IFLA_INET6_CACHEINFO:
 728         ci = NLA_DATA(nlattr);
 729         ci->max_reasm_len = tswap32(ci->max_reasm_len);
 730         ci->tstamp = tswap32(ci->tstamp);
 731         ci->reachable_time = tswap32(ci->reachable_time);
 732         ci->retrans_time = tswap32(ci->retrans_time);
 733         break;
 734     /* uint64_t[] */
 735     case QEMU_IFLA_INET6_STATS:
 736     case QEMU_IFLA_INET6_ICMP6STATS:
 737         u64 = NLA_DATA(nlattr);
 738         for (i = 0; i < (nlattr->nla_len - NLA_HDRLEN) / sizeof(*u64);
 739              i++) {
 740             u64[i] = tswap64(u64[i]);
 741         }
 742         break;
 743     default:
 744         gemu_log("Unknown host AF_INET6 type: %d\n", nlattr->nla_type);
 745     }
 746     return 0;
 747 }
 748
 749 static abi_long host_to_target_data_spec_nlattr(struct nlattr *nlattr,
 750                                                     void *context)
 751 {
 752     switch (nlattr->nla_type) {
 753     case AF_INET:
 754         return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
 755                                               NULL,
 756                                              host_to_target_data_inet_nlattr);
 757     case AF_INET6:
 758         return host_to_target_for_each_nlattr(NLA_DATA(nlattr), nlattr->nla_len,
 759                                               NULL,
 760                                              host_to_target_data_inet6_nlattr);
 761     default:
 762         gemu_log("Unknown host AF_SPEC type: %d\n", nlattr->nla_type);
 763         break;
 764     }
 765     return 0;
 766 }
 767
 768 static abi_long host_to_target_data_xdp_nlattr(struct nlattr *nlattr,
 769                                                void *context)
 770 {
 771     uint32_t *u32;
 772
 773     switch (nlattr->nla_type) {
 774     /* uint8_t */
 775     case QEMU_IFLA_XDP_ATTACHED:
 776         break;
 777     /* uint32_t */
 778     case QEMU_IFLA_XDP_PROG_ID:
 779         u32 = NLA_DATA(nlattr);
 780         *u32 = tswap32(*u32);
 781         break;
 782     default:
 783         gemu_log("Unknown host XDP type: %d\n", nlattr->nla_type);
 784         break;
 785     }
 786     return 0;
 787 }
 788
 789 static abi_long host_to_target_data_link_rtattr(struct rtattr *rtattr)
 790 {
 791     uint32_t *u32;
 792     struct rtnl_link_stats *st;
 793     struct rtnl_link_stats64 *st64;
 794     struct rtnl_link_ifmap *map;
 795     struct linkinfo_context li_context;
 796
 797     switch (rtattr->rta_type) {
 798     /* binary stream */
 799     case QEMU_IFLA_ADDRESS:
 800     case QEMU_IFLA_BROADCAST:
 801     /* string */
 802     case QEMU_IFLA_IFNAME:
 803     case QEMU_IFLA_QDISC:
 804         break;
 805     /* uin8_t */
 806     case QEMU_IFLA_OPERSTATE:
 807     case QEMU_IFLA_LINKMODE:
 808     case QEMU_IFLA_CARRIER:
 809     case QEMU_IFLA_PROTO_DOWN:
 810         break;
 811     /* uint32_t */
 812     case QEMU_IFLA_MTU:
 813     case QEMU_IFLA_LINK:
 814     case QEMU_IFLA_WEIGHT:
 815     case QEMU_IFLA_TXQLEN:
 816     case QEMU_IFLA_CARRIER_CHANGES:
 817     case QEMU_IFLA_NUM_RX_QUEUES:
 818     case QEMU_IFLA_NUM_TX_QUEUES:
 819     case QEMU_IFLA_PROMISCUITY:
 820     case QEMU_IFLA_EXT_MASK:
 821     case QEMU_IFLA_LINK_NETNSID:
 822     case QEMU_IFLA_GROUP:
 823     case QEMU_IFLA_MASTER:
 824     case QEMU_IFLA_NUM_VF:
 825     case QEMU_IFLA_GSO_MAX_SEGS:
 826     case QEMU_IFLA_GSO_MAX_SIZE:
 827     case QEMU_IFLA_CARRIER_UP_COUNT:
 828     case QEMU_IFLA_CARRIER_DOWN_COUNT:
 829     case QEMU_IFLA_MIN_MTU:
 830     case QEMU_IFLA_MAX_MTU:
 831         u32 = RTA_DATA(rtattr);
 832         *u32 = tswap32(*u32);
 833         break;
 834     /* struct rtnl_link_stats */
 835     case QEMU_IFLA_STATS:
 836         st = RTA_DATA(rtattr);
 837         st->rx_packets = tswap32(st->rx_packets);
 838         st->tx_packets = tswap32(st->tx_packets);
 839         st->rx_bytes = tswap32(st->rx_bytes);
 840         st->tx_bytes = tswap32(st->tx_bytes);
 841         st->rx_errors = tswap32(st->rx_errors);
 842         st->tx_errors = tswap32(st->tx_errors);
 843         st->rx_dropped = tswap32(st->rx_dropped);
 844         st->tx_dropped = tswap32(st->tx_dropped);
 845         st->multicast = tswap32(st->multicast);
 846         st->collisions = tswap32(st->collisions);
 847
 848         /* detailed rx_errors: */
 849         st->rx_length_errors = tswap32(st->rx_length_errors);
 850         st->rx_over_errors = tswap32(st->rx_over_errors);
 851         st->rx_crc_errors = tswap32(st->rx_crc_errors);
 852         st->rx_frame_errors = tswap32(st->rx_frame_errors);
 853         st->rx_fifo_errors = tswap32(st->rx_fifo_errors);
 854         st->rx_missed_errors = tswap32(st->rx_missed_errors);
 855
 856         /* detailed tx_errors */
 857         st->tx_aborted_errors = tswap32(st->tx_aborted_errors);
 858         st->tx_carrier_errors = tswap32(st->tx_carrier_errors);
 859         st->tx_fifo_errors = tswap32(st->tx_fifo_errors);
 860         st->tx_heartbeat_errors = tswap32(st->tx_heartbeat_errors);
 861         st->tx_window_errors = tswap32(st->tx_window_errors);
 862
 863         /* for cslip etc */
 864         st->rx_compressed = tswap32(st->rx_compressed);
 865         st->tx_compressed = tswap32(st->tx_compressed);
 866         break;
 867     /* struct rtnl_link_stats64 */
 868     case QEMU_IFLA_STATS64:
 869         st64 = RTA_DATA(rtattr);
 870         st64->rx_packets = tswap64(st64->rx_packets);
 871         st64->tx_packets = tswap64(st64->tx_packets);
 872         st64->rx_bytes = tswap64(st64->rx_bytes);
 873         st64->tx_bytes = tswap64(st64->tx_bytes);
 874         st64->rx_errors = tswap64(st64->rx_errors);
 875         st64->tx_errors = tswap64(st64->tx_errors);
 876         st64->rx_dropped = tswap64(st64->rx_dropped);
 877         st64->tx_dropped = tswap64(st64->tx_dropped);
 878         st64->multicast = tswap64(st64->multicast);
 879         st64->collisions = tswap64(st64->collisions);
 880
 881         /* detailed rx_errors: */
 882         st64->rx_length_errors = tswap64(st64->rx_length_errors);
 883         st64->rx_over_errors = tswap64(st64->rx_over_errors);
 884         st64->rx_crc_errors = tswap64(st64->rx_crc_errors);
 885         st64->rx_frame_errors = tswap64(st64->rx_frame_errors);
 886         st64->rx_fifo_errors = tswap64(st64->rx_fifo_errors);
 887         st64->rx_missed_errors = tswap64(st64->rx_missed_errors);
 888
 889         /* detailed tx_errors */
 890         st64->tx_aborted_errors = tswap64(st64->tx_aborted_errors);
 891         st64->tx_carrier_errors = tswap64(st64->tx_carrier_errors);
 892         st64->tx_fifo_errors = tswap64(st64->tx_fifo_errors);
 893         st64->tx_heartbeat_errors = tswap64(st64->tx_heartbeat_errors);
 894         st64->tx_window_errors = tswap64(st64->tx_window_errors);
 895
 896         /* for cslip etc */
 897         st64->rx_compressed = tswap64(st64->rx_compressed);
 898         st64->tx_compressed = tswap64(st64->tx_compressed);
 899         break;
 900     /* struct rtnl_link_ifmap */
 901     case QEMU_IFLA_MAP:
 902         map = RTA_DATA(rtattr);
 903         map->mem_start = tswap64(map->mem_start);
 904         map->mem_end = tswap64(map->mem_end);
 905         map->base_addr = tswap64(map->base_addr);
 906         map->irq = tswap16(map->irq);
 907         break;
 908     /* nested */
 909     case QEMU_IFLA_LINKINFO:
 910         memset(&li_context, 0, sizeof(li_context));
 911         return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
 912                                               &li_context,
 913                                            host_to_target_data_linkinfo_nlattr);
 914     case QEMU_IFLA_AF_SPEC:
 915         return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
 916                                               NULL,
 917                                              host_to_target_data_spec_nlattr);
 918     case QEMU_IFLA_XDP:
 919         return host_to_target_for_each_nlattr(RTA_DATA(rtattr), rtattr->rta_len,
 920                                               NULL,
 921                                                 host_to_target_data_xdp_nlattr);
 922     default:
 923         gemu_log("Unknown host QEMU_IFLA type: %d\n", rtattr->rta_type);
 924         break;
 925     }
 926     return 0;
 927 }
 928
 929 static abi_long host_to_target_data_addr_rtattr(struct rtattr *rtattr)
 930 {
 931     uint32_t *u32;
 932     struct ifa_cacheinfo *ci;
 933
 934     switch (rtattr->rta_type) {
 935     /* binary: depends on family type */
 936     case IFA_ADDRESS:
 937     case IFA_LOCAL:
 938         break;
 939     /* string */
 940     case IFA_LABEL:
 941         break;
 942     /* u32 */
 943     case IFA_FLAGS:
 944     case IFA_BROADCAST:
 945         u32 = RTA_DATA(rtattr);
 946         *u32 = tswap32(*u32);
 947         break;
 948     /* struct ifa_cacheinfo */
 949     case IFA_CACHEINFO:
 950         ci = RTA_DATA(rtattr);
 951         ci->ifa_prefered = tswap32(ci->ifa_prefered);
 952         ci->ifa_valid = tswap32(ci->ifa_valid);
 953         ci->cstamp = tswap32(ci->cstamp);
 954         ci->tstamp = tswap32(ci->tstamp);
 955         break;
 956     default:
 957         gemu_log("Unknown host IFA type: %d\n", rtattr->rta_type);
 958         break;
 959     }
 960     return 0;
 961 }
 962
 963 static abi_long host_to_target_data_route_rtattr(struct rtattr *rtattr)
 964 {
 965     uint32_t *u32;
 966     struct rta_cacheinfo *ci;
 967
 968     switch (rtattr->rta_type) {
 969     /* binary: depends on family type */
 970     case QEMU_RTA_GATEWAY:
 971     case QEMU_RTA_DST:
 972     case QEMU_RTA_PREFSRC:
 973         break;
 974     /* u8 */
 975     case QEMU_RTA_PREF:
 976         break;
 977     /* u32 */
 978     case QEMU_RTA_PRIORITY:
 979     case QEMU_RTA_TABLE:
 980     case QEMU_RTA_OIF:
 981         u32 = RTA_DATA(rtattr);
 982         *u32 = tswap32(*u32);
 983         break;
 984     /* struct rta_cacheinfo */
 985     case QEMU_RTA_CACHEINFO:
 986         ci = RTA_DATA(rtattr);
 987         ci->rta_clntref = tswap32(ci->rta_clntref);
 988         ci->rta_lastuse = tswap32(ci->rta_lastuse);
 989         ci->rta_expires = tswap32(ci->rta_expires);
 990         ci->rta_error = tswap32(ci->rta_error);
 991         ci->rta_used = tswap32(ci->rta_used);
 992 #if defined(RTNETLINK_HAVE_PEERINFO)
 993         ci->rta_id = tswap32(ci->rta_id);
 994         ci->rta_ts = tswap32(ci->rta_ts);
 995         ci->rta_tsage = tswap32(ci->rta_tsage);
 996 #endif
 997         break;
 998     default:
 999         gemu_log("Unknown host RTA type: %d\n", rtattr->rta_type);
1000         break;
1001     }
1002     return 0;
1003 }
1004
1005 static abi_long host_to_target_link_rtattr(struct rtattr *rtattr,
1006                                          uint32_t rtattr_len)
1007 {
1008     return host_to_target_for_each_rtattr(rtattr, rtattr_len,
1009                                           host_to_target_data_link_rtattr);
1010 }
1011
1012 static abi_long host_to_target_addr_rtattr(struct rtattr *rtattr,
1013                                          uint32_t rtattr_len)
1014 {
1015     return host_to_target_for_each_rtattr(rtattr, rtattr_len,
1016                                           host_to_target_data_addr_rtattr);
1017 }
1018
1019 static abi_long host_to_target_route_rtattr(struct rtattr *rtattr,
1020                                          uint32_t rtattr_len)
1021 {
1022     return host_to_target_for_each_rtattr(rtattr, rtattr_len,
1023                                           host_to_target_data_route_rtattr);
1024 }
1025
1026 static abi_long host_to_target_data_route(struct nlmsghdr *nlh)
1027 {
1028     uint32_t nlmsg_len;
1029     struct ifinfomsg *ifi;
1030     struct ifaddrmsg *ifa;
1031     struct rtmsg *rtm;
1032
1033     nlmsg_len = nlh->nlmsg_len;
1034     switch (nlh->nlmsg_type) {
1035     case RTM_NEWLINK:
1036     case RTM_DELLINK:
1037     case RTM_GETLINK:
1038         if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
1039             ifi = NLMSG_DATA(nlh);
1040             ifi->ifi_type = tswap16(ifi->ifi_type);
1041             ifi->ifi_index = tswap32(ifi->ifi_index);
1042             ifi->ifi_flags = tswap32(ifi->ifi_flags);
1043             ifi->ifi_change = tswap32(ifi->ifi_change);
1044             host_to_target_link_rtattr(IFLA_RTA(ifi),
1045                                        nlmsg_len - NLMSG_LENGTH(sizeof(*ifi)));
1046         }
1047         break;
1048     case RTM_NEWADDR:
1049     case RTM_DELADDR:
1050     case RTM_GETADDR:
1051         if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
1052             ifa = NLMSG_DATA(nlh);
1053             ifa->ifa_index = tswap32(ifa->ifa_index);
1054             host_to_target_addr_rtattr(IFA_RTA(ifa),
1055                                        nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));
1056         }
1057         break;
1058     case RTM_NEWROUTE:
1059     case RTM_DELROUTE:
1060     case RTM_GETROUTE:
1061         if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
1062             rtm = NLMSG_DATA(nlh);
1063             rtm->rtm_flags = tswap32(rtm->rtm_flags);
1064             host_to_target_route_rtattr(RTM_RTA(rtm),
1065                                         nlmsg_len - NLMSG_LENGTH(sizeof(*rtm)));
1066         }
1067         break;
1068     default:
1069         return -TARGET_EINVAL;
1070     }
1071     return 0;
1072 }
1073
1074 static inline abi_long host_to_target_nlmsg_route(struct nlmsghdr *nlh,
1075                                                   size_t len)
1076 {
1077     return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_route);
1078 }
1079
1080 static abi_long target_to_host_for_each_rtattr(struct rtattr *rtattr,
1081                                                size_t len,
1082                                                abi_long (*target_to_host_rtattr)
1083                                                         (struct rtattr *))
1084 {
1085     unsigned short aligned_rta_len;
1086     abi_long ret;
1087
1088     while (len >= sizeof(struct rtattr)) {
1089         if (tswap16(rtattr->rta_len) < sizeof(struct rtattr) ||
1090             tswap16(rtattr->rta_len) > len) {
1091             break;
1092         }
1093         rtattr->rta_len = tswap16(rtattr->rta_len);
1094         rtattr->rta_type = tswap16(rtattr->rta_type);
1095         ret = target_to_host_rtattr(rtattr);
1096         if (ret < 0) {
1097             return ret;
1098         }
1099
1100         aligned_rta_len = RTA_ALIGN(rtattr->rta_len);
1101         if (aligned_rta_len >= len) {
1102             break;
1103         }
1104         len -= aligned_rta_len;
1105         rtattr = (struct rtattr *)(((char *)rtattr) + aligned_rta_len);
1106     }
1107     return 0;
1108 }
1109
1110 static abi_long target_to_host_data_link_rtattr(struct rtattr *rtattr)
1111 {
1112     switch (rtattr->rta_type) {
1113     default:
1114         gemu_log("Unknown target QEMU_IFLA type: %d\n", rtattr->rta_type);
1115         break;
1116     }
1117     return 0;
1118 }
1119
1120 static abi_long target_to_host_data_addr_rtattr(struct rtattr *rtattr)
1121 {
1122     switch (rtattr->rta_type) {
1123     /* binary: depends on family type */
1124     case IFA_LOCAL:
1125     case IFA_ADDRESS:
1126         break;
1127     default:
1128         gemu_log("Unknown target IFA type: %d\n", rtattr->rta_type);
1129         break;
1130     }
1131     return 0;
1132 }
1133
1134 static abi_long target_to_host_data_route_rtattr(struct rtattr *rtattr)
1135 {
1136     uint32_t *u32;
1137     switch (rtattr->rta_type) {
1138     /* binary: depends on family type */
1139     case QEMU_RTA_DST:
1140     case QEMU_RTA_SRC:
1141     case QEMU_RTA_GATEWAY:
1142         break;
1143     /* u32 */
1144     case QEMU_RTA_PRIORITY:
1145     case QEMU_RTA_OIF:
1146         u32 = RTA_DATA(rtattr);
1147         *u32 = tswap32(*u32);
1148         break;
1149     default:
1150         gemu_log("Unknown target RTA type: %d\n", rtattr->rta_type);
1151         break;
1152     }
1153     return 0;
1154 }
1155
1156 static void target_to_host_link_rtattr(struct rtattr *rtattr,
1157                                        uint32_t rtattr_len)
1158 {
1159     target_to_host_for_each_rtattr(rtattr, rtattr_len,
1160                                    target_to_host_data_link_rtattr);
1161 }
1162
1163 static void target_to_host_addr_rtattr(struct rtattr *rtattr,
1164                                      uint32_t rtattr_len)
1165 {
1166     target_to_host_for_each_rtattr(rtattr, rtattr_len,
1167                                    target_to_host_data_addr_rtattr);
1168 }
1169
1170 static void target_to_host_route_rtattr(struct rtattr *rtattr,
1171                                      uint32_t rtattr_len)
1172 {
1173     target_to_host_for_each_rtattr(rtattr, rtattr_len,
1174                                    target_to_host_data_route_rtattr);
1175 }
1176
1177 static abi_long target_to_host_data_route(struct nlmsghdr *nlh)
1178 {
1179     struct ifinfomsg *ifi;
1180     struct ifaddrmsg *ifa;
1181     struct rtmsg *rtm;
1182
1183     switch (nlh->nlmsg_type) {
1184     case RTM_GETLINK:
1185         break;
1186     case RTM_NEWLINK:
1187     case RTM_DELLINK:
1188         if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifi))) {
1189             ifi = NLMSG_DATA(nlh);
1190             ifi->ifi_type = tswap16(ifi->ifi_type);
1191             ifi->ifi_index = tswap32(ifi->ifi_index);
1192             ifi->ifi_flags = tswap32(ifi->ifi_flags);
1193             ifi->ifi_change = tswap32(ifi->ifi_change);
1194             target_to_host_link_rtattr(IFLA_RTA(ifi), nlh->nlmsg_len -
1195                                        NLMSG_LENGTH(sizeof(*ifi)));
1196         }
1197         break;
1198     case RTM_GETADDR:
1199     case RTM_NEWADDR:
1200     case RTM_DELADDR:
1201         if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*ifa))) {
1202             ifa = NLMSG_DATA(nlh);
1203             ifa->ifa_index = tswap32(ifa->ifa_index);
1204             target_to_host_addr_rtattr(IFA_RTA(ifa), nlh->nlmsg_len -
1205                                        NLMSG_LENGTH(sizeof(*ifa)));
1206         }
1207         break;
1208     case RTM_GETROUTE:
1209         break;
1210     case RTM_NEWROUTE:
1211     case RTM_DELROUTE:
1212         if (nlh->nlmsg_len >= NLMSG_LENGTH(sizeof(*rtm))) {
1213             rtm = NLMSG_DATA(nlh);
1214             rtm->rtm_flags = tswap32(rtm->rtm_flags);
1215             target_to_host_route_rtattr(RTM_RTA(rtm), nlh->nlmsg_len -
1216                                         NLMSG_LENGTH(sizeof(*rtm)));
1217         }
1218         break;
1219     default:
1220         return -TARGET_EOPNOTSUPP;
1221     }
1222     return 0;
1223 }
1224
1225 static abi_long target_to_host_nlmsg_route(struct nlmsghdr *nlh, size_t len)
1226 {
1227     return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_route);
1228 }
1229 #endif /* CONFIG_RTNETLINK */
1230
1231 static abi_long host_to_target_data_audit(struct nlmsghdr *nlh)
1232 {
1233     switch (nlh->nlmsg_type) {
1234     default:
1235         gemu_log("Unknown host audit message type %d\n",
1236                  nlh->nlmsg_type);
1237         return -TARGET_EINVAL;
1238     }
1239     return 0;
1240 }
1241
1242 static inline abi_long host_to_target_nlmsg_audit(struct nlmsghdr *nlh,
1243                                                   size_t len)
1244 {
1245     return host_to_target_for_each_nlmsg(nlh, len, host_to_target_data_audit);
1246 }
1247
1248 static abi_long target_to_host_data_audit(struct nlmsghdr *nlh)
1249 {
1250     switch (nlh->nlmsg_type) {
1251     case AUDIT_USER:
1252     case AUDIT_FIRST_USER_MSG ... AUDIT_LAST_USER_MSG:
1253     case AUDIT_FIRST_USER_MSG2 ... AUDIT_LAST_USER_MSG2:
1254         break;
1255     default:
1256         gemu_log("Unknown target audit message type %d\n",
1257                  nlh->nlmsg_type);
1258         return -TARGET_EINVAL;
1259     }
1260
1261     return 0;
1262 }
1263
1264 static abi_long target_to_host_nlmsg_audit(struct nlmsghdr *nlh, size_t len)
1265 {
1266     return target_to_host_for_each_nlmsg(nlh, len, target_to_host_data_audit);
1267 }
1268
1269 static abi_long packet_target_to_host_sockaddr(void *host_addr,
1270                                                abi_ulong target_addr,
1271                                                socklen_t len)
1272 {
1273     struct sockaddr *addr = host_addr;
1274     struct target_sockaddr *target_saddr;
1275
1276     target_saddr = lock_user(VERIFY_READ, target_addr, len, 1);
1277     if (!target_saddr) {
1278         return -TARGET_EFAULT;
1279     }
1280
1281     memcpy(addr, target_saddr, len);
1282     addr->sa_family = tswap16(target_saddr->sa_family);
1283     /* spkt_protocol is big-endian */
1284
1285     unlock_user(target_saddr, target_addr, 0);
1286     return 0;
1287 }
1288
1289 TargetFdTrans target_packet_trans = {
1290     .target_to_host_addr = packet_target_to_host_sockaddr,
1291 };
1292
1293 #ifdef CONFIG_RTNETLINK
1294 static abi_long netlink_route_target_to_host(void *buf, size_t len)
1295 {
1296     abi_long ret;
1297
1298     ret = target_to_host_nlmsg_route(buf, len);
1299     if (ret < 0) {
1300         return ret;
1301     }
1302
1303     return len;
1304 }
1305
1306 static abi_long netlink_route_host_to_target(void *buf, size_t len)
1307 {
1308     abi_long ret;
1309
1310     ret = host_to_target_nlmsg_route(buf, len);
1311     if (ret < 0) {
1312         return ret;
1313     }
1314
1315     return len;
1316 }
1317
1318 TargetFdTrans target_netlink_route_trans = {
1319     .target_to_host_data = netlink_route_target_to_host,
1320     .host_to_target_data = netlink_route_host_to_target,
1321 };
1322 #endif /* CONFIG_RTNETLINK */
1323
1324 static abi_long netlink_audit_target_to_host(void *buf, size_t len)
1325 {
1326     abi_long ret;
1327
1328     ret = target_to_host_nlmsg_audit(buf, len);
1329     if (ret < 0) {
1330         return ret;
1331     }
1332
1333     return len;
1334 }
1335
1336 static abi_long netlink_audit_host_to_target(void *buf, size_t len)
1337 {
1338     abi_long ret;
1339
1340     ret = host_to_target_nlmsg_audit(buf, len);
1341     if (ret < 0) {
1342         return ret;
1343     }
1344
1345     return len;
1346 }
1347
1348 TargetFdTrans target_netlink_audit_trans = {
1349     .target_to_host_data = netlink_audit_target_to_host,
1350     .host_to_target_data = netlink_audit_host_to_target,
1351 };
1352
1353 /* signalfd siginfo conversion */
1354
1355 static void
1356 host_to_target_signalfd_siginfo(struct signalfd_siginfo *tinfo,
1357                                 const struct signalfd_siginfo *info)
1358 {
1359     int sig = host_to_target_signal(info->ssi_signo);
1360
1361     /* linux/signalfd.h defines a ssi_addr_lsb
1362      * not defined in sys/signalfd.h but used by some kernels
1363      */
1364
1365 #ifdef BUS_MCEERR_AO
1366     if (tinfo->ssi_signo == SIGBUS &&
1367         (tinfo->ssi_code == BUS_MCEERR_AR ||
1368          tinfo->ssi_code == BUS_MCEERR_AO)) {
1369         uint16_t *ssi_addr_lsb = (uint16_t *)(&info->ssi_addr + 1);
1370         uint16_t *tssi_addr_lsb = (uint16_t *)(&tinfo->ssi_addr + 1);
1371         *tssi_addr_lsb = tswap16(*ssi_addr_lsb);
1372     }
1373 #endif
1374
1375     tinfo->ssi_signo = tswap32(sig);
1376     tinfo->ssi_errno = tswap32(tinfo->ssi_errno);
1377     tinfo->ssi_code = tswap32(info->ssi_code);
1378     tinfo->ssi_pid = tswap32(info->ssi_pid);
1379     tinfo->ssi_uid = tswap32(info->ssi_uid);
1380     tinfo->ssi_fd = tswap32(info->ssi_fd);
1381     tinfo->ssi_tid = tswap32(info->ssi_tid);
1382     tinfo->ssi_band = tswap32(info->ssi_band);
1383     tinfo->ssi_overrun = tswap32(info->ssi_overrun);
1384     tinfo->ssi_trapno = tswap32(info->ssi_trapno);
1385     tinfo->ssi_status = tswap32(info->ssi_status);
1386     tinfo->ssi_int = tswap32(info->ssi_int);
1387     tinfo->ssi_ptr = tswap64(info->ssi_ptr);
1388     tinfo->ssi_utime = tswap64(info->ssi_utime);
1389     tinfo->ssi_stime = tswap64(info->ssi_stime);
1390     tinfo->ssi_addr = tswap64(info->ssi_addr);
1391 }
1392
1393 static abi_long host_to_target_data_signalfd(void *buf, size_t len)
1394 {
1395     int i;
1396
1397     for (i = 0; i < len; i += sizeof(struct signalfd_siginfo)) {
1398         host_to_target_signalfd_siginfo(buf + i, buf + i);
1399     }
1400
1401     return len;
1402 }
1403
1404 TargetFdTrans target_signalfd_trans = {
1405     .host_to_target_data = host_to_target_data_signalfd,
1406 };
1407
1408 static abi_long swap_data_eventfd(void *buf, size_t len)
1409 {
1410     uint64_t *counter = buf;
1411     int i;
1412
1413     if (len < sizeof(uint64_t)) {
1414         return -EINVAL;
1415     }
1416
1417     for (i = 0; i < len; i += sizeof(uint64_t)) {
1418         *counter = tswap64(*counter);
1419         counter++;
1420     }
1421
1422     return len;
1423 }
1424
1425 TargetFdTrans target_eventfd_trans = {
1426     .host_to_target_data = swap_data_eventfd,
1427     .target_to_host_data = swap_data_eventfd,
1428 };
1429
1430 #if (defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)) || \
1431     (defined(CONFIG_INOTIFY1) && defined(TARGET_NR_inotify_init1) && \
1432      defined(__NR_inotify_init1))
1433 static abi_long host_to_target_data_inotify(void *buf, size_t len)
1434 {
1435     struct inotify_event *ev;
1436     int i;
1437     uint32_t name_len;
1438
1439     for (i = 0; i < len; i += sizeof(struct inotify_event) + name_len) {
1440         ev = (struct inotify_event *)((char *)buf + i);
1441         name_len = ev->len;
1442
1443         ev->wd = tswap32(ev->wd);
1444         ev->mask = tswap32(ev->mask);
1445         ev->cookie = tswap32(ev->cookie);
1446         ev->len = tswap32(name_len);
1447     }
1448
1449     return len;
1450 }
1451
1452 TargetFdTrans target_inotify_trans = {
1453     .host_to_target_data = host_to_target_data_inotify,
1454 };
1455 #endif