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