[qemu.git] / ui / vnc-ws.c

/*
 * QEMU VNC display driver: Websockets support
 *
 * Copyright (C) 2010 Joel Martin
 * Copyright (C) 2012 Tim Hardeck
 *
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this software; if not, see <http://www.gnu.org/licenses/>.
 */

#include "vnc.h"
#include "qemu/main-loop.h"

#ifdef CONFIG_VNC_TLS
#include "qemu/sockets.h"

static void vncws_tls_handshake_io(void *opaque);

static int vncws_start_tls_handshake(struct VncState *vs)
{
    int ret = gnutls_handshake(vs->ws_tls.session);

    if (ret < 0) {
        if (!gnutls_error_is_fatal(ret)) {
            VNC_DEBUG("Handshake interrupted (blocking)\n");
            if (!gnutls_record_get_direction(vs->ws_tls.session)) {
                qemu_set_fd_handler(vs->csock, vncws_tls_handshake_io,
                                    NULL, vs);
            } else {
                qemu_set_fd_handler(vs->csock, NULL, vncws_tls_handshake_io,
                                    vs);
            }
            return 0;
        }
        VNC_DEBUG("Handshake failed %s\n", gnutls_strerror(ret));
        vnc_client_error(vs);
        return -1;
    }

    VNC_DEBUG("Handshake done, switching to TLS data mode\n");
    vs->ws_tls.wiremode = VNC_WIREMODE_TLS;
    qemu_set_fd_handler2(vs->csock, NULL, vncws_handshake_read, NULL, vs);

    return 0;
}

static void vncws_tls_handshake_io(void *opaque)
{
    struct VncState *vs = (struct VncState *)opaque;

    VNC_DEBUG("Handshake IO continue\n");
    vncws_start_tls_handshake(vs);
}

void vncws_tls_handshake_peek(void *opaque)
{
    VncState *vs = opaque;
    long ret;

    if (!vs->ws_tls.session) {
        char peek[4];
        ret = qemu_recv(vs->csock, peek, sizeof(peek), MSG_PEEK);
        if (ret && (strncmp(peek, "\x16", 1) == 0
                    || strncmp(peek, "\x80", 1) == 0)) {
            VNC_DEBUG("TLS Websocket connection recognized");
            vnc_tls_client_setup(vs, 1);
            vncws_start_tls_handshake(vs);
        } else {
            vncws_handshake_read(vs);
        }
    } else {
        qemu_set_fd_handler2(vs->csock, NULL, vncws_handshake_read, NULL, vs);
    }
}
#endif /* CONFIG_VNC_TLS */

void vncws_handshake_read(void *opaque)
{
    VncState *vs = opaque;
    uint8_t *handshake_end;
    long ret;
    buffer_reserve(&vs->ws_input, 4096);
    ret = vnc_client_read_buf(vs, buffer_end(&vs->ws_input), 4096);

    if (!ret) {
        if (vs->csock == -1) {
            vnc_disconnect_finish(vs);
        }
        return;
    }
    vs->ws_input.offset += ret;

    handshake_end = (uint8_t *)g_strstr_len((char *)vs->ws_input.buffer,
            vs->ws_input.offset, WS_HANDSHAKE_END);
    if (handshake_end) {
        qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
        vncws_process_handshake(vs, vs->ws_input.buffer, vs->ws_input.offset);
        buffer_advance(&vs->ws_input, handshake_end - vs->ws_input.buffer +
                strlen(WS_HANDSHAKE_END));
    }
}


long vnc_client_read_ws(VncState *vs)
{
    int ret, err;
    uint8_t *payload;
    size_t payload_size, frame_size;
    VNC_DEBUG("Read websocket %p size %zd offset %zd\n", vs->ws_input.buffer,
            vs->ws_input.capacity, vs->ws_input.offset);
    buffer_reserve(&vs->ws_input, 4096);
    ret = vnc_client_read_buf(vs, buffer_end(&vs->ws_input), 4096);
    if (!ret) {
        return 0;
    }
    vs->ws_input.offset += ret;

    /* make sure that nothing is left in the ws_input buffer */
    do {
        err = vncws_decode_frame(&vs->ws_input, &payload,
                              &payload_size, &frame_size);
        if (err <= 0) {
            return err;
        }

        buffer_reserve(&vs->input, payload_size);
        buffer_append(&vs->input, payload, payload_size);

        buffer_advance(&vs->ws_input, frame_size);
    } while (vs->ws_input.offset > 0);

    return ret;
}

long vnc_client_write_ws(VncState *vs)
{
    long ret;
    VNC_DEBUG("Write WS: Pending output %p size %zd offset %zd\n",
              vs->output.buffer, vs->output.capacity, vs->output.offset);
    vncws_encode_frame(&vs->ws_output, vs->output.buffer, vs->output.offset);
    buffer_reset(&vs->output);
    ret = vnc_client_write_buf(vs, vs->ws_output.buffer, vs->ws_output.offset);
    if (!ret) {
        return 0;
    }

    buffer_advance(&vs->ws_output, ret);

    if (vs->ws_output.offset == 0) {
        qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
    }

    return ret;
}

static char *vncws_extract_handshake_entry(const char *handshake,
        size_t handshake_len, const char *name)
{
    char *begin, *end, *ret = NULL;
    char *line = g_strdup_printf("%s%s: ", WS_HANDSHAKE_DELIM, name);
    begin = g_strstr_len(handshake, handshake_len, line);
    if (begin != NULL) {
        begin += strlen(line);
        end = g_strstr_len(begin, handshake_len - (begin - handshake),
                WS_HANDSHAKE_DELIM);
        if (end != NULL) {
            ret = g_strndup(begin, end - begin);
        }
    }
    g_free(line);
    return ret;
}

static void vncws_send_handshake_response(VncState *vs, const char* key)
{
    char combined_key[WS_CLIENT_KEY_LEN + WS_GUID_LEN + 1];
    unsigned char hash[SHA1_DIGEST_LEN];
    size_t hash_size = sizeof(hash);
    char *accept = NULL, *response = NULL;
    gnutls_datum_t in;
    int ret;

    g_strlcpy(combined_key, key, WS_CLIENT_KEY_LEN + 1);
    g_strlcat(combined_key, WS_GUID, WS_CLIENT_KEY_LEN + WS_GUID_LEN + 1);

    /* hash and encode it */
    in.data = (void *)combined_key;
    in.size = WS_CLIENT_KEY_LEN + WS_GUID_LEN;
    ret = gnutls_fingerprint(GNUTLS_DIG_SHA1, &in, hash, &hash_size);
    if (ret == GNUTLS_E_SUCCESS && hash_size <= SHA1_DIGEST_LEN) {
        accept = g_base64_encode(hash, hash_size);
    }
    if (accept == NULL) {
        VNC_DEBUG("Hashing Websocket combined key failed\n");
        vnc_client_error(vs);
        return;
    }

    response = g_strdup_printf(WS_HANDSHAKE, accept);
    vnc_write(vs, response, strlen(response));
    vnc_flush(vs);

    g_free(accept);
    g_free(response);

    vs->encode_ws = 1;
    vnc_init_state(vs);
}

void vncws_process_handshake(VncState *vs, uint8_t *line, size_t size)
{
    char *protocols = vncws_extract_handshake_entry((const char *)line, size,
            "Sec-WebSocket-Protocol");
    char *version = vncws_extract_handshake_entry((const char *)line, size,
            "Sec-WebSocket-Version");
    char *key = vncws_extract_handshake_entry((const char *)line, size,
            "Sec-WebSocket-Key");

    if (protocols && version && key
            && g_strrstr(protocols, "binary")
            && !strcmp(version, WS_SUPPORTED_VERSION)
            && strlen(key) == WS_CLIENT_KEY_LEN) {
        vncws_send_handshake_response(vs, key);
    } else {
        VNC_DEBUG("Defective Websockets header or unsupported protocol\n");
        vnc_client_error(vs);
    }

    g_free(protocols);
    g_free(version);
    g_free(key);
}

void vncws_encode_frame(Buffer *output, const void *payload,
        const size_t payload_size)
{
    size_t header_size = 0;
    unsigned char opcode = WS_OPCODE_BINARY_FRAME;
    union {
        char buf[WS_HEAD_MAX_LEN];
        WsHeader ws;
    } header;

    if (!payload_size) {
        return;
    }

    header.ws.b0 = 0x80 | (opcode & 0x0f);
    if (payload_size <= 125) {
        header.ws.b1 = (uint8_t)payload_size;
        header_size = 2;
    } else if (payload_size < 65536) {
        header.ws.b1 = 0x7e;
        header.ws.u.s16.l16 = cpu_to_be16((uint16_t)payload_size);
        header_size = 4;
    } else {
        header.ws.b1 = 0x7f;
        header.ws.u.s64.l64 = cpu_to_be64(payload_size);
        header_size = 10;
    }

    buffer_reserve(output, header_size + payload_size);
    buffer_append(output, header.buf, header_size);
    buffer_append(output, payload, payload_size);
}

int vncws_decode_frame(Buffer *input, uint8_t **payload,
                           size_t *payload_size, size_t *frame_size)
{
    unsigned char opcode = 0, fin = 0, has_mask = 0;
    size_t header_size = 0;
    uint32_t *payload32;
    WsHeader *header = (WsHeader *)input->buffer;
    WsMask mask;
    int i;

    if (input->offset < WS_HEAD_MIN_LEN + 4) {
        /* header not complete */
        return 0;
    }

    fin = (header->b0 & 0x80) >> 7;
    opcode = header->b0 & 0x0f;
    has_mask = (header->b1 & 0x80) >> 7;
    *payload_size = header->b1 & 0x7f;

    if (opcode == WS_OPCODE_CLOSE) {
        /* disconnect */
        return -1;
    }

    /* Websocket frame sanity check:
     * * Websocket fragmentation is not supported.
     * * All  websockets frames sent by a client have to be masked.
     * * Only binary encoding is supported.
     */
    if (!fin || !has_mask || opcode != WS_OPCODE_BINARY_FRAME) {
        VNC_DEBUG("Received faulty/unsupported Websocket frame\n");
        return -2;
    }

    if (*payload_size < 126) {
        header_size = 6;
        mask = header->u.m;
    } else if (*payload_size == 126 && input->offset >= 8) {
        *payload_size = be16_to_cpu(header->u.s16.l16);
        header_size = 8;
        mask = header->u.s16.m16;
    } else if (*payload_size == 127 && input->offset >= 14) {
        *payload_size = be64_to_cpu(header->u.s64.l64);
        header_size = 14;
        mask = header->u.s64.m64;
    } else {
        /* header not complete */
        return 0;
    }

    *frame_size = header_size + *payload_size;

    if (input->offset < *frame_size) {
        /* frame not complete */
        return 0;
    }

    *payload = input->buffer + header_size;

    /* unmask frame */
    /* process 1 frame (32 bit op) */
    payload32 = (uint32_t *)(*payload);
    for (i = 0; i < *payload_size / 4; i++) {
        payload32[i] ^= mask.u;
    }
    /* process the remaining bytes (if any) */
    for (i *= 4; i < *payload_size; i++) {
        (*payload)[i] ^= mask.c[i % 4];
    }

    return 1;
}
Commit	Line	Data
7536ee4b TH	1	/*
	2	* QEMU VNC display driver: Websockets support
	3	*
	4	* Copyright (C) 2010 Joel Martin
	5	* Copyright (C) 2012 Tim Hardeck
	6	*
	7	* This is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This software is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this software; if not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
	21	#include "vnc.h"
6a1751b7	22	#include "qemu/main-loop.h"
7536ee4b	23
0057a0d5 TH	24	#ifdef CONFIG_VNC_TLS
	25	#include "qemu/sockets.h"
	26
	27	static void vncws_tls_handshake_io(void *opaque);
	28
	29	static int vncws_start_tls_handshake(struct VncState *vs)
	30	{
	31	int ret = gnutls_handshake(vs->ws_tls.session);
	32
	33	if (ret < 0) {
	34	if (!gnutls_error_is_fatal(ret)) {
	35	VNC_DEBUG("Handshake interrupted (blocking)\n");
	36	if (!gnutls_record_get_direction(vs->ws_tls.session)) {
	37	qemu_set_fd_handler(vs->csock, vncws_tls_handshake_io,
	38	NULL, vs);
	39	} else {
	40	qemu_set_fd_handler(vs->csock, NULL, vncws_tls_handshake_io,
	41	vs);
	42	}
	43	return 0;
	44	}
	45	VNC_DEBUG("Handshake failed %s\n", gnutls_strerror(ret));
	46	vnc_client_error(vs);
	47	return -1;
	48	}
	49
	50	VNC_DEBUG("Handshake done, switching to TLS data mode\n");
	51	vs->ws_tls.wiremode = VNC_WIREMODE_TLS;
	52	qemu_set_fd_handler2(vs->csock, NULL, vncws_handshake_read, NULL, vs);
	53
	54	return 0;
	55	}
	56
	57	static void vncws_tls_handshake_io(void *opaque)
	58	{
	59	struct VncState vs = (struct VncState )opaque;
	60
	61	VNC_DEBUG("Handshake IO continue\n");
	62	vncws_start_tls_handshake(vs);
	63	}
	64
	65	void vncws_tls_handshake_peek(void *opaque)
	66	{
	67	VncState *vs = opaque;
	68	long ret;
	69
	70	if (!vs->ws_tls.session) {
	71	char peek[4];
	72	ret = qemu_recv(vs->csock, peek, sizeof(peek), MSG_PEEK);
	73	if (ret && (strncmp(peek, "\x16", 1) == 0
	74	\|\| strncmp(peek, "\x80", 1) == 0)) {
	75	VNC_DEBUG("TLS Websocket connection recognized");
	76	vnc_tls_client_setup(vs, 1);
	77	vncws_start_tls_handshake(vs);
	78	} else {
	79	vncws_handshake_read(vs);
	80	}
	81	} else {
	82	qemu_set_fd_handler2(vs->csock, NULL, vncws_handshake_read, NULL, vs);
	83	}
	84	}
	85	#endif /* CONFIG_VNC_TLS */
	86
7536ee4b TH	87	void vncws_handshake_read(void *opaque)
	88	{
	89	VncState *vs = opaque;
	90	uint8_t *handshake_end;
	91	long ret;
	92	buffer_reserve(&vs->ws_input, 4096);
	93	ret = vnc_client_read_buf(vs, buffer_end(&vs->ws_input), 4096);
	94
	95	if (!ret) {
	96	if (vs->csock == -1) {
	97	vnc_disconnect_finish(vs);
	98	}
	99	return;
	100	}
	101	vs->ws_input.offset += ret;
	102
	103	handshake_end = (uint8_t )g_strstr_len((char )vs->ws_input.buffer,
	104	vs->ws_input.offset, WS_HANDSHAKE_END);
	105	if (handshake_end) {
	106	qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
	107	vncws_process_handshake(vs, vs->ws_input.buffer, vs->ws_input.offset);
	108	buffer_advance(&vs->ws_input, handshake_end - vs->ws_input.buffer +
	109	strlen(WS_HANDSHAKE_END));
	110	}
	111	}
	112
	113
	114	long vnc_client_read_ws(VncState *vs)
	115	{
	116	int ret, err;
	117	uint8_t *payload;
	118	size_t payload_size, frame_size;
	119	VNC_DEBUG("Read websocket %p size %zd offset %zd\n", vs->ws_input.buffer,
	120	vs->ws_input.capacity, vs->ws_input.offset);
	121	buffer_reserve(&vs->ws_input, 4096);
	122	ret = vnc_client_read_buf(vs, buffer_end(&vs->ws_input), 4096);
	123	if (!ret) {
	124	return 0;
	125	}
	126	vs->ws_input.offset += ret;
	127
	128	/* make sure that nothing is left in the ws_input buffer */
	129	do {
	130	err = vncws_decode_frame(&vs->ws_input, &payload,
	131	&payload_size, &frame_size);
	132	if (err <= 0) {
	133	return err;
	134	}
	135
	136	buffer_reserve(&vs->input, payload_size);
	137	buffer_append(&vs->input, payload, payload_size);
	138
	139	buffer_advance(&vs->ws_input, frame_size);
	140	} while (vs->ws_input.offset > 0);
	141
	142	return ret;
	143	}
	144
	145	long vnc_client_write_ws(VncState *vs)
	146	{
	147	long ret;
	148	VNC_DEBUG("Write WS: Pending output %p size %zd offset %zd\n",
	149	vs->output.buffer, vs->output.capacity, vs->output.offset);
	150	vncws_encode_frame(&vs->ws_output, vs->output.buffer, vs->output.offset);
151	buffer_reset(&vs->output);
152	ret = vnc_client_write_buf(vs, vs->ws_output.buffer, vs->ws_output.offset);
153	if (!ret) {
154	return 0;
155	}
156
157	buffer_advance(&vs->ws_output, ret);
158
159	if (vs->ws_output.offset == 0) {
160	qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
161	}
162
163	return ret;
164	}
165
166	static char vncws_extract_handshake_entry(const char handshake,
167	size_t handshake_len, const char *name)
168	{
169	char begin, end, *ret = NULL;
170	char *line = g_strdup_printf("%s%s: ", WS_HANDSHAKE_DELIM, name);
171	begin = g_strstr_len(handshake, handshake_len, line);
172	if (begin != NULL) {
173	begin += strlen(line);
174	end = g_strstr_len(begin, handshake_len - (begin - handshake),
175	WS_HANDSHAKE_DELIM);
176	if (end != NULL) {
177	ret = g_strndup(begin, end - begin);
178	}
179	}
180	g_free(line);
181	return ret;
182	}
183
184	static void vncws_send_handshake_response(VncState vs, const char key)
185	{
186	char combined_key[WS_CLIENT_KEY_LEN + WS_GUID_LEN + 1];
cfba8e6f MA	187	unsigned char hash[SHA1_DIGEST_LEN];
cfba8e6f MA	188	size_t hash_size = sizeof(hash);
7536ee4b TH	189	char accept = NULL, response = NULL;
7536ee4b TH	190	gnutls_datum_t in;
cfba8e6f	191	int ret;
7536ee4b TH	192
	193	g_strlcpy(combined_key, key, WS_CLIENT_KEY_LEN + 1);
	194	g_strlcat(combined_key, WS_GUID, WS_CLIENT_KEY_LEN + WS_GUID_LEN + 1);
	195
	196	/* hash and encode it */
	197	in.data = (void *)combined_key;
	198	in.size = WS_CLIENT_KEY_LEN + WS_GUID_LEN;
cfba8e6f MA	199	ret = gnutls_fingerprint(GNUTLS_DIG_SHA1, &in, hash, &hash_size);
	200	if (ret == GNUTLS_E_SUCCESS && hash_size <= SHA1_DIGEST_LEN) {
	201	accept = g_base64_encode(hash, hash_size);
7536ee4b TH	202	}
	203	if (accept == NULL) {
	204	VNC_DEBUG("Hashing Websocket combined key failed\n");
	205	vnc_client_error(vs);
	206	return;
	207	}
	208
	209	response = g_strdup_printf(WS_HANDSHAKE, accept);
	210	vnc_write(vs, response, strlen(response));
	211	vnc_flush(vs);
	212
	213	g_free(accept);
	214	g_free(response);
	215
	216	vs->encode_ws = 1;
	217	vnc_init_state(vs);
	218	}
	219
	220	void vncws_process_handshake(VncState vs, uint8_t line, size_t size)
	221	{
	222	char protocols = vncws_extract_handshake_entry((const char )line, size,
	223	"Sec-WebSocket-Protocol");
	224	char version = vncws_extract_handshake_entry((const char )line, size,
	225	"Sec-WebSocket-Version");
	226	char key = vncws_extract_handshake_entry((const char )line, size,
	227	"Sec-WebSocket-Key");
	228
	229	if (protocols && version && key
	230	&& g_strrstr(protocols, "binary")
	231	&& !strcmp(version, WS_SUPPORTED_VERSION)
	232	&& strlen(key) == WS_CLIENT_KEY_LEN) {
	233	vncws_send_handshake_response(vs, key);
	234	} else {
	235	VNC_DEBUG("Defective Websockets header or unsupported protocol\n");
	236	vnc_client_error(vs);
	237	}
	238
	239	g_free(protocols);
	240	g_free(version);
	241	g_free(key);
	242	}
	243
	244	void vncws_encode_frame(Buffer output, const void payload,
	245	const size_t payload_size)
	246	{
	247	size_t header_size = 0;
	248	unsigned char opcode = WS_OPCODE_BINARY_FRAME;
	249	union {
	250	char buf[WS_HEAD_MAX_LEN];
	251	WsHeader ws;
	252	} header;
	253
	254	if (!payload_size) {
	255	return;
	256	}
	257
	258	header.ws.b0 = 0x80 \| (opcode & 0x0f);
	259	if (payload_size <= 125) {
	260	header.ws.b1 = (uint8_t)payload_size;
	261	header_size = 2;
	262	} else if (payload_size < 65536) {
	263	header.ws.b1 = 0x7e;
	264	header.ws.u.s16.l16 = cpu_to_be16((uint16_t)payload_size);
	265	header_size = 4;
266	} else {
267	header.ws.b1 = 0x7f;
268	header.ws.u.s64.l64 = cpu_to_be64(payload_size);
269	header_size = 10;
270	}
271
272	buffer_reserve(output, header_size + payload_size);
273	buffer_append(output, header.buf, header_size);
274	buffer_append(output, payload, payload_size);
275	}
276
277	int vncws_decode_frame(Buffer input, uint8_t *payload,
278	size_t payload_size, size_t frame_size)
279	{
280	unsigned char opcode = 0, fin = 0, has_mask = 0;
281	size_t header_size = 0;
282	uint32_t *payload32;
283	WsHeader header = (WsHeader )input->buffer;
284	WsMask mask;
285	int i;
286
287	if (input->offset < WS_HEAD_MIN_LEN + 4) {
288	/* header not complete */
289	return 0;
290	}
291
292	fin = (header->b0 & 0x80) >> 7;
293	opcode = header->b0 & 0x0f;
294	has_mask = (header->b1 & 0x80) >> 7;
295	*payload_size = header->b1 & 0x7f;
296
297	if (opcode == WS_OPCODE_CLOSE) {
298	/* disconnect */
299	return -1;
300	}
301
302	/* Websocket frame sanity check:
303	* * Websocket fragmentation is not supported.
304	* * All websockets frames sent by a client have to be masked.
305	* * Only binary encoding is supported.
306	*/
307	if (!fin \|\| !has_mask \|\| opcode != WS_OPCODE_BINARY_FRAME) {
308	VNC_DEBUG("Received faulty/unsupported Websocket frame\n");
309	return -2;
310	}
311
312	if (*payload_size < 126) {
313	header_size = 6;
314	mask = header->u.m;
315	} else if (*payload_size == 126 && input->offset >= 8) {
316	*payload_size = be16_to_cpu(header->u.s16.l16);
317	header_size = 8;
318	mask = header->u.s16.m16;
319	} else if (*payload_size == 127 && input->offset >= 14) {
320	*payload_size = be64_to_cpu(header->u.s64.l64);
321	header_size = 14;
322	mask = header->u.s64.m64;
323	} else {
324	/* header not complete */
325	return 0;
326	}
327
328	frame_size = header_size + payload_size;
329
330	if (input->offset < *frame_size) {
331	/* frame not complete */
332	return 0;
333	}
334
335	*payload = input->buffer + header_size;
336
337	/* unmask frame */
338	/* process 1 frame (32 bit op) */
339	payload32 = (uint32_t )(payload);
340	for (i = 0; i < *payload_size / 4; i++) {
341	payload32[i] ^= mask.u;
342	}
343	/* process the remaining bytes (if any) */
344	for (i = 4; i < payload_size; i++) {
345	(*payload)[i] ^= mask.c[i % 4];
346	}
347
348	return 1;
349	}