[mirror_qemu.git] / net / filter-rewriter.c

/*
 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
 * Copyright (c) 2016 FUJITSU LIMITED
 * Copyright (c) 2016 Intel Corporation
 *
 * Author: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or
 * later.  See the COPYING file in the top-level directory.
 */

#include "qemu/osdep.h"
#include "trace.h"
#include "net/colo.h"
#include "net/filter.h"
#include "net/net.h"
#include "qemu-common.h"
#include "qapi/error.h"
#include "qapi/qmp/qerror.h"
#include "qapi-visit.h"
#include "qom/object.h"
#include "qemu/main-loop.h"
#include "qemu/iov.h"
#include "net/checksum.h"

#define FILTER_COLO_REWRITER(obj) \
    OBJECT_CHECK(RewriterState, (obj), TYPE_FILTER_REWRITER)

#define TYPE_FILTER_REWRITER "filter-rewriter"

typedef struct RewriterState {
    NetFilterState parent_obj;
    NetQueue *incoming_queue;
    /* hashtable to save connection */
    GHashTable *connection_track_table;
} RewriterState;

static void filter_rewriter_flush(NetFilterState *nf)
{
    RewriterState *s = FILTER_COLO_REWRITER(nf);

    if (!qemu_net_queue_flush(s->incoming_queue)) {
        /* Unable to empty the queue, purge remaining packets */
        qemu_net_queue_purge(s->incoming_queue, nf->netdev);
    }
}

/*
 * Return 1 on success, if return 0 means the pkt
 * is not TCP packet
 */
static int is_tcp_packet(Packet *pkt)
{
    if (!parse_packet_early(pkt) &&
        pkt->ip->ip_p == IPPROTO_TCP) {
        return 1;
    } else {
        return 0;
    }
}

/* handle tcp packet from primary guest */
static int handle_primary_tcp_pkt(NetFilterState *nf,
                                  Connection *conn,
                                  Packet *pkt)
{
    struct tcphdr *tcp_pkt;

    tcp_pkt = (struct tcphdr *)pkt->transport_header;
    if (trace_event_get_state(TRACE_COLO_FILTER_REWRITER_DEBUG)) {
        char *sdebug, *ddebug;
        sdebug = strdup(inet_ntoa(pkt->ip->ip_src));
        ddebug = strdup(inet_ntoa(pkt->ip->ip_dst));
        trace_colo_filter_rewriter_pkt_info(__func__, sdebug, ddebug,
                    ntohl(tcp_pkt->th_seq), ntohl(tcp_pkt->th_ack),
                    tcp_pkt->th_flags);
        trace_colo_filter_rewriter_conn_offset(conn->offset);
        g_free(sdebug);
        g_free(ddebug);
    }

    if (((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == TH_SYN)) {
        /*
         * we use this flag update offset func
         * run once in independent tcp connection
         */
        conn->syn_flag = 1;
    }

    if (((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == TH_ACK)) {
        if (conn->syn_flag) {
            /*
             * offset = secondary_seq - primary seq
             * ack packet sent by guest from primary node,
             * so we use th_ack - 1 get primary_seq
             */
            conn->offset -= (ntohl(tcp_pkt->th_ack) - 1);
            conn->syn_flag = 0;
        }
        /* handle packets to the secondary from the primary */
        tcp_pkt->th_ack = htonl(ntohl(tcp_pkt->th_ack) + conn->offset);

        net_checksum_calculate((uint8_t *)pkt->data, pkt->size);
    }

    return 0;
}

/* handle tcp packet from secondary guest */
static int handle_secondary_tcp_pkt(NetFilterState *nf,
                                    Connection *conn,
                                    Packet *pkt)
{
    struct tcphdr *tcp_pkt;

    tcp_pkt = (struct tcphdr *)pkt->transport_header;

    if (trace_event_get_state(TRACE_COLO_FILTER_REWRITER_DEBUG)) {
        char *sdebug, *ddebug;
        sdebug = strdup(inet_ntoa(pkt->ip->ip_src));
        ddebug = strdup(inet_ntoa(pkt->ip->ip_dst));
        trace_colo_filter_rewriter_pkt_info(__func__, sdebug, ddebug,
                    ntohl(tcp_pkt->th_seq), ntohl(tcp_pkt->th_ack),
                    tcp_pkt->th_flags);
        trace_colo_filter_rewriter_conn_offset(conn->offset);
        g_free(sdebug);
        g_free(ddebug);
    }

    if (((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == (TH_ACK | TH_SYN))) {
        /*
         * save offset = secondary_seq and then
         * in handle_primary_tcp_pkt make offset
         * = secondary_seq - primary_seq
         */
        conn->offset = ntohl(tcp_pkt->th_seq);
    }

    if ((tcp_pkt->th_flags & (TH_ACK | TH_SYN)) == TH_ACK) {
        /* handle packets to the primary from the secondary*/
        tcp_pkt->th_seq = htonl(ntohl(tcp_pkt->th_seq) - conn->offset);

        net_checksum_calculate((uint8_t *)pkt->data, pkt->size);
    }

    return 0;
}

static ssize_t colo_rewriter_receive_iov(NetFilterState *nf,
                                         NetClientState *sender,
                                         unsigned flags,
                                         const struct iovec *iov,
                                         int iovcnt,
                                         NetPacketSent *sent_cb)
{
    RewriterState *s = FILTER_COLO_REWRITER(nf);
    Connection *conn;
    ConnectionKey key;
    Packet *pkt;
    ssize_t size = iov_size(iov, iovcnt);
    char *buf = g_malloc0(size);

    iov_to_buf(iov, iovcnt, 0, buf, size);
    pkt = packet_new(buf, size);

    /*
     * if we get tcp packet
     * we will rewrite it to make secondary guest's
     * connection established successfully
     */
    if (pkt && is_tcp_packet(pkt)) {

        fill_connection_key(pkt, &key);

        if (sender == nf->netdev) {
            /*
             * We need make tcp TX and RX packet
             * into one connection.
             */
            reverse_connection_key(&key);
        }
        conn = connection_get(s->connection_track_table,
                              &key,
                              NULL);

        if (sender == nf->netdev) {
            /* NET_FILTER_DIRECTION_TX */
            if (!handle_primary_tcp_pkt(nf, conn, pkt)) {
                qemu_net_queue_send(s->incoming_queue, sender, 0,
                (const uint8_t *)pkt->data, pkt->size, NULL);
                packet_destroy(pkt, NULL);
                pkt = NULL;
                /*
                 * We block the packet here,after rewrite pkt
                 * and will send it
                 */
                return 1;
            }
        } else {
            /* NET_FILTER_DIRECTION_RX */
            if (!handle_secondary_tcp_pkt(nf, conn, pkt)) {
                qemu_net_queue_send(s->incoming_queue, sender, 0,
                (const uint8_t *)pkt->data, pkt->size, NULL);
                packet_destroy(pkt, NULL);
                pkt = NULL;
                /*
                 * We block the packet here,after rewrite pkt
                 * and will send it
                 */
                return 1;
            }
        }
    }

    packet_destroy(pkt, NULL);
    pkt = NULL;
    return 0;
}

static void colo_rewriter_cleanup(NetFilterState *nf)
{
    RewriterState *s = FILTER_COLO_REWRITER(nf);

    /* flush packets */
    if (s->incoming_queue) {
        filter_rewriter_flush(nf);
        g_free(s->incoming_queue);
    }
}

static void colo_rewriter_setup(NetFilterState *nf, Error **errp)
{
    RewriterState *s = FILTER_COLO_REWRITER(nf);

    s->connection_track_table = g_hash_table_new_full(connection_key_hash,
                                                      connection_key_equal,
                                                      g_free,
                                                      connection_destroy);
    s->incoming_queue = qemu_new_net_queue(qemu_netfilter_pass_to_next, nf);
}

static void colo_rewriter_class_init(ObjectClass *oc, void *data)
{
    NetFilterClass *nfc = NETFILTER_CLASS(oc);

    nfc->setup = colo_rewriter_setup;
    nfc->cleanup = colo_rewriter_cleanup;
    nfc->receive_iov = colo_rewriter_receive_iov;
}

static const TypeInfo colo_rewriter_info = {
    .name = TYPE_FILTER_REWRITER,
    .parent = TYPE_NETFILTER,
    .class_init = colo_rewriter_class_init,
    .instance_size = sizeof(RewriterState),
};

static void register_types(void)
{
    type_register_static(&colo_rewriter_info);
}

type_init(register_types);
Commit	Line	Data
e6eee8ab ZC	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"
30656b09	13	#include "trace.h"
e6eee8ab ZC	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
afe46124 ZC	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
30656b09 ZC	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
e6eee8ab ZC	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	{
afe46124 ZC	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
e6eee8ab ZC	166	/*
	167	* if we get tcp packet
	168	* we will rewrite it to make secondary guest's
	169	* connection established successfully
	170	*/
afe46124 ZC	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 */
30656b09 ZC	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	}
afe46124 ZC	199	} else {
afe46124 ZC	200	/* NET_FILTER_DIRECTION_RX */
30656b09 ZC	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	}
afe46124 ZC	212	}
	213	}
	214
	215	packet_destroy(pkt, NULL);
	216	pkt = NULL;
e6eee8ab ZC	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);