/**************************************************************************** ** ** Copyright (C) 2014 BlackBerry Limited. All rights reserved. ** Copyright (C) 2016 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtNetwork module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and The Qt Company. For licensing terms ** and conditions see https://www.qt.io/terms-conditions. For further ** information use the contact form at https://www.qt.io/contact-us. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 3 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL3 included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 3 requirements ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU ** General Public License version 2.0 or (at your option) the GNU General ** Public license version 3 or any later version approved by the KDE Free ** Qt Foundation. The licenses are as published by the Free Software ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 ** included in the packaging of this file. Please review the following ** information to ensure the GNU General Public License requirements will ** be met: https://www.gnu.org/licenses/gpl-2.0.html and ** https://www.gnu.org/licenses/gpl-3.0.html. ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include #include #include #include #if !defined(QT_NO_SSL) QT_BEGIN_NAMESPACE static const char spdyDictionary[] = { 0x00, 0x00, 0x00, 0x07, 0x6f, 0x70, 0x74, 0x69, // ....opti 0x6f, 0x6e, 0x73, 0x00, 0x00, 0x00, 0x04, 0x68, // ons....h 0x65, 0x61, 0x64, 0x00, 0x00, 0x00, 0x04, 0x70, // ead....p 0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x03, 0x70, // ost....p 0x75, 0x74, 0x00, 0x00, 0x00, 0x06, 0x64, 0x65, // ut....de 0x6c, 0x65, 0x74, 0x65, 0x00, 0x00, 0x00, 0x05, // lete.... 0x74, 0x72, 0x61, 0x63, 0x65, 0x00, 0x00, 0x00, // trace... 0x06, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x00, // .accept. 0x00, 0x00, 0x0e, 0x61, 0x63, 0x63, 0x65, 0x70, // ...accep 0x74, 0x2d, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, // t-charse 0x74, 0x00, 0x00, 0x00, 0x0f, 0x61, 0x63, 0x63, // t....acc 0x65, 0x70, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f, // ept-enco 0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x0f, // ding.... 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x6c, // accept-l 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x00, // anguage. 0x00, 0x00, 0x0d, 0x61, 0x63, 0x63, 0x65, 0x70, // ...accep 0x74, 0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, // t-ranges 0x00, 0x00, 0x00, 0x03, 0x61, 0x67, 0x65, 0x00, // ....age. 0x00, 0x00, 0x05, 0x61, 0x6c, 0x6c, 0x6f, 0x77, // ...allow 0x00, 0x00, 0x00, 0x0d, 0x61, 0x75, 0x74, 0x68, // ....auth 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, // orizatio 0x6e, 0x00, 0x00, 0x00, 0x0d, 0x63, 0x61, 0x63, // n....cac 0x68, 0x65, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, // he-contr 0x6f, 0x6c, 0x00, 0x00, 0x00, 0x0a, 0x63, 0x6f, // ol....co 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, // nnection 0x00, 0x00, 0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, // ....cont 0x65, 0x6e, 0x74, 0x2d, 0x62, 0x61, 0x73, 0x65, // ent-base 0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, 0x6e, 0x74, // ....cont 0x65, 0x6e, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f, // ent-enco 0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, // ding.... 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, // content- 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, // language 0x00, 0x00, 0x00, 0x0e, 0x63, 0x6f, 0x6e, 0x74, // ....cont 0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x65, 0x6e, 0x67, // ent-leng 0x74, 0x68, 0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, // th....co 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x6f, // ntent-lo 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, // cation.. 0x00, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, // ..conten 0x74, 0x2d, 0x6d, 0x64, 0x35, 0x00, 0x00, 0x00, // t-md5... 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, // .content 0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, // -range.. 0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, // ..conten 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x00, 0x00, // t-type.. 0x00, 0x04, 0x64, 0x61, 0x74, 0x65, 0x00, 0x00, // ..date.. 0x00, 0x04, 0x65, 0x74, 0x61, 0x67, 0x00, 0x00, // ..etag.. 0x00, 0x06, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, // ..expect 0x00, 0x00, 0x00, 0x07, 0x65, 0x78, 0x70, 0x69, // ....expi 0x72, 0x65, 0x73, 0x00, 0x00, 0x00, 0x04, 0x66, // res....f 0x72, 0x6f, 0x6d, 0x00, 0x00, 0x00, 0x04, 0x68, // rom....h 0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x08, 0x69, // ost....i 0x66, 0x2d, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, // f-match. 0x00, 0x00, 0x11, 0x69, 0x66, 0x2d, 0x6d, 0x6f, // ...if-mo 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2d, 0x73, // dified-s 0x69, 0x6e, 0x63, 0x65, 0x00, 0x00, 0x00, 0x0d, // ince.... 0x69, 0x66, 0x2d, 0x6e, 0x6f, 0x6e, 0x65, 0x2d, // if-none- 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, 0x00, 0x00, // match... 0x08, 0x69, 0x66, 0x2d, 0x72, 0x61, 0x6e, 0x67, // .if-rang 0x65, 0x00, 0x00, 0x00, 0x13, 0x69, 0x66, 0x2d, // e....if- 0x75, 0x6e, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, // unmodifi 0x65, 0x64, 0x2d, 0x73, 0x69, 0x6e, 0x63, 0x65, // ed-since 0x00, 0x00, 0x00, 0x0d, 0x6c, 0x61, 0x73, 0x74, // ....last 0x2d, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, // -modifie 0x64, 0x00, 0x00, 0x00, 0x08, 0x6c, 0x6f, 0x63, // d....loc 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, // ation... 0x0c, 0x6d, 0x61, 0x78, 0x2d, 0x66, 0x6f, 0x72, // .max-for 0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x00, 0x00, // wards... 0x06, 0x70, 0x72, 0x61, 0x67, 0x6d, 0x61, 0x00, // .pragma. 0x00, 0x00, 0x12, 0x70, 0x72, 0x6f, 0x78, 0x79, // ...proxy 0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, // -authent 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00, // icate... 0x13, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2d, 0x61, // .proxy-a 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, // uthoriza 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x05, // tion.... 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, 0x00, // range... 0x07, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x72, // .referer 0x00, 0x00, 0x00, 0x0b, 0x72, 0x65, 0x74, 0x72, // ....retr 0x79, 0x2d, 0x61, 0x66, 0x74, 0x65, 0x72, 0x00, // y-after. 0x00, 0x00, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65, // ...serve 0x72, 0x00, 0x00, 0x00, 0x02, 0x74, 0x65, 0x00, // r....te. 0x00, 0x00, 0x07, 0x74, 0x72, 0x61, 0x69, 0x6c, // ...trail 0x65, 0x72, 0x00, 0x00, 0x00, 0x11, 0x74, 0x72, // er....tr 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2d, 0x65, // ansfer-e 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x00, // ncoding. 0x00, 0x00, 0x07, 0x75, 0x70, 0x67, 0x72, 0x61, // ...upgra 0x64, 0x65, 0x00, 0x00, 0x00, 0x0a, 0x75, 0x73, // de....us 0x65, 0x72, 0x2d, 0x61, 0x67, 0x65, 0x6e, 0x74, // er-agent 0x00, 0x00, 0x00, 0x04, 0x76, 0x61, 0x72, 0x79, // ....vary 0x00, 0x00, 0x00, 0x03, 0x76, 0x69, 0x61, 0x00, // ....via. 0x00, 0x00, 0x07, 0x77, 0x61, 0x72, 0x6e, 0x69, // ...warni 0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, 0x77, 0x77, // ng....ww 0x77, 0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, // w-authen 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, // ticate.. 0x00, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, // ..method 0x00, 0x00, 0x00, 0x03, 0x67, 0x65, 0x74, 0x00, // ....get. 0x00, 0x00, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, // ...statu 0x73, 0x00, 0x00, 0x00, 0x06, 0x32, 0x30, 0x30, // s....200 0x20, 0x4f, 0x4b, 0x00, 0x00, 0x00, 0x07, 0x76, // .OK....v 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00, // ersion.. 0x00, 0x08, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, // ..HTTP.1 0x2e, 0x31, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72, // .1....ur 0x6c, 0x00, 0x00, 0x00, 0x06, 0x70, 0x75, 0x62, // l....pub 0x6c, 0x69, 0x63, 0x00, 0x00, 0x00, 0x0a, 0x73, // lic....s 0x65, 0x74, 0x2d, 0x63, 0x6f, 0x6f, 0x6b, 0x69, // et-cooki 0x65, 0x00, 0x00, 0x00, 0x0a, 0x6b, 0x65, 0x65, // e....kee 0x70, 0x2d, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x00, // p-alive. 0x00, 0x00, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, // ...origi 0x6e, 0x31, 0x30, 0x30, 0x31, 0x30, 0x31, 0x32, // n1001012 0x30, 0x31, 0x32, 0x30, 0x32, 0x32, 0x30, 0x35, // 01202205 0x32, 0x30, 0x36, 0x33, 0x30, 0x30, 0x33, 0x30, // 20630030 0x32, 0x33, 0x30, 0x33, 0x33, 0x30, 0x34, 0x33, // 23033043 0x30, 0x35, 0x33, 0x30, 0x36, 0x33, 0x30, 0x37, // 05306307 0x34, 0x30, 0x32, 0x34, 0x30, 0x35, 0x34, 0x30, // 40240540 0x36, 0x34, 0x30, 0x37, 0x34, 0x30, 0x38, 0x34, // 64074084 0x30, 0x39, 0x34, 0x31, 0x30, 0x34, 0x31, 0x31, // 09410411 0x34, 0x31, 0x32, 0x34, 0x31, 0x33, 0x34, 0x31, // 41241341 0x34, 0x34, 0x31, 0x35, 0x34, 0x31, 0x36, 0x34, // 44154164 0x31, 0x37, 0x35, 0x30, 0x32, 0x35, 0x30, 0x34, // 17502504 0x35, 0x30, 0x35, 0x32, 0x30, 0x33, 0x20, 0x4e, // 505203.N 0x6f, 0x6e, 0x2d, 0x41, 0x75, 0x74, 0x68, 0x6f, // on-Autho 0x72, 0x69, 0x74, 0x61, 0x74, 0x69, 0x76, 0x65, // ritative 0x20, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, // .Informa 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x30, 0x34, 0x20, // tion204. 0x4e, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65, // No.Conte 0x6e, 0x74, 0x33, 0x30, 0x31, 0x20, 0x4d, 0x6f, // nt301.Mo 0x76, 0x65, 0x64, 0x20, 0x50, 0x65, 0x72, 0x6d, // ved.Perm 0x61, 0x6e, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x34, // anently4 0x30, 0x30, 0x20, 0x42, 0x61, 0x64, 0x20, 0x52, // 00.Bad.R 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x34, 0x30, // equest40 0x31, 0x20, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, // 1.Unauth 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x34, 0x30, // orized40 0x33, 0x20, 0x46, 0x6f, 0x72, 0x62, 0x69, 0x64, // 3.Forbid 0x64, 0x65, 0x6e, 0x34, 0x30, 0x34, 0x20, 0x4e, // den404.N 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, // ot.Found 0x35, 0x30, 0x30, 0x20, 0x49, 0x6e, 0x74, 0x65, // 500.Inte 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x53, 0x65, 0x72, // rnal.Ser 0x76, 0x65, 0x72, 0x20, 0x45, 0x72, 0x72, 0x6f, // ver.Erro 0x72, 0x35, 0x30, 0x31, 0x20, 0x4e, 0x6f, 0x74, // r501.Not 0x20, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, // .Impleme 0x6e, 0x74, 0x65, 0x64, 0x35, 0x30, 0x33, 0x20, // nted503. 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, // Service. 0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, // Unavaila 0x62, 0x6c, 0x65, 0x4a, 0x61, 0x6e, 0x20, 0x46, // bleJan.F 0x65, 0x62, 0x20, 0x4d, 0x61, 0x72, 0x20, 0x41, // eb.Mar.A 0x70, 0x72, 0x20, 0x4d, 0x61, 0x79, 0x20, 0x4a, // pr.May.J 0x75, 0x6e, 0x20, 0x4a, 0x75, 0x6c, 0x20, 0x41, // un.Jul.A 0x75, 0x67, 0x20, 0x53, 0x65, 0x70, 0x74, 0x20, // ug.Sept. 0x4f, 0x63, 0x74, 0x20, 0x4e, 0x6f, 0x76, 0x20, // Oct.Nov. 0x44, 0x65, 0x63, 0x20, 0x30, 0x30, 0x3a, 0x30, // Dec.00.0 0x30, 0x3a, 0x30, 0x30, 0x20, 0x4d, 0x6f, 0x6e, // 0.00.Mon 0x2c, 0x20, 0x54, 0x75, 0x65, 0x2c, 0x20, 0x57, // ..Tue..W 0x65, 0x64, 0x2c, 0x20, 0x54, 0x68, 0x75, 0x2c, // ed..Thu. 0x20, 0x46, 0x72, 0x69, 0x2c, 0x20, 0x53, 0x61, // .Fri..Sa 0x74, 0x2c, 0x20, 0x53, 0x75, 0x6e, 0x2c, 0x20, // t..Sun.. 0x47, 0x4d, 0x54, 0x63, 0x68, 0x75, 0x6e, 0x6b, // GMTchunk 0x65, 0x64, 0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, // ed.text. 0x68, 0x74, 0x6d, 0x6c, 0x2c, 0x69, 0x6d, 0x61, // html.ima 0x67, 0x65, 0x2f, 0x70, 0x6e, 0x67, 0x2c, 0x69, // ge.png.i 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x6a, 0x70, 0x67, // mage.jpg 0x2c, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x67, // .image.g 0x69, 0x66, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69, // if.appli 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78, // cation.x 0x6d, 0x6c, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69, // ml.appli 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78, // cation.x 0x68, 0x74, 0x6d, 0x6c, 0x2b, 0x78, 0x6d, 0x6c, // html.xml 0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x70, 0x6c, // .text.pl 0x61, 0x69, 0x6e, 0x2c, 0x74, 0x65, 0x78, 0x74, // ain.text 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, // .javascr 0x69, 0x70, 0x74, 0x2c, 0x70, 0x75, 0x62, 0x6c, // ipt.publ 0x69, 0x63, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, // icprivat 0x65, 0x6d, 0x61, 0x78, 0x2d, 0x61, 0x67, 0x65, // emax-age 0x3d, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x64, 0x65, // .gzip.de 0x66, 0x6c, 0x61, 0x74, 0x65, 0x2c, 0x73, 0x64, // flate.sd 0x63, 0x68, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, // chcharse 0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x63, // t.utf-8c 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x69, // harset.i 0x73, 0x6f, 0x2d, 0x38, 0x38, 0x35, 0x39, 0x2d, // so-8859- 0x31, 0x2c, 0x75, 0x74, 0x66, 0x2d, 0x2c, 0x2a, // 1.utf-.. 0x2c, 0x65, 0x6e, 0x71, 0x3d, 0x30, 0x2e // .enq.0. }; // uncomment to debug //static void printHex(const QByteArray &ba) //{ // QByteArray hex; // QByteArray clearText; // for (int a = 0; a < ba.count(); ++a) { // QByteArray currentHexChar = QByteArray(1, ba.at(a)).toHex().rightJustified(2, ' '); // QByteArray currentChar; // if (ba.at(a) >= 32 && ba.at(a) < 126) { // if ASCII, print the letter // currentChar = QByteArray(1, ba.at(a)); // } else { // currentChar = " "; // } // clearText.append(currentChar.rightJustified(2, ' ')); // hex.append(currentHexChar); // hex.append(' '); // clearText.append(' '); // } // int chunkSize = 102; // 12 == 4 bytes per line // for (int a = 0; a < hex.count(); a += chunkSize) { // qDebug() << hex.mid(a, chunkSize); // qDebug() << clearText.mid(a, chunkSize); // } //} QSpdyProtocolHandler::QSpdyProtocolHandler(QHttpNetworkConnectionChannel *channel) : QObject(0), QAbstractProtocolHandler(channel), m_nextStreamID(-1), m_maxConcurrentStreams(100), // 100 is recommended in the SPDY RFC m_initialWindowSize(0), m_waitingForCompleteStream(false) { m_inflateStream.zalloc = Z_NULL; m_inflateStream.zfree = Z_NULL; m_inflateStream.opaque = Z_NULL; int zlibRet = inflateInit(&m_inflateStream); Q_ASSERT(zlibRet == Z_OK); m_deflateStream.zalloc = Z_NULL; m_deflateStream.zfree = Z_NULL; m_deflateStream.opaque = Z_NULL; // Do actually not compress (i.e. compression level = 0) // when sending the headers because of the CRIME attack zlibRet = deflateInit(&m_deflateStream, /* compression level = */ 0); Q_ASSERT(zlibRet == Z_OK); Q_UNUSED(zlibRet); // silence -Wunused-variable } QSpdyProtocolHandler::~QSpdyProtocolHandler() { deflateEnd(&m_deflateStream); deflateEnd(&m_inflateStream); } bool QSpdyProtocolHandler::sendRequest() { Q_ASSERT(!m_reply); int maxPossibleRequests = m_maxConcurrentStreams - m_inFlightStreams.count(); Q_ASSERT(maxPossibleRequests >= 0); if (maxPossibleRequests == 0) return true; // return early if max concurrent requests are exceeded m_channel->state = QHttpNetworkConnectionChannel::WritingState; int requestsToSend = qMin(m_channel->spdyRequestsToSend.size(), maxPossibleRequests); QMultiMap::iterator it = m_channel->spdyRequestsToSend.begin(); // requests will be ordered by priority (see QMultiMap doc) for (int a = 0; a < requestsToSend; ++a) { HttpMessagePair currentPair = *it; QHttpNetworkRequest currentRequest = currentPair.first; QHttpNetworkReply *currentReply = currentPair.second; currentReply->setSpdyWasUsed(true); qint32 streamID = generateNextStreamID(); currentReply->setProperty("SPDYStreamID", streamID); currentReply->setRequest(currentRequest); currentReply->d_func()->connection = m_connection; currentReply->d_func()->connectionChannel = m_channel; m_inFlightStreams.insert(streamID, currentPair); connect(currentReply, SIGNAL(destroyed(QObject*)), this, SLOT(_q_replyDestroyed(QObject*))); sendSYN_STREAM(currentPair, streamID, /* associatedToStreamID = */ 0); m_channel->spdyRequestsToSend.erase(it++); } m_channel->state = QHttpNetworkConnectionChannel::IdleState; return true; } void QSpdyProtocolHandler::_q_replyDestroyed(QObject* reply) { qint32 streamID = reply->property("SPDYStreamID").toInt(); if (m_inFlightStreams.remove(streamID)) sendRST_STREAM(streamID, RST_STREAM_CANCEL); } void QSpdyProtocolHandler::_q_receiveReply() { Q_ASSERT(m_socket); // only run when the QHttpNetworkConnection is not currently being destructed, e.g. // this function is called from _q_disconnected which is called because // of ~QHttpNetworkConnectionPrivate if (!qobject_cast(m_connection)) { return; } if (bytesAvailable() < 8) return; // cannot read frame headers, wait for more data char frameHeadersRaw[8]; if (!readNextChunk(8, frameHeadersRaw)) return; // this should not happen, we just checked const QByteArray frameHeaders(frameHeadersRaw, 8); // ### try without memcpy if (frameHeadersRaw[0] & 0x80) { handleControlFrame(frameHeaders); } else { handleDataFrame(frameHeaders); } // after handling the current frame, check whether there is more data waiting if (m_socket->bytesAvailable() > 0) QMetaObject::invokeMethod(m_channel, "_q_receiveReply", Qt::QueuedConnection); } void QSpdyProtocolHandler::_q_readyRead() { _q_receiveReply(); } static qint16 twoBytesToInt(const char *bytes) { return qFromBigEndian(bytes); } static qint32 threeBytesToInt(const char *bytes) { return qFromBigEndian(bytes) >> 8; } static qint32 fourBytesToInt(const char *bytes) { return qFromBigEndian(bytes); } static void appendIntToThreeBytes(char *output, qint32 number) { qToBigEndian(number, output + 1); qToBigEndian(number >> 16, output); } static void appendIntToFourBytes(char *output, qint32 number) { qToBigEndian(number, output); } static QByteArray intToFourBytes(qint32 number) // ### try to use appendIntToFourBytes where possible { char data[4]; qToBigEndian(number, data); QByteArray ret(data, 4); return ret; } static QByteArray intToThreeBytes(qint32 number) { char data[4]; qToBigEndian(number << 8, data); QByteArray ret(data, 3); return ret; } static qint32 getStreamID(const char *bytes) { // eliminate most significant bit; it might be 0 or 1 depending on whether // we are dealing with a control or data frame return fourBytesToInt(bytes) & 0x3fffffff; } static QByteArray headerField(const QByteArray &name, const QByteArray &value) { QByteArray ret; ret.reserve(name.count() + value.count() + 8); // 4 byte for length each ret.append(intToFourBytes(name.count())); ret.append(name); ret.append(intToFourBytes(value.count())); ret.append(value); return ret; } bool QSpdyProtocolHandler::uncompressHeader(const QByteArray &input, QByteArray *output) { const size_t chunkSize = 1024; char outputRaw[chunkSize]; // input bytes will not be changed by zlib, so it is safe to const_cast here m_inflateStream.next_in = const_cast(reinterpret_cast(input.constData())); m_inflateStream.avail_in = input.count(); m_inflateStream.total_in = input.count(); int zlibRet; do { m_inflateStream.next_out = reinterpret_cast(outputRaw); m_inflateStream.avail_out = chunkSize; zlibRet = inflate(&m_inflateStream, Z_SYNC_FLUSH); if (zlibRet == Z_NEED_DICT) { zlibRet = inflateSetDictionary(&m_inflateStream, reinterpret_cast(spdyDictionary), /* dictionaryLength = */ 1423); Q_ASSERT(zlibRet == Z_OK); continue; } switch (zlibRet) { case Z_BUF_ERROR: { if (m_inflateStream.avail_in == 0) { int outputSize = chunkSize - m_inflateStream.avail_out; output->append(outputRaw, outputSize); m_inflateStream.avail_out = chunkSize; } break; } case Z_OK: { int outputSize = chunkSize - m_inflateStream.avail_out; output->append(outputRaw, outputSize); break; } default: { qWarning("got unexpected zlib return value: %d", zlibRet); return false; } } } while (m_inflateStream.avail_in > 0 && zlibRet != Z_STREAM_END); Q_ASSERT(m_inflateStream.avail_in == 0); return true; } QByteArray QSpdyProtocolHandler::composeHeader(const QHttpNetworkRequest &request) { QByteArray uncompressedHeader; uncompressedHeader.reserve(300); // rough estimate // calculate additional headers first, because we need to know the size // ### do not partially copy the list, but restrict the set header fields // in QHttpNetworkConnection QVector > additionalHeaders; for (int a = 0; a < request.header().count(); ++a) { QByteArray key = request.header().at(a).first; if (key == "Connection" || key == "Host" || key == "Keep-Alive" || key == "Proxy-Connection" || key == "Transfer-Encoding") continue; // those headers are not valid (section 3.2.1) additionalHeaders.append(request.header().at(a)); } qint32 numberOfHeaderPairs = 5 + additionalHeaders.count(); // 5 mandatory below + the additional ones uncompressedHeader.append(intToFourBytes(numberOfHeaderPairs)); // mandatory header fields: uncompressedHeader.append(headerField(":method", request.methodName())); #ifndef QT_NO_NETWORKPROXY bool useProxy = m_connection->d_func()->networkProxy.type() != QNetworkProxy::NoProxy; uncompressedHeader.append(headerField(":path", request.uri(useProxy))); #else uncompressedHeader.append(headerField(":path", request.uri(false))); #endif uncompressedHeader.append(headerField(":version", "HTTP/1.1")); uncompressedHeader.append(headerField(":host", request.url().authority(QUrl::FullyEncoded | QUrl::RemoveUserInfo).toLatin1())); uncompressedHeader.append(headerField(":scheme", request.url().scheme().toLatin1())); // end of mandatory header fields // now add the additional headers for (int a = 0; a < additionalHeaders.count(); ++a) { uncompressedHeader.append(headerField(additionalHeaders.at(a).first.toLower(), additionalHeaders.at(a).second)); } m_deflateStream.total_in = uncompressedHeader.count(); m_deflateStream.avail_in = uncompressedHeader.count(); m_deflateStream.next_in = reinterpret_cast(uncompressedHeader.data()); int outputBytes = uncompressedHeader.count() + 30; // 30 bytes of compression header overhead m_deflateStream.avail_out = outputBytes; unsigned char *out = new unsigned char[outputBytes]; m_deflateStream.next_out = out; int availOutBefore = m_deflateStream.avail_out; int zlibRet = deflate(&m_deflateStream, Z_SYNC_FLUSH); // do everything in one go since we use no compression int compressedHeaderSize = availOutBefore - m_deflateStream.avail_out; Q_ASSERT(zlibRet == Z_OK); // otherwise, we need to allocate more outputBytes Q_UNUSED(zlibRet); // silence -Wunused-variable Q_ASSERT(m_deflateStream.avail_in == 0); QByteArray compressedHeader(reinterpret_cast(out), compressedHeaderSize); delete[] out; return compressedHeader; } quint64 QSpdyProtocolHandler::bytesAvailable() const { Q_ASSERT(m_socket); return m_spdyBuffer.byteAmount() + m_socket->bytesAvailable(); } bool QSpdyProtocolHandler::readNextChunk(qint64 length, char *sink) { qint64 expectedReadBytes = length; qint64 requiredBytesFromBuffer = 0; if (m_waitingForCompleteStream) { requiredBytesFromBuffer = qMin(length, m_spdyBuffer.byteAmount()); // ### if next chunk from buffer bigger than what we want to read, // we have to call read() (which memcpy's). Otherwise, we can just // read the next chunk without memcpy'ing. qint64 bytesReadFromBuffer = m_spdyBuffer.read(sink, requiredBytesFromBuffer); Q_ASSERT(bytesReadFromBuffer == requiredBytesFromBuffer); if (length <= bytesReadFromBuffer) { return true; // buffer > required size -> no need to read from socket } expectedReadBytes -= requiredBytesFromBuffer; } qint64 readBytes = m_socket->read(sink + requiredBytesFromBuffer, expectedReadBytes); if (readBytes < expectedReadBytes) { m_waitingForCompleteStream = true; // ### this is inefficient, we should not put back so much data into the buffer QByteArray temp(sink, requiredBytesFromBuffer + readBytes); m_spdyBuffer.append(temp); return false; } else { return true; // buffer must be cleared by calling function } } void QSpdyProtocolHandler::sendControlFrame(FrameType type, ControlFrameFlags flags, const char *data, quint32 length) { // frame type and stream ID char header[8]; header[0] = 0x80u; // leftmost bit == 1 -> is a control frame header[1] = 0x03; // 3 bit == version 3 header[2] = 0; switch (type) { case FrameType_CREDENTIAL: { qWarning("sending SPDY CREDENTIAL frame is not yet implemented"); // QTBUG-36188 return; } default: header[3] = type; } // flags header[4] = 0; if (flags & ControlFrame_FLAG_FIN || length == 0) { Q_ASSERT(type == FrameType_SYN_STREAM || type == FrameType_SYN_REPLY || type == FrameType_HEADERS || length == 0); header[4] |= ControlFrame_FLAG_FIN; } if (flags & ControlFrame_FLAG_UNIDIRECTIONAL) { Q_ASSERT(type == FrameType_SYN_STREAM); header[4] |= ControlFrame_FLAG_UNIDIRECTIONAL; } // length appendIntToThreeBytes(header + 5, length); qint64 written = m_socket->write(header, 8); Q_ASSERT(written == 8); written = m_socket->write(data, length); Q_ASSERT(written == length); Q_UNUSED(written); // silence -Wunused-variable } void QSpdyProtocolHandler::sendSYN_STREAM(const HttpMessagePair &messagePair, qint32 streamID, qint32 associatedToStreamID) { QHttpNetworkRequest request = messagePair.first; QHttpNetworkReply *reply = messagePair.second; ControlFrameFlags flags = 0; if (!request.uploadByteDevice()) { // no upload -> this is the last frame, send the FIN flag flags |= ControlFrame_FLAG_FIN; reply->d_func()->state = QHttpNetworkReplyPrivate::SPDYHalfClosed; } else { reply->d_func()->state = QHttpNetworkReplyPrivate::SPDYUploading; // hack: set the stream ID on the device directly, so when we get // the signal for uploading we know which stream we are sending on request.uploadByteDevice()->setProperty("SPDYStreamID", streamID); QObject::connect(request.uploadByteDevice(), SIGNAL(readyRead()), this, SLOT(_q_uploadDataReadyRead()), Qt::QueuedConnection); } QByteArray namesAndValues = composeHeader(request); quint32 length = namesAndValues.count() + 10; // 10 == 4 for Stream-ID + 4 for Associated-To-Stream-ID // + 2 for Priority, Unused and Slot QByteArray wireData; wireData.reserve(length); wireData.append(intToFourBytes(streamID)); wireData.append(intToFourBytes(associatedToStreamID)); // priority (3 bits) / unused (5 bits) / slot (8 bits) char prioAndSlot[2]; switch (request.priority()) { case QHttpNetworkRequest::HighPriority: prioAndSlot[0] = 0x00; // == prio 0 (highest) break; case QHttpNetworkRequest::NormalPriority: prioAndSlot[0] = 0x80u; // == prio 4 break; case QHttpNetworkRequest::LowPriority: prioAndSlot[0] = 0xe0u; // == prio 7 (lowest) break; } prioAndSlot[1] = 0x00; // slot in client certificates (not supported currently) wireData.append(prioAndSlot, 2); wireData.append(namesAndValues); sendControlFrame(FrameType_SYN_STREAM, flags, wireData.constData(), length); if (reply->d_func()->state == QHttpNetworkReplyPrivate::SPDYUploading) uploadData(streamID); } void QSpdyProtocolHandler::sendRST_STREAM(qint32 streamID, RST_STREAM_STATUS_CODE statusCode) { char wireData[8]; appendIntToFourBytes(wireData, streamID); appendIntToFourBytes(wireData + 4, statusCode); sendControlFrame(FrameType_RST_STREAM, /* flags = */ 0, wireData, /* length = */ 8); } void QSpdyProtocolHandler::sendPING(quint32 pingID) { char rawData[4]; appendIntToFourBytes(rawData, pingID); sendControlFrame(FrameType_PING, /* flags = */ 0, rawData, /* length = */ 4); } bool QSpdyProtocolHandler::uploadData(qint32 streamID) { // we only rely on SPDY flow control here and don't care about TCP buffers if (!m_inFlightStreams.contains(streamID)) { sendRST_STREAM(streamID, RST_STREAM_INVALID_STREAM); return false; } HttpMessagePair messagePair = m_inFlightStreams.value(streamID); QHttpNetworkRequest request = messagePair.first; QHttpNetworkReply *reply = messagePair.second; Q_ASSERT(reply); QHttpNetworkReplyPrivate *replyPrivate = reply->d_func(); Q_ASSERT(replyPrivate); if (reply->d_func()->state == QHttpNetworkReplyPrivate::SPDYHalfClosed || reply->d_func()->state == QHttpNetworkReplyPrivate::SPDYClosed) { qWarning("Trying to upload to closed stream"); return false; } qint32 dataLeftInWindow = replyPrivate->windowSizeUpload - replyPrivate->currentlyUploadedDataInWindow; while (dataLeftInWindow > 0 && !request.uploadByteDevice()->atEnd()) { // get pointer to upload data qint64 currentReadSize = 0; const char *readPointer = request.uploadByteDevice()->readPointer(dataLeftInWindow, currentReadSize); if (currentReadSize == -1) { // premature eof happened m_connection->d_func()->emitReplyError(m_socket, reply, QNetworkReply::UnknownNetworkError); return false; } else if (readPointer == 0 || currentReadSize == 0) { // nothing to read currently, break the loop break; } else { DataFrameFlags flags = 0; // we will send the FIN flag later if appropriate qint64 currentWriteSize = sendDataFrame(streamID, flags, currentReadSize, readPointer); if (currentWriteSize == -1 || currentWriteSize != currentReadSize) { // socket broke down m_connection->d_func()->emitReplyError(m_socket, reply, QNetworkReply::UnknownNetworkError); return false; } else { replyPrivate->currentlyUploadedDataInWindow += currentWriteSize; replyPrivate->totallyUploadedData += currentWriteSize; dataLeftInWindow = replyPrivate->windowSizeUpload - replyPrivate->currentlyUploadedDataInWindow; request.uploadByteDevice()->advanceReadPointer(currentWriteSize); emit reply->dataSendProgress(replyPrivate->totallyUploadedData, request.contentLength()); } } } if (replyPrivate->totallyUploadedData == request.contentLength()) { DataFrameFlags finFlag = DataFrame_FLAG_FIN; qint64 writeSize = sendDataFrame(streamID, finFlag, 0, 0); Q_ASSERT(writeSize == 0); Q_UNUSED(writeSize); // silence -Wunused-variable replyPrivate->state = QHttpNetworkReplyPrivate::SPDYHalfClosed; if (reply->request().uploadByteDevice()) reply->request().uploadByteDevice()->disconnect(this); // ### this will not work if the content length is not known, but // then again many servers will fail in this case anyhow according // to the SPDY RFC } return true; } void QSpdyProtocolHandler::_q_uploadDataReadyRead() { QNonContiguousByteDevice *device = qobject_cast(sender()); Q_ASSERT(device); qint32 streamID = device->property("SPDYStreamID").toInt(); Q_ASSERT(streamID > 0); uploadData(streamID); } void QSpdyProtocolHandler::sendWINDOW_UPDATE(qint32 streamID, quint32 deltaWindowSize) { char windowUpdateData[8]; appendIntToFourBytes(windowUpdateData, streamID); appendIntToFourBytes(windowUpdateData + 4, deltaWindowSize); sendControlFrame(FrameType_WINDOW_UPDATE, /* flags = */ 0, windowUpdateData, /* length = */ 8); } qint64 QSpdyProtocolHandler::sendDataFrame(qint32 streamID, DataFrameFlags flags, quint32 length, const char *data) { QByteArray wireData; wireData.reserve(8); wireData.append(intToFourBytes(streamID)); wireData.append(flags); wireData.append(intToThreeBytes(length)); Q_ASSERT(m_socket); m_socket->write(wireData); if (data) { qint64 ret = m_socket->write(data, length); return ret; } else { return 0; // nothing to write, e.g. FIN flag } } void QSpdyProtocolHandler::handleControlFrame(const QByteArray &frameHeaders) // ### make it char * { Q_ASSERT(frameHeaders.count() >= 8); qint16 version = twoBytesToInt(frameHeaders.constData()); version &= 0x3fff; // eliminate most significant bit to determine version Q_ASSERT(version == 3); qint16 type = twoBytesToInt(frameHeaders.constData() + 2); char flags = frameHeaders.at(4); qint32 length = threeBytesToInt(frameHeaders.constData() + 5); Q_ASSERT(length > 0); QByteArray frameData; frameData.resize(length); if (!readNextChunk(length, frameData.data())) { // put back the frame headers to the buffer m_spdyBuffer.prepend(frameHeaders); return; // we couldn't read the whole frame and need to wait } else { m_spdyBuffer.clear(); m_waitingForCompleteStream = false; } switch (type) { case FrameType_SYN_STREAM: { handleSYN_STREAM(flags, length, frameData); break; } case FrameType_SYN_REPLY: { handleSYN_REPLY(flags, length, frameData); break; } case FrameType_RST_STREAM: { handleRST_STREAM(flags, length, frameData); break; } case FrameType_SETTINGS: { handleSETTINGS(flags, length, frameData); break; } case FrameType_PING: { handlePING(flags, length, frameData); break; } case FrameType_GOAWAY: { handleGOAWAY(flags, length, frameData); break; } case FrameType_HEADERS: { handleHEADERS(flags, length, frameData); break; } case FrameType_WINDOW_UPDATE: { handleWINDOW_UPDATE(flags, length, frameData); break; } default: qWarning("cannot handle frame of type %d", int(type)); } } void QSpdyProtocolHandler::handleSYN_STREAM(char /*flags*/, quint32 /*length*/, const QByteArray &frameData) { // not implemented; will be implemented when servers start using it // we just tell the server that we do not accept that qint32 streamID = getStreamID(frameData.constData()); sendRST_STREAM(streamID, RST_STREAM_REFUSED_STREAM); } void QSpdyProtocolHandler::handleSYN_REPLY(char flags, quint32 /*length*/, const QByteArray &frameData) { parseHttpHeaders(flags, frameData); } void QSpdyProtocolHandler::parseHttpHeaders(char flags, const QByteArray &frameData) { qint32 streamID = getStreamID(frameData.constData()); const auto it = m_inFlightStreams.constFind(streamID); if (it == m_inFlightStreams.cend()) { sendRST_STREAM(streamID, RST_STREAM_INVALID_STREAM); return; } flags &= 0x3f; bool flag_fin = flags & 0x01; QByteArray headerValuePairs = frameData.mid(4); HttpMessagePair pair = it.value(); QHttpNetworkReply *httpReply = pair.second; Q_ASSERT(httpReply != 0); if (httpReply->d_func()->state == QHttpNetworkReplyPrivate::SPDYClosed) { sendRST_STREAM(streamID, RST_STREAM_STREAM_ALREADY_CLOSED); return; } QByteArray uncompressedHeader; if (!uncompressHeader(headerValuePairs, &uncompressedHeader)) { qWarning("error reading header from SYN_REPLY message"); return; } qint32 headerCount = fourBytesToInt(uncompressedHeader.constData()); if (headerCount * 8 > uncompressedHeader.size()) { qWarning("error parsing header from SYN_REPLY message"); sendRST_STREAM(streamID, RST_STREAM_PROTOCOL_ERROR); return; } qint32 readPointer = 4; for (qint32 a = 0; a < headerCount; ++a) { qint32 count = fourBytesToInt(uncompressedHeader.constData() + readPointer); readPointer += 4; QByteArray name = uncompressedHeader.mid(readPointer, count); readPointer += count; if (readPointer > uncompressedHeader.size()) { qWarning("error parsing header from SYN_REPLY message"); sendRST_STREAM(streamID, RST_STREAM_PROTOCOL_ERROR); return; } count = fourBytesToInt(uncompressedHeader.constData() + readPointer); readPointer += 4; QByteArray value = uncompressedHeader.mid(readPointer, count); readPointer += count; if (readPointer > uncompressedHeader.size()) { qWarning("error parsing header from SYN_REPLY message"); sendRST_STREAM(streamID, RST_STREAM_PROTOCOL_ERROR); return; } if (name == ":status") { httpReply->setStatusCode(value.left(3).toInt()); httpReply->d_func()->reasonPhrase = QString::fromLatin1(value.mid(4)); } else if (name == ":version") { int majorVersion = value.at(5) - 48; int minorVersion = value.at(7) - 48; httpReply->d_func()->majorVersion = majorVersion; httpReply->d_func()->minorVersion = minorVersion; } else if (name == "content-length") { httpReply->setContentLength(value.toLongLong()); } else { value.replace('\0', name == "set-cookie" ? "\n" : ", "); httpReply->setHeaderField(name, value); } } emit httpReply->headerChanged(); if (flag_fin) { if (httpReply->d_func()->state != QHttpNetworkReplyPrivate::SPDYHalfClosed) sendDataFrame(streamID, DataFrame_FLAG_FIN, 0, 0); replyFinished(httpReply, streamID); } } void QSpdyProtocolHandler::handleRST_STREAM(char /*flags*/, quint32 length, const QByteArray &frameData) { // flags are ignored Q_ASSERT(length == 8); Q_UNUSED(length); // silence -Wunused-parameter qint32 streamID = getStreamID(frameData.constData()); QHttpNetworkReply *httpReply = m_inFlightStreams.value(streamID).second; qint32 statusCodeInt = fourBytesToInt(frameData.constData() + 4); RST_STREAM_STATUS_CODE statusCode = static_cast(statusCodeInt); QNetworkReply::NetworkError errorCode; QByteArray errorMessage; switch (statusCode) { case RST_STREAM_PROTOCOL_ERROR: errorCode = QNetworkReply::ProtocolFailure; errorMessage = "SPDY protocol error"; break; case RST_STREAM_INVALID_STREAM: errorCode = QNetworkReply::ProtocolFailure; errorMessage = "SPDY stream is not active"; break; case RST_STREAM_REFUSED_STREAM: errorCode = QNetworkReply::ProtocolFailure; errorMessage = "SPDY stream was refused"; break; case RST_STREAM_UNSUPPORTED_VERSION: errorCode = QNetworkReply::ProtocolUnknownError; errorMessage = "SPDY version is unknown to the server"; break; case RST_STREAM_CANCEL: errorCode = QNetworkReply::ProtocolFailure; errorMessage = "SPDY stream is no longer needed"; break; case RST_STREAM_INTERNAL_ERROR: errorCode = QNetworkReply::InternalServerError; errorMessage = "Internal server error"; break; case RST_STREAM_FLOW_CONTROL_ERROR: errorCode = QNetworkReply::ProtocolFailure; errorMessage = "peer violated the flow control protocol"; break; case RST_STREAM_STREAM_IN_USE: errorCode = QNetworkReply::ProtocolFailure; errorMessage = "server received a SYN_REPLY for an already open stream"; break; case RST_STREAM_STREAM_ALREADY_CLOSED: errorCode = QNetworkReply::ProtocolFailure; errorMessage = "server received data or a SYN_REPLY for an already half-closed stream"; break; case RST_STREAM_INVALID_CREDENTIALS: errorCode = QNetworkReply::ContentAccessDenied; errorMessage = "server received invalid credentials"; break; case RST_STREAM_FRAME_TOO_LARGE: errorCode = QNetworkReply::ProtocolFailure; errorMessage = "server cannot process the frame because it is too large"; break; default: qWarning("could not understand servers RST_STREAM status code"); errorCode = QNetworkReply::ProtocolFailure; errorMessage = "got SPDY RST_STREAM message with unknown error code"; } if (httpReply) replyFinishedWithError(httpReply, streamID, errorCode, errorMessage.constData()); } void QSpdyProtocolHandler::handleSETTINGS(char flags, quint32 /*length*/, const QByteArray &frameData) { Q_ASSERT(frameData.count() > 0); SETTINGS_Flags settingsFlags = static_cast(flags); if (settingsFlags & FLAG_SETTINGS_CLEAR_SETTINGS) { // ### clear all persistent settings; since we do not persist settings // as of now, we don't need to clear anything either } qint32 numberOfEntries = fourBytesToInt(frameData.constData()); Q_ASSERT(numberOfEntries > 0); for (int a = 0, frameDataIndex = 4; a < numberOfEntries; ++a, frameDataIndex += 8) { SETTINGS_ID_Flag idFlag = static_cast(frameData[frameDataIndex]); if (idFlag & FLAG_SETTINGS_PERSIST_VALUE) { // ### we SHOULD persist the settings here according to the RFC, but we don't have to, // so implement that later } // the other value is only sent by us, but not received quint32 uniqueID = static_cast( threeBytesToInt(frameData.constData() + frameDataIndex + 1)); quint32 value = fourBytesToInt(frameData.constData() + frameDataIndex + 4); switch (uniqueID) { case SETTINGS_UPLOAD_BANDWIDTH: { // ignored for now, just an estimated informative value break; } case SETTINGS_DOWNLOAD_BANDWIDTH: { // ignored for now, just an estimated informative value break; } case SETTINGS_ROUND_TRIP_TIME: { // ignored for now, just an estimated informative value break; } case SETTINGS_MAX_CONCURRENT_STREAMS: { m_maxConcurrentStreams = value; break; } case SETTINGS_CURRENT_CWND: { // ignored for now, just an informative value break; } case SETTINGS_DOWNLOAD_RETRANS_RATE: { // ignored for now, just an estimated informative value break; } case SETTINGS_INITIAL_WINDOW_SIZE: { m_initialWindowSize = value; break; } case SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE: { // client certificates are not supported break; } default: qWarning("found unknown settings value %u", uint(value)); } } } void QSpdyProtocolHandler::handlePING(char /*flags*/, quint32 length, const QByteArray &frameData) { // flags are ignored Q_ASSERT(length == 4); Q_UNUSED(length); // silence -Wunused-parameter quint32 pingID = fourBytesToInt(frameData.constData()); // odd numbered IDs must be ignored if ((pingID & 1) == 0) // is even? sendPING(pingID); } void QSpdyProtocolHandler::handleGOAWAY(char /*flags*/, quint32 /*length*/, const QByteArray &frameData) { // flags are ignored qint32 statusCode = static_cast(fourBytesToInt(frameData.constData() + 4)); QNetworkReply::NetworkError errorCode; switch (statusCode) { case GOAWAY_OK: { errorCode = QNetworkReply::NoError; break; } case GOAWAY_PROTOCOL_ERROR: { errorCode = QNetworkReply::ProtocolFailure; break; } case GOAWAY_INTERNAL_ERROR: { errorCode = QNetworkReply::InternalServerError; break; } default: qWarning("unexpected status code %d", int(statusCode)); errorCode = QNetworkReply::ProtocolUnknownError; } qint32 lastGoodStreamID = getStreamID(frameData.constData()); // emit errors for all replies after the last good stream ID Q_ASSERT(m_connection); for (qint32 currentStreamID = lastGoodStreamID + 2; currentStreamID <= m_nextStreamID; ++currentStreamID) { QHttpNetworkReply *reply = m_inFlightStreams.value(currentStreamID).second; Q_ASSERT(reply); m_connection->d_func()->emitReplyError(m_socket, reply, errorCode); } // ### we could make sure a new session is initiated anyhow } void QSpdyProtocolHandler::handleHEADERS(char flags, quint32 /*length*/, const QByteArray &frameData) { parseHttpHeaders(flags, frameData); } void QSpdyProtocolHandler::handleWINDOW_UPDATE(char /*flags*/, quint32 /*length*/, const QByteArray &frameData) { qint32 streamID = getStreamID(frameData.constData()); qint32 deltaWindowSize = fourBytesToInt(frameData.constData() + 4); const auto it = m_inFlightStreams.constFind(streamID); if (it == m_inFlightStreams.cend()) { sendRST_STREAM(streamID, RST_STREAM_INVALID_STREAM); return; } QHttpNetworkReply *reply = it.value().second; Q_ASSERT(reply); QHttpNetworkReplyPrivate *replyPrivate = reply->d_func(); Q_ASSERT(replyPrivate); // Ignore WINDOW_UPDATE if we are already done. if (replyPrivate->state == QHttpNetworkReplyPrivate::SPDYHalfClosed || replyPrivate->state == QHttpNetworkReplyPrivate::SPDYClosed) return; replyPrivate->currentlyUploadedDataInWindow = replyPrivate->windowSizeUpload - deltaWindowSize; uploadData(streamID); // we hopefully can continue to upload } void QSpdyProtocolHandler::handleDataFrame(const QByteArray &frameHeaders) { Q_ASSERT(frameHeaders.count() >= 8); qint32 streamID = getStreamID(frameHeaders.constData()); const auto it = m_inFlightStreams.constFind(streamID); if (it == m_inFlightStreams.cend()) { sendRST_STREAM(streamID, RST_STREAM_INVALID_STREAM); return; } unsigned char flags = static_cast(frameHeaders.at(4)); flags &= 0x3f; bool flag_fin = flags & 0x01; bool flag_compress = flags & 0x02; qint32 length = threeBytesToInt(frameHeaders.constData() + 5); QByteArray data; data.resize(length); if (!readNextChunk(length, data.data())) { // put back the frame headers to the buffer m_spdyBuffer.prepend(frameHeaders); return; // we couldn't read the whole frame and need to wait } else { m_spdyBuffer.clear(); m_waitingForCompleteStream = false; } HttpMessagePair pair = it.value(); QHttpNetworkRequest httpRequest = pair.first; QHttpNetworkReply *httpReply = pair.second; Q_ASSERT(httpReply != 0); QHttpNetworkReplyPrivate *replyPrivate = httpReply->d_func(); if (replyPrivate->state == QHttpNetworkReplyPrivate::SPDYClosed) { sendRST_STREAM(streamID, RST_STREAM_STREAM_ALREADY_CLOSED); return; } // check whether we need to send WINDOW_UPDATE (i.e. tell the sender it can send more) replyPrivate->currentlyReceivedDataInWindow += length; qint32 dataLeftInWindow = replyPrivate->windowSizeDownload - replyPrivate->currentlyReceivedDataInWindow; if (replyPrivate->currentlyReceivedDataInWindow > 0 && dataLeftInWindow < replyPrivate->windowSizeDownload / 2) { // socket read buffer size is 64K actually, hard coded in the channel // We can read way more than 64K per socket, because the window size // here is per stream. if (replyPrivate->windowSizeDownload >= m_socket->readBufferSize()) { replyPrivate->windowSizeDownload = m_socket->readBufferSize(); } else { replyPrivate->windowSizeDownload *= 1.5; } QMetaObject::invokeMethod(this, "sendWINDOW_UPDATE", Qt::QueuedConnection, Q_ARG(qint32, streamID), Q_ARG(quint32, replyPrivate->windowSizeDownload)); // setting the current data count to 0 is a race condition, // because we call sendWINDOW_UPDATE through the event loop. // But then again, the whole situation is a race condition because // we don't know when the packet will arrive at the server; so // this is most likely good enough here. replyPrivate->currentlyReceivedDataInWindow = 0; } httpReply->d_func()->compressedData.append(data); replyPrivate->totalProgress += length; if (httpRequest.d->autoDecompress && httpReply->d_func()->isCompressed()) { QByteDataBuffer inDataBuffer; // ### should we introduce one in the http reply? inDataBuffer.append(data); qint64 compressedCount = httpReply->d_func()->uncompressBodyData(&inDataBuffer, &replyPrivate->responseData); Q_ASSERT(compressedCount >= 0); Q_UNUSED(compressedCount); // silence -Wunused-variable } else { replyPrivate->responseData.append(data); } if (replyPrivate->shouldEmitSignals()) { emit httpReply->readyRead(); emit httpReply->dataReadProgress(replyPrivate->totalProgress, replyPrivate->bodyLength); } if (flag_compress) { qWarning("SPDY level compression is not supported"); } if (flag_fin) { if (httpReply->d_func()->state != QHttpNetworkReplyPrivate::SPDYHalfClosed) sendDataFrame(streamID, DataFrame_FLAG_FIN, 0, 0); replyFinished(httpReply, streamID); } } void QSpdyProtocolHandler::replyFinished(QHttpNetworkReply *httpReply, qint32 streamID) { httpReply->d_func()->state = QHttpNetworkReplyPrivate::SPDYClosed; httpReply->disconnect(this); if (httpReply->request().uploadByteDevice()) httpReply->request().uploadByteDevice()->disconnect(this); int streamsRemoved = m_inFlightStreams.remove(streamID); Q_ASSERT(streamsRemoved == 1); Q_UNUSED(streamsRemoved); // silence -Wunused-variable emit httpReply->finished(); } void QSpdyProtocolHandler::replyFinishedWithError(QHttpNetworkReply *httpReply, qint32 streamID, QNetworkReply::NetworkError errorCode, const char *errorMessage) { Q_ASSERT(httpReply); httpReply->d_func()->state = QHttpNetworkReplyPrivate::SPDYClosed; httpReply->disconnect(this); if (httpReply->request().uploadByteDevice()) httpReply->request().uploadByteDevice()->disconnect(this); int streamsRemoved = m_inFlightStreams.remove(streamID); Q_ASSERT(streamsRemoved == 1); Q_UNUSED(streamsRemoved); // silence -Wunused-variable emit httpReply->finishedWithError(errorCode, QSpdyProtocolHandler::tr(errorMessage)); } qint32 QSpdyProtocolHandler::generateNextStreamID() { // stream IDs initiated by the client must be odd m_nextStreamID += 2; return m_nextStreamID; } QT_END_NAMESPACE #endif // !defined(QT_NO_SSL)