net/filter-rewriter.c

   1 /*
   2  * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
   3  * Copyright (c) 2016 FUJITSU LIMITED
   4  * Copyright (c) 2016 Intel Corporation
   5  *
   6  * Author: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
   7  *
   8  * This work is licensed under the terms of the GNU GPL, version 2 or
   9  * later.  See the COPYING file in the top-level directory.
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include "trace.h"
  14 #include "net/colo.h"
  15 #include "net/filter.h"
  16 #include "net/net.h"
  17 #include "qemu-common.h"
  18 #include "qapi/error.h"
  19 #include "qapi/qmp/qerror.h"
  20 #include "qapi-visit.h"
  21 #include "qom/object.h"
  22 #include "qemu/main-loop.h"
  23 #include "qemu/iov.h"
  24 #include "net/checksum.h"
  25
  26 #define FILTER_COLO_REWRITER(obj) \
  27     OBJECT_CHECK(RewriterState, (obj), TYPE_FILTER_REWRITER)
  28
  29 #define TYPE_FILTER_REWRITER "filter-rewriter"
  30
  31 typedef struct RewriterState {
  32     NetFilterState parent_obj;
  33     NetQueue *incoming_queue;
  34     /* hashtable to save connection */
  35     GHashTable *connection_track_table;
  36 } RewriterState;
  37
  38 static void filter_rewriter_flush(NetFilterState *nf)
  39 {
  40     RewriterState *s = FILTER_COLO_REWRITER(nf);
  41
  42     if (!qemu_net_queue_flush(s->incoming_queue)) {
  43         /* Unable to empty the queue, purge remaining packets */
  44         qemu_net_queue_purge(s->incoming_queue, nf->netdev);
  45     }
  46 }
  47
  48 /*
  49  * Return 1 on success, if return 0 means the pkt
  50  * is not TCP packet
  51  */
  52 static int is_tcp_packet(Packet *pkt)
  53 {
  54     if (!parse_packet_early(pkt) &&
  55         pkt->ip->ip_p == IPPROTO_TCP) {
  56         return 1;
  57     } else {
  58         return 0;
  59     }
  60 }
  61
  62 /* handle tcp packet from primary guest */
  63 static int handle_primary_tcp_pkt(NetFilterState *nf,
  64                                   Connection *conn,
  65                                   Packet *pkt)
  66 {
  67     struct tcphdr *tcp_pkt;
  68
  69     tcp_pkt = (struct tcphdr *)pkt->transport_header;
  70     if (trace_event_get_state(TRACE_COLO_FILTER_REWRITER_DEBUG)) {
  71         char *sdebug, *ddebug;
  72         sdebug = strdup(inet_ntoa(pkt->ip->ip_src));
  73         ddebug = strdup(inet_ntoa(pkt->ip->ip_dst));
  74         trace_colo_filter_rewriter_pkt_info(__func__, sdebug, ddebug,
  75                     ntohl(tcp_pkt->th_seq), ntohl(tcp_pkt->th_ack),
  76                     tcp_pkt->th_flags);
  77         trace_colo_filter_rewriter_conn_offset(conn->offset);
  78         g_free(sdebug);
  79         g_free(ddebug);
  80     }
  81
  82     if (((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == TH_SYN)) {
  83         /*
  84          * we use this flag update offset func
  85          * run once in independent tcp connection
  86          */
  87         conn->syn_flag = 1;
  88     }
  89
  90     if (((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == TH_ACK)) {
  91         if (conn->syn_flag) {
  92             /*
  93              * offset = secondary_seq - primary seq
  94              * ack packet sent by guest from primary node,
  95              * so we use th_ack - 1 get primary_seq
  96              */
  97             conn->offset -= (ntohl(tcp_pkt->th_ack) - 1);
  98             conn->syn_flag = 0;
  99         }
 100         /* handle packets to the secondary from the primary */
 101         tcp_pkt->th_ack = htonl(ntohl(tcp_pkt->th_ack) + conn->offset);
 102
 103         net_checksum_calculate((uint8_t *)pkt->data, pkt->size);
 104     }
 105
 106     return 0;
 107 }
 108
 109 /* handle tcp packet from secondary guest */
 110 static int handle_secondary_tcp_pkt(NetFilterState *nf,
 111                                     Connection *conn,
 112                                     Packet *pkt)
 113 {
 114     struct tcphdr *tcp_pkt;
 115
 116     tcp_pkt = (struct tcphdr *)pkt->transport_header;
 117
 118     if (trace_event_get_state(TRACE_COLO_FILTER_REWRITER_DEBUG)) {
 119         char *sdebug, *ddebug;
 120         sdebug = strdup(inet_ntoa(pkt->ip->ip_src));
 121         ddebug = strdup(inet_ntoa(pkt->ip->ip_dst));
 122         trace_colo_filter_rewriter_pkt_info(__func__, sdebug, ddebug,
 123                     ntohl(tcp_pkt->th_seq), ntohl(tcp_pkt->th_ack),
 124                     tcp_pkt->th_flags);
 125         trace_colo_filter_rewriter_conn_offset(conn->offset);
 126         g_free(sdebug);
 127         g_free(ddebug);
 128     }
 129
 130     if (((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == (TH_ACK | TH_SYN))) {
 131         /*
 132          * save offset = secondary_seq and then
 133          * in handle_primary_tcp_pkt make offset
 134          * = secondary_seq - primary_seq
 135          */
 136         conn->offset = ntohl(tcp_pkt->th_seq);
 137     }
 138
 139     if ((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == TH_ACK) {
 140         /* handle packets to the primary from the secondary*/
 141         tcp_pkt->th_seq = htonl(ntohl(tcp_pkt->th_seq) - conn->offset);
 142
 143         net_checksum_calculate((uint8_t *)pkt->data, pkt->size);
 144     }
 145
 146     return 0;
 147 }
 148
 149 static ssize_t colo_rewriter_receive_iov(NetFilterState *nf,
 150                                          NetClientState *sender,
 151                                          unsigned flags,
 152                                          const struct iovec *iov,
 153                                          int iovcnt,
 154                                          NetPacketSent *sent_cb)
 155 {
 156     RewriterState *s = FILTER_COLO_REWRITER(nf);
 157     Connection *conn;
 158     ConnectionKey key;
 159     Packet *pkt;
 160     ssize_t size = iov_size(iov, iovcnt);
 161     char *buf = g_malloc0(size);
 162
 163     iov_to_buf(iov, iovcnt, 0, buf, size);
 164     pkt = packet_new(buf, size);
 165
 166     /*
 167      * if we get tcp packet
 168      * we will rewrite it to make secondary guest's
 169      * connection established successfully
 170      */
 171     if (pkt && is_tcp_packet(pkt)) {
 172
 173         fill_connection_key(pkt, &key);
 174
 175         if (sender == nf->netdev) {
 176             /*
 177              * We need make tcp TX and RX packet
 178              * into one connection.
 179              */
 180             reverse_connection_key(&key);
 181         }
 182         conn = connection_get(s->connection_track_table,
 183                               &key,
 184                               NULL);
 185
 186         if (sender == nf->netdev) {
 187             /* NET_FILTER_DIRECTION_TX */
 188             if (!handle_primary_tcp_pkt(nf, conn, pkt)) {
 189                 qemu_net_queue_send(s->incoming_queue, sender, 0,
 190                 (const uint8_t *)pkt->data, pkt->size, NULL);
 191                 packet_destroy(pkt, NULL);
 192                 pkt = NULL;
 193                 /*
 194                  * We block the packet here,after rewrite pkt
 195                  * and will send it
 196                  */
 197                 return 1;
 198             }
 199         } else {
 200             /* NET_FILTER_DIRECTION_RX */
 201             if (!handle_secondary_tcp_pkt(nf, conn, pkt)) {
 202                 qemu_net_queue_send(s->incoming_queue, sender, 0,
 203                 (const uint8_t *)pkt->data, pkt->size, NULL);
 204                 packet_destroy(pkt, NULL);
 205                 pkt = NULL;
 206                 /*
 207                  * We block the packet here,after rewrite pkt
 208                  * and will send it
 209                  */
 210                 return 1;
 211             }
 212         }
 213     }
 214
 215     packet_destroy(pkt, NULL);
 216     pkt = NULL;
 217     return 0;
 218 }
 219
 220 static void colo_rewriter_cleanup(NetFilterState *nf)
 221 {
 222     RewriterState *s = FILTER_COLO_REWRITER(nf);
 223
 224     /* flush packets */
 225     if (s->incoming_queue) {
 226         filter_rewriter_flush(nf);
 227         g_free(s->incoming_queue);
 228     }
 229 }
 230
 231 static void colo_rewriter_setup(NetFilterState *nf, Error **errp)
 232 {
 233     RewriterState *s = FILTER_COLO_REWRITER(nf);
 234
 235     s->connection_track_table = g_hash_table_new_full(connection_key_hash,
 236                                                       connection_key_equal,
 237                                                       g_free,
 238                                                       connection_destroy);
 239     s->incoming_queue = qemu_new_net_queue(qemu_netfilter_pass_to_next, nf);
 240 }
 241
 242 static void colo_rewriter_class_init(ObjectClass *oc, void *data)
 243 {
 244     NetFilterClass *nfc = NETFILTER_CLASS(oc);
 245
 246     nfc->setup = colo_rewriter_setup;
 247     nfc->cleanup = colo_rewriter_cleanup;
 248     nfc->receive_iov = colo_rewriter_receive_iov;
 249 }
 250
 251 static const TypeInfo colo_rewriter_info = {
 252     .name = TYPE_FILTER_REWRITER,
 253     .parent = TYPE_NETFILTER,
 254     .class_init = colo_rewriter_class_init,
 255     .instance_size = sizeof(RewriterState),
 256 };
 257
 258 static void register_types(void)
 259 {
 260     type_register_static(&colo_rewriter_info);
 261 }
 262
 263 type_init(register_types);