1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // This file contains some protocol structures for use with SPDY 2 and 3 6 // The SPDY 2 spec can be found at: 7 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft2 8 // The SPDY 3 spec can be found at: 9 // http://dev.chromium.org/spdy/spdy-protocol/spdy-protocol-draft3 10 11 #ifndef NET_SPDY_SPDY_PROTOCOL_H_ 12 #define NET_SPDY_SPDY_PROTOCOL_H_ 13 14 #include <map> 15 #include <string> 16 #include <vector> 17 18 #include "base/basictypes.h" 19 #include "base/compiler_specific.h" 20 #include "base/logging.h" 21 #include "base/memory/scoped_ptr.h" 22 #include "base/strings/string_piece.h" 23 #include "base/sys_byteorder.h" 24 #include "net/base/net_export.h" 25 #include "net/spdy/spdy_bitmasks.h" 26 27 namespace net { 28 29 // The major versions of SPDY. Major version differences indicate 30 // framer-layer incompatibility, as opposed to minor version numbers 31 // which indicate application-layer incompatibility. Do not rely on 32 // the mapping from enum value SPDYn to the integer n. 33 enum SpdyMajorVersion { 34 SPDY2 = 2, 35 SPDY_MIN_VERSION = SPDY2, 36 SPDY3 = 3, 37 SPDY4 = 4, 38 SPDY5 = 5, 39 SPDY_MAX_VERSION = SPDY5 40 }; 41 42 // A SPDY stream id is a 31 bit entity. 43 typedef uint32 SpdyStreamId; 44 45 // Specifies the stream ID used to denote the current session (for 46 // flow control). 47 const SpdyStreamId kSessionFlowControlStreamId = 0; 48 49 // Initial window size for a Spdy stream in bytes. 50 const int32 kSpdyStreamInitialWindowSize = 64 * 1024; // 64 KBytes 51 52 // The maxmium possible control frame size allowed by the spec. 53 const int32 kSpdyMaxControlFrameSize = (1 << 24) - 1; 54 55 // The maximum control frame size we actually send/accept. 56 const int32 kControlFrameSizeLimit = 1 << 14; 57 58 // Initial window size for a Spdy session in bytes. 59 const int32 kSpdySessionInitialWindowSize = 64 * 1024; // 64 KBytes 60 61 // Maximum window size for a Spdy stream or session. 62 const int32 kSpdyMaximumWindowSize = 0x7FFFFFFF; // Max signed 32bit int 63 64 // Maximum padding size in octets for one DATA or HEADERS or PUSH_PROMISE frame. 65 const int32 kPaddingSizePerFrame = 256; 66 67 // SPDY 2 dictionary. 68 // This is just a hacked dictionary to use for shrinking HTTP-like headers. 69 const char kV2Dictionary[] = 70 "optionsgetheadpostputdeletetraceacceptaccept-charsetaccept-encodingaccept-" 71 "languageauthorizationexpectfromhostif-modified-sinceif-matchif-none-matchi" 72 "f-rangeif-unmodifiedsincemax-forwardsproxy-authorizationrangerefererteuser" 73 "-agent10010120020120220320420520630030130230330430530630740040140240340440" 74 "5406407408409410411412413414415416417500501502503504505accept-rangesageeta" 75 "glocationproxy-authenticatepublicretry-afterservervarywarningwww-authentic" 76 "ateallowcontent-basecontent-encodingcache-controlconnectiondatetrailertran" 77 "sfer-encodingupgradeviawarningcontent-languagecontent-lengthcontent-locati" 78 "oncontent-md5content-rangecontent-typeetagexpireslast-modifiedset-cookieMo" 79 "ndayTuesdayWednesdayThursdayFridaySaturdaySundayJanFebMarAprMayJunJulAugSe" 80 "pOctNovDecchunkedtext/htmlimage/pngimage/jpgimage/gifapplication/xmlapplic" 81 "ation/xhtmltext/plainpublicmax-agecharset=iso-8859-1utf-8gzipdeflateHTTP/1" 82 ".1statusversionurl"; 83 const int kV2DictionarySize = arraysize(kV2Dictionary); 84 85 // SPDY 3 dictionary. 86 const char kV3Dictionary[] = { 87 0x00, 0x00, 0x00, 0x07, 0x6f, 0x70, 0x74, 0x69, // ....opti 88 0x6f, 0x6e, 0x73, 0x00, 0x00, 0x00, 0x04, 0x68, // ons....h 89 0x65, 0x61, 0x64, 0x00, 0x00, 0x00, 0x04, 0x70, // ead....p 90 0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x03, 0x70, // ost....p 91 0x75, 0x74, 0x00, 0x00, 0x00, 0x06, 0x64, 0x65, // ut....de 92 0x6c, 0x65, 0x74, 0x65, 0x00, 0x00, 0x00, 0x05, // lete.... 93 0x74, 0x72, 0x61, 0x63, 0x65, 0x00, 0x00, 0x00, // trace... 94 0x06, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x00, // .accept. 95 0x00, 0x00, 0x0e, 0x61, 0x63, 0x63, 0x65, 0x70, // ...accep 96 0x74, 0x2d, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, // t-charse 97 0x74, 0x00, 0x00, 0x00, 0x0f, 0x61, 0x63, 0x63, // t....acc 98 0x65, 0x70, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f, // ept-enco 99 0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x0f, // ding.... 100 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x6c, // accept-l 101 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x00, // anguage. 102 0x00, 0x00, 0x0d, 0x61, 0x63, 0x63, 0x65, 0x70, // ...accep 103 0x74, 0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73, // t-ranges 104 0x00, 0x00, 0x00, 0x03, 0x61, 0x67, 0x65, 0x00, // ....age. 105 0x00, 0x00, 0x05, 0x61, 0x6c, 0x6c, 0x6f, 0x77, // ...allow 106 0x00, 0x00, 0x00, 0x0d, 0x61, 0x75, 0x74, 0x68, // ....auth 107 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, // orizatio 108 0x6e, 0x00, 0x00, 0x00, 0x0d, 0x63, 0x61, 0x63, // n....cac 109 0x68, 0x65, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, // he-contr 110 0x6f, 0x6c, 0x00, 0x00, 0x00, 0x0a, 0x63, 0x6f, // ol....co 111 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, // nnection 112 0x00, 0x00, 0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, // ....cont 113 0x65, 0x6e, 0x74, 0x2d, 0x62, 0x61, 0x73, 0x65, // ent-base 114 0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, 0x6e, 0x74, // ....cont 115 0x65, 0x6e, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f, // ent-enco 116 0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, // ding.... 117 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, // content- 118 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, // language 119 0x00, 0x00, 0x00, 0x0e, 0x63, 0x6f, 0x6e, 0x74, // ....cont 120 0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x65, 0x6e, 0x67, // ent-leng 121 0x74, 0x68, 0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, // th....co 122 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x6f, // ntent-lo 123 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, // cation.. 124 0x00, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, // ..conten 125 0x74, 0x2d, 0x6d, 0x64, 0x35, 0x00, 0x00, 0x00, // t-md5... 126 0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, // .content 127 0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, // -range.. 128 0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, // ..conten 129 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x00, 0x00, // t-type.. 130 0x00, 0x04, 0x64, 0x61, 0x74, 0x65, 0x00, 0x00, // ..date.. 131 0x00, 0x04, 0x65, 0x74, 0x61, 0x67, 0x00, 0x00, // ..etag.. 132 0x00, 0x06, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, // ..expect 133 0x00, 0x00, 0x00, 0x07, 0x65, 0x78, 0x70, 0x69, // ....expi 134 0x72, 0x65, 0x73, 0x00, 0x00, 0x00, 0x04, 0x66, // res....f 135 0x72, 0x6f, 0x6d, 0x00, 0x00, 0x00, 0x04, 0x68, // rom....h 136 0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x08, 0x69, // ost....i 137 0x66, 0x2d, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, // f-match. 138 0x00, 0x00, 0x11, 0x69, 0x66, 0x2d, 0x6d, 0x6f, // ...if-mo 139 0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2d, 0x73, // dified-s 140 0x69, 0x6e, 0x63, 0x65, 0x00, 0x00, 0x00, 0x0d, // ince.... 141 0x69, 0x66, 0x2d, 0x6e, 0x6f, 0x6e, 0x65, 0x2d, // if-none- 142 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, 0x00, 0x00, // match... 143 0x08, 0x69, 0x66, 0x2d, 0x72, 0x61, 0x6e, 0x67, // .if-rang 144 0x65, 0x00, 0x00, 0x00, 0x13, 0x69, 0x66, 0x2d, // e....if- 145 0x75, 0x6e, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, // unmodifi 146 0x65, 0x64, 0x2d, 0x73, 0x69, 0x6e, 0x63, 0x65, // ed-since 147 0x00, 0x00, 0x00, 0x0d, 0x6c, 0x61, 0x73, 0x74, // ....last 148 0x2d, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65, // -modifie 149 0x64, 0x00, 0x00, 0x00, 0x08, 0x6c, 0x6f, 0x63, // d....loc 150 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, // ation... 151 0x0c, 0x6d, 0x61, 0x78, 0x2d, 0x66, 0x6f, 0x72, // .max-for 152 0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x00, 0x00, // wards... 153 0x06, 0x70, 0x72, 0x61, 0x67, 0x6d, 0x61, 0x00, // .pragma. 154 0x00, 0x00, 0x12, 0x70, 0x72, 0x6f, 0x78, 0x79, // ...proxy 155 0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74, // -authent 156 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00, // icate... 157 0x13, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2d, 0x61, // .proxy-a 158 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, // uthoriza 159 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x05, // tion.... 160 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, 0x00, // range... 161 0x07, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x72, // .referer 162 0x00, 0x00, 0x00, 0x0b, 0x72, 0x65, 0x74, 0x72, // ....retr 163 0x79, 0x2d, 0x61, 0x66, 0x74, 0x65, 0x72, 0x00, // y-after. 164 0x00, 0x00, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65, // ...serve 165 0x72, 0x00, 0x00, 0x00, 0x02, 0x74, 0x65, 0x00, // r....te. 166 0x00, 0x00, 0x07, 0x74, 0x72, 0x61, 0x69, 0x6c, // ...trail 167 0x65, 0x72, 0x00, 0x00, 0x00, 0x11, 0x74, 0x72, // er....tr 168 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2d, 0x65, // ansfer-e 169 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x00, // ncoding. 170 0x00, 0x00, 0x07, 0x75, 0x70, 0x67, 0x72, 0x61, // ...upgra 171 0x64, 0x65, 0x00, 0x00, 0x00, 0x0a, 0x75, 0x73, // de....us 172 0x65, 0x72, 0x2d, 0x61, 0x67, 0x65, 0x6e, 0x74, // er-agent 173 0x00, 0x00, 0x00, 0x04, 0x76, 0x61, 0x72, 0x79, // ....vary 174 0x00, 0x00, 0x00, 0x03, 0x76, 0x69, 0x61, 0x00, // ....via. 175 0x00, 0x00, 0x07, 0x77, 0x61, 0x72, 0x6e, 0x69, // ...warni 176 0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, 0x77, 0x77, // ng....ww 177 0x77, 0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, // w-authen 178 0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, // ticate.. 179 0x00, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, // ..method 180 0x00, 0x00, 0x00, 0x03, 0x67, 0x65, 0x74, 0x00, // ....get. 181 0x00, 0x00, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, // ...statu 182 0x73, 0x00, 0x00, 0x00, 0x06, 0x32, 0x30, 0x30, // s....200 183 0x20, 0x4f, 0x4b, 0x00, 0x00, 0x00, 0x07, 0x76, // .OK....v 184 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00, // ersion.. 185 0x00, 0x08, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, // ..HTTP.1 186 0x2e, 0x31, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72, // .1....ur 187 0x6c, 0x00, 0x00, 0x00, 0x06, 0x70, 0x75, 0x62, // l....pub 188 0x6c, 0x69, 0x63, 0x00, 0x00, 0x00, 0x0a, 0x73, // lic....s 189 0x65, 0x74, 0x2d, 0x63, 0x6f, 0x6f, 0x6b, 0x69, // et-cooki 190 0x65, 0x00, 0x00, 0x00, 0x0a, 0x6b, 0x65, 0x65, // e....kee 191 0x70, 0x2d, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x00, // p-alive. 192 0x00, 0x00, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69, // ...origi 193 0x6e, 0x31, 0x30, 0x30, 0x31, 0x30, 0x31, 0x32, // n1001012 194 0x30, 0x31, 0x32, 0x30, 0x32, 0x32, 0x30, 0x35, // 01202205 195 0x32, 0x30, 0x36, 0x33, 0x30, 0x30, 0x33, 0x30, // 20630030 196 0x32, 0x33, 0x30, 0x33, 0x33, 0x30, 0x34, 0x33, // 23033043 197 0x30, 0x35, 0x33, 0x30, 0x36, 0x33, 0x30, 0x37, // 05306307 198 0x34, 0x30, 0x32, 0x34, 0x30, 0x35, 0x34, 0x30, // 40240540 199 0x36, 0x34, 0x30, 0x37, 0x34, 0x30, 0x38, 0x34, // 64074084 200 0x30, 0x39, 0x34, 0x31, 0x30, 0x34, 0x31, 0x31, // 09410411 201 0x34, 0x31, 0x32, 0x34, 0x31, 0x33, 0x34, 0x31, // 41241341 202 0x34, 0x34, 0x31, 0x35, 0x34, 0x31, 0x36, 0x34, // 44154164 203 0x31, 0x37, 0x35, 0x30, 0x32, 0x35, 0x30, 0x34, // 17502504 204 0x35, 0x30, 0x35, 0x32, 0x30, 0x33, 0x20, 0x4e, // 505203.N 205 0x6f, 0x6e, 0x2d, 0x41, 0x75, 0x74, 0x68, 0x6f, // on-Autho 206 0x72, 0x69, 0x74, 0x61, 0x74, 0x69, 0x76, 0x65, // ritative 207 0x20, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, // .Informa 208 0x74, 0x69, 0x6f, 0x6e, 0x32, 0x30, 0x34, 0x20, // tion204. 209 0x4e, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65, // No.Conte 210 0x6e, 0x74, 0x33, 0x30, 0x31, 0x20, 0x4d, 0x6f, // nt301.Mo 211 0x76, 0x65, 0x64, 0x20, 0x50, 0x65, 0x72, 0x6d, // ved.Perm 212 0x61, 0x6e, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x34, // anently4 213 0x30, 0x30, 0x20, 0x42, 0x61, 0x64, 0x20, 0x52, // 00.Bad.R 214 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x34, 0x30, // equest40 215 0x31, 0x20, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, // 1.Unauth 216 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x34, 0x30, // orized40 217 0x33, 0x20, 0x46, 0x6f, 0x72, 0x62, 0x69, 0x64, // 3.Forbid 218 0x64, 0x65, 0x6e, 0x34, 0x30, 0x34, 0x20, 0x4e, // den404.N 219 0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64, // ot.Found 220 0x35, 0x30, 0x30, 0x20, 0x49, 0x6e, 0x74, 0x65, // 500.Inte 221 0x72, 0x6e, 0x61, 0x6c, 0x20, 0x53, 0x65, 0x72, // rnal.Ser 222 0x76, 0x65, 0x72, 0x20, 0x45, 0x72, 0x72, 0x6f, // ver.Erro 223 0x72, 0x35, 0x30, 0x31, 0x20, 0x4e, 0x6f, 0x74, // r501.Not 224 0x20, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, // .Impleme 225 0x6e, 0x74, 0x65, 0x64, 0x35, 0x30, 0x33, 0x20, // nted503. 226 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20, // Service. 227 0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, // Unavaila 228 0x62, 0x6c, 0x65, 0x4a, 0x61, 0x6e, 0x20, 0x46, // bleJan.F 229 0x65, 0x62, 0x20, 0x4d, 0x61, 0x72, 0x20, 0x41, // eb.Mar.A 230 0x70, 0x72, 0x20, 0x4d, 0x61, 0x79, 0x20, 0x4a, // pr.May.J 231 0x75, 0x6e, 0x20, 0x4a, 0x75, 0x6c, 0x20, 0x41, // un.Jul.A 232 0x75, 0x67, 0x20, 0x53, 0x65, 0x70, 0x74, 0x20, // ug.Sept. 233 0x4f, 0x63, 0x74, 0x20, 0x4e, 0x6f, 0x76, 0x20, // Oct.Nov. 234 0x44, 0x65, 0x63, 0x20, 0x30, 0x30, 0x3a, 0x30, // Dec.00.0 235 0x30, 0x3a, 0x30, 0x30, 0x20, 0x4d, 0x6f, 0x6e, // 0.00.Mon 236 0x2c, 0x20, 0x54, 0x75, 0x65, 0x2c, 0x20, 0x57, // ..Tue..W 237 0x65, 0x64, 0x2c, 0x20, 0x54, 0x68, 0x75, 0x2c, // ed..Thu. 238 0x20, 0x46, 0x72, 0x69, 0x2c, 0x20, 0x53, 0x61, // .Fri..Sa 239 0x74, 0x2c, 0x20, 0x53, 0x75, 0x6e, 0x2c, 0x20, // t..Sun.. 240 0x47, 0x4d, 0x54, 0x63, 0x68, 0x75, 0x6e, 0x6b, // GMTchunk 241 0x65, 0x64, 0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, // ed.text. 242 0x68, 0x74, 0x6d, 0x6c, 0x2c, 0x69, 0x6d, 0x61, // html.ima 243 0x67, 0x65, 0x2f, 0x70, 0x6e, 0x67, 0x2c, 0x69, // ge.png.i 244 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x6a, 0x70, 0x67, // mage.jpg 245 0x2c, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x67, // .image.g 246 0x69, 0x66, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69, // if.appli 247 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78, // cation.x 248 0x6d, 0x6c, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69, // ml.appli 249 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78, // cation.x 250 0x68, 0x74, 0x6d, 0x6c, 0x2b, 0x78, 0x6d, 0x6c, // html.xml 251 0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x70, 0x6c, // .text.pl 252 0x61, 0x69, 0x6e, 0x2c, 0x74, 0x65, 0x78, 0x74, // ain.text 253 0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, // .javascr 254 0x69, 0x70, 0x74, 0x2c, 0x70, 0x75, 0x62, 0x6c, // ipt.publ 255 0x69, 0x63, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74, // icprivat 256 0x65, 0x6d, 0x61, 0x78, 0x2d, 0x61, 0x67, 0x65, // emax-age 257 0x3d, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x64, 0x65, // .gzip.de 258 0x66, 0x6c, 0x61, 0x74, 0x65, 0x2c, 0x73, 0x64, // flate.sd 259 0x63, 0x68, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, // chcharse 260 0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x63, // t.utf-8c 261 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x69, // harset.i 262 0x73, 0x6f, 0x2d, 0x38, 0x38, 0x35, 0x39, 0x2d, // so-8859- 263 0x31, 0x2c, 0x75, 0x74, 0x66, 0x2d, 0x2c, 0x2a, // 1.utf-.. 264 0x2c, 0x65, 0x6e, 0x71, 0x3d, 0x30, 0x2e // .enq.0. 265 }; 266 const int kV3DictionarySize = arraysize(kV3Dictionary); 267 268 // The HTTP/2 connection header prefix, which must be the first bytes 269 // sent by the client upon starting an HTTP/2 connection, and which 270 // must be followed by a SETTINGS frame. 271 // 272 // Equivalent to the string "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" 273 // (without the null terminator). 274 const char kHttp2ConnectionHeaderPrefix[] = { 275 0x50, 0x52, 0x49, 0x20, 0x2a, 0x20, 0x48, 0x54, // PRI * HT 276 0x54, 0x50, 0x2f, 0x32, 0x2e, 0x30, 0x0d, 0x0a, // TP/2.0.. 277 0x0d, 0x0a, 0x53, 0x4d, 0x0d, 0x0a, 0x0d, 0x0a // ..SM.... 278 }; 279 const int kHttp2ConnectionHeaderPrefixSize = 280 arraysize(kHttp2ConnectionHeaderPrefix); 281 282 const char kHttp2VersionString[] = "HTTP/1.1"; 283 284 // Types of SPDY frames. 285 enum SpdyFrameType { 286 DATA, 287 SYN_STREAM, 288 SYN_REPLY, 289 RST_STREAM, 290 SETTINGS, 291 PING, 292 GOAWAY, 293 HEADERS, 294 WINDOW_UPDATE, 295 CREDENTIAL = 10, // No longer valid. Kept for identifiability. 296 PUSH_PROMISE, 297 CONTINUATION, 298 PRIORITY, 299 // BLOCKED and ALTSVC are recognized extensions. 300 BLOCKED, 301 ALTSVC, 302 }; 303 304 // Flags on data packets. 305 enum SpdyDataFlags { 306 DATA_FLAG_NONE = 0x00, 307 DATA_FLAG_FIN = 0x01, 308 DATA_FLAG_END_SEGMENT = 0x02, 309 DATA_FLAG_PADDED = 0x08, 310 DATA_FLAG_COMPRESSED = 0x20, 311 }; 312 313 // Flags on control packets 314 enum SpdyControlFlags { 315 CONTROL_FLAG_NONE = 0x00, 316 CONTROL_FLAG_FIN = 0x01, 317 CONTROL_FLAG_UNIDIRECTIONAL = 0x02, 318 }; 319 320 enum SpdyPingFlags { 321 PING_FLAG_ACK = 0x01, 322 }; 323 324 // Used by HEADERS, PUSH_PROMISE, and CONTINUATION. 325 enum SpdyHeadersFlags { 326 HEADERS_FLAG_END_SEGMENT = 0x02, 327 HEADERS_FLAG_END_HEADERS = 0x04, 328 HEADERS_FLAG_PADDED = 0x08, 329 HEADERS_FLAG_PRIORITY = 0x20, 330 }; 331 332 enum SpdyPushPromiseFlags { 333 PUSH_PROMISE_FLAG_END_PUSH_PROMISE = 0x04, 334 PUSH_PROMISE_FLAG_PADDED = 0x08, 335 }; 336 337 // Flags on the SETTINGS control frame. 338 enum SpdySettingsControlFlags { 339 SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS = 0x01, 340 }; 341 342 enum Http2SettingsControlFlags { 343 SETTINGS_FLAG_ACK = 0x01, 344 }; 345 346 // Flags for settings within a SETTINGS frame. 347 enum SpdySettingsFlags { 348 SETTINGS_FLAG_NONE = 0x00, 349 SETTINGS_FLAG_PLEASE_PERSIST = 0x01, 350 SETTINGS_FLAG_PERSISTED = 0x02, 351 }; 352 353 // List of known settings. Avoid changing these enum values, as persisted 354 // settings are keyed on them, and they are also exposed in net-internals. 355 enum SpdySettingsIds { 356 SETTINGS_UPLOAD_BANDWIDTH = 0x1, 357 SETTINGS_DOWNLOAD_BANDWIDTH = 0x2, 358 // Network round trip time in milliseconds. 359 SETTINGS_ROUND_TRIP_TIME = 0x3, 360 // The maximum number of simultaneous live streams in each direction. 361 SETTINGS_MAX_CONCURRENT_STREAMS = 0x4, 362 // TCP congestion window in packets. 363 SETTINGS_CURRENT_CWND = 0x5, 364 // Downstream byte retransmission rate in percentage. 365 SETTINGS_DOWNLOAD_RETRANS_RATE = 0x6, 366 // Initial window size in bytes 367 SETTINGS_INITIAL_WINDOW_SIZE = 0x7, 368 // HPACK header table maximum size. 369 SETTINGS_HEADER_TABLE_SIZE = 0x8, 370 // Whether or not server push (PUSH_PROMISE) is enabled. 371 SETTINGS_ENABLE_PUSH = 0x9, 372 // The size of the largest frame payload that a receiver is willing to accept. 373 SETTINGS_MAX_FRAME_SIZE = 0xa, 374 // The maximum size of header list that the sender is prepared to accept. 375 SETTINGS_MAX_HEADER_LIST_SIZE = 0xb, 376 }; 377 378 // Status codes for RST_STREAM frames. 379 enum SpdyRstStreamStatus { 380 RST_STREAM_INVALID = 0, 381 RST_STREAM_PROTOCOL_ERROR = 1, 382 RST_STREAM_INVALID_STREAM = 2, 383 RST_STREAM_STREAM_CLOSED = 2, // Equivalent to INVALID_STREAM 384 RST_STREAM_REFUSED_STREAM = 3, 385 RST_STREAM_UNSUPPORTED_VERSION = 4, 386 RST_STREAM_CANCEL = 5, 387 RST_STREAM_INTERNAL_ERROR = 6, 388 RST_STREAM_FLOW_CONTROL_ERROR = 7, 389 RST_STREAM_STREAM_IN_USE = 8, 390 RST_STREAM_STREAM_ALREADY_CLOSED = 9, 391 RST_STREAM_INVALID_CREDENTIALS = 10, 392 // FRAME_TOO_LARGE (defined by SPDY versions 3.1 and below), and 393 // FRAME_SIZE_ERROR (defined by HTTP/2) are mapped to the same internal 394 // reset status. 395 RST_STREAM_FRAME_TOO_LARGE = 11, 396 RST_STREAM_FRAME_SIZE_ERROR = 11, 397 RST_STREAM_SETTINGS_TIMEOUT = 12, 398 RST_STREAM_CONNECT_ERROR = 13, 399 RST_STREAM_ENHANCE_YOUR_CALM = 14, 400 RST_STREAM_NUM_STATUS_CODES = 15 401 }; 402 403 // Status codes for GOAWAY frames. 404 enum SpdyGoAwayStatus { 405 GOAWAY_OK = 0, 406 GOAWAY_NO_ERROR = GOAWAY_OK, 407 GOAWAY_PROTOCOL_ERROR = 1, 408 GOAWAY_INTERNAL_ERROR = 2, 409 GOAWAY_FLOW_CONTROL_ERROR = 3, 410 GOAWAY_SETTINGS_TIMEOUT = 4, 411 GOAWAY_STREAM_CLOSED = 5, 412 GOAWAY_FRAME_SIZE_ERROR = 6, 413 GOAWAY_REFUSED_STREAM = 7, 414 GOAWAY_CANCEL = 8, 415 GOAWAY_COMPRESSION_ERROR = 9, 416 GOAWAY_CONNECT_ERROR = 10, 417 GOAWAY_ENHANCE_YOUR_CALM = 11, 418 GOAWAY_INADEQUATE_SECURITY = 12 419 }; 420 421 // A SPDY priority is a number between 0 and 7 (inclusive). 422 // SPDY priority range is version-dependent. For SPDY 2 and below, priority is a 423 // number between 0 and 3. 424 typedef uint8 SpdyPriority; 425 426 typedef std::map<std::string, std::string> SpdyNameValueBlock; 427 428 typedef uint64 SpdyPingId; 429 430 typedef std::string SpdyProtocolId; 431 432 // TODO(hkhalil): Add direct testing for this? It won't increase coverage any, 433 // but is good to do anyway. 434 class NET_EXPORT_PRIVATE SpdyConstants { 435 public: 436 // Returns true if a given on-the-wire enumeration of a frame type is valid 437 // for a given protocol version, false otherwise. 438 static bool IsValidFrameType(SpdyMajorVersion version, int frame_type_field); 439 440 // Parses a frame type from an on-the-wire enumeration of a given protocol 441 // version. 442 // Behavior is undefined for invalid frame type fields; consumers should first 443 // use IsValidFrameType() to verify validity of frame type fields. 444 static SpdyFrameType ParseFrameType(SpdyMajorVersion version, 445 int frame_type_field); 446 447 // Serializes a given frame type to the on-the-wire enumeration value for the 448 // given protocol version. 449 // Returns -1 on failure (I.E. Invalid frame type for the given version). 450 static int SerializeFrameType(SpdyMajorVersion version, 451 SpdyFrameType frame_type); 452 453 // Returns the frame type for non-control (i.e. data) frames 454 // in the given SPDY version. 455 static int DataFrameType(SpdyMajorVersion version); 456 457 // Returns true if a given on-the-wire enumeration of a setting id is valid 458 // for a given protocol version, false otherwise. 459 static bool IsValidSettingId(SpdyMajorVersion version, int setting_id_field); 460 461 // Parses a setting id from an on-the-wire enumeration of a given protocol 462 // version. 463 // Behavior is undefined for invalid setting id fields; consumers should first 464 // use IsValidSettingId() to verify validity of setting id fields. 465 static SpdySettingsIds ParseSettingId(SpdyMajorVersion version, 466 int setting_id_field); 467 468 // Serializes a given setting id to the on-the-wire enumeration value for the 469 // given protocol version. 470 // Returns -1 on failure (I.E. Invalid setting id for the given version). 471 static int SerializeSettingId(SpdyMajorVersion version, SpdySettingsIds id); 472 473 // Returns true if a given on-the-wire enumeration of a RST_STREAM status code 474 // is valid for a given protocol version, false otherwise. 475 static bool IsValidRstStreamStatus(SpdyMajorVersion version, 476 int rst_stream_status_field); 477 478 // Parses a RST_STREAM status code from an on-the-wire enumeration of a given 479 // protocol version. 480 // Behavior is undefined for invalid RST_STREAM status code fields; consumers 481 // should first use IsValidRstStreamStatus() to verify validity of RST_STREAM 482 // status code fields.. 483 static SpdyRstStreamStatus ParseRstStreamStatus(SpdyMajorVersion version, 484 int rst_stream_status_field); 485 486 // Serializes a given RST_STREAM status code to the on-the-wire enumeration 487 // value for the given protocol version. 488 // Returns -1 on failure (I.E. Invalid RST_STREAM status code for the given 489 // version). 490 static int SerializeRstStreamStatus(SpdyMajorVersion version, 491 SpdyRstStreamStatus rst_stream_status); 492 493 // Returns true if a given on-the-wire enumeration of a GOAWAY status code is 494 // valid for the given protocol version, false otherwise. 495 static bool IsValidGoAwayStatus(SpdyMajorVersion version, 496 int goaway_status_field); 497 498 // Parses a GOAWAY status from an on-the-wire enumeration of a given protocol 499 // version. 500 // Behavior is undefined for invalid GOAWAY status fields; consumers should 501 // first use IsValidGoAwayStatus() to verify validity of GOAWAY status fields. 502 static SpdyGoAwayStatus ParseGoAwayStatus(SpdyMajorVersion version, 503 int goaway_status_field); 504 505 // Serializes a given GOAWAY status to the on-the-wire enumeration value for 506 // the given protocol version. 507 // Returns -1 on failure (I.E. Invalid GOAWAY status for the given version). 508 static int SerializeGoAwayStatus(SpdyMajorVersion version, 509 SpdyGoAwayStatus status); 510 511 // Size, in bytes, of the data frame header. Future versions of SPDY 512 // will likely vary this, so we allow for the flexibility of a function call 513 // for this value as opposed to a constant. 514 static size_t GetDataFrameMinimumSize(SpdyMajorVersion version); 515 516 // Size, in bytes, of the control frame header. 517 static size_t GetControlFrameHeaderSize(SpdyMajorVersion version); 518 519 static size_t GetPrefixLength(SpdyFrameType type, SpdyMajorVersion version); 520 521 static size_t GetFrameMaximumSize(SpdyMajorVersion version); 522 523 // Returns the size of a header block size field. Valid only for SPDY 524 // versions <= 3. 525 static size_t GetSizeOfSizeField(SpdyMajorVersion version); 526 527 // Returns the size (in bytes) of a wire setting ID and value. 528 static size_t GetSettingSize(SpdyMajorVersion version); 529 530 static SpdyMajorVersion ParseMajorVersion(int version_number); 531 532 static int SerializeMajorVersion(SpdyMajorVersion version); 533 534 static std::string GetVersionString(SpdyMajorVersion version); 535 }; 536 537 class SpdyFrame; 538 typedef SpdyFrame SpdySerializedFrame; 539 540 class SpdyFrameVisitor; 541 542 // Intermediate representation for SPDY frames. 543 // TODO(hkhalil): Rename this class to SpdyFrame when the existing SpdyFrame is 544 // gone. 545 class NET_EXPORT_PRIVATE SpdyFrameIR { 546 public: 547 virtual ~SpdyFrameIR() {} 548 549 virtual void Visit(SpdyFrameVisitor* visitor) const = 0; 550 551 protected: 552 SpdyFrameIR() {} 553 554 private: 555 DISALLOW_COPY_AND_ASSIGN(SpdyFrameIR); 556 }; 557 558 // Abstract class intended to be inherited by IRs that have a stream associated 559 // to them. 560 class NET_EXPORT_PRIVATE SpdyFrameWithStreamIdIR : public SpdyFrameIR { 561 public: 562 virtual ~SpdyFrameWithStreamIdIR() {} 563 SpdyStreamId stream_id() const { return stream_id_; } 564 void set_stream_id(SpdyStreamId stream_id) { 565 DCHECK_EQ(0u, stream_id & ~kStreamIdMask); 566 stream_id_ = stream_id; 567 } 568 569 protected: 570 explicit SpdyFrameWithStreamIdIR(SpdyStreamId stream_id) { 571 set_stream_id(stream_id); 572 } 573 574 private: 575 SpdyStreamId stream_id_; 576 577 DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithStreamIdIR); 578 }; 579 580 // Abstract class intended to be inherited by IRs that have the option of a FIN 581 // flag. Implies SpdyFrameWithStreamIdIR. 582 class NET_EXPORT_PRIVATE SpdyFrameWithFinIR : public SpdyFrameWithStreamIdIR { 583 public: 584 virtual ~SpdyFrameWithFinIR() {} 585 bool fin() const { return fin_; } 586 void set_fin(bool fin) { fin_ = fin; } 587 588 protected: 589 explicit SpdyFrameWithFinIR(SpdyStreamId stream_id) 590 : SpdyFrameWithStreamIdIR(stream_id), 591 fin_(false) {} 592 593 private: 594 bool fin_; 595 596 DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithFinIR); 597 }; 598 599 // Abstract class intended to be inherited by IRs that contain a name-value 600 // block. Implies SpdyFrameWithFinIR. 601 class NET_EXPORT_PRIVATE SpdyFrameWithNameValueBlockIR 602 : public NON_EXPORTED_BASE(SpdyFrameWithFinIR) { 603 public: 604 const SpdyNameValueBlock& name_value_block() const { 605 return name_value_block_; 606 } 607 void set_name_value_block(const SpdyNameValueBlock& name_value_block) { 608 // Deep copy. 609 name_value_block_ = name_value_block; 610 } 611 void SetHeader(const base::StringPiece& name, 612 const base::StringPiece& value) { 613 name_value_block_[name.as_string()] = value.as_string(); 614 } 615 SpdyNameValueBlock* mutable_name_value_block() { 616 return &name_value_block_; 617 } 618 619 protected: 620 explicit SpdyFrameWithNameValueBlockIR(SpdyStreamId stream_id); 621 virtual ~SpdyFrameWithNameValueBlockIR(); 622 623 private: 624 SpdyNameValueBlock name_value_block_; 625 626 DISALLOW_COPY_AND_ASSIGN(SpdyFrameWithNameValueBlockIR); 627 }; 628 629 class NET_EXPORT_PRIVATE SpdyDataIR 630 : public NON_EXPORTED_BASE(SpdyFrameWithFinIR) { 631 public: 632 // Performs deep copy on data. 633 SpdyDataIR(SpdyStreamId stream_id, const base::StringPiece& data); 634 635 // Use in conjunction with SetDataShallow() for shallow-copy on data. 636 explicit SpdyDataIR(SpdyStreamId stream_id); 637 638 virtual ~SpdyDataIR(); 639 640 base::StringPiece data() const { return data_; } 641 642 bool padded() const { return padded_; } 643 644 int padding_payload_len() const { return padding_payload_len_; } 645 646 void set_padding_len(int padding_len) { 647 DCHECK_GT(padding_len, 0); 648 DCHECK_LE(padding_len, kPaddingSizePerFrame); 649 padded_ = true; 650 // The pad field takes one octet on the wire. 651 padding_payload_len_ = padding_len - 1; 652 } 653 654 // Deep-copy of data (keep private copy). 655 void SetDataDeep(const base::StringPiece& data) { 656 data_store_.reset(new std::string(data.data(), data.length())); 657 data_ = *(data_store_.get()); 658 } 659 660 // Shallow-copy of data (do not keep private copy). 661 void SetDataShallow(const base::StringPiece& data) { 662 data_store_.reset(); 663 data_ = data; 664 } 665 666 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 667 668 private: 669 // Used to store data that this SpdyDataIR should own. 670 scoped_ptr<std::string> data_store_; 671 base::StringPiece data_; 672 673 bool padded_; 674 // padding_payload_len_ = desired padding length - len(padding length field). 675 int padding_payload_len_; 676 677 DISALLOW_COPY_AND_ASSIGN(SpdyDataIR); 678 }; 679 680 class NET_EXPORT_PRIVATE SpdySynStreamIR 681 : public SpdyFrameWithNameValueBlockIR { 682 public: 683 explicit SpdySynStreamIR(SpdyStreamId stream_id) 684 : SpdyFrameWithNameValueBlockIR(stream_id), 685 associated_to_stream_id_(0), 686 priority_(0), 687 unidirectional_(false) {} 688 SpdyStreamId associated_to_stream_id() const { 689 return associated_to_stream_id_; 690 } 691 void set_associated_to_stream_id(SpdyStreamId stream_id) { 692 associated_to_stream_id_ = stream_id; 693 } 694 SpdyPriority priority() const { return priority_; } 695 void set_priority(SpdyPriority priority) { priority_ = priority; } 696 bool unidirectional() const { return unidirectional_; } 697 void set_unidirectional(bool unidirectional) { 698 unidirectional_ = unidirectional; 699 } 700 701 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 702 703 private: 704 SpdyStreamId associated_to_stream_id_; 705 SpdyPriority priority_; 706 bool unidirectional_; 707 708 DISALLOW_COPY_AND_ASSIGN(SpdySynStreamIR); 709 }; 710 711 class NET_EXPORT_PRIVATE SpdySynReplyIR : public SpdyFrameWithNameValueBlockIR { 712 public: 713 explicit SpdySynReplyIR(SpdyStreamId stream_id) 714 : SpdyFrameWithNameValueBlockIR(stream_id) {} 715 716 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 717 718 private: 719 DISALLOW_COPY_AND_ASSIGN(SpdySynReplyIR); 720 }; 721 722 class NET_EXPORT_PRIVATE SpdyRstStreamIR : public SpdyFrameWithStreamIdIR { 723 public: 724 SpdyRstStreamIR(SpdyStreamId stream_id, SpdyRstStreamStatus status, 725 base::StringPiece description); 726 727 virtual ~SpdyRstStreamIR(); 728 729 SpdyRstStreamStatus status() const { 730 return status_; 731 } 732 void set_status(SpdyRstStreamStatus status) { 733 status_ = status; 734 } 735 736 base::StringPiece description() const { return description_; } 737 738 void set_description(base::StringPiece description) { 739 description_ = description; 740 } 741 742 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 743 744 private: 745 SpdyRstStreamStatus status_; 746 base::StringPiece description_; 747 748 DISALLOW_COPY_AND_ASSIGN(SpdyRstStreamIR); 749 }; 750 751 class NET_EXPORT_PRIVATE SpdySettingsIR : public SpdyFrameIR { 752 public: 753 // Associates flags with a value. 754 struct Value { 755 Value() : persist_value(false), 756 persisted(false), 757 value(0) {} 758 bool persist_value; 759 bool persisted; 760 int32 value; 761 }; 762 typedef std::map<SpdySettingsIds, Value> ValueMap; 763 764 SpdySettingsIR(); 765 766 virtual ~SpdySettingsIR(); 767 768 // Overwrites as appropriate. 769 const ValueMap& values() const { return values_; } 770 void AddSetting(SpdySettingsIds id, 771 bool persist_value, 772 bool persisted, 773 int32 value) { 774 values_[id].persist_value = persist_value; 775 values_[id].persisted = persisted; 776 values_[id].value = value; 777 } 778 779 bool clear_settings() const { return clear_settings_; } 780 void set_clear_settings(bool clear_settings) { 781 clear_settings_ = clear_settings; 782 } 783 bool is_ack() const { return is_ack_; } 784 void set_is_ack(bool is_ack) { 785 is_ack_ = is_ack; 786 } 787 788 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 789 790 private: 791 ValueMap values_; 792 bool clear_settings_; 793 bool is_ack_; 794 795 DISALLOW_COPY_AND_ASSIGN(SpdySettingsIR); 796 }; 797 798 class NET_EXPORT_PRIVATE SpdyPingIR : public SpdyFrameIR { 799 public: 800 explicit SpdyPingIR(SpdyPingId id) : id_(id), is_ack_(false) {} 801 SpdyPingId id() const { return id_; } 802 803 // ACK logic is valid only for SPDY versions 4 and above. 804 bool is_ack() const { return is_ack_; } 805 void set_is_ack(bool is_ack) { is_ack_ = is_ack; } 806 807 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 808 809 private: 810 SpdyPingId id_; 811 bool is_ack_; 812 813 DISALLOW_COPY_AND_ASSIGN(SpdyPingIR); 814 }; 815 816 class NET_EXPORT_PRIVATE SpdyGoAwayIR : public SpdyFrameIR { 817 public: 818 SpdyGoAwayIR(SpdyStreamId last_good_stream_id, SpdyGoAwayStatus status, 819 const base::StringPiece& description); 820 virtual ~SpdyGoAwayIR(); 821 SpdyStreamId last_good_stream_id() const { return last_good_stream_id_; } 822 void set_last_good_stream_id(SpdyStreamId last_good_stream_id) { 823 DCHECK_LE(0u, last_good_stream_id); 824 DCHECK_EQ(0u, last_good_stream_id & ~kStreamIdMask); 825 last_good_stream_id_ = last_good_stream_id; 826 } 827 SpdyGoAwayStatus status() const { return status_; } 828 void set_status(SpdyGoAwayStatus status) { 829 // TODO(hkhalil): Check valid ranges of status? 830 status_ = status; 831 } 832 833 const base::StringPiece& description() const; 834 835 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 836 837 private: 838 SpdyStreamId last_good_stream_id_; 839 SpdyGoAwayStatus status_; 840 const base::StringPiece description_; 841 842 DISALLOW_COPY_AND_ASSIGN(SpdyGoAwayIR); 843 }; 844 845 class NET_EXPORT_PRIVATE SpdyHeadersIR : public SpdyFrameWithNameValueBlockIR { 846 public: 847 explicit SpdyHeadersIR(SpdyStreamId stream_id) 848 : SpdyFrameWithNameValueBlockIR(stream_id), 849 has_priority_(false), 850 priority_(0) {} 851 852 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 853 854 bool has_priority() const { return has_priority_; } 855 void set_has_priority(bool has_priority) { has_priority_ = has_priority; } 856 uint32 priority() const { return priority_; } 857 void set_priority(SpdyPriority priority) { priority_ = priority; } 858 859 private: 860 bool has_priority_; 861 // 31-bit priority. 862 uint32 priority_; 863 DISALLOW_COPY_AND_ASSIGN(SpdyHeadersIR); 864 }; 865 866 class NET_EXPORT_PRIVATE SpdyWindowUpdateIR : public SpdyFrameWithStreamIdIR { 867 public: 868 SpdyWindowUpdateIR(SpdyStreamId stream_id, int32 delta) 869 : SpdyFrameWithStreamIdIR(stream_id) { 870 set_delta(delta); 871 } 872 int32 delta() const { return delta_; } 873 void set_delta(int32 delta) { 874 DCHECK_LT(0, delta); 875 DCHECK_LE(delta, kSpdyMaximumWindowSize); 876 delta_ = delta; 877 } 878 879 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 880 881 private: 882 int32 delta_; 883 884 DISALLOW_COPY_AND_ASSIGN(SpdyWindowUpdateIR); 885 }; 886 887 class NET_EXPORT_PRIVATE SpdyBlockedIR 888 : public NON_EXPORTED_BASE(SpdyFrameWithStreamIdIR) { 889 public: 890 explicit SpdyBlockedIR(SpdyStreamId stream_id) 891 : SpdyFrameWithStreamIdIR(stream_id) {} 892 893 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 894 895 private: 896 DISALLOW_COPY_AND_ASSIGN(SpdyBlockedIR); 897 }; 898 899 class NET_EXPORT_PRIVATE SpdyPushPromiseIR 900 : public SpdyFrameWithNameValueBlockIR { 901 public: 902 SpdyPushPromiseIR(SpdyStreamId stream_id, SpdyStreamId promised_stream_id) 903 : SpdyFrameWithNameValueBlockIR(stream_id), 904 promised_stream_id_(promised_stream_id) {} 905 SpdyStreamId promised_stream_id() const { return promised_stream_id_; } 906 void set_promised_stream_id(SpdyStreamId id) { promised_stream_id_ = id; } 907 908 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 909 910 private: 911 SpdyStreamId promised_stream_id_; 912 DISALLOW_COPY_AND_ASSIGN(SpdyPushPromiseIR); 913 }; 914 915 // TODO(jgraettinger): This representation needs review. SpdyContinuationIR 916 // needs to frame a portion of a single, arbitrarily-broken encoded buffer. 917 class NET_EXPORT_PRIVATE SpdyContinuationIR 918 : public SpdyFrameWithNameValueBlockIR { 919 public: 920 explicit SpdyContinuationIR(SpdyStreamId stream_id) 921 : SpdyFrameWithNameValueBlockIR(stream_id), 922 end_headers_(false) {} 923 924 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 925 926 bool end_headers() const { return end_headers_; } 927 void set_end_headers(bool end_headers) {end_headers_ = end_headers;} 928 929 private: 930 bool end_headers_; 931 DISALLOW_COPY_AND_ASSIGN(SpdyContinuationIR); 932 }; 933 934 class NET_EXPORT_PRIVATE SpdyAltSvcIR : public SpdyFrameWithStreamIdIR { 935 public: 936 explicit SpdyAltSvcIR(SpdyStreamId stream_id); 937 938 uint32 max_age() const { return max_age_; } 939 uint16 port() const { return port_; } 940 SpdyProtocolId protocol_id() const { 941 return protocol_id_; 942 } 943 std::string host() const { return host_; } 944 std::string origin() const { return origin_; } 945 946 void set_max_age(uint32 max_age) { max_age_ = max_age; } 947 void set_port(uint16 port) { port_ = port; } 948 void set_protocol_id(SpdyProtocolId protocol_id) { 949 protocol_id_ = protocol_id; 950 } 951 void set_host(std::string host) { 952 host_ = host; 953 } 954 void set_origin(std::string origin) { 955 origin_ = origin; 956 } 957 958 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 959 960 private: 961 uint32 max_age_; 962 uint16 port_; 963 SpdyProtocolId protocol_id_; 964 std::string host_; 965 std::string origin_; 966 DISALLOW_COPY_AND_ASSIGN(SpdyAltSvcIR); 967 }; 968 969 class NET_EXPORT_PRIVATE SpdyPriorityIR : public SpdyFrameWithStreamIdIR { 970 public: 971 explicit SpdyPriorityIR(SpdyStreamId stream_id); 972 explicit SpdyPriorityIR(SpdyStreamId stream_id, 973 SpdyStreamId parent_stream_id, 974 uint8 weight, 975 bool exclusive); 976 SpdyStreamId parent_stream_id() const { return parent_stream_id_; } 977 void set_parent_stream_id(SpdyStreamId id) { parent_stream_id_ = id; } 978 uint8 weight() const { return weight_; } 979 void set_weight(uint8 weight) { weight_ = weight; } 980 bool exclusive() const { return exclusive_; } 981 void set_exclusive(bool exclusive) { exclusive_ = exclusive; } 982 983 virtual void Visit(SpdyFrameVisitor* visitor) const OVERRIDE; 984 985 private: 986 SpdyStreamId parent_stream_id_; 987 uint8 weight_; 988 bool exclusive_; 989 DISALLOW_COPY_AND_ASSIGN(SpdyPriorityIR); 990 }; 991 992 // ------------------------------------------------------------------------- 993 // Wrapper classes for various SPDY frames. 994 995 // All Spdy Frame types derive from this SpdyFrame class. 996 class SpdyFrame { 997 public: 998 // Create a SpdyFrame using a pre-created buffer. 999 // If |owns_buffer| is true, this class takes ownership of the buffer 1000 // and will delete it on cleanup. The buffer must have been created using 1001 // new char[]. 1002 // If |owns_buffer| is false, the caller retains ownership of the buffer and 1003 // is responsible for making sure the buffer outlives this frame. In other 1004 // words, this class does NOT create a copy of the buffer. 1005 SpdyFrame(char* data, size_t size, bool owns_buffer) 1006 : frame_(data), 1007 size_(size), 1008 owns_buffer_(owns_buffer) { 1009 DCHECK(frame_); 1010 } 1011 1012 ~SpdyFrame() { 1013 if (owns_buffer_) { 1014 delete [] frame_; 1015 } 1016 frame_ = NULL; 1017 } 1018 1019 // Provides access to the frame bytes, which is a buffer containing 1020 // the frame packed as expected for sending over the wire. 1021 char* data() const { return frame_; } 1022 1023 // Returns the actual size of the underlying buffer. 1024 size_t size() const { return size_; } 1025 1026 protected: 1027 char* frame_; 1028 1029 private: 1030 size_t size_; 1031 bool owns_buffer_; 1032 DISALLOW_COPY_AND_ASSIGN(SpdyFrame); 1033 }; 1034 1035 // This interface is for classes that want to process SpdyFrameIRs without 1036 // having to know what type they are. An instance of this interface can be 1037 // passed to a SpdyFrameIR's Visit method, and the appropriate type-specific 1038 // method of this class will be called. 1039 class SpdyFrameVisitor { 1040 public: 1041 virtual void VisitSynStream(const SpdySynStreamIR& syn_stream) = 0; 1042 virtual void VisitSynReply(const SpdySynReplyIR& syn_reply) = 0; 1043 virtual void VisitRstStream(const SpdyRstStreamIR& rst_stream) = 0; 1044 virtual void VisitSettings(const SpdySettingsIR& settings) = 0; 1045 virtual void VisitPing(const SpdyPingIR& ping) = 0; 1046 virtual void VisitGoAway(const SpdyGoAwayIR& goaway) = 0; 1047 virtual void VisitHeaders(const SpdyHeadersIR& headers) = 0; 1048 virtual void VisitWindowUpdate(const SpdyWindowUpdateIR& window_update) = 0; 1049 virtual void VisitBlocked(const SpdyBlockedIR& blocked) = 0; 1050 virtual void VisitPushPromise(const SpdyPushPromiseIR& push_promise) = 0; 1051 virtual void VisitContinuation(const SpdyContinuationIR& continuation) = 0; 1052 virtual void VisitAltSvc(const SpdyAltSvcIR& altsvc) = 0; 1053 virtual void VisitPriority(const SpdyPriorityIR& priority) = 0; 1054 virtual void VisitData(const SpdyDataIR& data) = 0; 1055 1056 protected: 1057 SpdyFrameVisitor() {} 1058 virtual ~SpdyFrameVisitor() {} 1059 1060 private: 1061 DISALLOW_COPY_AND_ASSIGN(SpdyFrameVisitor); 1062 }; 1063 1064 } // namespace net 1065 1066 #endif // NET_SPDY_SPDY_PROTOCOL_H_ 1067
