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