pax_global_header00006660000000000000000000000064140652654210014517gustar00rootroot0000000000000052 comment=8a2d5c1e37efdeb0f43a9083b6cefe093959aece java-http-client-2.2.2/000077500000000000000000000000001406526542100146745ustar00rootroot00000000000000java-http-client-2.2.2/.gitignore000066400000000000000000000001061406526542100166610ustar00rootroot00000000000000.gradle /local.properties .DS_Store /build bin out .idea /*.iml tmp java-http-client-2.2.2/LICENSE000066400000000000000000000020671406526542100157060ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2019 Andrew Groot Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. java-http-client-2.2.2/README.md000066400000000000000000000001001406526542100161420ustar00rootroot00000000000000# Java HTTP Client Components for making outbound HTTP calls. java-http-client-2.2.2/build.gradle000066400000000000000000000044261406526542100171610ustar00rootroot00000000000000group 'com.softwareverde' version '2.2.2' apply plugin: 'java' apply plugin: 'java-library' java { sourceCompatibility = JavaVersion.VERSION_1_8 targetCompatibility = JavaVersion.VERSION_1_8 } repositories { mavenCentral() maven { url "https://jitpack.io" } } dependencies { api group: 'com.github.softwareverde', name: 'json', version: 'v2.0.0' implementation group: 'com.github.softwareverde', name: 'java-logging', version: 'v2.2.0' implementation group: 'com.github.softwareverde', name: 'java-util', version: 'v2.7.3' implementation group: 'com.github.softwareverde', name: 'java-cryptography', version: 'v3.2.1' testImplementation group: 'junit', name: 'junit', version: '4.12' } tasks.withType(Test) { testLogging { // set options for log level LIFECYCLE events "passed", "skipped", "failed", "standardOut" showExceptions true exceptionFormat "full" showCauses true showStackTraces true // set options for log level DEBUG and INFO debug { events "started", "passed", "skipped", "failed", "standardOut", "standardError" exceptionFormat "full" } info.events = debug.events info.exceptionFormat = debug.exceptionFormat afterSuite { desc, result -> if (! desc.parent) { // will match the outermost suite def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)" def startItem = '| ', endItem = ' |' def repeatLength = startItem.length() + output.length() + endItem.length() println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength)) } } } } tasks.withType(Javadoc) { options.addStringOption('Xdoclint:none', '-quiet') } task sourcesJar(type: Jar, dependsOn: classes) { classifier = 'sources' from sourceSets.main.allSource } task javadocJar(type: Jar, dependsOn: javadoc) { classifier = 'javadoc' from javadoc.destinationDir } artifacts { archives sourcesJar archives javadocJar } java-http-client-2.2.2/gradle/000077500000000000000000000000001406526542100161325ustar00rootroot00000000000000java-http-client-2.2.2/gradle/wrapper/000077500000000000000000000000001406526542100176125ustar00rootroot00000000000000java-http-client-2.2.2/gradle/wrapper/gradle-wrapper.jar000066400000000000000000001630361406526542100232350ustar00rootroot00000000000000PK A META-INF/PK Am>=@?META-INF/MANIFEST.MFMLK-. K-*ϳR03-IM+I, dZ)%*%rrPK Aorg/PK A org/gradle/PK Aorg/gradle/wrapper/PK A%Ӧ/org/gradle/wrapper/BootstrapMainStarter$1.classRn@=Ӹu1Ey@_Iik6U@.,RuL!G 6 (ı ]t1ssչ_x󸳈ᾏM|4isZ}.kތ=ed/cΥei0c =<Ob+7.PmB%M -wźl6i<Z293#ұwںl hx8FEv~ė9P%pw8.R3S ѵAc+jgQEoN SzBzj\: zQ^oPK Ai,$ -org/gradle/wrapper/BootstrapMainStarter.classVSWsٰ,1*BI/VV(-m.!nvfjﭽ< %2ӗv;IIbٳ]7>1IF2^ C0%cA0#aVF d\{2Ǽd\UqBNPp]R2"!c7%|؉^|$A aQʋ .aI~ ee41rtSwN3+ U U䳕"E(ak{wuT-.Z黶9rhu48C, -펖64:n=n/whviX iFZ$K]hO&VoFWc-MDqhƛ:UTT;#RNvRzH$['tk=e&śoh86lsܕP=֣ ed,X: ׶`Զl"zϼNE/wۼ-j=𒶨y1/ [\f UevS/7,xBY|͙ZI,¶Cw\o4 Hn"#RGw Nb(Utm{ۣ*z*ch #9_xWchyG}ը/CCASs/A݇~8# ER7q%B# ܤ@-8q;Dv{K0*GcM%8NMUK;I1D %ĞↄDvNަDgy|px#UcU]@}iP8T(j@ 1*B qg)_X~:pDv%x}QJ \wWl~QI۵ 瓻x,Ȟ)W"MyŸi^;SܷsM C簸«NSd+:JEéxhTDf+TWkx:ɛ%e9ii1."4 e-a}G}OH??~RRę6 )$A5v\uhX Q~PLgn@Op{8 9'UD;v.BN%tm4 :Ӯ>@ZOT_1~#twdFJ8k$iJT'I'VnUI1Ii*:h X &(+78=h`Z}s -D̥xRϧr.р#A$q4 ?&`S}Z}_l1nb:݊3 ˦PK A#: !org/gradle/wrapper/Download.classY xu~Kpy(A,X'Ӓub$HD!YbBۑqbKi6M#%(IҸGz鑶i{%a,@h_ 3o޼̮^+_&M~/R];K#1c]KJџ{//i+|_hK;o;~^ZDॗEO*^Q_DyM4ᥗu/'hzGҏ Di/3%d2/}]*\H`EPU+OrxV I5 l^ hfhN4K^_e^l| oWyAU^*x^/H*oPAK 7zUn2ZS*oR.7EmBvwܦr;U[]*E,G w0iD°:z*eV1FtcIM=ocJuRF&HgNFŽEtf`o]`_/غOָk V,1Ti&RxPchޮ.&ꉩo@W(ts?dD`]g_ooW 4 t vwC]L{J20yؘnkhh=cɤavIX`ܫOL^ +3L9h.%VdX"fbꨟǂޛK040;0z#5 3LJu+&m y-Yfq[LҖ1;]*dS=zٍu"1r:4tֽ!5(z4*LCj"Fʎ%]k]g#FRLbqmNg0aVBcA:eX 'H(0%0in#1fH29@$si  ]K F!%0 2132# {06ai;o<\37ؗia0 LŠfq~6(TR1dg]= w)W} W8g1>+0f;E!t.aglN 1u^EfgƆ$H~Q &FM@2nJDd-/Ьv̰7e|15C2x*ʾXjAguV<&pzH2n+`ȬBgI r!C-cF# i<1O ?1+q'[|2iS-¦I~@cƤ0MsB"+Q#ZY b`2'᳢9Rpf-`gej *lz+꺰f4~&!<,]4+o<Ȍ8`r^iH6IJN7qiN w{RbGA0OV@O)#80BI `Q`L@`F҂%7bY*WyTPgZd]?.xXl"-5~ߍĜYLN]_QA3nGO!*|QiohpovgrK_m9;o%-{t[% ><$!Κց:Vo% - $L;J'&D l8+h1Ao9[N;9#tkÉbZg".yTT~m]Py~v+эܙ+Ap`/`(`/[%tq#Z\] 谮^,ɓ{^7I)3Ms!b">)J-3fĩhJkmJ9s7GF܋TUc-%ZîҸ8j}]wXs)YJQ,)pKEZ!s~ f%vamQɩ*|n\|R[v,99 ,,A~ VXU7 )nv:9i¦ngREUk"q3%޺d9g;U;4̟Ly@CqC~3eg{p|P;61!|MtM%\JLXAԬ|ȹHX|"~lmA.b'\qĭ}@^)5R漦-K6O!~;J8i8gmuv(>V9_ ykքnϲot01%"4iZFgl~| om0~h/_|>< 1c4DƳ'H1eh[I; nz[! Ue''@a*T0Epc$)WICŌI.LմV8oҦYymZ'[&{M'sIǺ>i-"Uޤ)CBEֻ.)C5= `fY!N)7]S jyzV}7(@N4yw6k6- O0MҒ^'CK ~$em[W2t߽`}mnw+ 6UVY_W3*cd\Z!Z9Z[STmu+.*䳪j5NT<0%Z&iƶ/Z]ujP_u-P akН3&5gh M hsxfhv2W&F[Mi!⯹qk8<?3hAdpu#O{Ԅ\DȒCA0O)B(F6AE܇9O<8(Jlh%ty MJp %y=[); Y'xڨ0t}.!Òa@EC )vU$(Ua/ߢ_@N-9^6x;`;ky 2/Us}>5T9 eU PhBV3 K 1^b7fbɵn+%yc$9S]Q>;-46y+ըF<? i hvo7~y{¾, nO< # &\$3R9<ĺekB/9:6W|FؔHEqEUPAo~ 3` 8,y =3Ů<ʃ. Aʰz;MJ`~Ze?JDvQޟ`F׳8z0snPOP|!חh0CCMa1>8̘gH[/d8j}`8:v+Ow[Kx!((㎏B((!}%5y%sE"u<\^M_D R}8znW|=#(b+Qxʦ%5Qǧ=< IŒM'/a$7AtV9;m[-$ڜ͗.r>c1"l5Y啂L٘~fܳ`7B$Z>S*LMc&2kwD$1(,IkDž6xNUeP؍Gy(4 =~'VCZO9t&.Ϻ\X85宣 ^!1%?k7_ߐ{M7?$*z吳iceiEus+p8_Ay PK AyL1org/gradle/wrapper/DownloadProgressListener.classu @E+jDE@ۖEERI#3c[>4v9OĪ.r%J[M DŽ,]8kߟ_PU:]3aG\^&at"-EeY˛8\3K tЎBNk؁PK A!9| 3org/gradle/wrapper/ExclusiveFileAccessManager.classWsWYګu|iVMNZ*;JlBNKƎ[t-vjSB[(P`x 3L$x0 }0+9%L=sݿOt]o3;6lKqoF3VB>%lW !8$` Dղ3"x D]AمEU WxcLQV$Cn.O#&A7zx N5@T3(zY4} ] ҳ4?Evqݏ<̏ LNp8>K.1Dg[A|4nkhLpSESv\c~]+蘭vvR5dw=#r<\KT8lo7`.ՐS WĮT U4]~T76v7BZ H ҫ@'c Klϓ31cDQDDwp>Pzp}@8B gmγ*& _$W +kr}FA?~(AZ8:ưq8 ӛ"؅Qc? z5)qjsDPh hF9҈u>c~iMȈvz5HM $?b)nIP$)SݳhѠǧB<q0.Ҷxd(WWw@M߉߭5S< a-sc-gONQM} (1#j R`뛿̀imP/QWM:;"+) Qgc@'Q)f! Ip @"pHwbo8=N%Ťډ;RN 8C?ӕ7oWy+V b3Bųl9ܭ9**$U<~PΫx^Kx{TJZ\/SrB+UtɯRj+akZu ^x 7)xxxX, *xw]rxE?.*>`XR0F|HeqE]LJ冏QPI| g<"9?+!I>//"؎ i?}GwvuDNh걭Xr`V3_ PޖH{[.˲g_W{o:Zbc,7  Z~JĒƮtaTҌ,gRK"54`q錥 VS3=v$%+03|dGn cY@"o-j#f6m VY&협2M-Fފ!JXg4kj5 =/2j&OHnX[\6sZǶC1!ґӟREtk_ڎśNk4"n HezE!,r_M~ֈmrI9 n)\™Jr^PPڬB2Kqf-Inڷkr{%mlmS663o,==Srr^7V'j[&F!T{̴5YrVHL6L2nG`#(DB7-P2&s Nsٖ |YjOS1X; ?5?V ̢CԩD ?B/+ 1kYb63R1Gs%qB{(,2\;Nxau%䋂g^W4Ox l؏!!vB`gSPyw\|w޼=yi7u4WqS.9,8V8s\[>$7{TiWGPY:NFQ7 e?_Fe_Yz2A8FIQrgA(uN#p$9&F9J)2:r@0G>̒RMŀmC|iL u1J/ٴb.%׎rB9,,G oE)2[;nV,ܣtԻ7f:5`jdؐ0[|g[qU:!lɪ6r g6[ aaO<0ùuPNYpiᬎ;Ug$~cO_-|{{ u)Gg>' ݋n9ȠS=.ƲPS9̵qw.prZ1b͊YS=Da(<,`*KPK A"org/gradle/wrapper/IDownload.classE 0  ^b* A{(l|JTf $_uX! ai'$|T:/ ?&NJ@XaXQГ7&zDVʙ&6X`-6L͉veLCz~@F@Y%H')9~<~WxL߰"Ni avyܲ'; WQ?/D\V+mĪM˩NjJjǢN4 55e-$| ¤iuMGOhSBWt%+i/ƌFKL\гva:Pљ^hw4*\kQ^\)6jkdQ|5\$5gʧ@yЊp6`&ƚewRr,oIښRe~멶\sngBs`2ҎKu1j4ZIWU|WP1PjYmlj 949U[:ycc)GܧvN45gjּyΚ !BRgyq)P1.(e%OWUNqMm;֚guhwX pg/0aŧM[˦mi9lHvX(65c ()X,J|{vg>BT᫪DTvjt7s1`t.Uz{̈́ze%ؒK)y9X튢u,5N V>]E#+K%TӗN >+*)P%ӃM,r{z77~;|n Q]]D]  Qfj-VI@wĚAO#=[`=eYDYBG7S2_ ӻV}\6T/z&pyg"D]թXB~i'>H6?e]G1< ˧LhYQbWfI+" & kX|!]ۗx+Z 3N`yte%XtLϚpp}';Ƞ.zG?lnyjOඖ@,d+/;m.PǶ-">G=dk-&ⱶϝ:ul ?g5 t%R}u2ei=[Ȳ"!&n▉Q\3a"e@XgX#-Ctۛ#a&QT Q z"H4H;4&('wJ:4OwYJ5N1. \ 0dy60uC.eQǨH~Zp&C%$,FٜB2LfL6=sT+еOТ't!uk*ߣ 34U xVȋI_=f%s &3lxѫwv+e/u6W.U1}d6PK Avp.- org/gradle/wrapper/Install.classY |T?'ax,0lH +aGb$%, K߼1 ]ZjV]肭$h*Z[jmk}~~M羙$y޻s?{-i/KS Lp rH< ϐ l>Sp ೤qq|_qIKti\\Rz[-xq ^:^&˥Y!t*exukA~VFDuBX"^A UXlIl[N٪q=;cgj]Ҵyޥn-|~O6_}#n6iVjljN&sqvs({fecp"|88)*NRG uUo<{y Ry~@4A H'I#X97씅k(IӮl1ӊEIhnP4O8-ljN2M퉔ūZz}ŠQ$?nE"1+!i6:c dQ:5!%T7K2R]"3?D +u_ F;#qlcSR j%Mo\5%Z.LR+u,>c[.NFq1 Y^F$!a9_2rS13=J,o)7*Ʈ@?'նDw_NbZXesy˿CIZgGM$YWzi[sq[Npe%zđ j11Q9.RT.ihnEPwH'6(aJBdvgt֝J(y(Kt+v6j{7'׳vW7 F\86h$;^]𵻶TnR-:ڢ$zuR,?ۉ ÷@%  ^CE1|]^< иA ϧGH?BʏVVqeGhaN'?ڹ)tdGoZ9<I"&2zԛAut=zD$ ϵ4iMeDW{C~*j?'4,*+>HEw:sd/RrnpVʹnOA"ip 2`n}nf3gsK3Vbm㸣ߍFL;JM4|f4yVx'ӷվBoޭ42맙+[Zy 䬃CIK@E?YpͩyV !iQ> 8JsOgyo!E4og'];'dwBIt6 ϥ(BP@bxIQZ@12y$fYTJQNVn @녉/W&I /ax~ Sv .ZN_n504 =_+ٯCtdnkt' X6~jT]C&^ё(8רM0•4xD2xTy/-`:@S JSi(;1Rs+*Gyy RAh ,S O~z_ != {\V$ڬCQ6\.{>L5e[)!&Z .Y\S 7xѱWԊվAZ y?#!If)g3ȵ*dҷ+;xSC=RI橷練>( s5=u|ፃ QW-iiZǚ&hRyli'9@zEH|/Vv ~M« Z-7.|((ɲnL;<漬s# gIL1~?f =bIcm~%C6=@ÃTR^MT⿟Z<z_<@9y|8rPZ?H[nMT-Ձ(lub%hȏbmMiv^SwStWh]pA?G`G?]O6hzހ$pME{=ݏ(MՀY-`0Xo\F?'Qcɓ8a_x 1fDyp݉ I)E@u\J[iP{S|s ho?< =PFA Bz. z n ciTmԐP8FKDB$;'z1]DtKbjzqZ~jo,/0#vsY9e:MT̊Bz&+UV0[G&Y)@VZDW֛9t!H 4WKX֫/fZBF`1^ŘS۔sJY?(?ooy֛`'KD%AAŲ&(v1'fHnӃt j16@Q-ҕ R4OɢPo.oA:l 'RL./k&/MA~O:A%X >$CWy-ױO{+2՟5x|2j?c-I|g}=5]ˡ " i8;NUņV5zP,y , Q|fb>b&pjrMfL+*Uwp5s6S^JXS>4'ZL8?g/ZCYUkjwj, [D*Kmtq*a'i1K,co W~ %B!4O-eGvg`ӝ"VT>uayq?^@˙\NX~U̹v? | qi3ou$-`fc<]99@S&;;eM*Z|<`?4dckqǐ{0#bvtUwxQ; 6m!W\5]1,)@F\s ˵w/'.Hqϰ3:NWfu-Ce"!lU#;m"x*@obw=Cj[$B# %qcI![3̔JgX&ovHIFi QV(Iؔ)r /,*ꊧP*qw(P&n_ݖ7ۛPK AJJ'8org/gradle/wrapper/PathAssembler$LocalDistribution.classQJ@=wj7EA(*(mۥnI٦`|(qv[Ī ̙3sf@Y0mf]̻X`pk\&poy @bW*IŐޕLsMh)50R8jT:㕐2~9+q/$W0fj%Zd8bHb[-A-XՃPw7B'<ڧ Sk? ~]$_S[GӸ %[!Ep=Xb(_ 1*BՃJCT;_qiXOLZ|- Fd ]PM~$ ov`?ghYIAk #eV4cxf"ТxoM@^R'X&@0+Nla)ק:#]PK Atx7&org/gradle/wrapper/PathAssembler.classV=cKy<^ 6vP@dIM2]o `FDD1$viKiBiBW˷M-;3l!{sw7p p?;0 MU\H*PAa/aJ;Kv%ۛ!5Am%-lce:i=(:BbW]S }B]6K& *? $%Mj\.WyOY xH#iXƓxJ*e<,2~WdQ[bJՔS~NAI&KbU"/z-~'20O>~PdO2ʄԊVL V@ilQ nkeuןCSS*DuÎSF5}ñ^Ɍ3mrMl.nn m2)ҝu4Se5RrRF5+tm83=[~xF `Stk/ֲ"ϦttRff;>k-VD/<<"JirPh)WeSpoDL޽&ӹqy|r?r 9&`$*B˴L`gn7_7/sWwrr;MP,."bQqՄUK{ |˲ղyӠ[Y7(=ހv 8 Uu~3IP~\Տ( ##x$SyLS>#ɺoM(EF\CbiLo%D5d XЙ6U+\C6:i%Wa @C=5 أ٣Jơ6B5U "Dc PF&\.zݤ\ :,wPz CR;-ӷ4Ef G I!Ҥ VOĉ`mWqó _g:ƆVK9#]Q۶͔nv-mνv^g-*6`Ja#Y" GAN l-|,g+[ *DŧL縥 |+||+Xyvy)'1MnBʶ6w{/(X,(~> Wٹ## I=(DWF$v t$0;/~*xBDV` -n|/#)yeǤ2FIi&^ʫ,=A5ٶTmMfRص/}6-ƷbU $egRevX|3%_ ๡~cg5hOW -a.5T cO_ {LP; e3y؆:J{3Pw@y42ESp~Gw"03V;LM`q=4/Z>u`iN]xG7Y κcA=#7? I4lv14$ ĨnqR!9KM-z9BԯrW)5" ,9z|~_=/!~L08WIH-_{M F1WU> =SpL<`ݖ_bqWPK A=?-org/gradle/wrapper/WrapperConfiguration.classmOAgJK|i " HULCߐ-H&~*M$&3w e&33_:a`@EG xL<2O<%xN8mPk35 QOM5)!Bw~+ 1sM(/;0/w^9sܰ nZd,8t|ZkZMlONlڍiv,.smns =NN8u ѽq$&L*A=HL)BCO*A4dF r_ s )%Ƞ 2)AeE, $!X yw y%^}93 2y~Oȸ`;)H^V0YW^а;98147243Ot KNj-;ޞ-#;[N3}Ht e]rbbAqy1ypȖmGCN$*= 8%g9ݲ =/az629uȐ Nl=qԤ1.aCi[Z:k?̝`iafRݘizoX4֔r!vSF`N3M-1z_arTQ5c!2xݮ\)&* ԉ^-ޫcd {Zn! ]$E锞s=' r|˝4g9yJ YE n ts@fJBU(E2DK2t!cj'-BFY&v\vwdLmz^B6i5~g#M ;{,5;UkUD u=*$$)-^QI?dIe ͞P#1F/Q0'i?e6!#(莄1eL%|%y,dKܢ"|j¡SRqm5U;^GQ˚h&}#Y܎I7w<}EA'LQQWMUόD2 }ʉx>1COG)7raWTN{Rӓ|88aAXTYoe݂zfuytR{:v:Z|`G_8檫x8󨊣~̕7:+x@-I :bqJ޻q(Kq6۷bj &};dm?JpE)@a ڦŕfhr%Q2&xglL->lDM6uFgºߏ C!̣Bh^GЮ hϳ_F~;=U7Ӿ˳_0kZcz8Ivzv0ixUñp,sϢfa\s oе(C BbjJ%%@,,V.ZX@3#8ꚑRM`:BBNcX@ xe,^F88isO[`IQfQ?b^ Ϣa ItV9gw"3X6;kcs9['_@cp qvC,bW/\ťl 9OC(.H']T !ٞ ތīS]hDLyW!p 5 kN=NRnp؜ch⟐ϔ4=c/-ePK A׃X ;org/gradle/cli/AbstractPropertiesCommandLineConverter.classV[WUN20 HԄKKIQJ;L0fOZZ_tA}N.i2Y9};vO6Q0e|`|`w,'? H` = V>Bx&c.cC i?]cЗ1-ci8"qB[׊kcrƔmeBhЋfb~MVd8i ޞf'$ F]p䙶0fv}-QԬB"9U ёѻE#0ff[-PvT4V5%\X3LXQgIWW]p0?:ĒVJFOMA`i ҮqA1\W@ \A܊A)5"ɓ48,FhJ+g ^zKŽa@7e2ZfYTRQxuWx8R E10ogm74Ӂr_q9\WOw/jhz"#z,Zi.ZFkP*؏$}iB+ c na]bᶂ1|( 2>R1>aʠSz5 xA$>UDP~.*8 %>Ä;g+ZEkߌM' g6-0 : NVϟ=!!{LX`e2zFI3U\%Ne5CC]Z]AၺmѸYCYbZ.+&%b `)s4 "(({j^<Q*>\{#%N׃\&9I~r)C09ymjV!:|k"%*5&@TZ[AkI )Zb=Nʆr2j s噜(B`4JY:TCaecU*b2vTzCɘgKEԷNR9r,m:BM}V{"O.6u1᳠~-g~hWKt/Ovs }+ =]hY,l$ ֊7 4O? gԻ h;_!ѸwiPCEӞEVh`ll ,[m'GT&p DAnE!i/8<~[$"V8zb3%+>g*h/V!r'em3=:Irn wN0!؊u2aIPK AD&3org/gradle/cli/CommandLineParser$AfterOptions.classmOA{-r- >W+p"D!$MFxag9.D%2^rҒcffwn׷fqۀQiu4h IStLaTzj6Pɓ5&yյXOlե}G8]x2Crɫ< +M[>.YN w\:JIi0dmxBBr卆Mu0r$fu~^F+[.5k՗-o0$z<AekͨS bVgcg>v@]7|- ƪ-+CG@ϔ0 jE7 7ckމW7xؒ1f00yd835?UѶ= q~ :5hhkmq_2wC^2 \ G@I]TGi4gL,~AbT 4"A;`ȑm:C٤3qhboPK AMu <org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.classVrT串:I I|skiK^rը,Ӿ[2xHnbN0Ϲٳ=_~02Nc K2ȑ!aYFø ǪP&Cu!%6>1u(68 woz|a,oٕLVzF5VSawU9^6Lùps_u Wݢd֬ml4jeݾ$-Mn!M$2 -[au(7m2(MSתjڢ/xWCiX;PBNg, YtT)}3%l1T3,zoKf=H9 T_1$wbW5t?fk5s$]%4C Y Gp|@EYx.~H@]*[qrj;;kG柮G&İSEQɪz|q|ypj( mja8 ˔Ww[E^lq6v(=WN##rNYS.8~rWßK*b; Q"QiD@r0M[Ҭ$?!HvCIqf.Ɇ1JᮨoZ }4{JEFG?3x/J#'Gtr)Ipg{(EOJT).>Gd/-GWZo=sP#`K3Q[F]F]pՅڇbYh@~R (!ijJ3n8B# gHWܱa6:Nx*9g\.{b ׹ڸi^E` N$,SDgqc)/hRPK A*ZMForg/gradle/cli/CommandLineParser$CaseInsensitiveStringComparator.classS]OA=wPRˇ"UhAx1MLԏvn/`|EkC9{Ng?&6 Q)`,95=K&lfc*!|m2]Bt%a||ߓzGy)vV&+"M?~"u$ۑV~Q Nnx" %6m܏#nԍ֛uB_Є"[f)ְm*ȧHjfp\p ߩLbs E"Ld'h@Kӟ0}1/d MXEnqsYX'>9|r9\=wP5oy$L̑iftcye}ly:E1k-LYn3q2\uM&:c#2Oȭ㿈(&J`R؁p6k0,X\*wM/PK A|R&=org/gradle/cli/CommandLineParser$KnownOptionParserState.classXwU6ͤK*EqDt;VkEE+. ɐ3uf҂HQpCqP![>u\|I\@-V< gZY͓5ͨ-4Τjת 窬m͵l Znpi S5꿗$뻦 b^)Std%fsTCP`g^ t H@'؄Nr"#^hNoGQ7AUߑt$ YFRk|yaC@gpPn'I<:\(=Ěp,᝛aұV6dhd F^wމ& aࠑW~qpN߽̾2BI 7!?PK A$ľ<org/gradle/cli/CommandLineParser$MissingOptionArgState.classmOPw*LD ! ·'`0W̚o;oB~?ܶK˒s~퟿~Œr:'I*(uZG 7ٌqeМ-rD_K.]Sz3Bjs5]#ņu,nV4\k0#%rw[cU:3 WZ S69^RzxZsu-˲V;TJ?nI/GQw|m.UORn!eCw&à# ֻ @~+:0r`#:L:՞ͭ1𦯉)[PR2q\U%7ǖڒ#63Vt201,K`=org/gradle/cli/CommandLineParser$OptionAwareParserState.classUn@=q$6\%)MK@)p)E E*oĮO x$ J|Mݒ*A./ޝgf퟿PĽ8ȩ0*wTzc\ *L+(cVAQu4ܮ,dȖQ/5̂Ѱ OpC{i\e˶; ` CdթQIh5xƫ 7*\X.Cɶg9Zŵu6jI,s]SMj%} P녲',4!E]&8c$${]pG짍oRNK%ti!ӘЏSnbX[XPa sLf +~a[f:~Z)9hOS csmqr |FdUԩ0L-=ƽ_qkޥvrl0.ϥF|x!JӚ'vt!}rOYY,T6$a|iZ ̋dKTTȇC(Z7D!eSZ2B#oo+5UcCݢ{ B*^v#8GNi$y6+1E83$r]oPK A%̻7org/gradle/cli/CommandLineParser$OptionComparator.classTmOP~Q: 2@.,Ydďe4kI?/~#ƨ_ N6).]}s=~ E%d0#0+bNUJ"E,IHs;'"V8|USk"z6L7eA(;íi;- Vn)L!{䛎]vG Wlp˖y!P~`j2U6uyN_z`QWkH-T T|%|4y`P?UKjwMkwuz-֤$/0L[3xѪM7-O7 IRiu;?ڑ~Sb@ZaBhΟ\ia+6eYgљ{"!c /&q va[hǂZ00 }m j]{a=eўB$>P}4s2|=ѧQ*te躣K.@ >rd d$S3gH|$%!zp'a!xD"2{9 O蹀Sp HswnL8trI"!y3Ⱥ2GYv>i<2<l4!M{nV  #fdY"5>{}FCNS#ZOqϣHINQ2(R8˦Sqv[lB|'9乎OE;McBһ-!%."{N'MzzY%B65[m~kETBZƓq5<]/h}LѾ>McGMHx)PK A`M~U2org/gradle/cli/CommandLineParser$ParserState.classSoPN) s97ս&MLf.а.vF'_|(- AGmdQC-6xbaB{I/zI4\jϓdbs ?4iF^H(*tU?'tUav/Pcgw9`2r;$uTyP/#}@3I8c)O;B / Z &Wti2qfYC!zPڕh&ߗP2egvnӁ$$T@|*>A%W|):T Џ3_qI_q3!Źt^= xc @C!:Z_ eYq>8YMHEFw@@9\"!vCz1v񫮥x&҃k$}ˌf!uTsj]p99+1:*4*4fE!./1Y ?PK A=l)&org/gradle/cli/CommandLineParser.classYi`\őJ7zzeٲ=`l1S>K6XzFψ8B``d MͲaك= !l~ޛPwOwUuUuO{YT:jW5ױh/>)s3 O >ס yRa#||1ׄW%GģcxS5E]%_fFeu֤Pt|e&cuq8&&䞬JO|7#P"tM$(L8?=cq3֔&LMssOA0eAQC(j]Z-um 3f5if ≦mkG0JKͶh̚dcu;13cM0[1׬_ݸa5u֭X( ^N1U&VQQ[٥=IҨ]k G-\FګmWEc`kجn V"E9:Gw6v1|yqe41P<-l҉H(H[Rs,Jؽc[-`,~;DG|Kglloi5M% 9.bI+v"[FURo;R`FN3#mL= 4P%$lu * cLate+r"nuUCiظ̀J]B\ kX5Pj:)Bp(^Hi%n Zkn ݒ_>N &3A32g R4d Z8?lyOm'ˆf@hՌ%sƞUu63iʭ ŕ%p77DL^aE9͚V\EW p vX8)4iFf(Ma}.l?F,N@6 7w3§E5Fp J-fn1R^:t[BYԙd3R÷M΄A-Vvmϼ.(SYnZQ_;S[Zx|ڜ3KFR^9fpUg sPY1O/ }MX k#IRr ܊[ ܀ ܬFD- ;&-i{OP<1Mڹt\͐׍ku;5nHXv!]r1% 0Ґt *1T]Bحt-씸!ǐK2C.+%ª2C!W*or\MxղZmU3Wq\lE,rRz[UV3[r!7(G(Wr|ېjCn*%*Ų!wYX2u]4yӇY <'kP͝%w't3luY9LُC'dR{23$* 0d\/!{^C/hr7ܟŞkCPɈ: \lȃnяEb`*ƹc&{>Vi%=f ٽwbeic^Rĉ^Éww` OF3<,dn>g?_y2|% zX>"Nd1VfY72pLbh1s}6=JqŴ*9DuXUǻ?}e[ւeN(q%B=:FsWz~-)u+Z v{p,|{`8E< r_n۷Cc^{[܉բzv 46<[]kt6SNo;:ԃCqֻ[c`|ݽ(~zvV7\e"z>LP_kp6#+Lh1I`E4c/]AinعnV0=tziH_r3 %?~u'\vB A 7o}mh~ ǡWs _&%@,yő<ހ M3y⼃N wnW})m^YAhO YL+,l"G˱7<7hb>xi!_ph 9Q}( a`F˜Zoeۋ局v}r8i7N"eK{1\NIAU[k|6e)=LgitE:Rt=("4RA~?(N{,$)>ȡ)Y>gGK;Ȯ,J͡%TZX֋rE\ދ O܍€?i.UMj[W\V *Rv"uGYxm;>,.ӇK֑lwlfe/NoE'QbWb#`cm3< ؊_"K *#`x)hbtH):Ll&evH'҅.M^Q~;9˸T7C\)5?z9sr*hp?ۻ0=Q֜F {twtc1~DkUa!t0F!SE/wXS'Md_ø8缁羑gM'9K (=SX-,3,-N=uS9Pi Qc"%p;°s`qx<6V~,z*-wFG|:%f)XJXBV4[J^ ϑ^lT{ pg9܅*+/#ߒZJNxy*uìR6+|*,&VUV} 5^ƇbiҕbYЇ5y\$h:4"i4hpm7H8T ^Rx 0K%kAg鵓r7s~!o_ǜ9`9_K_$,+ J;~);܆%!Myxw#){9%qG2wR0 /r5{,5qBH\ d^pKPΓ7xY+b܋7X:yxY絲F园ɯS-18gO{zSe yNva`aZx 5mCd"QLtLq:ɛ ec%,3w]}sS}~e?2<_p媲>lJ0ݩjA^i uoQEpê8~?oSw/-Oijwg޶K/UGy^}B,ZJ,;;ɢxbf9rKa2J|ߋs=ijS8TPqhQnsʃYQU@O~lm.I=oA`2/-'a*o}CӑMswōiV*,K:&U@cHb{V5kyE=!#&P== kOц?r]?1>gAy{8u ca*^H*R!Vg-yh.#fN>_{EV43$ffN8Ѭ;ldO sN]wai ;{g>.a.=dzA#_;q eV)^?PK A>&org/gradle/cli/ParsedCommandLine.classWiwg~Fċ%vTMc[R8S)-LT(.Ph١li7 `rX;Ɵ}g$Kָ1G}.3ǽ?.v*`!*΢ .bufT,.+*WBM0#h'".T=^a}:|Fkt 0^7/㋸$__V0AVMa q[ ͼ1s#+3ɥ/E; f2n-C#2iҖ U0RҒKMfr)y(Q0r*T>c4yZq%sH˶YhM-C#\U08a~.k *)CxK )LAt\гkWYp#A͙ FA|Wݳw/뀽)xV5KԶx:ԕ|)#wOPccI(V^yU6KbѴ\j3TpUG(|VQH1M 7S8 RΊ|{Y#۶nQ/5^kKouO;=Fm,Rhq35$bwcLOFܙm Ln"9mG7Mhz*gJwrv詔DճEc YeyK?a{?՜qZ:fyȌYcm5 ^Xdkޏဂ6Y"|P[x[w= 1s=>4?RcfUDO38*$c/GW*S.5“~Un |ɘ_=0a 4 WU\0~pWLHZϖ:zypy*rK}jc븪֒[v.2}Ric9SVUPPIΝir+9gS QZyۇOBMkI'ƠG> =7rW=¶~̜gD1[f(O :6yP=𸟳J8Je2msQP0-^^Ц5[y?AC2?TjH܆mo"@1H1tXG1r}kL%װCРh&4o! ;]LHҰe(=Z[];7d?k'Wo A؅속=x5:ICab!Zcx(Dp1')1a8!N**&T=thT_P;='X/ FΙbX@u #Bwvp\}b9ûx?}dT}HH.o!syVOCI/a$qaxA1cx)R_J@{& (+}?Av3xG f97CTEB"]tF.'ޜ軅؜t<õ2i 1i_3%6 ;Aؓq6A-V4RgZlG orN$gdyE:+N:$̕ųxU '\5B%ǻ6 Z3]^ᜐk>lJ ;k>e'*6zEGe)A<],;[S;\Or=l8>Y ߀^9ي NLvczͭ&@S܇Қg\HVvWc .97{XŘ㰗Go )ȑ,I8sQHI 0$Abs9{`_i*^QUt  9%<' tEB^Krvs?`A^EAEXP QP dȹPK AytE,org/gradle/cli/ParsedCommandLineOption.classS]O@=ݯGePaeQ"hHV1YawRlIgN[`Y$ә{=?“4(H#b 冊$4-L%q[器+r⾊ [lpWAɶ(Ha1p#-g,C/{9*I Kxs UEJ%a:w^u"]a*s!"k~E쳟}V_*bTG;-%bXo"p(=@&_2w%^*$APPS =1D:!䉩If%ޱn05W(vbRD $"xj2Dϧxr7k> !V.p].GӱD\8"y RPK A\vB| :org/gradle/cli/ProjectPropertiesCommandLineConverter.classKO@D|?Pâu#Q+$C;1m  JW&.(1D,9vo/[@yl汕G)v }FHWkwLS!]nY7ZK:̿cJDZRysV;H+-)nkS#cruLXgh|BjFYDΏ%L%񎅎*_?ֈ:("<ڄbJՍ ؊tf^*K ߵ XUVi01k p8wZ8T0g?PaΛm=C Ss | 1\Zq-}C_JEˉjE+ w'PK A 8=|9org/gradle/cli/SystemPropertiesCommandLineConverter.classJ@ثmjE5BPąR/P~ӑ$&BJW 'iAY3͜l "lYlE <& d@HgL{:rRs:C*X4NĬQ ۴;hZ3a ѽG!]Gv7S"5eb o}ɸGtFMz9y~X{()spL`7e.KV, TXxɢfDTEGPWJmh~49AjxѰ sh gԙn85].FԒs9Q΢*s/@Ug J*ce+s+1 $p6/t-,;h-.Z >kZPK A?gradle-cli-classpath.properties+(JM.)**+MPK A%gradle-cli-parameter-names.propertiesPK A AMETA-INF/PK Am>=@?)META-INF/MANIFEST.MFPK AAorg/PK A Aorg/gradle/PK AAorg/gradle/wrapper/PK A%Ӧ/org/gradle/wrapper/BootstrapMainStarter$1.classPK Ai,$ -#org/gradle/wrapper/BootstrapMainStarter.classPK AhQ}#org/gradle/wrapper/Download$1.classPK A 1;Ap org/gradle/wrapper/Download$DefaultDownloadProgressListener.classPK A-L4 org/gradle/wrapper/Download$ProxyAuthenticator.classPK A#: !uorg/gradle/wrapper/Download.classPK AyL1 org/gradle/wrapper/DownloadProgressListener.classPK A!9| 3u!org/gradle/wrapper/ExclusiveFileAccessManager.classPK A,y-|(org/gradle/wrapper/GradleUserHomeLookup.classPK Ac67 *@+org/gradle/wrapper/GradleWrapperMain.classPK A"/5org/gradle/wrapper/IDownload.classPK A9lV"6org/gradle/wrapper/Install$1.classPK A $|->org/gradle/wrapper/Install$InstallCheck.classPK Avp.- vAorg/gradle/wrapper/Install.classPK A:o4WVorg/gradle/wrapper/Logger.classPK AJJ'8Yorg/gradle/wrapper/PathAssembler$LocalDistribution.classPK Atx7&Zorg/gradle/wrapper/PathAssembler.classPK A| 0aborg/gradle/wrapper/SystemPropertiesHandler.classPK A=?-qgorg/gradle/wrapper/WrapperConfiguration.classPK AG (ljorg/gradle/wrapper/WrapperExecutor.classPK Ae #sgradle-wrapper-classpath.propertiesPK A)'tgradle-wrapper-parameter-names.propertiesPK AAptorg/gradle/cli/PK A?<S1torg/gradle/cli/AbstractCommandLineConverter.classPK A׃X ;*worg/gradle/cli/AbstractPropertiesCommandLineConverter.classPK A}yGK1{org/gradle/cli/CommandLineArgumentException.classPK Ag)q}org/gradle/cli/CommandLineConverter.classPK ASf g&~org/gradle/cli/CommandLineOption.classPK A튯(org/gradle/cli/CommandLineParser$1.classPK A$f{K ;org/gradle/cli/CommandLineParser$AfterFirstSubCommand.classPK AD&3org/gradle/cli/CommandLineParser$AfterOptions.classPK AMu <org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.classPK A*ZMForg/gradle/cli/CommandLineParser$CaseInsensitiveStringComparator.classPK A|R&=org/gradle/cli/CommandLineParser$KnownOptionParserState.classPK A$ľ<˚org/gradle/cli/CommandLineParser$MissingOptionArgState.classPK ATK>=ʝorg/gradle/cli/CommandLineParser$OptionAwareParserState.classPK A%̻7Ϡorg/gradle/cli/CommandLineParser$OptionComparator.classPK AfC8ߣorg/gradle/cli/CommandLineParser$OptionParserState.classPK AE3ܥorg/gradle/cli/CommandLineParser$OptionString.classPK AgAqx=بorg/gradle/cli/CommandLineParser$OptionStringComparator.classPK A`M~U2ǫorg/gradle/cli/CommandLineParser$ParserState.classPK ApX k?org/gradle/cli/CommandLineParser$UnknownOptionParserState.classPK A=l)&Uorg/gradle/cli/CommandLineParser.classPK A>&org/gradle/cli/ParsedCommandLine.classPK AytE,org/gradle/cli/ParsedCommandLineOption.classPK A\vB| :org/gradle/cli/ProjectPropertiesCommandLineConverter.classPK A 8=|9org/gradle/cli/SystemPropertiesCommandLineConverter.classPK A?gradle-cli-classpath.propertiesPK A%gradle-cli-parameter-names.propertiesPK66java-http-client-2.2.2/gradle/wrapper/gradle-wrapper.properties000066400000000000000000000003121406526542100246400ustar00rootroot00000000000000distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists distributionUrl=https\://services.gradle.org/distributions/gradle-6.4.1-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists java-http-client-2.2.2/gradlew000077500000000000000000000132121406526542100162460ustar00rootroot00000000000000#!/usr/bin/env sh # # Copyright 2015 the original author or authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ############################################################################## ## ## Gradle start up script for UN*X ## ############################################################################## # Attempt to set APP_HOME # Resolve links: $0 may be a link PRG="$0" # Need this for relative symlinks. while [ -h "$PRG" ] ; do ls=`ls -ld "$PRG"` link=`expr "$ls" : '.*-> \(.*\)$'` if expr "$link" : '/.*' > /dev/null; then PRG="$link" else PRG=`dirname "$PRG"`"/$link" fi done SAVED="`pwd`" cd "`dirname \"$PRG\"`/" >/dev/null APP_HOME="`pwd -P`" cd "$SAVED" >/dev/null APP_NAME="Gradle" APP_BASE_NAME=`basename "$0"` # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD="maximum" warn () { echo "$*" } die () { echo echo "$*" echo exit 1 } # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false nonstop=false case "`uname`" in CYGWIN* ) cygwin=true ;; Darwin* ) darwin=true ;; MINGW* ) msys=true ;; NONSTOP* ) nonstop=true ;; esac CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD="$JAVA_HOME/jre/sh/java" else JAVACMD="$JAVA_HOME/bin/java" fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else JAVACMD="java" which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi # Increase the maximum file descriptors if we can. if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then MAX_FD_LIMIT=`ulimit -H -n` if [ $? -eq 0 ] ; then if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then MAX_FD="$MAX_FD_LIMIT" fi ulimit -n $MAX_FD if [ $? -ne 0 ] ; then warn "Could not set maximum file descriptor limit: $MAX_FD" fi else warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" fi fi # For Darwin, add options to specify how the application appears in the dock if $darwin; then GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" fi # For Cygwin or MSYS, switch paths to Windows format before running java if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then APP_HOME=`cygpath --path --mixed "$APP_HOME"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` JAVACMD=`cygpath --unix "$JAVACMD"` # We build the pattern for arguments to be converted via cygpath ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` SEP="" for dir in $ROOTDIRSRAW ; do ROOTDIRS="$ROOTDIRS$SEP$dir" SEP="|" done OURCYGPATTERN="(^($ROOTDIRS))" # Add a user-defined pattern to the cygpath arguments if [ "$GRADLE_CYGPATTERN" != "" ] ; then OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" fi # Now convert the arguments - kludge to limit ourselves to /bin/sh i=0 for arg in "$@" ; do CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` else eval `echo args$i`="\"$arg\"" fi i=`expr $i + 1` done case $i in 0) set -- ;; 1) set -- "$args0" ;; 2) set -- "$args0" "$args1" ;; 3) set -- "$args0" "$args1" "$args2" ;; 4) set -- "$args0" "$args1" "$args2" "$args3" ;; 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; esac fi # Escape application args save () { for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done echo " " } APP_ARGS=`save "$@"` # Collect all arguments for the java command, following the shell quoting and substitution rules eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" exec "$JAVACMD" "$@" java-http-client-2.2.2/gradlew.bat000066400000000000000000000057621406526542100170230ustar00rootroot00000000000000@rem @rem Copyright 2015 the original author or authors. @rem @rem Licensed under the Apache License, Version 2.0 (the "License"); @rem you may not use this file except in compliance with the License. @rem You may obtain a copy of the License at @rem @rem https://www.apache.org/licenses/LICENSE-2.0 @rem @rem Unless required by applicable law or agreed to in writing, software @rem distributed under the License is distributed on an "AS IS" BASIS, @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @rem See the License for the specific language governing permissions and @rem limitations under the License. @rem @if "%DEBUG%" == "" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @rem @rem ########################################################################## @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal set DIRNAME=%~dp0 if "%DIRNAME%" == "" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Resolve any "." and ".." in APP_HOME to make it shorter. for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if "%ERRORLEVEL%" == "0" goto init echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :findJavaFromJavaHome set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto init echo. echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :init @rem Get command-line arguments, handling Windows variants if not "%OS%" == "Windows_NT" goto win9xME_args :win9xME_args @rem Slurp the command line arguments. set CMD_LINE_ARGS= set _SKIP=2 :win9xME_args_slurp if "x%~1" == "x" goto execute set CMD_LINE_ARGS=%* :execute @rem Setup the command line set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar @rem Execute Gradle "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% :end @rem End local scope for the variables with windows NT shell if "%ERRORLEVEL%"=="0" goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 exit /b 1 :mainEnd if "%OS%"=="Windows_NT" endlocal :omega java-http-client-2.2.2/scripts/000077500000000000000000000000001406526542100163635ustar00rootroot00000000000000java-http-client-2.2.2/scripts/clean.sh000077500000000000000000000000661406526542100200060ustar00rootroot00000000000000#!/bin/bash ./gradlew clean rm -rf out 2>/dev/null java-http-client-2.2.2/scripts/make-jar.sh000077500000000000000000000002311406526542100204050ustar00rootroot00000000000000#!/bin/bash rm -rf out/bin 2>/dev/null mkdir -p out/bin ./gradlew jar && cp $(ls -tr build/libs/*.jar | tail -1) out/bin/. && chmod 770 out/bin/*.jar java-http-client-2.2.2/scripts/run-tests.sh000077500000000000000000000000351406526542100206640ustar00rootroot00000000000000#!/bin/bash ./gradlew test java-http-client-2.2.2/settings.gradle000066400000000000000000000000471406526542100177150ustar00rootroot00000000000000rootProject.name = 'java-http-client' java-http-client-2.2.2/src/000077500000000000000000000000001406526542100154635ustar00rootroot00000000000000java-http-client-2.2.2/src/main/000077500000000000000000000000001406526542100164075ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/000077500000000000000000000000001406526542100173305ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/com/000077500000000000000000000000001406526542100201065ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/com/softwareverde/000077500000000000000000000000001406526542100227665ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/com/softwareverde/api/000077500000000000000000000000001406526542100235375ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/com/softwareverde/api/ApiCall.java000066400000000000000000000047251406526542100257170ustar00rootroot00000000000000package com.softwareverde.api; import com.softwareverde.constable.bytearray.ByteArray; import com.softwareverde.constable.bytearray.MutableByteArray; import com.softwareverde.http.HttpMethod; import com.softwareverde.http.HttpRequest; import com.softwareverde.http.HttpResponse; import com.softwareverde.logging.Logger; import com.softwareverde.logging.LoggerInstance; import com.softwareverde.util.Util; public abstract class ApiCall { private final LoggerInstance _logger = Logger.getInstance(getClass()); private final ApiConfiguration _configuration; public ApiCall(final ApiConfiguration configuration) { _configuration = configuration; } protected ApiConfiguration _getConfiguration() { return _configuration; } public abstract RESPONSE call(final REQUEST request) throws Exception; protected HttpResponse _call(final String requestPath, final HttpMethod requestMethod, final REQUEST request) throws Exception { long startTime = System.currentTimeMillis(); final HttpRequest httpRequest; try { final String baseUrl = _getConfiguration().getApiUrl(); final String fullUrl = baseUrl + Util.coalesce(requestPath); final ByteArray requestData = MutableByteArray.wrap(request.toBytes()); httpRequest = new HttpRequest(); httpRequest.setUrl(fullUrl); httpRequest.setMethod(requestMethod); httpRequest.setRequestData(requestData); for (final String header : request.getHeaderNames()) { final String value = request.getHeader(header); httpRequest.setHeader(header, value); } } catch (final Exception exception) { throw new RuntimeException("Unable to build HTTP request for " + request.getClass().getSimpleName(), exception); } HttpResponse httpResponse = null; try { httpResponse = httpRequest.execute(); return httpResponse; } finally { if (httpResponse != null) { long duration = System.currentTimeMillis() - startTime; final String httpResponseString = httpResponse.getResponseCode() + " " + httpResponse.getResponseMessage(); _logger.info(requestMethod.name() + " | " + httpRequest.getUrl() + " | " + httpResponseString + " | " + duration + " ms"); } } } } java-http-client-2.2.2/src/main/java/com/softwareverde/api/ApiConfiguration.java000066400000000000000000000001361406526542100276430ustar00rootroot00000000000000package com.softwareverde.api; public interface ApiConfiguration { String getApiUrl(); } java-http-client-2.2.2/src/main/java/com/softwareverde/api/ApiRequest.java000066400000000000000000000010271406526542100264640ustar00rootroot00000000000000package com.softwareverde.api; import java.util.HashMap; import java.util.Set; public abstract class ApiRequest { private final HashMap _headers = new HashMap<>(); public Set getHeaderNames() { return _headers.keySet(); } public String getHeader(final String header) { return _headers.get(header); } public void putHeader(final String header, final String value) { _headers.put(header, value); } public abstract byte[] toBytes() throws Exception; } java-http-client-2.2.2/src/main/java/com/softwareverde/api/ApiResponse.java000066400000000000000000000021011406526542100266240ustar00rootroot00000000000000package com.softwareverde.api; import com.softwareverde.http.HttpResponse; public class ApiResponse { private final int _httpResponseCode; private final String _httpResponseMessage; public ApiResponse(final HttpResponse httpResponse) { _httpResponseCode = httpResponse.getResponseCode(); _httpResponseMessage = httpResponse.getResponseMessage(); } /** * Returns the HTTP response code. * @return */ public int getHttpResponseCode() { return _httpResponseCode; } /** * Returns the HTTP response message (e.g. "OK"). Does not include the response code. * @return */ public String getHttpResponseMessage() { return _httpResponseMessage; } /** * Returns a string indicating the HTTP response code and message (e.g. "200 OK"). * @return */ @Override public String toString() { return _httpResponseCode + " " + _httpResponseMessage; } public boolean isSuccess() { return (_httpResponseCode >= 200 && _httpResponseCode < 300); } } java-http-client-2.2.2/src/main/java/com/softwareverde/api/JsonApiRequest.java000066400000000000000000000017411406526542100273210ustar00rootroot00000000000000package com.softwareverde.api; import com.softwareverde.json.Json; import com.softwareverde.logging.Logger; import com.softwareverde.logging.LoggerInstance; import java.nio.charset.StandardCharsets; public abstract class JsonApiRequest extends ApiRequest { protected final LoggerInstance _logger = Logger.getInstance(getClass()); public JsonApiRequest() { // header added in constructor to allow for it to be overridden afterward if necessary this.putHeader("Content-Type", "application/json"); } protected abstract Json _toJson() throws Exception; @Override public byte[] toBytes() throws Exception { final Json jsonObject = _toJson(); if (jsonObject == null) { return new byte[0]; } final String jsonString = jsonObject.toString(); final byte[] jsonBytes = jsonString.getBytes(StandardCharsets.UTF_8); _logger.debug("Json message: " + jsonString); return jsonBytes; } } java-http-client-2.2.2/src/main/java/com/softwareverde/api/JsonApiResponse.java000066400000000000000000000015131406526542100274640ustar00rootroot00000000000000package com.softwareverde.api; import com.softwareverde.http.HttpResponse; import com.softwareverde.json.Json; import com.softwareverde.util.Util; public class JsonApiResponse extends ApiResponse { private final Json _json; private final boolean _wasSuccess; private final String _errorMessage; public JsonApiResponse(final HttpResponse httpResponse) { super(httpResponse); _json = httpResponse.getJsonResult(); _wasSuccess = Util.coalesce(_json.getOrNull("wasSuccess", Json.Types.BOOLEAN), true); _errorMessage = _json.getString("errorMessage"); } public Json getJson() { return _json; } public String getErrorMessage() { return _errorMessage; } @Override public boolean isSuccess() { return super.isSuccess() && _wasSuccess; } } java-http-client-2.2.2/src/main/java/com/softwareverde/http/000077500000000000000000000000001406526542100237455ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/com/softwareverde/http/HttpMethod.java000066400000000000000000000006131406526542100266700ustar00rootroot00000000000000package com.softwareverde.http; public enum HttpMethod { GET, POST, HEAD, PATCH, PUT, DELETE, OPTIONS, TRACE; public static HttpMethod fromString(final String string) { for (final HttpMethod httpMethod : HttpMethod.values()) { if (httpMethod.name().equalsIgnoreCase(string)) { return httpMethod; } } return null; } }java-http-client-2.2.2/src/main/java/com/softwareverde/http/HttpRequest.java000066400000000000000000000212451406526542100271040ustar00rootroot00000000000000package com.softwareverde.http; import com.softwareverde.constable.bytearray.ByteArray; import com.softwareverde.constable.bytearray.MutableByteArray; import com.softwareverde.cryptography.util.HashUtil; import com.softwareverde.http.websocket.ConnectionLayer; import com.softwareverde.http.websocket.WebSocket; import com.softwareverde.logging.Logger; import com.softwareverde.util.Base64Util; import com.softwareverde.util.Container; import com.softwareverde.util.StringUtil; import com.softwareverde.util.Util; import javax.net.ssl.HostnameVerifier; import javax.net.ssl.HttpsURLConnection; import javax.net.ssl.SSLSession; import javax.net.ssl.X509ExtendedTrustManager; import java.net.Socket; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.atomic.AtomicLong; public class HttpRequest { static { // Allow for HttpUrlConnection to set non-trivial headers (required for WebSockets). System.setProperty("sun.net.http.allowRestrictedHeaders", "true"); } public static final String SEC_WEB_SOCKET_KEY = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; public interface Callback { void run(HttpResponse response); } public interface WebSocketFactory { WebSocket newWebSocket(Socket socket); } public static class DefaultWebSocketFactory implements WebSocketFactory { private static final AtomicLong NEXT_WEB_SOCKET_ID = new AtomicLong(1L); @Override public WebSocket newWebSocket(final Socket socket) { final Long webSocketId = NEXT_WEB_SOCKET_ID.getAndIncrement(); return new WebSocket(webSocketId, WebSocket.Mode.CLIENT, ConnectionLayer.newConnectionLayer(socket), WebSocket.DEFAULT_MAX_PACKET_BYTE_COUNT); } } protected static final HostnameVerifier NAIVE_HOSTNAME_VERIFIER = new HostnameVerifier() { @Override public boolean verify(final String hostname, final SSLSession sslSession) { return true; } }; protected static final X509ExtendedTrustManager NAIVE_TRUST_MANAGER = new NaiveTrustManager(); public static boolean containsHeaderValue(final String key, final String value, final Map> headers) { for (final String headerKey : headers.keySet()) { if (Util.areEqual(Util.coalesce(key).toLowerCase(), Util.coalesce(headerKey).toLowerCase())) { for (final String headerValue : headers.get(headerKey)) { if (Util.areEqual(Util.coalesce(value).toLowerCase(), Util.coalesce(headerValue).toLowerCase())) { return true; } } } } return false; } public Set getHeaderKeys() { return Util.copySet(_headers.keySet()); } public static String getHeaderValue(final String key, final Map> headers) { for (final String headerKey : headers.keySet()) { if (Util.areEqual(Util.coalesce(key).toLowerCase(), Util.coalesce(headerKey).toLowerCase())) { final List headerValues = headers.get(headerKey); if (headerValues.isEmpty()) { continue; } return headerValues.get(0); } } return null; } protected static String calculateSecWebSocketAcceptKey(final String wssKey) { // https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake final byte[] preImage = StringUtil.stringToBytes(Util.coalesce(wssKey) + HttpRequest.SEC_WEB_SOCKET_KEY); final byte[] acceptKey = HashUtil.sha1(preImage); return Base64Util.toBase64String(acceptKey); } public static boolean containsUpgradeToWebSocketHeader(final Map> headers, final String wssKey) { if (HttpRequest.containsHeaderValue("upgrade", "websocket", headers)) { return true; } final String returnedWssKeyString = HttpRequest.getHeaderValue("sec-websocket-accept", headers); if ( (wssKey != null) && (returnedWssKeyString == null) ) { return false; } if (returnedWssKeyString != null) { if (wssKey == null) { return true; } final String expectedWebSocketAcceptKey = HttpRequest.calculateSecWebSocketAcceptKey(wssKey); final Boolean keysAreEqual = Util.areEqual(expectedWebSocketAcceptKey, returnedWssKeyString); if (! keysAreEqual) { Logger.debug("sec-websocket-accept: " + expectedWebSocketAcceptKey + " != " + returnedWssKeyString); } return keysAreEqual; } return false; } protected String _url; protected HttpMethod _method = HttpMethod.GET; protected final List _cookies = new LinkedList(); protected final Map _headers = new HashMap(); protected ByteArray _postData = new MutableByteArray(0); protected String _queryString = ""; protected Boolean _followsRedirects = false; protected Integer _maxRedirectCount = 10; protected Boolean _validateSslCertificates = true; protected Boolean _allowWebSocketUpgrade = false; protected WebSocketFactory _webSocketFactory = new DefaultWebSocketFactory(); protected HttpRequestExecutionThread _executionThread; public HttpRequest() { } public void setUrl(final String url) { _url = url; } public String getUrl() { return _url; } public void setCookie(final String cookie) { if (cookie.contains(";")) { _cookies.add(cookie.substring(0, cookie.indexOf(";"))); } else { _cookies.add(cookie); } } public void setHeader(final String key, final String value) { _headers.put(key, value); } public void setFollowsRedirects(final Boolean followsRedirects) { _followsRedirects = followsRedirects; } public Boolean followsRedirects() { return _followsRedirects; } public void setMethod(final HttpMethod method) { _method = method; } public HttpMethod getMethod() { return _method; } public void setQueryString(final String queryString) { _queryString = Util.coalesce(queryString); } public void setRequestData(final ByteArray byteArray) { if (byteArray != null) { _postData = byteArray.asConst(); } else { _postData = new MutableByteArray(0); } } public void setRequestData(final String requestData) { if (requestData != null) { _postData = MutableByteArray.wrap(StringUtil.stringToBytes(requestData)); } else { _postData = new MutableByteArray(0); } } public void setAllowWebSocketUpgrade(final boolean allowWebSocketUpgrade) { _allowWebSocketUpgrade = allowWebSocketUpgrade; } public void setWebSocketFactory(final WebSocketFactory webSocketFactory) { _webSocketFactory = webSocketFactory; } public boolean allowsWebSocketUpgrade() { return _allowWebSocketUpgrade; } public void setMaxRedirectCount(final int maxRedirectCount) { _maxRedirectCount = maxRedirectCount; } public int getMaxRedirectCount() { return _maxRedirectCount; } public void setValidateSslCertificates(final boolean validateSslCertificates) { _validateSslCertificates = validateSslCertificates; } public boolean validatesSslCertificates() { return _validateSslCertificates; } public HttpResponse execute() { final Container responseContainer = new Container(null); _executionThread = new HttpRequestExecutionThread(_url, this, new Callback() { @Override public void run(final HttpResponse response) { responseContainer.value = response; _executionThread = null; } }, 0); _executionThread.run(); return responseContainer.value; } public void execute(final Callback callback) { _executionThread = new HttpRequestExecutionThread(_url, this, callback, 0); _executionThread.start(); } public void cancel() { final HttpRequestExecutionThread executionThread = _executionThread; if (executionThread != null) { executionThread.cancel(); } } public boolean isExecuting() { final HttpRequestExecutionThread executionThread = _executionThread; if (executionThread == null) { return false; } return executionThread.isExecuting(); } @SuppressWarnings("unused") protected static final Class[] unused = { HttpsURLConnection.class }; }java-http-client-2.2.2/src/main/java/com/softwareverde/http/HttpRequestExecutionThread.java000066400000000000000000000303231406526542100321150ustar00rootroot00000000000000package com.softwareverde.http; import com.softwareverde.constable.bytearray.ByteArray; import com.softwareverde.constable.bytearray.MutableByteArray; import com.softwareverde.logging.Logger; import com.softwareverde.util.Base64Util; import com.softwareverde.util.IoUtil; import com.softwareverde.util.ReflectionUtil; import com.softwareverde.util.Util; import javax.net.ssl.HttpsURLConnection; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLSocketFactory; import javax.net.ssl.X509TrustManager; import java.io.DataOutputStream; import java.io.InputStream; import java.net.HttpURLConnection; import java.net.Socket; import java.net.URL; import java.security.SecureRandom; import java.util.List; import java.util.Map; class HttpRequestExecutionThread extends Thread { protected final String _httpRequestUrl; protected HttpRequest _httpRequest; protected HttpRequest.Callback _callback; protected final Integer _redirectCount; protected HttpURLConnection _connection; protected String _origin = null; protected Socket _extractConnectionSocket() { Object httpConnectionHolder = null; try { httpConnectionHolder = ((_connection instanceof HttpsURLConnection) ? ReflectionUtil.getValue(_connection, "delegate") : _connection); final Object httpClient = ReflectionUtil.getValue(httpConnectionHolder, "http"); return ReflectionUtil.getValue(httpClient, "serverSocket"); } catch (final Exception exception) { if (httpConnectionHolder == null) { throw new RuntimeException("Unable to obtain connection socket via reflection.", exception); } try { // Unable to get standard http server socket, check for OkHttp implementation. final Object httpEngine = ReflectionUtil.getValue(httpConnectionHolder, "httpEngine"); final Object streamAllocation = ReflectionUtil.getValue(httpEngine, "streamAllocation"); final Object realConnection = ReflectionUtil.getValue(streamAllocation, "connection"); return ReflectionUtil.getValue(realConnection, "socket"); } catch (final Exception exception2) { exception2.addSuppressed(exception); throw new RuntimeException("Unable to obtain connection socket via reflection.", exception2); } } } protected String _configureRequestForWebSocketUpgrade(final Boolean isSecureWebSocket) { final SecureRandom secureRandom = new SecureRandom(); final byte[] key = new byte[16]; secureRandom.nextBytes(key); _httpRequest.setAllowWebSocketUpgrade(true); _httpRequest.setHeader("Upgrade", "websocket"); _httpRequest.setHeader("Connection", "upgrade"); if (isSecureWebSocket) { final String wssKey = Base64Util.toBase64String(key); _httpRequest.setHeader("Sec-WebSocket-Version", "13"); _httpRequest.setHeader("Sec-WebSocket-Key", wssKey); _httpRequest.setHeader("Sec-WebSocket-Extensions", "permessage-deflate; client_max_window_bits"); return wssKey; } return null; } protected ByteArray _readErrorStream(final InputStream inputStream) throws Exception { if (inputStream == null) { return null; } // Only attempt to read from the stream if bytes are immediately available without blocking... // The inputStream type is HttpInputStream which appears to honor InputStream::available(). if (inputStream.available() < 1) { return null; } return MutableByteArray.wrap(IoUtil.readStreamOrThrow(inputStream)); } public HttpRequestExecutionThread(final String httpRequestUrl, final HttpRequest httpRequest, final HttpRequest.Callback callback, final Integer redirectCount) { _httpRequestUrl = httpRequestUrl; _httpRequest = httpRequest; _callback = callback; _redirectCount = redirectCount; } public void setOrigin(final String origin) { _origin = origin; } public void run() { try { final String wssKey; final String urlString; { final boolean isSecureWebSocketRequest = _httpRequestUrl.startsWith("wss://"); final boolean isWebSocketRequest = _httpRequestUrl.startsWith("ws://"); final String requestUrl; if (isWebSocketRequest || isSecureWebSocketRequest) { requestUrl = _httpRequestUrl.replaceFirst("ws", "http"); final String generatedWssKey = _configureRequestForWebSocketUpgrade(isSecureWebSocketRequest); wssKey = (_httpRequest.validatesSslCertificates() ? generatedWssKey : null); } else { requestUrl = _httpRequestUrl; wssKey = null; } final String queryString = _httpRequest._queryString; if (! Util.isBlank(queryString)) { urlString = (requestUrl + (requestUrl.contains("?") ? "" : "?") + queryString); } else { urlString = requestUrl; } } final URL url = new URL(urlString); if (_origin == null) { _origin = (url.getProtocol() + "://" + url.getHost()); } _httpRequest.setHeader("Origin", _origin); _connection = (HttpURLConnection) url.openConnection(); if (_connection instanceof HttpsURLConnection) { final HttpsURLConnection httpsConnection = ((HttpsURLConnection) _connection); if (! _httpRequest.validatesSslCertificates()) { httpsConnection.setHostnameVerifier(HttpRequest.NAIVE_HOSTNAME_VERIFIER); final SSLContext sslContext = SSLContext.getInstance("TLS"); sslContext.init(null, new X509TrustManager[]{ HttpRequest.NAIVE_TRUST_MANAGER }, new SecureRandom()); final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory(); httpsConnection.setSSLSocketFactory(sslSocketFactory); } } final Boolean followsRedirects = _httpRequest.followsRedirects(); _connection.setInstanceFollowRedirects(followsRedirects); _connection.setDoInput(true); _connection.setUseCaches(false); final StringBuilder cookies = new StringBuilder(); { final List httpRequestCookies = _httpRequest._cookies; String separator = ""; for (final String cookie : httpRequestCookies) { cookies.append(separator); cookies.append(cookie); separator = "; "; } } _connection.setRequestProperty("Cookie", cookies.toString()); final Map httpRequestHeaders = _httpRequest._headers; for (final String key : httpRequestHeaders.keySet()) { final String value = httpRequestHeaders.get(key); _connection.setRequestProperty(key, value); } final HttpMethod httpMethod = _httpRequest.getMethod(); _connection.setRequestMethod(httpMethod.name()); if ((httpMethod == HttpMethod.POST) || (httpMethod == HttpMethod.PUT) || (httpMethod == HttpMethod.PATCH)) { final ByteArray postData = _httpRequest._postData; if (postData != null) { _connection.setDoOutput(true); try (final DataOutputStream outputStream = new DataOutputStream(_connection.getOutputStream())) { outputStream.write(postData.getBytes()); outputStream.flush(); } } } _connection.connect(); final HttpResponse httpResponse = new HttpResponse(); final int responseCode = _connection.getResponseCode(); httpResponse._responseCode = responseCode; httpResponse._responseMessage = _connection.getResponseMessage(); final Map> responseHeaders = _connection.getHeaderFields(); httpResponse._headers = responseHeaders; // HttpURLConnection will not handle redirection from http to https, so it is is handled here... // NOTE: Protocol switches will not be handled, except for http to https. Downgrades from https to http will not be followed. if ( (followsRedirects) && (_redirectCount < _httpRequest._maxRedirectCount) ) { if (responseCode >= 300 && responseCode < 400) { final String newLocation = HttpRequest.getHeaderValue("location", responseHeaders); if (newLocation != null) { final boolean isHttpBase = ( (_httpRequestUrl.startsWith("http") && (newLocation.startsWith("http"))) ); final boolean isHttpDowngrade = ( (_httpRequestUrl.startsWith("https")) && (! newLocation.startsWith("https")) ); if ( (isHttpBase) && (! isHttpDowngrade) ) { _connection.disconnect(); (new HttpRequestExecutionThread(newLocation, _httpRequest, _callback, (_redirectCount + 1))).run(); return; } } } } final boolean upgradeToWebSocket = (_httpRequest.allowsWebSocketUpgrade() && HttpRequest.containsUpgradeToWebSocketHeader(responseHeaders, wssKey)); if (! upgradeToWebSocket) { if ( (responseCode >= 400) || (responseCode == 101) ) { // NOTE: Switching Protocols (101) when upgradeToWebSocket was not expected indicates a problem within the WebSocket handshake. InputStream errorStream = null; { // Attempt to obtain the errorStream, but fallback to the inputStream if errorStream is unavailable. try { errorStream = _connection.getErrorStream(); } catch (final Exception exception) { } if (errorStream == null) { try { errorStream = _connection.getInputStream(); } catch (final Exception exception) { } } } httpResponse._rawResult = _readErrorStream(errorStream); } else { final InputStream inputStream = _connection.getInputStream(); httpResponse._rawResult = (inputStream != null ? MutableByteArray.wrap(IoUtil.readStreamOrThrow(inputStream)) : null); } // Close Connection _connection.disconnect(); } else { try { final Socket socket = _extractConnectionSocket(); final HttpRequest.WebSocketFactory webSocketFactory = _httpRequest._webSocketFactory; httpResponse._webSocket = webSocketFactory.newWebSocket(socket); } catch (final Exception exception) { Logger.warn("Unable to get underlying socket for WebSocket within HttpRequest via reflection.", exception); _connection.disconnect(); } } _connection = null; if (_callback != null) { _callback.run(httpResponse); } } catch (final Exception exception) { Logger.debug("Unable to execute request.", exception); _connection = null; if (_callback != null) { _callback.run(null); } } finally { _connection = null; } } public void cancel() { final HttpURLConnection connection = _connection; if (connection == null) { return; } connection.disconnect(); } public boolean isExecuting() { return (_connection != null); } }java-http-client-2.2.2/src/main/java/com/softwareverde/http/HttpResponse.java000066400000000000000000000054521406526542100272540ustar00rootroot00000000000000package com.softwareverde.http; import com.softwareverde.constable.bytearray.ByteArray; import com.softwareverde.http.websocket.WebSocket; import com.softwareverde.json.Json; import com.softwareverde.util.StringUtil; import java.util.LinkedList; import java.util.List; import java.util.Map; public class HttpResponse { protected ByteArray _rawResult; protected Integer _responseCode; protected String _responseMessage; protected WebSocket _webSocket = null; protected Map> _headers = null; // NOTE: Handles both android-formatted and ios-formatted cookie strings. // iOS concatenates their cookies into one string, delimited by commas; // Android cookies are separate cookie-records. protected List _parseCookies(final String cookie) { final List cookies = new LinkedList(); if (cookie.contains(";")) { Boolean skipNext = false; for (final String cookieSegment : cookie.replaceAll(",", ";").split(";")) { if (skipNext) { skipNext = false; continue; } final String cleanedCookie = cookieSegment.trim(); if (cleanedCookie.toLowerCase().contains("expires=")) { skipNext = true; continue; } if (cleanedCookie.toLowerCase().contains("max-age=")) { continue; } if (cleanedCookie.toLowerCase().contains("path=")) { continue; } if (cleanedCookie.toLowerCase().contains("httponly")) { continue; } cookies.add(cleanedCookie); } } else { cookies.add(cookie.trim()); } return cookies; } public WebSocket getWebSocket() { return _webSocket; } public Integer getResponseCode() { return _responseCode; } public String getResponseMessage() { return _responseMessage; } public synchronized Json getJsonResult() { return Json.parse(StringUtil.bytesToString(_rawResult.getBytes())); } public synchronized ByteArray getRawResult() { return _rawResult; } public Map> getHeaders() { return _headers; } public List getCookies() { if (_headers.containsKey("Set-Cookie")) { List cookies = new LinkedList(); for (final String cookie : _headers.get("Set-Cookie")) { cookies.addAll(_parseCookies(cookie)); } return cookies; } return new LinkedList(); } public boolean didUpgradeToWebSocket() { return (_webSocket != null); } } java-http-client-2.2.2/src/main/java/com/softwareverde/http/NaiveTrustManager.java000066400000000000000000000025351406526542100302140ustar00rootroot00000000000000package com.softwareverde.http; import javax.net.ssl.SSLEngine; import javax.net.ssl.X509ExtendedTrustManager; import java.net.Socket; import java.security.cert.CertificateException; import java.security.cert.X509Certificate; public class NaiveTrustManager extends X509ExtendedTrustManager { @Override public void checkClientTrusted(final X509Certificate[] x509Certificates, final String authType, final Socket socket) throws CertificateException { } @Override public void checkServerTrusted(final X509Certificate[] x509Certificates, final String authType, final Socket socket) throws CertificateException { } @Override public void checkClientTrusted(final X509Certificate[] x509Certificates, final String authType, final SSLEngine sslEngine) throws CertificateException { } @Override public void checkServerTrusted(final X509Certificate[] x509Certificates, final String authType, final SSLEngine sslEngine) throws CertificateException { } @Override public void checkClientTrusted(final X509Certificate[] x509Certificates, final String authType) throws CertificateException { } @Override public void checkServerTrusted(final X509Certificate[] x509Certificates, final String authType) throws CertificateException { } @Override public X509Certificate[] getAcceptedIssuers() { return new X509Certificate[0]; } } java-http-client-2.2.2/src/main/java/com/softwareverde/http/WebRequest.java000066400000000000000000000065101406526542100267000ustar00rootroot00000000000000package com.softwareverde.http; import com.softwareverde.constable.bytearray.MutableByteArray; import com.softwareverde.http.querystring.QueryStringParser; import com.softwareverde.util.StringUtil; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class WebRequest extends HttpRequest { protected Map _getParams; protected Map _postParams; protected Map> _arrayGetParams; protected Map> _arrayPostParams; protected void _preExecute() { if (_queryString.isEmpty()) { _queryString = QueryStringParser.toString(_getParams, _arrayGetParams); } if (_method == HttpMethod.POST) { if (_postData.isEmpty()) { _postData = MutableByteArray.wrap(StringUtil.stringToBytes(QueryStringParser.toString(_postParams, _arrayPostParams))); } _headers.put("Content-Type", "application/x-www-form-urlencoded"); _headers.put("Charset", "UTF-8"); _headers.put("Content-Length", Integer.toString(_postData.getByteCount())); } } public WebRequest() { _getParams = new HashMap(); _postParams = new HashMap(); _arrayGetParams = new HashMap>(); _arrayPostParams = new HashMap>(); } public void setGetParam(String key, String value) { if (key == null) { return; } if (value == null) { _getParams.remove(key); } else { _getParams.put(key, value); } } public void setPostParam(String key, String value) { if (key == null) { return; } if (value == null) { _postParams.remove(key); } else { _postParams.put(key, value); } } public void addGetParam(String key, String value) { if (! _arrayGetParams.containsKey(key)) { _arrayGetParams.put(key, new ArrayList()); } _getParams.remove(key); final List array = _arrayGetParams.get(key); array.add(value); } public void addPostParam(String key, String value) { if (! _arrayPostParams.containsKey(key)) { _arrayPostParams.put(key, new ArrayList()); } final List array = _arrayPostParams.get(key); array.add(value); } public Map getGetParams() { final Map getParams = new HashMap(); for (final String key : _getParams.keySet()) { final String value = _getParams.get(key); getParams.put(key, value); } return getParams; } public Map getPostParams() { final Map postParams = new HashMap(); for (final String key : _postParams.keySet()) { final String value = _postParams.get(key); postParams.put(key, value); } return postParams; } @Override public HttpResponse execute() { _preExecute(); return super.execute(); } @Override public void execute(final Callback callback) { _preExecute(); super.execute(callback); } } java-http-client-2.2.2/src/main/java/com/softwareverde/http/cookie/000077500000000000000000000000001406526542100252165ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/com/softwareverde/http/cookie/Cookie.java000066400000000000000000000162641406526542100273030ustar00rootroot00000000000000package com.softwareverde.http.cookie; import com.softwareverde.util.Util; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.TimeZone; /** * Cookie Class as defined by: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie */ public class Cookie { protected static final DateFormat _dateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz"); static { _dateFormat.setTimeZone(TimeZone.getTimeZone("GMT")); } /** * Returns the expirationDateString as a Time with ms. * If the expirationDateString is in an invalid format, null is returned. */ public static Long parseExpirationDate(final String expirationDateString) { try { return _dateFormat.parse(expirationDateString).getTime(); } catch (final ParseException exception) { return null; } } public static String formatExpirationDate(final Long expirationTime) { return _dateFormat.format(new Date(expirationTime)); } public static String sanitizeValue(final String value) { // Strip CTLs, whitespace, double quotes, comma, semicolon, and backslash... return value.replaceAll("[\\x00-\\x1F\\x7F \t\",;\\\\]", ""); } protected String _key; protected String _value; protected String _expirationDate; protected Integer _maxAge; protected String _domain; protected String _path; protected Boolean _isSecure = true; protected Boolean _isHttpOnly = true; protected Boolean _isSameSiteStrict = true; protected void _setExpirationDateFromMaxAge() { if (_maxAge == null) { _expirationDate = null; return; } final Long now = System.currentTimeMillis(); _expirationDate = Cookie.formatExpirationDate(now + (_maxAge * 1000L)); } protected void _setMaxAgeFromExpirationDate() { if (_expirationDate == null) { _maxAge = null; return; } final Long now = System.currentTimeMillis(); final Long expirationTime = Cookie.parseExpirationDate(_expirationDate); if (expirationTime == null) { _maxAge = null; } else { _maxAge = (int) ((expirationTime - now) / 1000L); } } public Cookie() { } public Cookie(final String key, final String value) { _key = key; _value = value; } public String getKey() { return _key; } public String getValue() { return _value; } public String getExpirationDate() { return _expirationDate; } public Integer getMaxAge() { return _maxAge; } public String getDomain() { return _domain; } public String getPath() { return _path; } public Boolean isSecure() { return _isSecure; } public Boolean isHttpOnly() { return _isHttpOnly; } public Boolean isSameSiteStrict() { return _isSameSiteStrict; } public void setKey(final String key) { _key = key; } public void setValue(final String value) { _value = Cookie.sanitizeValue(value); } /** * Sets the Expires property of the Cookie. * May be overwritten by subsequent calls to setMaxAge(). * If the maxAge has been set, maxAge will be updated to represent the expirationDate. * maxAge will be set as if the cookie was issued immediately. * Therefore, if the Cookie is issued later, the maxAge will be later than the expirationDate. */ public void setExpirationDate(final String expirationDate) { _expirationDate = expirationDate; if (_maxAge != null && _expirationDate != null) { _setMaxAgeFromExpirationDate(); } } public void setExpirationDate(final Long expirationDate) { if (expirationDate == null) { _expirationDate = null; } else { _expirationDate = Cookie.formatExpirationDate(expirationDate); } if (_maxAge != null && _expirationDate != null) { _setMaxAgeFromExpirationDate(); } } /** * Sets the Max-Age property of the Cookie. * May be overwritten to subsequent calls to setExpirationDate(). * If the expirationDate has been set, expirationDate will be update to represent maxAge. * expirationDate will be set as if the cookie was issued immediately. * Therefore, if the cookie is issued later, the expirationDate will be before the maxAge. * Note: Most modern browsers will disregard the Expires segment if the Max-Age segment is present; * Therefore, it if setting both maxAge and expirationDate, it is recommended to set expirationDate first. */ public void setMaxAge(final Integer maxAge) { _maxAge = maxAge; if (_expirationDate != null && _maxAge != null) { _setExpirationDateFromMaxAge(); } } /** * Sets the Max-Age property of the Cookie. * If setExpirationDate is true, then the Expires property will be set, regardless if it has/hasn't been set. * Setting setExpirationDate to false will not update the Expires property, even if it is mismatched. */ public void setMaxAge(final Integer maxAge, final Boolean setExpirationDate) { _maxAge = maxAge; if (setExpirationDate) { _setExpirationDateFromMaxAge(); } } public void setDomain(final String domain) { _domain = domain; } public void setPath(final String path) { _path = path; } public void setIsSecure(final Boolean isSecure) { _isSecure = isSecure; } public void setIsHttpOnly(final Boolean isHttpOnly) { _isHttpOnly = isHttpOnly; } public void setIsSameSiteStrict(final Boolean isSameSiteStrict) { _isSameSiteStrict = isSameSiteStrict; } @Override public String toString() { final StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append(_key); stringBuilder.append("="); stringBuilder.append(_value); stringBuilder.append("; "); if (_expirationDate != null) { stringBuilder.append("Expires="); stringBuilder.append(_expirationDate); stringBuilder.append("; "); } if (_maxAge != null) { stringBuilder.append("Max-Age="); stringBuilder.append(_maxAge); stringBuilder.append("; "); } if (_domain != null) { stringBuilder.append("Domain="); stringBuilder.append(_domain); stringBuilder.append("; "); } if (_path != null) { stringBuilder.append("Path="); stringBuilder.append(_path); stringBuilder.append("; "); } if (Util.coalesce(_isSecure)) { stringBuilder.append("Secure"); stringBuilder.append("; "); } if (Util.coalesce(_isHttpOnly)) { stringBuilder.append("HttpOnly"); stringBuilder.append("; "); } if (_isSameSiteStrict != null) { stringBuilder.append("SameSite="); stringBuilder.append(_isSameSiteStrict ? "Strict" : "Lax"); stringBuilder.append("; "); } return stringBuilder.toString(); } } java-http-client-2.2.2/src/main/java/com/softwareverde/http/cookie/CookieParser.java000066400000000000000000000215051406526542100304520ustar00rootroot00000000000000package com.softwareverde.http.cookie; import com.softwareverde.util.Util; import java.util.ArrayList; import java.util.List; public class CookieParser { protected Cookie _parseSingleCookieFromHeader(final String headerValue) { final String trimmedHeaderValue = headerValue.trim(); final Integer trimmedHeaderLength = trimmedHeaderValue.length(); final Integer endOfKeyIndex = trimmedHeaderValue.indexOf("="); if (endOfKeyIndex < 0) { return null; } final String key = trimmedHeaderValue.substring(0, endOfKeyIndex); final String value; final Integer endOfValueIndex; { Integer startOfValueIndex = endOfKeyIndex + 1; if (startOfValueIndex >= trimmedHeaderLength) { endOfValueIndex = startOfValueIndex; value = trimmedHeaderValue.substring(startOfValueIndex, endOfValueIndex); } else { final Integer indexOfNextSemicolon = trimmedHeaderValue.indexOf(';', startOfValueIndex); final Integer indexOfLastQuotation = trimmedHeaderValue.lastIndexOf('"'); final Boolean hasSemicolon = (indexOfNextSemicolon >= 0); final Boolean isEmpty = (indexOfNextSemicolon.equals(startOfValueIndex)); final Boolean isQuoted; { final Boolean nextCharIsQuotation = (trimmedHeaderValue.charAt(startOfValueIndex) == '"'); final Boolean hasTwoQuotationMarks = (! indexOfLastQuotation.equals(startOfValueIndex)); isQuoted = (nextCharIsQuotation && hasTwoQuotationMarks); } if (isEmpty) { endOfValueIndex = startOfValueIndex; } else if (isQuoted) { endOfValueIndex = indexOfLastQuotation; startOfValueIndex += 1; } else { if (hasSemicolon) { endOfValueIndex = indexOfNextSemicolon; } else { endOfValueIndex = trimmedHeaderLength; } } final String unTrimmedValue = trimmedHeaderValue.substring(startOfValueIndex, endOfValueIndex); if (isQuoted) { value = unTrimmedValue; } else { value = unTrimmedValue.trim(); } } } final Cookie cookie = new Cookie(); cookie._key = key.trim(); cookie._value = value; cookie._isSecure = false; cookie._isHttpOnly = false; cookie._isSameSiteStrict = false; final Integer indexOfNextSemicolon = trimmedHeaderValue.indexOf(';', endOfValueIndex); final Boolean hasSemicolon = (indexOfNextSemicolon >= 0); if (hasSemicolon) { final String[] segments = trimmedHeaderValue.substring(indexOfNextSemicolon).split(";"); for (final String segment : segments) { final String trimmedSegment = segment.trim(); final Integer indexOfTrimmedSegmentEqualSign = trimmedSegment.indexOf('='); final Boolean segmentHasEqualSign = (indexOfTrimmedSegmentEqualSign >= 0); if (! segmentHasEqualSign) { if (trimmedSegment.equalsIgnoreCase("secure")) { cookie._isSecure = true; } else if (trimmedSegment.equalsIgnoreCase("httponly")) { cookie._isHttpOnly = true; } } else { final String trimmedSegmentKey = trimmedSegment.substring(0, indexOfTrimmedSegmentEqualSign).trim(); final String trimmedSegmentValue = trimmedSegment.substring(indexOfTrimmedSegmentEqualSign+1); switch (trimmedSegmentKey.toLowerCase()) { case "expires": cookie._expirationDate = trimmedSegmentValue; break; case "max-age": cookie._maxAge = Util.parseInt(trimmedSegmentValue); break; case "domain": cookie._domain = trimmedSegmentValue; break; case "path": cookie._path = trimmedSegmentValue; break; case "samesite": cookie._isSameSiteStrict = (trimmedSegmentValue.equalsIgnoreCase("strict")); break; } } } } return cookie; } /** * Parses the value of a Set-Cookie header. * Accounts for Set-Cookie headers squashed into a single header delimited by commas. */ public List parseFromSetCookieHeader(final String setCookieHeaderValue) { final List cookies = new ArrayList(); String previousCookiePart = ""; for (final String headerValue : setCookieHeaderValue.split(",")) { final Integer headerValueLength = headerValue.length(); if (headerValueLength > 3) { final String expiresMatchString = "expires=" + headerValue.substring(headerValueLength-3, headerValueLength).toLowerCase(); final Integer matchIndex = headerValue.toLowerCase().lastIndexOf(expiresMatchString); if (matchIndex.equals(headerValueLength - expiresMatchString.length())) { previousCookiePart = headerValue + ","; continue; } } final Cookie cookie = _parseSingleCookieFromHeader(previousCookiePart + headerValue); if (cookie != null) { cookies.add(cookie); } previousCookiePart = ""; } return cookies; } /** * Parses the value of a Cookie header. */ public List parseFromCookieHeader(final String cookieHeaderValue) { final List cookies = new ArrayList(); for (final String keyValuePair : cookieHeaderValue.split(";")) { final Integer indexOfEqualsCharacter = keyValuePair.indexOf("="); if (indexOfEqualsCharacter < 0) { continue; } final Integer lengthOfKeyValuePair = keyValuePair.length(); final String key = keyValuePair.substring(0, indexOfEqualsCharacter).trim(); final String value = keyValuePair.substring(Math.min(indexOfEqualsCharacter+1, lengthOfKeyValuePair), lengthOfKeyValuePair).trim(); if (key.isEmpty()) { continue; } cookies.add(new Cookie(key, value)); } return cookies; } public List compileCookiesIntoSetCookieHeaderValues(final List cookies) { final List setCookieHeaderValues = new ArrayList(); for (final Cookie cookie : cookies) { final StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append(cookie.getKey()); stringBuilder.append("="); stringBuilder.append(cookie.getValue()); final String expiresDateString = cookie.getExpirationDate(); if (expiresDateString != null) { final String cookieExpiresValue = Cookie.formatExpirationDate(Cookie.parseExpirationDate(expiresDateString)); stringBuilder.append("; Expires="); stringBuilder.append(cookieExpiresValue); } final Integer maxAge = cookie.getMaxAge(); if (maxAge != null) { stringBuilder.append("; Max-Age="); stringBuilder.append(maxAge); } final String domain = cookie.getDomain(); if (domain != null) { stringBuilder.append("; Domain="); stringBuilder.append(domain); } final String path = cookie.getPath(); if (path != null) { stringBuilder.append("; Path="); stringBuilder.append(path); } final Boolean isSecure = cookie.isSecure(); if (isSecure) { stringBuilder.append("; Secure"); } final Boolean isHttpOnly = cookie.isHttpOnly(); if (isHttpOnly) { stringBuilder.append("; HttpOnly"); } final Boolean isSameSiteStrict = cookie.isSameSiteStrict(); if (isSameSiteStrict != null) { stringBuilder.append("; SameSite="+ (isSameSiteStrict ? "Strict" : "Lax")); } setCookieHeaderValues.add(stringBuilder.toString()); } return setCookieHeaderValues; } } java-http-client-2.2.2/src/main/java/com/softwareverde/http/querystring/000077500000000000000000000000001406526542100263415ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/com/softwareverde/http/querystring/QueryString.java000066400000000000000000000061451406526542100315060ustar00rootroot00000000000000package com.softwareverde.http.querystring; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; public class QueryString { private Map _values = new HashMap(); protected QueryString() { } protected void _setValues(final Map values) { _values = values; } protected Boolean _isArray(final String key) { if (! _values.containsKey(key)) { return false; } return _values.get(key).isArray(); } public String _get(final String key) { if (! _values.containsKey(key)) { return ""; } final QueryStringParameter queryStringParameter = _values.get(key); if (queryStringParameter.isArray()) { return queryStringParameter.getValues().get(0); } else { return queryStringParameter.getValue(); } } protected String[] _getArray(final String key) { if (! _values.containsKey(key)) { return new String[0]; } final QueryStringParameter queryStringParameter = _values.get(key); if (queryStringParameter.isArray()) { return queryStringParameter.getValues().toArray(new String[0]); } else { return new String[]{ queryStringParameter.getValue() }; } } public Set getKeys() { return _values.keySet(); } /** * Returns true if the key exists within the QueryString and is an array. * Returns false if the key does not exist within the QueryString. */ public Boolean isArray(final String key) { return _isArray(key); } /** * Returns true if the key exists in the QueryString. * NOTE: If the key exists, this function returns true regardless if the key is associated with a value or array. */ public Boolean containsKey(final String key) { return _values.containsKey(key); } /** * Returns the value associated with the provided key. * If the key does not exist, an empty string is returned. * If the key is associated with an array, the first value of the array is returned. */ public String get(final String key) { return _get(key); } /** * Returns the value(s) associated with the provided key. * If the key does not exist, an empty array is returned. * If the key is associated with a value, an array containing that value is turned. */ public String[] getArray(final String key) { return _getArray(key); } @Override public String toString() { final HashMap params = new HashMap(); final HashMap> arrayParams = new HashMap>(); for (final String key : _values.keySet()) { if (_isArray(key)) { arrayParams.put(key, Arrays.asList(_getArray(key))); } else { params.put(key, _get(key)); } } return QueryStringParser.toString(params, arrayParams); } }java-http-client-2.2.2/src/main/java/com/softwareverde/http/querystring/QueryStringParameter.java000066400000000000000000000012121406526542100333350ustar00rootroot00000000000000package com.softwareverde.http.querystring; import java.util.ArrayList; import java.util.List; class QueryStringParameter { private String _value; private List _values; QueryStringParameter() { } QueryStringParameter(final String value) { _value = value; } void setValue(final String value) { _value = value; } void addValue(final String value) { if (_values == null) { _values = new ArrayList(); } _values.add(value); } Boolean isArray() { return (_values != null); } String getValue() { return _value; } List getValues() { return _values; } }java-http-client-2.2.2/src/main/java/com/softwareverde/http/querystring/QueryStringParser.java000066400000000000000000000076501406526542100326650ustar00rootroot00000000000000package com.softwareverde.http.querystring; import com.softwareverde.logging.Logger; import com.softwareverde.util.Util; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.net.URLEncoder; import java.util.HashMap; import java.util.List; import java.util.Map; public class QueryStringParser { public interface QueryStringFactory { T newInstance(); } public static String toString(final Map params, final Map> arrayParams) { final StringBuilder stringBuilder = new StringBuilder(); String separator = ""; try { for (String key : params.keySet()) { String value = params.get(key); stringBuilder.append(separator); stringBuilder.append(URLEncoder.encode(key, "UTF-8")); stringBuilder.append("="); stringBuilder.append(URLEncoder.encode(Util.coalesce(value), "UTF-8")); separator = "&"; } for (final String key : arrayParams.keySet()) { final List values = arrayParams.get(key); for (final String value : values) { stringBuilder.append(separator); stringBuilder.append(URLEncoder.encode(key + "[]", "UTF-8")); stringBuilder.append("="); stringBuilder.append(URLEncoder.encode(Util.coalesce(value), "UTF-8")); separator = "&"; } } } catch (final Exception exception) { Logger.debug("Error building query string.", exception); } return stringBuilder.toString(); } private final QueryStringFactory _queryStringFactory; private Boolean _isKeyForAnArray(final String key) { if ( (key == null) || (key.length() < 2) ) { return false; } return (key.substring(key.length() - 2).equals("[]")); } private String _transformArrayKey(final String key) { return key.substring(0, key.length() - 2); } public QueryStringParser(final QueryStringFactory queryStringFactory) { _queryStringFactory = queryStringFactory; } public T parse(final String query) { final Map parameters = new HashMap(); if (query != null) { final String[] pairs = query.split("[&]"); for (final String pair : pairs) { final String[] keyValuePair = pair.split("[=]"); String key = null; String value = null; if (keyValuePair.length == 2) { try { key = URLDecoder.decode(keyValuePair[0], "UTF-8"); value = URLDecoder.decode(keyValuePair[1], "UTF-8"); } catch (final UnsupportedEncodingException e) { } } if ( (key != null) && (value != null) ) { if (_isKeyForAnArray(key)) { final String arrayKey = _transformArrayKey(key); final QueryStringParameter parameter; if (parameters.containsKey(arrayKey)) { parameter = parameters.get(arrayKey); } else { parameter = new QueryStringParameter(); } parameter.addValue(value); parameters.put(arrayKey, parameter); } else { parameters.put(key, new QueryStringParameter(value)); } } } } final T queryString = _queryStringFactory.newInstance(); queryString._setValues(parameters); return queryString; } }java-http-client-2.2.2/src/main/java/com/softwareverde/http/websocket/000077500000000000000000000000001406526542100257335ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/com/softwareverde/http/websocket/ConnectionLayer.java000066400000000000000000000026571406526542100317040ustar00rootroot00000000000000package com.softwareverde.http.websocket; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; public class ConnectionLayer { public static ConnectionLayer newConnectionLayer(final Socket socket) { try { return new ConnectionLayer(false, socket, socket.getInputStream(), socket.getOutputStream()); } catch (final IOException exception) { return null; } } public static ConnectionLayer newSecureConnectionLayer(final Socket socket, final InputStream sslInputStream, final OutputStream sslOutputStream) { return new ConnectionLayer(true, socket, sslInputStream, sslOutputStream); } protected final Boolean _isSecure; protected final Socket _socket; protected final InputStream _inputStream; protected final OutputStream _outputStream; protected ConnectionLayer(final Boolean isSecure, final Socket socket, final InputStream inputStream, final OutputStream outputStream) { _isSecure = isSecure; _socket = socket; _inputStream = inputStream; _outputStream = outputStream; } public Boolean isSecure() { return _isSecure; } public Socket getSocket() { return _socket; } public InputStream getInputStream() { return _inputStream; } public OutputStream getOutputStream() { return _outputStream; } }java-http-client-2.2.2/src/main/java/com/softwareverde/http/websocket/SocketStreams.java000066400000000000000000000050501406526542100313650ustar00rootroot00000000000000package com.softwareverde.http.websocket; import com.softwareverde.util.ByteBuffer; import org.eclipse.jetty.io.Buffer; import org.eclipse.jetty.io.EndPoint; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; import java.util.concurrent.atomic.AtomicBoolean; class SocketStreams implements EndPoint { protected final AtomicBoolean _isShutdown = new AtomicBoolean(false); protected final ByteBuffer _packetBuffer = new ByteBuffer(); protected final Socket _socket; protected final InputStream _inputStream; protected final OutputStream _outputStream; protected void _shutdown() { _isShutdown.set(true); try { _inputStream.close(); } catch (final Exception exception) { } try { _outputStream.close(); } catch (final Exception exception) { } try { _socket.close(); } catch (final Exception exception) { } } public SocketStreams(final ConnectionLayer connectionLayer) { _socket = connectionLayer.getSocket(); _inputStream = connectionLayer.getInputStream(); _outputStream = connectionLayer.getOutputStream(); } public void shutdown() { _shutdown(); } public ByteBuffer getPacketBuffer() { return _packetBuffer; } public InputStream getInputStream() { return _inputStream; } public OutputStream getOutputStream() { return _outputStream; } @Override public void shutdownOutput() { _shutdown(); } @Override public boolean isInputShutdown() { return _isShutdown.get(); } @Override public int fill(final Buffer buffer) { final byte[] bytes; synchronized (_packetBuffer) { final int byteCount = _packetBuffer.getByteCount(); bytes = _packetBuffer.readBytes(byteCount); } if (bytes.length > 0) { buffer.put(bytes); } return bytes.length; } @Override public int flush(final Buffer buffer) throws IOException { try { final byte[] bytes = buffer.asArray(); if (bytes.length > 0) { _outputStream.write(bytes); buffer.clear(); } return bytes.length; } catch (final IOException exception) { _shutdown(); throw exception; } } @Override public boolean isOpen() { return (! _isShutdown.get()); } } java-http-client-2.2.2/src/main/java/com/softwareverde/http/websocket/WebSocket.java000066400000000000000000000164631406526542100304760ustar00rootroot00000000000000package com.softwareverde.http.websocket; import com.softwareverde.util.Util; import org.eclipse.jetty.websocket.WebSocketBuffers; import org.eclipse.jetty.websocket.WebSocketConnectionRFC6455; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; import java.util.concurrent.atomic.AtomicBoolean; public class WebSocket implements AutoCloseable { public enum Mode { CLIENT, SERVER } public static final Integer DEFAULT_MAX_PACKET_BYTE_COUNT = 8192; public interface MessageReceivedCallback { void onMessage(String message); } public interface BinaryMessageReceivedCallback { void onMessage(byte[] bytes); } public interface ConnectionClosedCallback { void onClose(int code, String message); } protected static final Integer IGNORE_READS_SO_TIMEOUT = 100; protected final Long _webSocketId; protected final Mode _mode; protected final Integer _maxPacketByteCount; protected final ConnectionLayer _connectionLayer; protected final WebSocketReader _webSocketReader; protected final WebSocketWriter _webSocketWriter; protected MessageReceivedCallback _messageReceivedCallback; protected BinaryMessageReceivedCallback _binaryMessageReceivedCallback; protected ConnectionClosedCallback _connectionClosedCallback; protected final AtomicBoolean _closedCallbackInvoked = new AtomicBoolean(false); protected void _runOnSeparateThread(final Runnable runnable) { (new Thread(runnable)).start(); } protected void _close(final int code, final String message) { try { final InputStream inputStream = _connectionLayer.getInputStream(); inputStream.close(); } catch (final Exception exception) { } try { final OutputStream outputStream = _connectionLayer.getOutputStream(); outputStream.close(); } catch (final Exception exception) { } try { final Socket socket = _connectionLayer.getSocket(); socket.close(); } catch (final Exception exception) { } if (! _closedCallbackInvoked.getAndSet(true)) { final ConnectionClosedCallback connectionClosedCallback = _connectionClosedCallback; if (connectionClosedCallback != null) { _runOnSeparateThread(new Runnable() { @Override public void run() { connectionClosedCallback.onClose(code, message); } }); } } } public WebSocket(final Long webSocketId, final Mode mode, final ConnectionLayer connectionLayer, final Integer maxPacketByteCount) { _webSocketId = webSocketId; _mode = mode; _maxPacketByteCount = maxPacketByteCount; _connectionLayer = connectionLayer; try { // Setting the Socket Timeout prevents writes from being blocked by unprocessed reads. final Socket socket = connectionLayer.getSocket(); socket.setSoTimeout(IGNORE_READS_SO_TIMEOUT); } catch (final Exception exception) { } final WebSocketBuffers webSocketBuffers = new WebSocketBuffers(_maxPacketByteCount); final SocketStreams socketStreams = new SocketStreams(_connectionLayer); // try { socketStreams.setMaxIdleTime(0); } catch (final Exception exception) { } _webSocketReader = new WebSocketReader(_mode, socketStreams, webSocketBuffers, new WebSocketReader.MessageReceivedCallback() { @Override public void onTextMessage(final String message) { final MessageReceivedCallback messageReceivedCallback = _messageReceivedCallback; if (messageReceivedCallback != null) { messageReceivedCallback.onMessage(message); } } @Override public void onBinaryMessage(final byte[] message) { final BinaryMessageReceivedCallback binaryMessageReceivedCallback = _binaryMessageReceivedCallback; if (binaryMessageReceivedCallback != null) { binaryMessageReceivedCallback.onMessage(message); } } @Override public void onPing(final byte[] message) { synchronized (_webSocketWriter) { try { _webSocketWriter.writePong(message); } catch (final Exception exception) { _close(WebSocketConnectionRFC6455.CLOSE_NO_CODE, ""); } } } @Override public void onPong(final byte[] message) { } @Override public void onClose(final int code, final String message) { _close(code, message); } }); _webSocketWriter = new WebSocketWriter(_mode, webSocketBuffers, socketStreams); } public void setMessageReceivedCallback(final MessageReceivedCallback messageReceivedCallback) { _messageReceivedCallback = messageReceivedCallback; } public void setBinaryMessageReceivedCallback(final BinaryMessageReceivedCallback binaryMessageReceivedCallback) { _binaryMessageReceivedCallback = binaryMessageReceivedCallback; } public void setConnectionClosedCallback(final ConnectionClosedCallback connectionClosedCallback) { _connectionClosedCallback = connectionClosedCallback; } public Long getId() { return _webSocketId; } public void setSocketTimeout(final Integer socketTimeoutMs) { final Socket socket = _connectionLayer.getSocket(); try { socket.setSoTimeout(socketTimeoutMs); } catch (final Exception exception) { // Nothing. } } public void startListening() { try { // Disable SO_TIMEOUT to remove read-lag since reads are not being ignored. final Socket socket = _connectionLayer.getSocket(); final int soTimeout = socket.getSoTimeout(); final boolean soTimeoutWasChanged = (! Util.areEqual(IGNORE_READS_SO_TIMEOUT, soTimeout)); if (! soTimeoutWasChanged) { socket.setSoTimeout(0); } } catch (final Exception exception) { // Nothing. } _webSocketReader.start(); } public void sendMessage(final String message) { synchronized (_webSocketWriter) { try { _webSocketWriter.writeMessage(message); } catch (final Exception exception) { _close(WebSocketConnectionRFC6455.CLOSE_NO_CODE, ""); } } } public void sendMessage(final byte[] bytes) { synchronized (_webSocketWriter) { try { _webSocketWriter.writeMessage(bytes); } catch (final Exception exception) { _close(WebSocketConnectionRFC6455.CLOSE_NO_CODE, ""); } } } public Integer getMaxPacketByteCount() { return _maxPacketByteCount; } public ConnectionLayer getConnectionLayer() { return _connectionLayer; } @Override public void close() { _close(WebSocketConnectionRFC6455.CLOSE_NO_CODE, ""); } } java-http-client-2.2.2/src/main/java/com/softwareverde/http/websocket/WebSocketReader.java000066400000000000000000000101071406526542100316060ustar00rootroot00000000000000package com.softwareverde.http.websocket; import com.softwareverde.util.ByteBuffer; import org.eclipse.jetty.websocket.WSFrameHandler; import org.eclipse.jetty.websocket.WebSocketBuffers; import org.eclipse.jetty.websocket.WebSocketParserRFC6455; import java.io.InputStream; import java.net.SocketTimeoutException; class WebSocketReader { public interface MessageReceivedCallback { void onTextMessage(String message); void onBinaryMessage(byte[] message); void onPing(byte[] message); void onPong(byte[] message); void onClose(int code, String message); } protected final WebSocketParserRFC6455 _webSocketParser; protected final MessageReceivedCallback _messageReceivedCallback; final ByteBuffer _packetBuffer; protected final Thread _readThread; public WebSocketReader(final WebSocket.Mode mode, final SocketStreams endPoint, final WebSocketBuffers webSocketBuffers, final MessageReceivedCallback messageReceivedCallback) { _messageReceivedCallback = messageReceivedCallback; final InputStream inputStream = endPoint.getInputStream(); _packetBuffer = endPoint.getPacketBuffer(); final WSFrameHandler frameHandler = new WSFrameHandler(webSocketBuffers.getBufferSize(), new WSFrameHandler.CloseSocketHandler() { @Override public void close(final int code, final String message) { _readThread.interrupt(); try { inputStream.close(); } catch (final Exception exception) { } _messageReceivedCallback.onClose(code, message); } }); frameHandler.setTextMessageCallback(new WSFrameHandler.Callback() { @Override public void onMessage(final String message) { _messageReceivedCallback.onTextMessage(message); } }); frameHandler.setBinaryMessageCallback(new WSFrameHandler.Callback() { @Override public void onMessage(final byte[] message) { _messageReceivedCallback.onBinaryMessage(message); } }); frameHandler.setPingMessageCallback(new WSFrameHandler.Callback() { @Override public void onMessage(final byte[] message) { _messageReceivedCallback.onPing(message); } }); frameHandler.setPongMessageCallback(new WSFrameHandler.Callback() { @Override public void onMessage(final byte[] message) { _messageReceivedCallback.onPong(message); } }); _webSocketParser = new WebSocketParserRFC6455(webSocketBuffers, endPoint, frameHandler, (mode == WebSocket.Mode.SERVER)); _webSocketParser.setFakeFragments(true); _readThread = new Thread(new Runnable() { @Override public void run() { try { byte[] buffer; synchronized (_packetBuffer) { buffer = _packetBuffer.getRecycledBuffer(); } while (true) { final int readByteCount; try { readByteCount = inputStream.read(buffer); } catch (final SocketTimeoutException socketTimeoutException) { continue; } if (_readThread.isInterrupted()) { break; } if (readByteCount > 0) { synchronized (_packetBuffer) { _packetBuffer.appendBytes(buffer, readByteCount); _webSocketParser.parseNext(); buffer = _packetBuffer.getRecycledBuffer(); } } } } catch (final Exception exception) { } endPoint.shutdown(); } }); } public void start() { if (! _readThread.isAlive()) { _readThread.start(); } } } java-http-client-2.2.2/src/main/java/com/softwareverde/http/websocket/WebSocketWriter.java000066400000000000000000000053101406526542100316600ustar00rootroot00000000000000package com.softwareverde.http.websocket; import org.eclipse.jetty.util.StringUtil; import org.eclipse.jetty.websocket.MaskGen; import org.eclipse.jetty.websocket.WebSocketBuffers; import org.eclipse.jetty.websocket.WebSocketConnectionRFC6455; import org.eclipse.jetty.websocket.WebSocketGeneratorRFC6455; import java.io.IOException; import java.security.SecureRandom; class WebSocketWriter { protected final SocketStreams _endPoint; protected final WebSocketGeneratorRFC6455 _webSocketGeneratorRFC6455; public WebSocketWriter(final WebSocket.Mode mode, final WebSocketBuffers webSocketBuffers, final SocketStreams endPoint) { final MaskGen maskGen; if (mode == WebSocket.Mode.SERVER) { maskGen = null; } else { maskGen = new MaskGen() { private final SecureRandom _secureRandom = new SecureRandom(); @Override public void genMask(final byte[] mask) { _secureRandom.nextBytes(mask); } }; } _webSocketGeneratorRFC6455 = new WebSocketGeneratorRFC6455(webSocketBuffers, endPoint, maskGen); _endPoint = endPoint; } public void writeMessage(final String message) throws IOException { final byte[] bytes = StringUtil.getBytes(message); try { _webSocketGeneratorRFC6455.addFrame((byte) WebSocketConnectionRFC6455.FLAG_FIN, WebSocketConnectionRFC6455.OP_TEXT, bytes, 0, bytes.length); } catch (final IOException exception) { _endPoint.shutdown(); throw exception; } } public void writeMessage(final byte[] bytes) throws IOException { try { _webSocketGeneratorRFC6455.addFrame((byte) WebSocketConnectionRFC6455.FLAG_FIN, WebSocketConnectionRFC6455.OP_BINARY, bytes, 0, bytes.length); } catch (final IOException exception) { _endPoint.shutdown(); throw exception; } } public void writePong(final byte[] bytes) throws IOException { try { _webSocketGeneratorRFC6455.addFrame((byte) WebSocketConnectionRFC6455.FLAG_FIN, WebSocketConnectionRFC6455.OP_PONG, bytes, 0, bytes.length); } catch (final IOException exception) { _endPoint.shutdown(); throw exception; } } public void writePing(final byte[] bytes) throws IOException { try { _webSocketGeneratorRFC6455.addFrame((byte) WebSocketConnectionRFC6455.FLAG_FIN, WebSocketConnectionRFC6455.OP_PING, bytes, 0, bytes.length); } catch (final IOException exception) { _endPoint.shutdown(); throw exception; } } } java-http-client-2.2.2/src/main/java/org/000077500000000000000000000000001406526542100201175ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/org/eclipse/000077500000000000000000000000001406526542100215435ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/org/eclipse/jetty/000077500000000000000000000000001406526542100227025ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/000077500000000000000000000000001406526542100233115ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/AbstractBuffer.java000066400000000000000000000443261406526542100270620ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io; import org.eclipse.jetty.util.TypeUtil; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.nio.charset.Charset; /** * * */ public abstract class AbstractBuffer implements Buffer { private static final Logger LOG = Log.getLogger(AbstractBuffer.class); protected final static String __IMMUTABLE = "IMMUTABLE", __READONLY = "READONLY", __READWRITE = "READWRITE", __VOLATILE = "VOLATILE"; protected int _access; protected boolean _volatile; protected int _get; protected int _put; protected int _hash; protected int _hashGet; protected int _hashPut; protected int _mark; protected String _string; protected View _view; /** * Constructor for BufferView * * @param access 0==IMMUTABLE, 1==READONLY, 2==READWRITE */ public AbstractBuffer(int access, boolean isVolatile) { if (access == IMMUTABLE && isVolatile) throw new IllegalArgumentException("IMMUTABLE && VOLATILE"); setMarkIndex(-1); _access = access; _volatile = isVolatile; } /* * @see org.eclipse.io.Buffer#toArray() */ public byte[] asArray() { byte[] bytes = new byte[length()]; byte[] array = array(); if (array != null) System.arraycopy(array, getIndex(), bytes, 0, bytes.length); else peek(getIndex(), bytes, 0, length()); return bytes; } public ByteArrayBuffer duplicate(int access) { Buffer b=this.buffer(); if (this instanceof Buffer.CaseInsensitve || b instanceof Buffer.CaseInsensitve) return new ByteArrayBuffer.CaseInsensitive(asArray(), 0, length(),access); else return new ByteArrayBuffer(asArray(), 0, length(), access); } /* * @see org.eclipse.io.Buffer#asNonVolatile() */ public Buffer asNonVolatileBuffer() { if (!isVolatile()) return this; return duplicate(_access); } public Buffer asImmutableBuffer() { if (isImmutable()) return this; return duplicate(IMMUTABLE); } /* * @see org.eclipse.util.Buffer#asReadOnlyBuffer() */ public Buffer asReadOnlyBuffer() { if (isReadOnly()) return this; return new View(this, markIndex(), getIndex(), putIndex(), READONLY); } public Buffer asMutableBuffer() { if (!isImmutable()) return this; Buffer b=this.buffer(); if (b.isReadOnly()) { return duplicate(READWRITE); } return new View(b, markIndex(), getIndex(), putIndex(), _access); } public Buffer buffer() { return this; } public void clear() { setMarkIndex(-1); setGetIndex(0); setPutIndex(0); } public void compact() { if (isReadOnly()) throw new IllegalStateException(__READONLY); int s = markIndex() >= 0 ? markIndex() : getIndex(); if (s > 0) { byte array[] = array(); int length = putIndex() - s; if (length > 0) { if (array != null) System.arraycopy(array(), s, array(), 0, length); else poke(0, peek(s, length)); } if (markIndex() > 0) setMarkIndex(markIndex() - s); setGetIndex(getIndex() - s); setPutIndex(putIndex() - s); } } @Override public boolean equals(Object obj) { if (obj==this) return true; // reject non buffers; if (obj == null || !(obj instanceof Buffer)) return false; Buffer b = (Buffer) obj; if (this instanceof Buffer.CaseInsensitve || b instanceof Buffer.CaseInsensitve) return equalsIgnoreCase(b); // reject different lengths if (b.length() != length()) return false; // reject AbstractBuffer with different hash value if (_hash != 0 && obj instanceof AbstractBuffer) { AbstractBuffer ab = (AbstractBuffer) obj; if (ab._hash != 0 && _hash != ab._hash) return false; } // Nothing for it but to do the hard grind. int get=getIndex(); int bi=b.putIndex(); for (int i = putIndex(); i-->get;) { byte b1 = peek(i); byte b2 = b.peek(--bi); if (b1 != b2) return false; } return true; } public boolean equalsIgnoreCase(Buffer b) { if (b==this) return true; // reject different lengths if (b.length() != length()) return false; // reject AbstractBuffer with different hash value if (_hash != 0 && b instanceof AbstractBuffer) { AbstractBuffer ab = (AbstractBuffer) b; if (ab._hash != 0 && _hash != ab._hash) return false; } // Nothing for it but to do the hard grind. int get=getIndex(); int bi=b.putIndex(); byte[] array = array(); byte[] barray= b.array(); if (array!=null && barray!=null) { for (int i = putIndex(); i-->get;) { byte b1 = array[i]; byte b2 = barray[--bi]; if (b1 != b2) { if ('a' <= b1 && b1 <= 'z') b1 = (byte) (b1 - 'a' + 'A'); if ('a' <= b2 && b2 <= 'z') b2 = (byte) (b2 - 'a' + 'A'); if (b1 != b2) return false; } } } else { for (int i = putIndex(); i-->get;) { byte b1 = peek(i); byte b2 = b.peek(--bi); if (b1 != b2) { if ('a' <= b1 && b1 <= 'z') b1 = (byte) (b1 - 'a' + 'A'); if ('a' <= b2 && b2 <= 'z') b2 = (byte) (b2 - 'a' + 'A'); if (b1 != b2) return false; } } } return true; } public byte get() { return peek(_get++); } public int get(byte[] b, int offset, int length) { int gi = getIndex(); int l=length(); if (l==0) return -1; if (length>l) length=l; length = peek(gi, b, offset, length); if (length>0) setGetIndex(gi + length); return length; } public Buffer get(int length) { int gi = getIndex(); Buffer view = peek(gi, length); setGetIndex(gi + length); return view; } public final int getIndex() { return _get; } public boolean hasContent() { return _put > _get; } @Override public int hashCode() { if (_hash == 0 || _hashGet!=_get || _hashPut!=_put) { int get=getIndex(); byte[] array = array(); if (array==null) { for (int i = putIndex(); i-- >get;) { byte b = peek(i); if ('a' <= b && b <= 'z') b = (byte) (b - 'a' + 'A'); _hash = 31 * _hash + b; } } else { for (int i = putIndex(); i-- >get;) { byte b = array[i]; if ('a' <= b && b <= 'z') b = (byte) (b - 'a' + 'A'); _hash = 31 * _hash + b; } } if (_hash == 0) _hash = -1; _hashGet=_get; _hashPut=_put; } return _hash; } public boolean isImmutable() { return _access <= IMMUTABLE; } public boolean isReadOnly() { return _access <= READONLY; } public boolean isVolatile() { return _volatile; } public int length() { return _put - _get; } public void mark() { setMarkIndex(_get - 1); } public void mark(int offset) { setMarkIndex(_get + offset); } public int markIndex() { return _mark; } public byte peek() { return peek(_get); } public Buffer peek(int index, int length) { if (_view == null) { _view = new View(this, -1, index, index + length, isReadOnly() ? READONLY : READWRITE); } else { _view.update(this.buffer()); _view.setMarkIndex(-1); _view.setGetIndex(0); _view.setPutIndex(index + length); _view.setGetIndex(index); } return _view; } public int poke(int index, Buffer src) { _hash=0; /* if (isReadOnly()) throw new IllegalStateException(__READONLY); if (index < 0) throw new IllegalArgumentException("index<0: " + index + "<0"); */ int length=src.length(); if (index + length > capacity()) { length=capacity()-index; /* if (length<0) throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity()); */ } byte[] src_array = src.array(); byte[] dst_array = array(); if (src_array != null && dst_array != null) System.arraycopy(src_array, src.getIndex(), dst_array, index, length); else if (src_array != null) { int s=src.getIndex(); for (int i=0;i capacity()) { length=capacity()-index; /* if (length<0) throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity()); */ } byte[] dst_array = array(); if (dst_array != null) System.arraycopy(b, offset, dst_array, index, length); else { int s=offset; for (int i=0;i= 0) setGetIndex(markIndex()); } public void rewind() { setGetIndex(0); setMarkIndex(-1); } public void setGetIndex(int getIndex) { /* bounds checking if (isImmutable()) throw new IllegalStateException(__IMMUTABLE); if (getIndex < 0) throw new IllegalArgumentException("getIndex<0: " + getIndex + "<0"); if (getIndex > putIndex()) throw new IllegalArgumentException("getIndex>putIndex: " + getIndex + ">" + putIndex()); */ _get = getIndex; _hash=0; } public void setMarkIndex(int index) { /* if (index>=0 && isImmutable()) throw new IllegalStateException(__IMMUTABLE); */ _mark = index; } public void setPutIndex(int putIndex) { /* bounds checking if (isImmutable()) throw new IllegalStateException(__IMMUTABLE); if (putIndex > capacity()) throw new IllegalArgumentException("putIndex>capacity: " + putIndex + ">" + capacity()); if (getIndex() > putIndex) throw new IllegalArgumentException("getIndex>putIndex: " + getIndex() + ">" + putIndex); */ _put = putIndex; _hash=0; } public int skip(int n) { if (length() < n) n = length(); setGetIndex(getIndex() + n); return n; } public Buffer slice() { return peek(getIndex(), length()); } public Buffer sliceFromMark() { return sliceFromMark(getIndex() - markIndex() - 1); } public Buffer sliceFromMark(int length) { if (markIndex() < 0) return null; Buffer view = peek(markIndex(), length); setMarkIndex(-1); return view; } public int space() { return capacity() - _put; } public String toDetailString() { StringBuilder buf = new StringBuilder(); buf.append("["); buf.append(super.hashCode()); buf.append(","); buf.append(this.buffer().hashCode()); buf.append(",m="); buf.append(markIndex()); buf.append(",g="); buf.append(getIndex()); buf.append(",p="); buf.append(putIndex()); buf.append(",c="); buf.append(capacity()); buf.append("]={"); if (markIndex() >= 0) { for (int i = markIndex(); i < getIndex(); i++) { byte b = peek(i); TypeUtil.toHex(b,buf); } buf.append("}{"); } int count = 0; for (int i = getIndex(); i < putIndex(); i++) { byte b = peek(i); TypeUtil.toHex(b,buf); if (count++ == 50) { if (putIndex() - i > 20) { buf.append(" ... "); i = putIndex() - 20; } } } buf.append('}'); return buf.toString(); } /* ------------------------------------------------------------ */ @Override public String toString() { if (isImmutable()) { if (_string == null) _string = new String(asArray(), 0, length()); return _string; } return new String(asArray(), 0, length()); } /* ------------------------------------------------------------ */ public String toString(String charset) { try { byte[] bytes=array(); if (bytes!=null) return new String(bytes,getIndex(),length(),charset); return new String(asArray(), 0, length(),charset); } catch(Exception e) { LOG.warn(e); return new String(asArray(), 0, length()); } } /* ------------------------------------------------------------ */ public String toString(Charset charset) { try { byte[] bytes=array(); if (bytes!=null) return new String(bytes,getIndex(),length(),charset); return new String(asArray(), 0, length(),charset); } catch(Exception e) { LOG.warn(e); return new String(asArray(), 0, length()); } } /* ------------------------------------------------------------ */ public String toDebugString() { return getClass()+"@"+super.hashCode(); } /* ------------------------------------------------------------ */ public void writeTo(OutputStream out) throws IOException { byte[] array = array(); if (array!=null) { out.write(array,getIndex(),length()); } else { int len = this.length(); byte[] buf=new byte[len>1024?1024:len]; int offset=_get; while (len>0) { int l=peek(offset,buf,0,len>buf.length?buf.length:len); out.write(buf,0,l); offset+=l; len-=l; } } clear(); } /* ------------------------------------------------------------ */ public int readFrom(InputStream in,int max) throws IOException { byte[] array = array(); int s=space(); if (s>max) s=max; if (array!=null) { int l=in.read(array,_put,s); if (l>0) _put+=l; return l; } else { byte[] buf=new byte[s>1024?1024:s]; int total=0; while (s>0) { int l=in.read(buf,0,buf.length); if (l<0) return total>0?total:-1; int p=put(buf,0,l); assert l==p; s-=l; } return total; } } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/AbstractBuffers.java000066400000000000000000000122341406526542100272360ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io; import org.eclipse.jetty.io.nio.DirectNIOBuffer; import org.eclipse.jetty.io.nio.IndirectNIOBuffer; public abstract class AbstractBuffers implements Buffers { protected final Buffers.Type _headerType; protected final int _headerSize; protected final Buffers.Type _bufferType; protected final int _bufferSize; protected final Buffers.Type _otherType; /* ------------------------------------------------------------ */ public AbstractBuffers(Buffers.Type headerType, int headerSize, Buffers.Type bufferType, int bufferSize, Buffers.Type otherType) { _headerType=headerType; _headerSize=headerSize; _bufferType=bufferType; _bufferSize=bufferSize; _otherType=otherType; } /* ------------------------------------------------------------ */ /** * @return Returns the buffer size in bytes. */ public int getBufferSize() { return _bufferSize; } /* ------------------------------------------------------------ */ /** * @return Returns the header size in bytes. */ public int getHeaderSize() { return _headerSize; } /* ------------------------------------------------------------ */ /** * Create a new header Buffer * @return new Buffer */ final protected Buffer newHeader() { switch(_headerType) { case BYTE_ARRAY: return new ByteArrayBuffer(_headerSize); case DIRECT: return new DirectNIOBuffer(_headerSize); case INDIRECT: return new IndirectNIOBuffer(_headerSize); } throw new IllegalStateException(); } /* ------------------------------------------------------------ */ /** * Create a new content Buffer * @return new Buffer */ final protected Buffer newBuffer() { switch(_bufferType) { case BYTE_ARRAY: return new ByteArrayBuffer(_bufferSize); case DIRECT: return new DirectNIOBuffer(_bufferSize); case INDIRECT: return new IndirectNIOBuffer(_bufferSize); } throw new IllegalStateException(); } /* ------------------------------------------------------------ */ /** * Create a new content Buffer * @param size * @return new Buffer */ final protected Buffer newBuffer(int size) { switch(_otherType) { case BYTE_ARRAY: return new ByteArrayBuffer(size); case DIRECT: return new DirectNIOBuffer(size); case INDIRECT: return new IndirectNIOBuffer(size); } throw new IllegalStateException(); } /* ------------------------------------------------------------ */ /** * @param buffer * @return True if the buffer is the correct type to be a Header buffer */ public final boolean isHeader(Buffer buffer) { if (buffer.capacity()==_headerSize) { switch(_headerType) { case BYTE_ARRAY: return buffer instanceof ByteArrayBuffer && !(buffer instanceof IndirectNIOBuffer); case DIRECT: return buffer instanceof DirectNIOBuffer; case INDIRECT: return buffer instanceof IndirectNIOBuffer; } } return false; } /* ------------------------------------------------------------ */ /** * @param buffer * @return True if the buffer is the correct type to be a Header buffer */ public final boolean isBuffer(Buffer buffer) { if (buffer.capacity()==_bufferSize) { switch(_bufferType) { case BYTE_ARRAY: return buffer instanceof ByteArrayBuffer && !(buffer instanceof IndirectNIOBuffer); case DIRECT: return buffer instanceof DirectNIOBuffer; case INDIRECT: return buffer instanceof IndirectNIOBuffer; } } return false; } /* ------------------------------------------------------------ */ public String toString() { return String.format("%s [%d,%d]", getClass().getSimpleName(), _headerSize, _bufferSize); } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/Buffer.java000066400000000000000000000254041406526542100253720ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.nio.charset.Charset; /** * Byte Buffer interface. * * This is a byte buffer that is designed to work like a FIFO for bytes. Puts and Gets operate on different * pointers into the buffer and the valid _content of the buffer is always between the getIndex and the putIndex. * * This buffer interface is designed to be similar, but not dependent on the java.nio buffers, which may * be used to back an implementation of this Buffer. The main difference is that NIO buffer after a put have * their valid _content before the position and a flip is required to access that data. * * For this buffer it is always true that: * markValue <= getIndex <= putIndex <= capacity * * * @version 1.0 */ public interface Buffer extends Cloneable { public final static int IMMUTABLE=0, // neither indexes or contexts can be changed READONLY=1, // indexes may be changed, but not content READWRITE=2; // anything can be changed public final boolean VOLATILE=true; // The buffer may change outside of current scope. public final boolean NON_VOLATILE=false; /** * Get the underlying array, if one exists. * @return a byte[] backing this buffer or null if none exists. */ byte[] array(); /** * * @return a byte[] value of the bytes from the getIndex to the putIndex. */ byte[] asArray(); /** * Get the underlying buffer. If this buffer wraps a backing buffer. * @return The root backing buffer or this if there is no backing buffer; */ Buffer buffer(); /** * * @return a non volatile version of this Buffer value */ Buffer asNonVolatileBuffer(); /** * * @return a readonly version of this Buffer. */ Buffer asReadOnlyBuffer(); /** * * @return an immutable version of this Buffer. */ Buffer asImmutableBuffer(); /** * * @return an immutable version of this Buffer. */ Buffer asMutableBuffer(); /** * * The capacity of the buffer. This is the maximum putIndex that may be set. * @return an int value */ int capacity(); /** * the space remaining in the buffer. * @return capacity - putIndex */ int space(); /** * Clear the buffer. getIndex=0, putIndex=0. */ void clear(); /** * Compact the buffer by discarding bytes before the postion (or mark if set). * Bytes from the getIndex (or mark) to the putIndex are moved to the beginning of * the buffer and the values adjusted accordingly. */ void compact(); /** * Get the byte at the current getIndex and increment it. * @return The byte value from the current getIndex. */ byte get(); /** * Get bytes from the current postion and put them into the passed byte array. * The getIndex is incremented by the number of bytes copied into the array. * @param b The byte array to fill. * @param offset Offset in the array. * @param length The max number of bytes to read. * @return The number of bytes actually read. */ int get(byte[] b, int offset, int length); /** * * @param length an int value * @return a Buffer value */ Buffer get(int length); /** * The index within the buffer that will next be read or written. * @return an int value >=0 <= putIndex() */ int getIndex(); /** * @return true of putIndex > getIndex */ boolean hasContent(); /** * * @return a boolean value true if case sensitive comparison on this buffer */ boolean equalsIgnoreCase(Buffer buffer); /** * * @return a boolean value true if the buffer is immutable and that neither * the buffer contents nor the indexes may be changed. */ boolean isImmutable(); /** * * @return a boolean value true if the buffer is readonly. The buffer indexes may * be modified, but the buffer contents may not. For example a View onto an immutable Buffer will be * read only. */ boolean isReadOnly(); /** * * @return a boolean value true if the buffer contents may change * via alternate paths than this buffer. If the contents of this buffer are to be used outside of the * current context, then a copy must be made. */ boolean isVolatile(); /** * The number of bytes from the getIndex to the putIndex * @return an int == putIndex()-getIndex() */ int length(); /** * Set the mark to the current getIndex. */ void mark(); /** * Set the mark relative to the current getIndex * @param offset an int value to add to the current getIndex to obtain the mark value. */ void mark(int offset); /** * The current index of the mark. * @return an int index in the buffer or -1 if the mark is not set. */ int markIndex(); /** * Get the byte at the current getIndex without incrementing the getIndex. * @return The byte value from the current getIndex. */ byte peek(); /** * Get the byte at a specific index in the buffer. * @param index an int value * @return a byte value */ byte peek(int index); /** * * @param index an int value * @param length an int value * @return The Buffer value from the requested getIndex. */ Buffer peek(int index, int length); /** * * @param index an int value * @param b The byte array to peek into * @param offset The offset into the array to start peeking * @param length an int value * @return The number of bytes actually peeked */ int peek(int index, byte[] b, int offset, int length); /** * Put the contents of the buffer at the specific index. * @param index an int value * @param src a Buffer. If the source buffer is not modified * @return The number of bytes actually poked */ int poke(int index, Buffer src); /** * Put a specific byte to a specific getIndex. * @param index an int value * @param b a byte value */ void poke(int index, byte b); /** * Put a specific byte to a specific getIndex. * @param index an int value * @param b a byte array value * @return The number of bytes actually poked */ int poke(int index, byte b[], int offset, int length); /** * Write the bytes from the source buffer to the current getIndex. * @param src The source Buffer it is not modified. * @return The number of bytes actually poked */ int put(Buffer src); /** * Put a byte to the current getIndex and increment the getIndex. * @param b a byte value */ void put(byte b); /** * Put a byte to the current getIndex and increment the getIndex. * @param b a byte value * @return The number of bytes actually poked */ int put(byte[] b,int offset, int length); /** * Put a byte to the current getIndex and increment the getIndex. * @param b a byte value * @return The number of bytes actually poked */ int put(byte[] b); /** * The index of the first element that should not be read. * @return an int value >= getIndex() */ int putIndex(); /** * Reset the current getIndex to the mark */ void reset(); /** * Set the buffers start getIndex. * @param newStart an int value */ void setGetIndex(int newStart); /** * Set a specific value for the mark. * @param newMark an int value */ void setMarkIndex(int newMark); /** * * @param newLimit an int value */ void setPutIndex(int newLimit); /** * Skip _content. The getIndex is updated by min(remaining(), n) * @param n The number of bytes to skip * @return the number of bytes skipped. */ int skip(int n); /** * * @return a volitile Buffer from the postion to the putIndex. */ Buffer slice(); /** * * * @return a volitile Buffer value from the mark to the putIndex */ Buffer sliceFromMark(); /** * * * @param length an int value * @return a valitile Buffer value from the mark of the length requested. */ Buffer sliceFromMark(int length); /** * * @return a String value describing the state and contents of the buffer. */ String toDetailString(); /* ------------------------------------------------------------ */ /** Write the buffer's contents to the output stream * @param out */ void writeTo(OutputStream out) throws IOException; /* ------------------------------------------------------------ */ /** Read the buffer's contents from the input stream * @param in input stream * @param max maximum number of bytes that may be read * @return actual number of bytes read or -1 for EOF */ int readFrom(InputStream in, int max) throws IOException; /* ------------------------------------------------------------ */ String toString(String charset); /* ------------------------------------------------------------ */ String toString(Charset charset); /* * Buffers implementing this interface should be compared with case insensitive equals * */ public interface CaseInsensitve {} }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/Buffers.java000066400000000000000000000025261406526542100255550ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io; /* ------------------------------------------------------------ */ /** BufferSource. * Represents a pool or other source of buffers and abstracts the creation * of specific types of buffers (eg NIO). The concept of big and little buffers * is supported, but these terms have no absolute meaning and must be determined by context. * */ public interface Buffers { enum Type { BYTE_ARRAY, DIRECT, INDIRECT } ; Buffer getHeader(); Buffer getBuffer(); Buffer getBuffer(int size); void returnBuffer(Buffer buffer); }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/BuffersFactory.java000066400000000000000000000023331406526542100271010ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io; public class BuffersFactory { public static Buffers newBuffers(Buffers.Type headerType, int headerSize, Buffers.Type bufferType, int bufferSize, Buffers.Type otherType,int maxSize) { if (maxSize>=0) return new PooledBuffers(headerType,headerSize,bufferType,bufferSize,otherType,maxSize); return new ThreadLocalBuffers(headerType,headerSize,bufferType,bufferSize,otherType); } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/ByteArrayBuffer.java000066400000000000000000000270551406526542100272210ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io; import org.eclipse.jetty.util.StringUtil; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.UnsupportedEncodingException; /* ------------------------------------------------------------------------------- */ /** * */ public class ByteArrayBuffer extends AbstractBuffer { // Set a maximum size to a write for the writeTo method, to ensure that very large content is not // written as a single write (which may fall foul to write timeouts if consumed slowly). final static int MAX_WRITE=Integer.getInteger("org.eclipse.jetty.io.ByteArrayBuffer.MAX_WRITE",128*1024); final protected byte[] _bytes; protected ByteArrayBuffer(int size, int access, boolean isVolatile) { this(new byte[size],0,0,access, isVolatile); } public ByteArrayBuffer(byte[] bytes) { this(bytes, 0, bytes.length, READWRITE); } public ByteArrayBuffer(byte[] bytes, int index, int length) { this(bytes, index, length, READWRITE); } public ByteArrayBuffer(byte[] bytes, int index, int length, int access) { super(READWRITE, NON_VOLATILE); _bytes = bytes; setPutIndex(index + length); setGetIndex(index); _access = access; } public ByteArrayBuffer(byte[] bytes, int index, int length, int access, boolean isVolatile) { super(READWRITE, isVolatile); _bytes = bytes; setPutIndex(index + length); setGetIndex(index); _access = access; } public ByteArrayBuffer(int size) { this(new byte[size], 0, 0, READWRITE); setPutIndex(0); } public ByteArrayBuffer(String value) { super(READWRITE,NON_VOLATILE); _bytes = StringUtil.getBytes(value); setGetIndex(0); setPutIndex(_bytes.length); _access=IMMUTABLE; _string = value; } public ByteArrayBuffer(String value,boolean immutable) { super(READWRITE,NON_VOLATILE); _bytes = StringUtil.getBytes(value); setGetIndex(0); setPutIndex(_bytes.length); if (immutable) { _access=IMMUTABLE; _string = value; } } public ByteArrayBuffer(String value,String encoding) throws UnsupportedEncodingException { super(READWRITE,NON_VOLATILE); _bytes = value.getBytes(encoding); setGetIndex(0); setPutIndex(_bytes.length); _access=IMMUTABLE; _string = value; } public byte[] array() { return _bytes; } public int capacity() { return _bytes.length; } @Override public void compact() { if (isReadOnly()) throw new IllegalStateException(__READONLY); int s = markIndex() >= 0 ? markIndex() : getIndex(); if (s > 0) { int length = putIndex() - s; if (length > 0) { System.arraycopy(_bytes, s,_bytes, 0, length); } if (markIndex() > 0) setMarkIndex(markIndex() - s); setGetIndex(getIndex() - s); setPutIndex(putIndex() - s); } } @Override public boolean equals(Object obj) { if (obj==this) return true; if (obj == null || !(obj instanceof Buffer)) return false; if (obj instanceof Buffer.CaseInsensitve) return equalsIgnoreCase((Buffer)obj); Buffer b = (Buffer) obj; // reject different lengths if (b.length() != length()) return false; // reject AbstractBuffer with different hash value if (_hash != 0 && obj instanceof AbstractBuffer) { AbstractBuffer ab = (AbstractBuffer) obj; if (ab._hash != 0 && _hash != ab._hash) return false; } // Nothing for it but to do the hard grind. int get=getIndex(); int bi=b.putIndex(); for (int i = putIndex(); i-->get;) { byte b1 = _bytes[i]; byte b2 = b.peek(--bi); if (b1 != b2) return false; } return true; } @Override public boolean equalsIgnoreCase(Buffer b) { if (b==this) return true; // reject different lengths if (b==null || b.length() != length()) return false; // reject AbstractBuffer with different hash value if (_hash != 0 && b instanceof AbstractBuffer) { AbstractBuffer ab = (AbstractBuffer) b; if (ab._hash != 0 && _hash != ab._hash) return false; } // Nothing for it but to do the hard grind. int get=getIndex(); int bi=b.putIndex(); byte[] barray=b.array(); if (barray==null) { for (int i = putIndex(); i-->get;) { byte b1 = _bytes[i]; byte b2 = b.peek(--bi); if (b1 != b2) { if ('a' <= b1 && b1 <= 'z') b1 = (byte) (b1 - 'a' + 'A'); if ('a' <= b2 && b2 <= 'z') b2 = (byte) (b2 - 'a' + 'A'); if (b1 != b2) return false; } } } else { for (int i = putIndex(); i-->get;) { byte b1 = _bytes[i]; byte b2 = barray[--bi]; if (b1 != b2) { if ('a' <= b1 && b1 <= 'z') b1 = (byte) (b1 - 'a' + 'A'); if ('a' <= b2 && b2 <= 'z') b2 = (byte) (b2 - 'a' + 'A'); if (b1 != b2) return false; } } } return true; } @Override public byte get() { return _bytes[_get++]; } @Override public int hashCode() { if (_hash == 0 || _hashGet!=_get || _hashPut!=_put) { int get=getIndex(); for (int i = putIndex(); i-- >get;) { byte b = _bytes[i]; if ('a' <= b && b <= 'z') b = (byte) (b - 'a' + 'A'); _hash = 31 * _hash + b; } if (_hash == 0) _hash = -1; _hashGet=_get; _hashPut=_put; } return _hash; } public byte peek(int index) { return _bytes[index]; } public int peek(int index, byte[] b, int offset, int length) { int l = length; if (index + l > capacity()) { l = capacity() - index; if (l==0) return -1; } if (l < 0) return -1; System.arraycopy(_bytes, index, b, offset, l); return l; } public void poke(int index, byte b) { /* if (isReadOnly()) throw new IllegalStateException(__READONLY); if (index < 0) throw new IllegalArgumentException("index<0: " + index + "<0"); if (index > capacity()) throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity()); */ _bytes[index] = b; } @Override public int poke(int index, Buffer src) { _hash=0; /* if (isReadOnly()) throw new IllegalStateException(__READONLY); if (index < 0) throw new IllegalArgumentException("index<0: " + index + "<0"); */ int length=src.length(); if (index + length > capacity()) { length=capacity()-index; /* if (length<0) throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity()); */ } byte[] src_array = src.array(); if (src_array != null) System.arraycopy(src_array, src.getIndex(), _bytes, index, length); else { int s=src.getIndex(); for (int i=0;i capacity()) { length=capacity()-index; /* if (length<0) throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity()); */ } System.arraycopy(b, offset, _bytes, index, length); return length; } /* ------------------------------------------------------------ */ @Override public void writeTo(OutputStream out) throws IOException { int len=length(); if (MAX_WRITE>0 && len>MAX_WRITE) { int off=getIndex(); while(len>0) { int c=len>MAX_WRITE?MAX_WRITE:len; out.write(_bytes,off,c); off+=c; len-=c; } } else out.write(_bytes,getIndex(),len); if (!isImmutable()) clear(); } /* ------------------------------------------------------------ */ @Override public int readFrom(InputStream in,int max) throws IOException { if (max<0||max>space()) max=space(); int p = putIndex(); int len=0, total=0, available=max; while (total0) { p += len; total += len; available -= len; setPutIndex(p); } if (in.available()<=0) break; } if (len<0 && total==0) return -1; return total; } /* ------------------------------------------------------------ */ @Override public int space() { return _bytes.length - _put; } /* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */ public static class CaseInsensitive extends ByteArrayBuffer implements Buffer.CaseInsensitve { public CaseInsensitive(String s) { super(s); } public CaseInsensitive(byte[] b, int o, int l, int rw) { super(b,o,l,rw); } @Override public boolean equals(Object obj) { return obj instanceof Buffer && equalsIgnoreCase((Buffer)obj); } } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/EndPoint.java000066400000000000000000000045211406526542100256760ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // // Modifications: // 2019 - Software Verde, LLC // Removed unused methods. // 2020 - Software Verde, LLC // Removed unused methods. // package org.eclipse.jetty.io; import java.io.IOException; /** * * A transport EndPoint */ public interface EndPoint { /** * Shutdown any backing output stream associated with the endpoint */ void shutdownOutput() throws IOException; boolean isInputShutdown(); /** * Fill the buffer from the current putIndex to it's capacity from whatever * byte source is backing the buffer. The putIndex is increased if bytes filled. * The buffer may chose to do a compact before filling. * @return an int value indicating the number of bytes * filled or -1 if EOF is reached. * @throws EofException If input is shutdown or the endpoint is closed. */ int fill(Buffer buffer) throws IOException; /** * Flush the buffer from the current getIndex to it's putIndex using whatever byte * sink is backing the buffer. The getIndex is updated with the number of bytes flushed. * Any mark set is cleared. * If the entire contents of the buffer are flushed, then an implicit empty() is done. * * @param buffer The buffer to flush. This buffers getIndex is updated. * @return the number of bytes written * @throws EofException If the endpoint is closed or output is shutdown. */ int flush(Buffer buffer) throws IOException; /* ------------------------------------------------------------ */ public boolean isOpen(); }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/EofException.java000066400000000000000000000027501406526542100265500ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io; import java.io.EOFException; /* ------------------------------------------------------------ */ /** A Jetty specialization of EOFException. *

This is thrown by Jetty to distinguish between EOF received from * the connection, vs and EOF thrown by some application talking to some other file/socket etc. * The only difference in handling is that Jetty EOFs are logged less verbosely. */ @SuppressWarnings("serial") public class EofException extends EOFException { public EofException() { } public EofException(String reason) { super(reason); } public EofException(Throwable th) { if (th!=null) initCause(th); } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/PooledBuffers.java000066400000000000000000000076761406526542100267330ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io; import java.util.Queue; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.atomic.AtomicInteger; public class PooledBuffers extends AbstractBuffers { private final Queue _headers; private final Queue _buffers; private final Queue _others; private final AtomicInteger _size = new AtomicInteger(); private final int _maxSize; private final boolean _otherHeaders; private final boolean _otherBuffers; /* ------------------------------------------------------------ */ public PooledBuffers(Buffers.Type headerType, int headerSize, Buffers.Type bufferType, int bufferSize, Buffers.Type otherType,int maxSize) { super(headerType,headerSize,bufferType,bufferSize,otherType); _headers=new ConcurrentLinkedQueue(); _buffers=new ConcurrentLinkedQueue(); _others=new ConcurrentLinkedQueue(); _otherHeaders=headerType==otherType; _otherBuffers=bufferType==otherType; _maxSize=maxSize; } /* ------------------------------------------------------------ */ public Buffer getHeader() { Buffer buffer = _headers.poll(); if (buffer==null) buffer=newHeader(); else _size.decrementAndGet(); return buffer; } /* ------------------------------------------------------------ */ public Buffer getBuffer() { Buffer buffer = _buffers.poll(); if (buffer==null) buffer=newBuffer(); else _size.decrementAndGet(); return buffer; } /* ------------------------------------------------------------ */ public Buffer getBuffer(int size) { if (_otherHeaders && size==getHeaderSize()) return getHeader(); if (_otherBuffers && size==getBufferSize()) return getBuffer(); // Look for an other buffer Buffer buffer = _others.poll(); // consume all other buffers until one of the right size is found while (buffer!=null && buffer.capacity()!=size) { _size.decrementAndGet(); buffer = _others.poll(); } if (buffer==null) buffer=newBuffer(size); else _size.decrementAndGet(); return buffer; } /* ------------------------------------------------------------ */ public void returnBuffer(Buffer buffer) { buffer.clear(); if (buffer.isVolatile() || buffer.isImmutable()) return; if (_size.incrementAndGet() > _maxSize) _size.decrementAndGet(); else { if (isHeader(buffer)) _headers.add(buffer); else if (isBuffer(buffer)) _buffers.add(buffer); else _others.add(buffer); } } public String toString() { return String.format("%s [%d/%d@%d,%d/%d@%d,%d/%d@-]", getClass().getSimpleName(), _headers.size(),_maxSize,_headerSize, _buffers.size(),_maxSize,_bufferSize, _others.size(),_maxSize); } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/ThreadLocalBuffers.java000066400000000000000000000077021406526542100276610ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io; /* ------------------------------------------------------------ */ /** Abstract Buffer pool. * simple unbounded pool of buffers for header, request and response sizes. * */ public class ThreadLocalBuffers extends AbstractBuffers { /* ------------------------------------------------------------ */ private final ThreadLocal _buffers=new ThreadLocal() { @Override protected ThreadBuffers initialValue() { return new ThreadBuffers(); } }; /* ------------------------------------------------------------ */ public ThreadLocalBuffers(Buffers.Type headerType, int headerSize, Buffers.Type bufferType, int bufferSize, Buffers.Type otherType) { super(headerType,headerSize,bufferType,bufferSize,otherType); } /* ------------------------------------------------------------ */ public Buffer getBuffer() { ThreadBuffers buffers = _buffers.get(); if (buffers._buffer!=null) { Buffer b=buffers._buffer; buffers._buffer=null; return b; } if (buffers._other!=null && isBuffer(buffers._other)) { Buffer b=buffers._other; buffers._other=null; return b; } return newBuffer(); } /* ------------------------------------------------------------ */ public Buffer getHeader() { ThreadBuffers buffers = _buffers.get(); if (buffers._header!=null) { Buffer b=buffers._header; buffers._header=null; return b; } if (buffers._other!=null && isHeader(buffers._other)) { Buffer b=buffers._other; buffers._other=null; return b; } return newHeader(); } /* ------------------------------------------------------------ */ public Buffer getBuffer(int size) { ThreadBuffers buffers = _buffers.get(); if (buffers._other!=null && buffers._other.capacity()==size) { Buffer b=buffers._other; buffers._other=null; return b; } return newBuffer(size); } /* ------------------------------------------------------------ */ public void returnBuffer(Buffer buffer) { buffer.clear(); if (buffer.isVolatile() || buffer.isImmutable()) return; ThreadBuffers buffers = _buffers.get(); if (buffers._header==null && isHeader(buffer)) buffers._header=buffer; else if (buffers._buffer==null && isBuffer(buffer)) buffers._buffer=buffer; else buffers._other=buffer; } /* ------------------------------------------------------------ */ @Override public String toString() { return "{{"+getHeaderSize()+","+getBufferSize()+"}}"; } /* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */ protected static class ThreadBuffers { Buffer _buffer; Buffer _header; Buffer _other; } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/View.java000066400000000000000000000136411406526542100250730ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io; /** * A View on another buffer. Allows operations that do not change the _content or * indexes of the backing buffer. * * * */ public class View extends AbstractBuffer { Buffer _buffer; /** * @param buffer The Buffer on which we are presenting a View. * @param mark The initial value of the {@link Buffer#markIndex mark index} * @param get The initial value of the {@link Buffer#getIndex get index} * @param put The initial value of the {@link Buffer#putIndex put index} * @param access The access level - one of the constants from {@link Buffer}. */ public View(Buffer buffer, int mark, int get, int put,int access) { super(READWRITE,!buffer.isImmutable()); _buffer=buffer.buffer(); setPutIndex(put); setGetIndex(get); setMarkIndex(mark); _access=access; } public View(Buffer buffer) { super(READWRITE,!buffer.isImmutable()); _buffer=buffer.buffer(); setPutIndex(buffer.putIndex()); setGetIndex(buffer.getIndex()); setMarkIndex(buffer.markIndex()); _access=buffer.isReadOnly()?READONLY:READWRITE; } public View() { super(READWRITE,true); } /** * Update view to buffer */ public void update(Buffer buffer) { _access=READWRITE; _buffer=buffer.buffer(); setGetIndex(0); setPutIndex(buffer.putIndex()); setGetIndex(buffer.getIndex()); setMarkIndex(buffer.markIndex()); _access=buffer.isReadOnly()?READONLY:READWRITE; } public void update(int get, int put) { int a=_access; _access=READWRITE; setGetIndex(0); setPutIndex(put); setGetIndex(get); setMarkIndex(-1); _access=a; } /** * @return The {@link Buffer#array()} from the underlying buffer. */ public byte[] array() { return _buffer.array(); } /** * @return The {@link Buffer#buffer()} from the underlying buffer. */ @Override public Buffer buffer() { return _buffer.buffer(); } /** * @return The {@link Buffer#capacity} of the underlying buffer. */ public int capacity() { return _buffer.capacity(); } /** * */ @Override public void clear() { setMarkIndex(-1); setGetIndex(0); setPutIndex(_buffer.getIndex()); setGetIndex(_buffer.getIndex()); } /** * */ @Override public void compact() { // TODO } /* * (non-Javadoc) * * @see java.lang.Object#equals(java.lang.Object) */ @Override public boolean equals(Object obj) { return this==obj ||((obj instanceof Buffer)&& obj.equals(this)) || super.equals(obj); } /** * @return Whether the underlying buffer is {@link Buffer#isReadOnly read only} */ @Override public boolean isReadOnly() { return _buffer.isReadOnly(); } /** * @return Whether the underlying buffer is {@link Buffer#isVolatile volatile} */ @Override public boolean isVolatile() { return true; } /** * @return The result of calling {@link Buffer#peek(int)} on the underlying buffer */ public byte peek(int index) { return _buffer.peek(index); } /** * @return The result of calling {@link Buffer#peek(int, byte[], int, int)} on the underlying buffer */ public int peek(int index, byte[] b, int offset, int length) { return _buffer.peek(index,b,offset,length); } /** * @return The result of calling {@link Buffer#peek(int, int)} on the underlying buffer */ @Override public Buffer peek(int index, int length) { return _buffer.peek(index, length); } /** * @param index * @param src */ @Override public int poke(int index, Buffer src) { return _buffer.poke(index,src); } /** * @param index * @param b */ public void poke(int index, byte b) { _buffer.poke(index,b); } /** * @param index * @param b * @param offset * @param length */ @Override public int poke(int index, byte[] b, int offset, int length) { return _buffer.poke(index,b,offset,length); } @Override public String toString() { if (_buffer==null) return "INVALID"; return super.toString(); } public static class CaseInsensitive extends View implements Buffer.CaseInsensitve { public CaseInsensitive() { super(); } public CaseInsensitive(Buffer buffer, int mark, int get, int put, int access) { super(buffer,mark,get,put,access); } public CaseInsensitive(Buffer buffer) { super(buffer); } @Override public boolean equals(Object obj) { return this==obj ||((obj instanceof Buffer)&&((Buffer)obj).equalsIgnoreCase(this)) || super.equals(obj); } } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/nio/000077500000000000000000000000001406526542100240765ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/nio/DirectNIOBuffer.java000066400000000000000000000226571406526542100276670ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io.nio; import org.eclipse.jetty.io.AbstractBuffer; import org.eclipse.jetty.io.Buffer; import org.eclipse.jetty.util.IO; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.nio.ByteBuffer; import java.nio.channels.Channels; import java.nio.channels.FileChannel; import java.nio.channels.ReadableByteChannel; import java.nio.channels.WritableByteChannel; /* ------------------------------------------------------------------------------- */ /** * * */ public class DirectNIOBuffer extends AbstractBuffer implements NIOBuffer { private static final Logger LOG = Log.getLogger(DirectNIOBuffer.class); protected final ByteBuffer _buf; private ReadableByteChannel _in; private InputStream _inStream; private WritableByteChannel _out; private OutputStream _outStream; public DirectNIOBuffer(int size) { super(READWRITE,NON_VOLATILE); _buf = ByteBuffer.allocateDirect(size); _buf.position(0); _buf.limit(_buf.capacity()); } public DirectNIOBuffer(ByteBuffer buffer,boolean immutable) { super(immutable?IMMUTABLE:READWRITE,NON_VOLATILE); if (!buffer.isDirect()) throw new IllegalArgumentException(); _buf = buffer; setGetIndex(buffer.position()); setPutIndex(buffer.limit()); } /** * @param file */ public DirectNIOBuffer(File file) throws IOException { super(READONLY,NON_VOLATILE); FileInputStream fis = null; FileChannel fc = null; try { fis = new FileInputStream(file); fc = fis.getChannel(); _buf = fc.map(FileChannel.MapMode.READ_ONLY, 0, file.length()); setGetIndex(0); setPutIndex((int)file.length()); _access=IMMUTABLE; } finally { if (fc != null) try {fc.close();} catch (IOException e){LOG.ignore(e);} IO.close(fis); } } /* ------------------------------------------------------------ */ public boolean isDirect() { return true; } /* ------------------------------------------------------------ */ public byte[] array() { return null; } /* ------------------------------------------------------------ */ public int capacity() { return _buf.capacity(); } /* ------------------------------------------------------------ */ public byte peek(int position) { return _buf.get(position); } public int peek(int index, byte[] b, int offset, int length) { int l = length; if (index+l > capacity()) { l=capacity()-index; if (l==0) return -1; } if (l < 0) return -1; try { _buf.position(index); _buf.get(b,offset,l); } finally { _buf.position(0); } return l; } public void poke(int index, byte b) { if (isReadOnly()) throw new IllegalStateException(__READONLY); if (index < 0) throw new IllegalArgumentException("index<0: " + index + "<0"); if (index > capacity()) throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity()); _buf.put(index,b); } @Override public int poke(int index, Buffer src) { if (isReadOnly()) throw new IllegalStateException(__READONLY); byte[] array=src.array(); if (array!=null) { return poke(index,array,src.getIndex(),src.length()); } else { Buffer src_buf=src.buffer(); if (src_buf instanceof DirectNIOBuffer) { ByteBuffer src_bytebuf = ((DirectNIOBuffer)src_buf)._buf; if (src_bytebuf==_buf) src_bytebuf=_buf.duplicate(); try { _buf.position(index); int space = _buf.remaining(); int length=src.length(); if (length>space) length=space; src_bytebuf.position(src.getIndex()); src_bytebuf.limit(src.getIndex()+length); _buf.put(src_bytebuf); return length; } finally { _buf.position(0); src_bytebuf.limit(src_bytebuf.capacity()); src_bytebuf.position(0); } } else return super.poke(index,src); } } @Override public int poke(int index, byte[] b, int offset, int length) { if (isReadOnly()) throw new IllegalStateException(__READONLY); if (index < 0) throw new IllegalArgumentException("index<0: " + index + "<0"); if (index + length > capacity()) { length=capacity()-index; if (length<0) throw new IllegalArgumentException("index>capacity(): " + index + ">" + capacity()); } try { _buf.position(index); int space=_buf.remaining(); if (length>space) length=space; if (length>0) _buf.put(b,offset,length); return length; } finally { _buf.position(0); } } /* ------------------------------------------------------------ */ public ByteBuffer getByteBuffer() { return _buf; } /* ------------------------------------------------------------ */ @Override public int readFrom(InputStream in, int max) throws IOException { if (_in==null || !_in.isOpen() || in!=_inStream) { _in=Channels.newChannel(in); _inStream=in; } if (max<0 || max>space()) max=space(); int p = putIndex(); try { int len=0, total=0, available=max; int loop=0; while (total0) { p += len; total += len; available -= len; setPutIndex(p); loop=0; } else if (loop++>1) break; if (in.available()<=0) break; } if (len<0 && total==0) return -1; return total; } catch(IOException e) { _in=null; _inStream=in; throw e; } finally { if (_in!=null && !_in.isOpen()) { _in=null; _inStream=in; } _buf.position(0); _buf.limit(_buf.capacity()); } } /* ------------------------------------------------------------ */ @Override public void writeTo(OutputStream out) throws IOException { if (_out==null || !_out.isOpen() || out!=_outStream) { _out=Channels.newChannel(out); _outStream=out; } synchronized (_buf) { try { int loop=0; while(hasContent() && _out.isOpen()) { _buf.position(getIndex()); _buf.limit(putIndex()); int len=_out.write(_buf); if (len<0) break; else if (len>0) { skip(len); loop=0; } else if (loop++>1) break; } } catch(IOException e) { _out=null; _outStream=null; throw e; } finally { if (_out!=null && !_out.isOpen()) { _out=null; _outStream=null; } _buf.position(0); _buf.limit(_buf.capacity()); } } } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/nio/IndirectNIOBuffer.java000066400000000000000000000037611406526542100302110ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io.nio; import org.eclipse.jetty.io.ByteArrayBuffer; import java.nio.ByteBuffer; public class IndirectNIOBuffer extends ByteArrayBuffer implements NIOBuffer { protected final ByteBuffer _buf; /* ------------------------------------------------------------ */ public IndirectNIOBuffer(int size) { super(size,READWRITE,NON_VOLATILE); _buf = ByteBuffer.wrap(_bytes); _buf.position(0); _buf.limit(_buf.capacity()); } /* ------------------------------------------------------------ */ public IndirectNIOBuffer(ByteBuffer buffer,boolean immutable) { super(buffer.array(),0,0, immutable?IMMUTABLE:READWRITE,NON_VOLATILE); if (buffer.isDirect()) throw new IllegalArgumentException(); _buf = buffer; _get=buffer.position(); _put=buffer.limit(); buffer.position(0); buffer.limit(buffer.capacity()); } /* ------------------------------------------------------------ */ public ByteBuffer getByteBuffer() { return _buf; } /* ------------------------------------------------------------ */ public boolean isDirect() { return false; } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/io/nio/NIOBuffer.java000066400000000000000000000023461406526542100265250ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.io.nio; import org.eclipse.jetty.io.Buffer; import java.nio.ByteBuffer; /* ------------------------------------------------------------------------------- */ /** * * */ public interface NIOBuffer extends Buffer { /* ------------------------------------------------------------ */ public ByteBuffer getByteBuffer(); /* ------------------------------------------------------------ */ public boolean isDirect(); }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/util/000077500000000000000000000000001406526542100236575ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/org/eclipse/jetty/util/IO.java000066400000000000000000000032551406526542100250360ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // // Modifications: // 2019 - Software Verde, LLC // Removed all methods except for IO::close. // package org.eclipse.jetty.util; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; import java.io.IOException; import java.io.InputStream; /* ======================================================================== */ /** IO Utilities. * Provides stream handling utilities in * singleton Threadpool implementation accessed by static members. */ public class IO { private static final Logger LOG = Log.getLogger(IO.class); /** * closes an input stream, and logs exceptions * * @param is the input stream to close */ public static void close(InputStream is) { try { if (is != null) is.close(); } catch (IOException e) { LOG.ignore(e); } } } java-http-client-2.2.2/src/main/java/org/eclipse/jetty/util/StringUtil.java000066400000000000000000000037171406526542100266360ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // // Modifications: // 2019 - Software Verde, LLC // Removed all methods except for StringUtil::getBytes. // package org.eclipse.jetty.util; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; import java.nio.charset.Charset; /** Fast String Utilities. * * These string utilities provide both conveniance methods and * performance improvements over most standard library versions. The * main aim of the optimizations is to avoid object creation unless * absolutely required. * * */ public class StringUtil { private static final Logger LOG = Log.getLogger(StringUtil.class); public static final String __ISO_8859_1="ISO-8859-1"; public final static String __UTF8="UTF-8"; public final static Charset __UTF8_CHARSET; public final static Charset __ISO_8859_1_CHARSET; static { __UTF8_CHARSET=Charset.forName(__UTF8); __ISO_8859_1_CHARSET=Charset.forName(__ISO_8859_1); } public static byte[] getBytes(String s) { try { return s.getBytes(__ISO_8859_1); } catch(Exception e) { LOG.warn(e); return s.getBytes(); } } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/util/TypeUtil.java000066400000000000000000000061141406526542100263030ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // // // Modifications: // 2019 - Software Verde, LLC // Removed all non-hex related functions. // package org.eclipse.jetty.util; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; import java.io.IOException; /* ------------------------------------------------------------ */ /** * TYPE Utilities. * Provides various static utiltiy methods for manipulating types and their * string representations. * * @since Jetty 4.1 */ public class TypeUtil { private static final Logger LOG = Log.getLogger(TypeUtil.class); public static int CR = '\015'; public static int LF = '\012'; /* ------------------------------------------------------------ */ public static String toString(byte[] bytes, int base) { StringBuilder buf = new StringBuilder(); for (byte b : bytes) { int bi=0xff&b; int c='0'+(bi/base)%base; if (c>'9') c= 'a'+(c-'0'-10); buf.append((char)c); c='0'+bi%base; if (c>'9') c= 'a'+(c-'0'-10); buf.append((char)c); } return buf.toString(); } /* ------------------------------------------------------------ */ public static void toHex(byte b,Appendable buf) { try { int d=0xf&((0xF0&b)>>4); buf.append((char)((d>9?('A'-10):'0')+d)); d=0xf&b; buf.append((char)((d>9?('A'-10):'0')+d)); } catch(IOException e) { throw new RuntimeException(e); } } /* ------------------------------------------------------------ */ public static String toHexString(byte b) { return toHexString(new byte[]{b}, 0, 1); } /* ------------------------------------------------------------ */ public static String toHexString(byte[] b,int offset,int length) { StringBuilder buf = new StringBuilder(); for (int i=offset;i'9') c= 'A'+(c-'0'-10); buf.append((char)c); c='0'+bi%16; if (c>'9') c= 'a'+(c-'0'-10); buf.append((char)c); } return buf.toString(); } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/util/Utf8Appendable.java000066400000000000000000000204311406526542100273240ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.util; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; import java.io.IOException; /* ------------------------------------------------------------ */ /** * Utf8 Appendable abstract base class * * This abstract class wraps a standard {@link java.lang.Appendable} and provides methods to append UTF-8 encoded bytes, that are converted into characters. * * This class is stateful and up to 4 calls to {@link #append(byte)} may be needed before state a character is appended to the string buffer. * * The UTF-8 decoding is done by this class and no additional buffers or Readers are used. The UTF-8 code was inspired by * http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ * * License information for Bjoern Hoehrmann's code: * * Copyright (c) 2008-2009 Bjoern Hoehrmann * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. **/ public abstract class Utf8Appendable { protected static final Logger LOG = Log.getLogger(Utf8Appendable.class); public static final char REPLACEMENT = '\ufffd'; private static final int UTF8_ACCEPT = 0; private static final int UTF8_REJECT = 12; protected final Appendable _appendable; protected int _state = UTF8_ACCEPT; private static final byte[] BYTE_TABLE = { // The first part of the table maps bytes to character classes that // to reduce the size of the transition table and create bitmasks. 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 8,8,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, 10,3,3,3,3,3,3,3,3,3,3,3,3,4,3,3, 11,6,6,6,5,8,8,8,8,8,8,8,8,8,8,8 }; private static final byte[] TRANS_TABLE = { // The second part is a transition table that maps a combination // of a state of the automaton and a character class to a state. 0,12,24,36,60,96,84,12,12,12,48,72, 12,12,12,12,12,12,12,12,12,12,12,12, 12, 0,12,12,12,12,12, 0,12, 0,12,12, 12,24,12,12,12,12,12,24,12,24,12,12, 12,12,12,12,12,12,12,24,12,12,12,12, 12,24,12,12,12,12,12,12,12,24,12,12, 12,12,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,36,12,36,12,12, 12,36,12,12,12,12,12,12,12,12,12,12 }; private int _codep; public Utf8Appendable(Appendable appendable) { _appendable = appendable; } public abstract int length(); protected void reset() { _state = UTF8_ACCEPT; } public void append(byte b) { try { appendByte(b); } catch (IOException e) { throw new RuntimeException(e); } } public void append(byte[] b, int offset, int length) { try { int end = offset + length; for (int i = offset; i < end; i++) appendByte(b[i]); } catch (IOException e) { throw new RuntimeException(e); } } public boolean append(byte[] b, int offset, int length, int maxChars) { try { int end = offset + length; for (int i = offset; i < end; i++) { if (length() > maxChars) return false; appendByte(b[i]); } return true; } catch (IOException e) { throw new RuntimeException(e); } } protected void appendByte(byte b) throws IOException { if (b > 0 && _state == UTF8_ACCEPT) { _appendable.append((char)(b & 0xFF)); } else { int i = b & 0xFF; int type = BYTE_TABLE[i]; _codep = _state == UTF8_ACCEPT ? (0xFF >> type) & i : (i & 0x3F) | (_codep << 6); int next = TRANS_TABLE[_state + type]; switch(next) { case UTF8_ACCEPT: _state=next; if (_codep < Character.MIN_HIGH_SURROGATE) { _appendable.append((char)_codep); } else { for (char c : Character.toChars(_codep)) _appendable.append(c); } break; case UTF8_REJECT: String reason = "byte "+TypeUtil.toHexString(b)+" in state "+(_state/12); _codep=0; _state = UTF8_ACCEPT; _appendable.append(REPLACEMENT); throw new NotUtf8Exception(reason); default: _state=next; } } } public boolean isUtf8SequenceComplete() { return _state == UTF8_ACCEPT; } @SuppressWarnings("serial") public static class NotUtf8Exception extends IllegalArgumentException { public NotUtf8Exception(String reason) { super("Not valid UTF8! "+reason); } } protected void checkState() { if (!isUtf8SequenceComplete()) { _codep=0; _state = UTF8_ACCEPT; try { _appendable.append(REPLACEMENT); } catch(IOException e) { throw new RuntimeException(e); } throw new NotUtf8Exception("incomplete UTF8 sequence"); } } public String toReplacedString() { if (!isUtf8SequenceComplete()) { _codep=0; _state = UTF8_ACCEPT; try { _appendable.append(REPLACEMENT); } catch(IOException e) { throw new RuntimeException(e); } Throwable th= new NotUtf8Exception("incomplete UTF8 sequence"); LOG.warn(th.toString()); LOG.debug(th); } return _appendable.toString(); } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/util/Utf8StringBuilder.java000066400000000000000000000041731406526542100300530ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.util; /* ------------------------------------------------------------ */ /** UTF-8 StringBuilder. * * This class wraps a standard {@link java.lang.StringBuilder} and provides methods to append * UTF-8 encoded bytes, that are converted into characters. * * This class is stateful and up to 4 calls to {@link #append(byte)} may be needed before * state a character is appended to the string buffer. * * The UTF-8 decoding is done by this class and no additional buffers or Readers are used. * The UTF-8 code was inspired by http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ * */ public class Utf8StringBuilder extends Utf8Appendable { final StringBuilder _buffer; public Utf8StringBuilder() { super(new StringBuilder()); _buffer=(StringBuilder)_appendable; } public Utf8StringBuilder(int capacity) { super(new StringBuilder(capacity)); _buffer=(StringBuilder)_appendable; } @Override public int length() { return _buffer.length(); } @Override public void reset() { super.reset(); _buffer.setLength(0); } public StringBuilder getStringBuilder() { checkState(); return _buffer; } @Override public String toString() { checkState(); return _buffer.toString(); } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/util/log/000077500000000000000000000000001406526542100244405ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/org/eclipse/jetty/util/log/Log.java000066400000000000000000000002271406526542100260250ustar00rootroot00000000000000package org.eclipse.jetty.util.log; public class Log { public static Logger getLogger(final Object object) { return new Logger(); } } java-http-client-2.2.2/src/main/java/org/eclipse/jetty/util/log/Logger.java000066400000000000000000000005311406526542100265210ustar00rootroot00000000000000package org.eclipse.jetty.util.log; public class Logger { public void debug(final Object object) { com.softwareverde.logging.Logger.debug(object); } public void warn(final Object object) { com.softwareverde.logging.Logger.warn(object); } public void ignore(final Object object) { com.softwareverde.logging.Logger.debug(object); } } java-http-client-2.2.2/src/main/java/org/eclipse/jetty/websocket/000077500000000000000000000000001406526542100246705ustar00rootroot00000000000000java-http-client-2.2.2/src/main/java/org/eclipse/jetty/websocket/MaskGen.java000066400000000000000000000015741406526542100270670ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.websocket; public interface MaskGen { void genMask(byte[] mask); }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/websocket/WSFrameHandler.java000066400000000000000000000316771406526542100303530ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // // Modifications: // 2019 - Software Verde, LLC // Extracted and modified from WebSocketConnectionRFC6455. // package org.eclipse.jetty.websocket; import org.eclipse.jetty.io.Buffer; import org.eclipse.jetty.io.ByteArrayBuffer; import org.eclipse.jetty.util.StringUtil; import org.eclipse.jetty.util.Utf8Appendable; import org.eclipse.jetty.util.Utf8StringBuilder; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; public class WSFrameHandler implements WebSocketParser.FrameHandler { public interface Callback { void onMessage(T message); } public interface CloseSocketHandler { void close(int code, String message); } protected static final Logger LOG = Log.getLogger(WSFrameHandler.class); private static final int MAX_CONTROL_FRAME_PAYLOAD = 125; private final Utf8StringBuilder _utf8; private ByteArrayBuffer _aggregate; private byte _opcode = -1; protected Integer _maxMessageSize; final protected CloseSocketHandler _closeSocketHandler; protected Callback _textMessageCallback; protected Callback _binaryMessageCallback; protected Callback _pingMessageCallback; protected Callback _pongMessageCallback; private void _errorClose(final int code, final String message) { _closeSocketHandler.close(code, message); } private boolean _checkBinaryMessageSize(final int bufferLen, final int length) { if ( (_maxMessageSize > 0) && ((bufferLen + length) > _maxMessageSize) ) { LOG.warn("Binary message too large."); _closeSocketHandler.close(WebSocketConnectionRFC6455.CLOSE_MESSAGE_TOO_LARGE, ""); _opcode = -1; if (_aggregate != null) { _aggregate.clear(); } return false; } return true; } private void _textMessageTooLarge() { LOG.warn("Text message too large."); _closeSocketHandler.close(WebSocketConnectionRFC6455.CLOSE_MESSAGE_TOO_LARGE, ""); _opcode = -1; _utf8.reset(); } public WSFrameHandler(final Integer maxMessageSize, final CloseSocketHandler closeSocketHandler) { _maxMessageSize = maxMessageSize; _utf8 = new Utf8StringBuilder(maxMessageSize); _closeSocketHandler = closeSocketHandler; } public void setTextMessageCallback(final Callback textMessageCallback) { _textMessageCallback = textMessageCallback; } public void setBinaryMessageCallback(final Callback binaryMessageCallback) { _binaryMessageCallback = binaryMessageCallback; } public void setPingMessageCallback(final Callback pingMessageCallback) { _pingMessageCallback = pingMessageCallback; } public void setPongMessageCallback(final Callback pongMessageCallback) { _pongMessageCallback = pongMessageCallback; } @Override public void onFrame(final byte flags, final byte opcode, final Buffer buffer) { final boolean isLastFrame = WebSocketConnectionRFC6455.isLastFrame(flags); try { // final byte[] array = buffer.array(); if (WebSocketConnectionRFC6455.isControlFrame(opcode) && buffer.length()>MAX_CONTROL_FRAME_PAYLOAD) { _errorClose(WebSocketConnectionRFC6455.CLOSE_PROTOCOL,"Control frame too large: " + buffer.length() + " > " + MAX_CONTROL_FRAME_PAYLOAD); return; } if ((flags & 0x07) != 0) { _errorClose(WebSocketConnectionRFC6455.CLOSE_PROTOCOL,"RSV bits set 0x"+Integer.toHexString(flags)); return; } switch (opcode) { case WebSocketConnectionRFC6455.OP_CONTINUATION: { switch (_opcode) { case WebSocketConnectionRFC6455.OP_TEXT: { if (isLastFrame) { _opcode = -1; } final Callback onTextMessage = _textMessageCallback; if (onTextMessage != null) { if (_utf8.append(buffer.array(), buffer.getIndex(), buffer.length(), _maxMessageSize)) { if (isLastFrame) { final String msg = _utf8.toString(); _utf8.reset(); onTextMessage.onMessage(msg); } } else { _textMessageTooLarge(); } } } break; case WebSocketConnectionRFC6455.OP_BINARY: { if (isLastFrame) { _opcode = -1; } final Callback onBinaryMessage = _binaryMessageCallback; if (onBinaryMessage != null) { if ( (_aggregate != null) && (_checkBinaryMessageSize(_aggregate.length(), buffer.length())) ) { _aggregate.put(buffer); if (isLastFrame) { try { onBinaryMessage.onMessage(_aggregate.asArray()); } finally { _aggregate.clear(); } } } } } break; default: { _errorClose(WebSocketConnectionRFC6455.CLOSE_PROTOCOL, "Bad Continuation"); return; } } break; } case WebSocketConnectionRFC6455.OP_PING: { final Callback onPingMessage = _pingMessageCallback; if (onPingMessage != null) { onPingMessage.onMessage(buffer.asArray()); } } break; case WebSocketConnectionRFC6455.OP_PONG: { final Callback onPongMessage = _pongMessageCallback; if (onPongMessage != null) { onPongMessage.onMessage(buffer.asArray()); } } break; case WebSocketConnectionRFC6455.OP_CLOSE: { int code = WebSocketConnectionRFC6455.CLOSE_NO_CODE; String message = null; if (buffer.length() >= 2) { final byte[] bufferBytes = buffer.array(); code = (0xFF & bufferBytes[buffer.getIndex()]) * 0x100 + (0xFF & bufferBytes[buffer.getIndex() + 1]); boolean isValidClose = true; if (code < WebSocketConnectionRFC6455.CLOSE_NORMAL) { isValidClose = false; } else if (code == WebSocketConnectionRFC6455.CLOSE_UNDEFINED) { isValidClose = false; } else if (code == WebSocketConnectionRFC6455.CLOSE_NO_CLOSE) { isValidClose = false; } else if (code == WebSocketConnectionRFC6455.CLOSE_NO_CODE) { isValidClose = false; } else if ( (code > 1011 && code <= 2999 ) ) { isValidClose = false; } else if (code >= 5000) { isValidClose = false; } if (! isValidClose) { _errorClose(WebSocketConnectionRFC6455.CLOSE_PROTOCOL,"Invalid close code " + code); return; } if (buffer.length() > 2) { if (_utf8.append(buffer.array(),buffer.getIndex() + 2,buffer.length() - 2, _maxMessageSize)) { message = _utf8.toString(); _utf8.reset(); } } } else if (buffer.length() == 1) { // Invalid length. use status code 1002 (Protocol error) _errorClose(WebSocketConnectionRFC6455.CLOSE_PROTOCOL,"Invalid payload length of 1"); return; } _closeSocketHandler.close(code, message); } break; case WebSocketConnectionRFC6455.OP_TEXT: { if (_opcode != -1) { _errorClose(WebSocketConnectionRFC6455.CLOSE_PROTOCOL,"Expected Continuation" + Integer.toHexString(opcode)); return; } _opcode = (isLastFrame ? -1 : WebSocketConnectionRFC6455.OP_TEXT); final Callback onTextMessage = _textMessageCallback; if (onTextMessage != null) { if (_maxMessageSize <= 0) { // No size limit, so handle only final frames if (isLastFrame) { onTextMessage.onMessage(buffer.toString(StringUtil.__UTF8)); } else { LOG.warn("Frame discarded. Text aggregation disabled."); _errorClose(WebSocketConnectionRFC6455.CLOSE_POLICY_VIOLATION,"Text frame aggregation disabled"); } } else if (_utf8.append(buffer.array(), buffer.getIndex(), buffer.length(), _maxMessageSize)) { if (isLastFrame) { final String msg =_utf8.toString(); _utf8.reset(); onTextMessage.onMessage(msg); } } else _textMessageTooLarge(); } } break; case WebSocketConnectionRFC6455.OP_BINARY: { if (_opcode != -1) { _errorClose(WebSocketConnectionRFC6455.CLOSE_PROTOCOL,"Expected Continuation"+Integer.toHexString(opcode)); return; } _opcode = (isLastFrame ? -1 : WebSocketConnectionRFC6455.OP_BINARY); final Callback onBinaryMessage = _binaryMessageCallback; if (onBinaryMessage != null) { if(! _checkBinaryMessageSize(0, buffer.length())) { return; } if (isLastFrame) { final byte[] bytes = buffer.asArray(); onBinaryMessage.onMessage(bytes); } else if (_maxMessageSize >= 0) { if (_aggregate == null) { _aggregate = new ByteArrayBuffer(_maxMessageSize); _aggregate.clear(); } _aggregate.put(buffer); } else { LOG.warn("Frame discarded. Binary aggregation disabled."); _errorClose(WebSocketConnectionRFC6455.CLOSE_POLICY_VIOLATION,"Binary frame aggregation disabled"); } } } break; default: { _errorClose(WebSocketConnectionRFC6455.CLOSE_PROTOCOL, "Bad opcode 0x" + Integer.toHexString(opcode)); } break; } } catch (final Utf8Appendable.NotUtf8Exception notUtf8) { _errorClose(WebSocketConnectionRFC6455.CLOSE_BAD_PAYLOAD,"Invalid UTF-8"); } catch (final Exception exception) { _errorClose(WebSocketConnectionRFC6455.CLOSE_SERVER_ERROR,"Internal Server Error."); } } @Override public void close(final int code, final String message) { _closeSocketHandler.close(code, message); } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/websocket/WebSocketBuffers.java000066400000000000000000000036651406526542100307500ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.websocket; import org.eclipse.jetty.io.Buffer; import org.eclipse.jetty.io.Buffers; import org.eclipse.jetty.io.Buffers.Type; import org.eclipse.jetty.io.BuffersFactory; /* ------------------------------------------------------------ */ /** The WebSocket Buffer Pool. * * The normal buffers are byte array buffers so that user processes * can access directly. However the generator uses direct buffers * for the final output stage as they are filled in bulk and are more * efficient to flush. */ public class WebSocketBuffers { final private int _bufferSize; final private Buffers _buffers; public WebSocketBuffers(final int bufferSize) { _bufferSize=bufferSize; _buffers = BuffersFactory.newBuffers(Type.DIRECT,bufferSize,Type.INDIRECT,bufferSize,Type.INDIRECT,-1); } public Buffer getBuffer() { return _buffers.getBuffer(); } public Buffer getDirectBuffer() { return _buffers.getHeader(); } public void returnBuffer(Buffer buffer) { _buffers.returnBuffer(buffer); } public int getBufferSize() { return _bufferSize; } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/websocket/WebSocketConnectionRFC6455.java000066400000000000000000000073251406526542100323270ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // // Modifications: // 2019 - Software Verde, LLC // Removed all non-static methods. // package org.eclipse.jetty.websocket; /* ------------------------------------------------------------ */ /** * 

 *    0                   1                   2                   3
 *    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 *   +-+-+-+-+-------+-+-------------+-------------------------------+
 *   |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
 *   |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
 *   |N|V|V|V|       |S|             |   (if payload len==126/127)   |
 *   | |1|2|3|       |K|             |                               |
 *   +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
 *   |     Extended payload length continued, if payload len == 127  |
 *   + - - - - - - - - - - - - - - - +-------------------------------+
 *   |                               |Masking-key, if MASK set to 1  |
 *   +-------------------------------+-------------------------------+
 *   | Masking-key (continued)       |          Payload Data         |
 *   +-------------------------------- - - - - - - - - - - - - - - - +
 *   :                     Payload Data continued ...                :
 *   + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
 *   |                     Payload Data continued ...                |
 *   +---------------------------------------------------------------+
 *
*/ public class WebSocketConnectionRFC6455 { public static final byte OP_CONTINUATION = 0x00; public static final byte OP_TEXT = 0x01; public static final byte OP_BINARY = 0x02; public static final byte OP_EXT_DATA = 0x03; public static final byte OP_CONTROL = 0x08; public static final byte OP_CLOSE = 0x08; public static final byte OP_PING = 0x09; public static final byte OP_PONG = 0x0A; public static final byte OP_EXT_CTRL = 0x0B; public static final int CLOSE_NORMAL=1000; public static final int CLOSE_SHUTDOWN=1001; public static final int CLOSE_PROTOCOL=1002; public static final int CLOSE_BAD_DATA=1003; public static final int CLOSE_UNDEFINED=1004; public static final int CLOSE_NO_CODE=1005; public static final int CLOSE_NO_CLOSE=1006; public static final int CLOSE_BAD_PAYLOAD=1007; public static final int CLOSE_POLICY_VIOLATION=1008; public static final int CLOSE_MESSAGE_TOO_LARGE=1009; public static final int CLOSE_REQUIRED_EXTENSION=1010; public static final int CLOSE_SERVER_ERROR=1011; public static final int CLOSE_FAILED_TLS_HANDSHAKE=1015; public static final int FLAG_FIN=0x8; // Per RFC 6455, section 1.3 - Opening Handshake - this version is "13" public static final int VERSION=13; static boolean isLastFrame(byte flags) { return (flags&FLAG_FIN)!=0; } static boolean isControlFrame(byte opcode) { return (opcode&OP_CONTROL)!=0; } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/websocket/WebSocketGenerator.java000066400000000000000000000022161406526542100312710ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.websocket; import java.io.IOException; /* ------------------------------------------------------------ */ /** WebSocketGenerator. */ public interface WebSocketGenerator { int flush() throws IOException; boolean isBufferEmpty(); void addFrame(byte flags,byte opcode, byte[] content, int offset, int length) throws IOException; } java-http-client-2.2.2/src/main/java/org/eclipse/jetty/websocket/WebSocketGeneratorRFC6455.java000066400000000000000000000214341406526542100321530ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // // 2020 - Software Verde, LLC // FIX: pending reads no longer block socket writes. // package org.eclipse.jetty.websocket; import org.eclipse.jetty.io.Buffer; import org.eclipse.jetty.io.EndPoint; import org.eclipse.jetty.io.EofException; import java.io.IOException; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * WebSocketGenerator. * This class generates websocket packets. * It is fully synchronized because it is likely that async * threads will call the addMessage methods while other * threads are flushing the generator. */ public class WebSocketGeneratorRFC6455 implements WebSocketGenerator { private final Lock _lock = new ReentrantLock(); private final WebSocketBuffers _buffers; private final EndPoint _endp; private final byte[] _mask = new byte[4]; private final MaskGen _maskGen; private Buffer _buffer; private int _m; private boolean _opsent; private boolean _closed; public WebSocketGeneratorRFC6455(WebSocketBuffers buffers, EndPoint endp) { this(buffers, endp, null); } public WebSocketGeneratorRFC6455(WebSocketBuffers buffers, EndPoint endp, MaskGen maskGen) { _buffers = buffers; _endp = endp; _maskGen = maskGen; } public Buffer getBuffer() { _lock.lock(); try { return _buffer; } finally { _lock.unlock(); } } public void addFrame(byte flags, byte opcode, byte[] content, int offset, int length) throws IOException { _lock.lock(); try { if (_closed) throw new EofException("Closed"); if (opcode == WebSocketConnectionRFC6455.OP_CLOSE) _closed = true; boolean mask = _maskGen != null; if (_buffer == null) _buffer = mask ? _buffers.getBuffer() : _buffers.getDirectBuffer(); boolean last = WebSocketConnectionRFC6455.isLastFrame(flags); int space = mask ? 14 : 10; do { opcode = _opsent ? WebSocketConnectionRFC6455.OP_CONTINUATION : opcode; opcode = (byte)(((0xf & flags) << 4) + (0xf & opcode)); _opsent = true; int payload = length; if (payload + space > _buffer.capacity()) { // We must fragement, so clear FIN bit opcode = (byte)(opcode & 0x7F); // Clear the FIN bit payload = _buffer.capacity() - space; } else if (last) opcode = (byte)(opcode | 0x80); // Set the FIN bit // ensure there is space for header if (_buffer.space() <= space) { flushBuffer(); if (_buffer.space() <= space) flush(); } // write the opcode and length if (payload > 0xffff) { _buffer.put(new byte[]{ opcode, mask ? (byte)0xff : (byte)0x7f, (byte)0, (byte)0, (byte)0, (byte)0, (byte)((payload >> 24) & 0xff), (byte)((payload >> 16) & 0xff), (byte)((payload >> 8) & 0xff), (byte)(payload & 0xff)}); } else if (payload >= 0x7e) { _buffer.put(new byte[]{ opcode, mask ? (byte)0xfe : (byte)0x7e, (byte)(payload >> 8), (byte)(payload & 0xff)}); } else { _buffer.put(new byte[]{ opcode, (byte)(mask ? (0x80 | payload) : payload)}); } // write mask if (mask) { _maskGen.genMask(_mask); _m = 0; _buffer.put(_mask); } // write payload int remaining = payload; while (remaining > 0) { _buffer.compact(); int chunk = remaining < _buffer.space() ? remaining : _buffer.space(); if (mask) { for (int i = 0; i < chunk; i++) _buffer.put((byte)(content[offset + (payload - remaining) + i] ^ _mask[+_m++ % 4])); } else _buffer.put(content, offset + (payload - remaining), chunk); remaining -= chunk; if (_buffer.space() > 0) { // Gently flush the data, issuing a non-blocking write flushBuffer(); } else { // Forcibly flush the data, issuing a blocking write flush(); if (remaining == 0) { // Gently flush the data, issuing a non-blocking write flushBuffer(); } } } offset += payload; length -= payload; } while (length > 0); _opsent = !last; if (_buffer != null && _buffer.length() == 0) { _buffers.returnBuffer(_buffer); _buffer = null; } } finally { _lock.unlock(); } } public int flushBuffer() throws IOException { if (!_lock.tryLock()) return 0; try { if (!_endp.isOpen()) throw new EofException(); if (_buffer != null) { int flushed = _buffer.hasContent() ? _endp.flush(_buffer) : 0; if (_closed && _buffer.length() == 0) _endp.shutdownOutput(); return flushed; } return 0; } finally { _lock.unlock(); } } public int flush() throws IOException { if (!_lock.tryLock()) return 0; try { if (_buffer == null) return 0; int result = flushBuffer(); { while (_buffer.length() > 0) { result += flushBuffer(); } } _buffer.compact(); return result; } finally { _lock.unlock(); } } public boolean isBufferEmpty() { _lock.lock(); try { return _buffer == null || _buffer.length() == 0; } finally { _lock.unlock(); } } public void returnBuffer() { _lock.lock(); try { if (_buffer != null && _buffer.length() == 0) { _buffers.returnBuffer(_buffer); _buffer = null; } } finally { _lock.unlock(); } } @Override public String toString() { // Do NOT use synchronized (this) // because it's very easy to deadlock when debugging is enabled. // We do a best effort to print the right toString() and that's it. Buffer buffer = _buffer; return String.format("%s@%x closed=%b buffer=%d", getClass().getSimpleName(), hashCode(), _closed, buffer == null ? -1 : buffer.length()); } }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/websocket/WebSocketParser.java000066400000000000000000000031121406526542100305730ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.websocket; import org.eclipse.jetty.io.Buffer; /* ------------------------------------------------------------ */ /** * Parser the WebSocket protocol. * */ public interface WebSocketParser { /* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */ public interface FrameHandler { void onFrame(byte flags, byte opcode, Buffer buffer); void close(int code,String message); } Buffer getBuffer(); /** * @return an indication of progress, normally bytes filled plus events parsed, or -1 for EOF */ int parseNext(); boolean isBufferEmpty(); void fill(Buffer buffer); }java-http-client-2.2.2/src/main/java/org/eclipse/jetty/websocket/WebSocketParserRFC6455.java000066400000000000000000000336761406526542100314740ustar00rootroot00000000000000// // ======================================================================== // Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // All rights reserved. This program and the accompanying materials // are made available under the terms of the Eclipse Public License v1.0 // and Apache License v2.0 which accompanies this distribution. // // The Eclipse Public License is available at // http://www.eclipse.org/legal/epl-v10.html // // The Apache License v2.0 is available at // http://www.opensource.org/licenses/apache2.0.php // // You may elect to redistribute this code under either of these licenses. // ======================================================================== // package org.eclipse.jetty.websocket; import org.eclipse.jetty.io.Buffer; import org.eclipse.jetty.io.Buffers; import org.eclipse.jetty.io.EndPoint; import org.eclipse.jetty.util.log.Log; import org.eclipse.jetty.util.log.Logger; import java.io.IOException; /* ------------------------------------------------------------ */ /** * Parser the WebSocket protocol. * */ public class WebSocketParserRFC6455 implements WebSocketParser { private static final Logger LOG = Log.getLogger(WebSocketParserRFC6455.class); public enum State { START(0), OPCODE(1), LENGTH_7(1), LENGTH_16(2), LENGTH_63(8), MASK(4), PAYLOAD(0), DATA(0), SKIP(1), SEEK_EOF(1); int _needs; State(int needs) { _needs=needs; } int getNeeds() { return _needs; } } private final WebSocketBuffers _buffers; private final EndPoint _endp; private final FrameHandler _handler; private final boolean _shouldBeMasked; private State _state; private Buffer _buffer; private byte _flags; private byte _opcode; private int _bytesNeeded; private long _length; private boolean _masked; private final byte[] _mask = new byte[4]; private int _m; private boolean _skip; private boolean _fragmentFrames=true; /* ------------------------------------------------------------ */ /** * @param buffers The buffers to use for parsing. Only the {@link Buffers#getBuffer()} is used. * This should be a direct buffer if binary data is mostly used or an indirect buffer if utf-8 data * is mostly used. * @param endp the endpoint * @param handler the handler to notify when a parse event occurs * @param shouldBeMasked whether masking should be handled */ public WebSocketParserRFC6455(WebSocketBuffers buffers, EndPoint endp, FrameHandler handler, boolean shouldBeMasked) { _buffers=buffers; _endp=endp; _handler=handler; _shouldBeMasked=shouldBeMasked; _state=State.START; } /* ------------------------------------------------------------ */ /** * @return True if fake fragments should be created for frames larger than the buffer. */ public boolean isFakeFragments() { return _fragmentFrames; } /* ------------------------------------------------------------ */ /** * @param fakeFragments True if fake fragments should be created for frames larger than the buffer. */ public void setFakeFragments(boolean fakeFragments) { _fragmentFrames = fakeFragments; } /* ------------------------------------------------------------ */ public boolean isBufferEmpty() { return _buffer==null || _buffer.length()==0; } /* ------------------------------------------------------------ */ public Buffer getBuffer() { return _buffer; } /* ------------------------------------------------------------ */ /** Parse to next event. * Parse to the next {@link WebSocketParser.FrameHandler} event or until no more data is * available. Fill data from the {@link EndPoint} only as necessary. * @return An indication of progress or otherwise. -1 indicates EOF, 0 indicates * that no bytes were read and no messages parsed. A positive number indicates either * the bytes filled or the messages parsed. */ public int parseNext() { if (_buffer==null) _buffer=_buffers.getBuffer(); boolean progress=false; int filled=-1; // Loop until a datagram call back or can't fill anymore while(!progress && (!_endp.isInputShutdown()||_buffer.length()>0)) { int available=_buffer.length(); // Fill buffer if we need a byte or need length while (available<(_state==State.SKIP?1:_bytesNeeded)) { // compact to mark (set at start of data) _buffer.compact(); // if no space, then the data is too big for buffer if (_buffer.space() == 0) { // Can we send a fake frame? if (_fragmentFrames && _state==State.DATA) { Buffer data =_buffer.get(4*(available/4)); _buffer.compact(); if (_masked) { if (data.array()==null) data=_buffer.asMutableBuffer(); byte[] array = data.array(); final int end=data.putIndex(); for (int i=data.getIndex();i>\n",TypeUtil.toHexString(_flags),TypeUtil.toHexString(_opcode),data.length()); _bytesNeeded-=data.length(); progress=true; _handler.onFrame((byte)(_flags&(0xff^WebSocketConnectionRFC6455.FLAG_FIN)), _opcode, data); _opcode=WebSocketConnectionRFC6455.OP_CONTINUATION; } if (_buffer.space() == 0) throw new IllegalStateException("FULL: "+_state+" "+_bytesNeeded+">"+_buffer.capacity()); } // catch IOExceptions (probably EOF) and try to parse what we have try { filled=_endp.isInputShutdown()?-1:_endp.fill(_buffer); available=_buffer.length(); // System.err.printf(">> filled %d/%d%n",filled,available); if (filled<=0) break; } catch(IOException e) { LOG.debug(e); filled=-1; break; } } // Did we get enough? if (available<(_state==State.SKIP?1:_bytesNeeded)) break; // if we are here, then we have sufficient bytes to process the current state. // Parse the buffer byte by byte (unless it is STATE_DATA) byte b; while (_state!=State.DATA && available>=(_state==State.SKIP?1:_bytesNeeded)) { switch (_state) { case START: _skip=false; _state=_opcode==WebSocketConnectionRFC6455.OP_CLOSE?State.SEEK_EOF:State.OPCODE; _bytesNeeded=_state.getNeeds(); continue; case OPCODE: b=_buffer.get(); available--; _opcode=(byte)(b&0xf); _flags=(byte)(0xf&(b>>4)); if (WebSocketConnectionRFC6455.isControlFrame(_opcode)&&!WebSocketConnectionRFC6455.isLastFrame(_flags)) { LOG.warn("Fragmented Control from "+_endp); _handler.close(WebSocketConnectionRFC6455.CLOSE_PROTOCOL,"Fragmented control"); progress=true; _skip=true; } _state=State.LENGTH_7; _bytesNeeded=_state.getNeeds(); continue; case LENGTH_7: b=_buffer.get(); available--; _masked=(b&0x80)!=0; b=(byte)(0x7f&b); switch(b) { case 0x7f: _length=0; _state=State.LENGTH_63; break; case 0x7e: _length=0; _state=State.LENGTH_16; break; default: _length=(0x7f&b); _state=_masked?State.MASK:State.PAYLOAD; } _bytesNeeded=_state.getNeeds(); continue; case LENGTH_16: b=_buffer.get(); available--; _length = _length*0x100 + (0xff&b); if (--_bytesNeeded==0) { if (_length>_buffer.capacity() && !_fragmentFrames) { progress=true; _handler.close(WebSocketConnectionRFC6455.CLOSE_POLICY_VIOLATION,"frame size "+_length+">"+_buffer.capacity()); _skip=true; } _state=_masked?State.MASK:State.PAYLOAD; _bytesNeeded=_state.getNeeds(); } continue; case LENGTH_63: b=_buffer.get(); available--; _length = _length*0x100 + (0xff&b); if (--_bytesNeeded==0) { _bytesNeeded=(int)_length; if (_length>=_buffer.capacity() && !_fragmentFrames) { progress=true; _handler.close(WebSocketConnectionRFC6455.CLOSE_POLICY_VIOLATION,"frame size "+_length+">"+_buffer.capacity()); _skip=true; } _state=_masked?State.MASK:State.PAYLOAD; _bytesNeeded=_state.getNeeds(); } continue; case MASK: _buffer.get(_mask,0,4); _m=0; available-=4; _state=State.PAYLOAD; _bytesNeeded=_state.getNeeds(); break; case PAYLOAD: _bytesNeeded=(int)_length; _state=_skip?State.SKIP:State.DATA; break; case DATA: break; case SKIP: int skip=Math.min(available,_bytesNeeded); progress=true; _buffer.skip(skip); available-=skip; _bytesNeeded-=skip; if (_bytesNeeded==0) _state=State.START; break; case SEEK_EOF: progress=true; _buffer.skip(available); available=0; break; } } if (_state==State.DATA && available>=_bytesNeeded) { if ( _masked!=_shouldBeMasked) { _buffer.skip(_bytesNeeded); _state=State.START; progress=true; _handler.close(WebSocketConnectionRFC6455.CLOSE_PROTOCOL,"Not masked"); } else { Buffer data =_buffer.get(_bytesNeeded); if (_masked) { if (data.array()==null) data=_buffer.asMutableBuffer(); byte[] array = data.array(); final int end=data.putIndex(); for (int i=data.getIndex();i>\n",TypeUtil.toHexString(_flags),TypeUtil.toHexString(_opcode),data.length()); progress=true; _handler.onFrame(_flags, _opcode, data); _bytesNeeded=0; _state=State.START; } break; } } return progress?1:filled; } /* ------------------------------------------------------------ */ public void fill(Buffer buffer) { if (buffer!=null && buffer.length()>0) { if (_buffer==null) _buffer=_buffers.getBuffer(); _buffer.put(buffer); buffer.clear(); } } /* ------------------------------------------------------------ */ public void returnBuffer() { if (_buffer!=null && _buffer.length()==0) { _buffers.returnBuffer(_buffer); _buffer=null; } } /* ------------------------------------------------------------ */ @Override public String toString() { return String.format("%s@%x state=%s buffer=%s", getClass().getSimpleName(), hashCode(), _state, _buffer); } }java-http-client-2.2.2/src/test/000077500000000000000000000000001406526542100164425ustar00rootroot00000000000000java-http-client-2.2.2/src/test/java/000077500000000000000000000000001406526542100173635ustar00rootroot00000000000000java-http-client-2.2.2/src/test/java/com/000077500000000000000000000000001406526542100201415ustar00rootroot00000000000000java-http-client-2.2.2/src/test/java/com/softwareverde/000077500000000000000000000000001406526542100230215ustar00rootroot00000000000000java-http-client-2.2.2/src/test/java/com/softwareverde/http/000077500000000000000000000000001406526542100240005ustar00rootroot00000000000000java-http-client-2.2.2/src/test/java/com/softwareverde/http/v2/000077500000000000000000000000001406526542100243275ustar00rootroot00000000000000java-http-client-2.2.2/src/test/java/com/softwareverde/http/v2/HttpRequestTests.java000066400000000000000000000024531406526542100305110ustar00rootroot00000000000000package com.softwareverde.http.v2; import com.softwareverde.http.HttpMethod; import com.softwareverde.http.HttpRequest; import com.softwareverde.http.HttpResponse; import com.softwareverde.util.Container; import org.junit.Assert; import org.junit.Test; public class HttpRequestTests { @Test public void should_cancel_request() throws Exception { // Setup final Container responseContainer = new Container<>(); final HttpRequest httpRequest = new HttpRequest(); httpRequest.setMethod(HttpMethod.GET); httpRequest.setUrl("https://speed.hetzner.de/100MB.bin"); final Object pin = new Object(); // Action (new Thread(new Runnable() { @Override public void run() { try { responseContainer.value = httpRequest.execute(); } finally { synchronized (pin) { pin.notifyAll(); } } } })).start(); Thread.sleep(500L); Assert.assertTrue(httpRequest.isExecuting()); httpRequest.cancel(); synchronized (pin) { pin.wait(); } // Assert Assert.assertNull(responseContainer.value); } }