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