[0001]
[0002]
[0003]
[0004]
[0005]
[0006]
[0007]
[0008]
[0009]
[0010]
[0011]
[0012]
[0013]
[0014]
[0015]
[0016]
[0017]
[0018]
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
[0033]
[0034]
[0035]
[0036]
[0037]
[0038]
[0039]
[0040]
[0041]
[0042]
[0043]
[0044]
[0045]
[0046]
[0047]
[0048]
[0049]
[0050]
[0051]
[0052]
[0053]
[0054]
[0055]
[0056]
[0057]
[0058]
[0059]
[0060]
[0061]
[0062]
[0063]
[0064]
[0065]
[0066]
[0067]
[0068]
[0069]
[0070]
[0071]
[0072]
[0073]
[0074]
[0075]
[0076]
[0077]
[0078]
[0079]
[0080]
[0081]
[0082]
[0083]
[0084]
[0085]
[0086]
[0087]
[0088]
[0089]
[0090]
[0091]
[0092]
[0093]
[0094]
[0095]
[0096]
[0097]
[0098]
[0099]
[0100]
[0101]
[0102]
[0103]
[0104]
[0105]
[0106]
[0107]
[0108]
[0109]
[0110]
[0111]
[0112]
[0113]
[0114]
[0115]
[0116]
[0117]
[0118]
[0119]
[0120]
[0121]
[0122]
[0123]
[0124]
[0125]
[0126]
[0127]
[0128]
[0129]
[0130]
[0131]
[0132]
[0133]
[0134]
[0135]
[0136]
[0137]
[0138]
[0139]
[0140]
[0141]
[0142]
[0143]
[0144]
[0145]
[0146]
[0147]
[0148]
[0149]
[0150]
[0151]
[0152]
[0153]
[0154]
[0155]
[0156]
[0157]
[0158]
[0159]
[0160]
[0161]
[0162]
[0163]
[0164]
[0165]
[0166]
[0167]
[0168]
[0169]
[0170]
[0171]
[0172]
[0173]
[0174]
[0175]
[0176]
[0177]
[0178]
[0179]
[0180]
[0181]
[0182]
[0183]
[0184]
[0185]
[0186]
[0187]
[0188]
[0189]
[0190]
[0191]
[0192]
[0193]
[0194]
[0195]
[0196]
[0197]
[0198]
[0199]
[0200]
[0201]
[0202]
[0203]
[0204]
[0205]
[0206]
[0207]
[0208]
[0209]
[0210]
[0211]
[0212]
[0213]
[0214]
[0215]
[0216]
[0217]
[0218]
[0219]
[0220]
[0221]
[0222]
[0223]
[0224]
[0225]
[0226]
[0227]
[0228]
[0229]
[0230]
[0231]
[0232]
[0233]
[0234]
[0235]
[0236]
[0237]
[0238]
[0239]
[0240]
[0241]
[0242]
[0243]
[0244]
[0245]
[0246]
[0247]
[0248]
[0249]
[0250]
[0251]
[0252]
[0253]
[0254]
[0255]
[0256]
[0257]
[0258]
[0259]
[0260]
[0261]
[0262]
[0263]
[0264]
[0265]
[0266]
[0267]
[0268]
[0269]
[0270]
[0271]
[0272]
[0273]
[0274]
[0275]
[0276]
[0277]
[0278]
[0279]
[0280]
[0281]
[0282]
[0283]
[0284]
[0285]
[0286]
[0287]
[0288]
[0289]
[0290]
[0291]
[0292]
[0293]
[0294]
[0295]
[0296]
[0297]
[0298]
[0299]
[0300]
[0301]
[0302]
[0303]
[0304]
[0305]
[0306]
[0307]
[0308]
[0309]
[0310]
[0311]
[0312]
[0313]
[0314]
[0315]
[0316]
[0317]
[0318]
[0319]
[0320]
[0321]
[0322]
[0323]
[0324]
[0325]
[0326]
[0327]
[0328]
[0329]
[0330]
[0331]
[0332]
[0333]
[0334]
[0335]
[0336]
[0337]
[0338]
[0339]
[0340]
[0341]
[0342]
[0343]
[0344]
[0345]
[0346]
[0347]
[0348]
[0349]
[0350]
[0351]
[0352]
[0353]
[0354]
[0355]
[0356]
[0357]
[0358]
[0359]
[0360]
[0361]
[0362]
[0363]
[0364]
[0365]
[0366]
[0367]
[0368]
[0369]
[0370]
[0371]
[0372]
[0373]
[0374]
[0375]
[0376]
[0377]
[0378]
[0379]
[0380]
[0381]
[0382]
[0383]
[0384]
[0385]
[0386]
[0387]
[0388]
[0389]
[0390]
[0391]
[0392]
[0393]
[0394]
[0395]
[0396]
[0397]
[0398]
[0399]
[0400]
[0401]
[0402]
[0403]
[0404]
[0405]
[0406]
[0407]
[0408]
[0409]
[0410]
[0411]
[0412]
[0413]
[0414]
[0415]
[0416]
[0417]
[0418]
[0419]
[0420]
[0421]
[0422]
[0423]
[0424]
[0425]
[0426]
[0427]
[0428]
[0429]
[0430]
[0431]
[0432]
[0433]
[0434]
[0435]
[0436]
[0437]
[0438]
[0439]
[0440]
[0441]
[0442]
[0443]
[0444]
[0445]
[0446]
[0447]
[0448]
[0449]
[0450]
[0451]
[0452]
[0453]
[0454]
[0455]
[0456]
[0457]
[0458]
[0459]
[0460]
[0461]
[0462]
[0463]
[0464]
[0465]
[0466]
[0467]
[0468]
[0469]
[0470]
[0471]
[0472]
[0473]
[0474]
[0475]
[0476]
[0477]
[0478]
[0479]
[0480]
[0481]
[0482]
[0483]
[0484]
[0485]
[0486]
[0487]
[0488]
[0489]
[0490]
[0491]
[0492]
[0493]
[0494]
[0495]
[0496]
[0497]
[0498]
[0499]
[0500]
[0501]
[0502]
[0503]
[0504]
[0505]
[0506]
[0507]
[0508]
[0509]
[0510]
[0511]
[0512]
[0513]
[0514]
[0515]
[0516]
[0517]
[0518]
[0519]
[0520]
[0521]
[0522]
[0523]
[0524]
[0525]
[0526]
[0527]
[0528]
[0529]
[0530]
[0531]
[0532]
[0533]
[0534]
[0535]
[0536]
[0537]
[0538]
[0539]
[0540]
[0541]
[0542]
[0543]
[0544]
[0545]
[0546]
[0547]
[0548]
[0549]
[0550]
[0551]
[0552]
[0553]
[0554]
[0555]
[0556]
[0557]
[0558]
[0559]
[0560]
[0561]
[0562]
[0563]
[0564]
[0565]
[0566]
[0567]
[0568]
[0569]
[0570]
[0571]
[0572]
[0573]
[0574]
[0575]
[0576]
[0577]
[0578]
[0579]
[0580]
[0581]
[0582]
[0583]
[0584]
[0585]
[0586]
[0587]
[0588]
[0589]
[0590]
[0591]
[0592]
[0593]
[0594]
[0595]
[0596]
[0597]
[0598]
[0599]
[0600]
[0601]
[0602]
[0603]
[0604]
[0605]
[0606]
[0607]
[0608]
[0609]
[0610]
[0611]
[0612]
[0613]
[0614]
[0615]
[0616]
[0617]
[0618]
[0619]
[0620]
[0621]
[0622]
[0623]
[0624]
[0625]
[0626]
[0627]
[0628]
[0629]
[0630]
[0631]
[0632]
[0633]
[0634]
[0635]
[0636]
[0637]
[0638]
[0639]
[0640]
[0641]
[0642]
[0643]
[0644]
[0645]
[0646]
[0647]
[0648]
[0649]
[0650]
[0651]
[0652]
[0653]
[0654]
[0655]
[0656]
[0657]
[0658]
[0659]
[0660]
[0661]
[0662]
[0663]
[0664]
[0665]
[0666]
[0667]
[0668]
[0669]
[0670]
[0671]
[0672]
[0673]
[0674]
[0675]
[0676]
[0677]
[0678]
[0679]
[0680]
[0681]
[0682]
[0683]
[0684]
[0685]
[0686]
[0687]
[0688]
[0689]
[0690]
[0691]
[0692]
[0693]
[0694]
[0695]
[0696]
[0697]
[0698]
[0699]
[0700]
[0701]
[0702]
[0703]
[0704]
[0705]
[0706]
[0707]
[0708]
[0709]
[0710]
[0711]
[0712]
[0713]
[0714]
[0715]
[0716]
[0717]
[0718]
[0719]
[0720]
[0721]
[0722]
[0723]
[0724]
[0725]
[0726]
[0727]
[0728]
[0729]
[0730]
[0731]
[0732]
[0733]
[0734]
[0735]
[0736]
[0737]
[0738]
[0739]
[0740]
[0741]
[0742]
[0743]
[0744]
[0745]
[0746]
[0747]
[0748]
[0749]
[0750]
[0751]
[0752]
[0753]
[0754]
[0755]
[0756]
[0757]
[0758]
[0759]
[0760]
[0761]
[0762]
[0763]
[0764]
[0765]
[0766]
[0767]
[0768]
[0769]
[0770]
[0771]
[0772]
[0773]
[0774]
[0775]
[0776]
[0777]
[0778]
[0779]
[0780]
[0781]
[0782]
[0783]
[0784]
[0785]
[0786]
[0787]
[0788]
[0789]
[0790]
[0791]
[0792]
[0793]
[0794]
[0795]
[0796]
[0797]
[0798]
[0799]
[0800]
[0801]
[0802]
[0803]
[0804]
[0805]
[0806]
[0807]
[0808]
[0809]
[0810]
[0811]
[0812]
[0813]
[0814]
[0815]
[0816]
[0817]
[0818]
[0819]
[0820]
[0821]
[0822]
[0823]
[0824]
[0825]
[0826]
[0827]
[0828]
[0829]
[0830]
[0831]
[0832]
[0833]
[0834]
[0835]
[0836]
[0837]
[0838]
[0839]
[0840]
[0841]
[0842]
[0843]
[0844]
[0845]
[0846]
[0847]
[0848]
[0849]
[0850]
[0851]
[0852]
[0853]
[0854]
[0855]
[0856]
[0857]
[0858]
[0859]
[0860]
[0861]
[0862]
[0863]
[0864]
[0865]
[0866]
[0867]
[0868]
[0869]
[0870]
[0871]
[0872]
[0873]
[0874]
[0875]
[0876]
[0877]
[0878]
[0879]
[0880]
[0881]
[0882]
[0883]
[0884]
[0885]
[0886]
[0887]
[0888]
[0889]
[0890]
[0891]
[0892]
[0893]
[0894]
[0895]
[0896]
[0897]
[0898]
[0899]
[0900]
[0901]
[0902]
[0903]
[0904]
[0905]
[0906]
[0907]
[0908]
[0909]
[0910]
[0911]
[0912]
[0913]
[0914]
[0915]
[0916]
[0917]
[0918]
[0919]
[0920]
[0921]
[0922]
[0923]
[0924]
[0925]
[0926]
[0927]
[0928]
[0929]
[0930]
[0931]
[0932]
[0933]
[0934]
[0935]
[0936]
[0937]
[0938]
[0939]
[0940]
[0941]
[0942]
[0943]
[0944]
[0945]
[0946]
[0947]
[0948]
[0949]
[0950]
[0951]
[0952]
[0953]
[0954]
[0955]
[0956]
[0957]
[0958]
[0959]
[0960]
[0961]
[0962]
[0963]
[0964]
[0965]
[0966]
[0967]
[0968]
[0969]
[0970]
[0971]
[0972]
[0973]
[0974]
[0975]
[0976]
[0977]
[0978]
[0979]
[0980]
[0981]
[0982]
[0983]
[0984]
[0985]
[0986]
[0987]
[0988]
[0989]
[0990]
[0991]
[0992]
[0993]
[0994]
[0995]
[0996]
[0997]
[0998]
[0999]
[1000]
[1001]
[1002]
[1003]
[1004]
[1005]
[1006]
[1007]
[1008]
[1009]
[1010]
[1011]
[1012]
[1013]
[1014]
[1015]
[1016]
[1017]
[1018]
[1019]
[1020]
[1021]
[1022]
[1023]
[1024]
[1025]
[1026]
[1027]
[1028]
[1029]
[1030]
[1031]
[1032]
[1033]
[1034]
[1035]
[1036]
[1037]
[1038]
[1039]
[1040]
[1041]
[1042]
[1043]
[1044]
[1045]
[1046]
[1047]
[1048]
[1049]
[1050]
[1051]
[1052]
[1053]
[1054]
[1055]
[1056]
[1057]
[1058]
[1059]
[1060]
[1061]
[1062]
[1063]
[1064]
[1065]
[1066]
[1067]
[1068]
[1069]
[1070]
[1071]
[1072]
[1073]
[1074]
[1075]
[1076]
[1077]
[1078]
[1079]
[1080]
[1081]
[1082]
[1083]
[1084]
[1085]
[1086]
[1087]
[1088]
[1089]
[1090]
[1091]
[1092]
[1093]
[1094]
[1095]
[1096]
[1097]
[1098]
[1099]
[1100]
[1101]
[1102]
[1103]
[1104]
[1105]
[1106]
[1107]
[1108]
[1109]
[1110]
[1111]
[1112]
[1113]
[1114]
[1115]
[1116]
[1117]
[1118]
[1119]
[1120]
[1121]
[1122]
[1123]
[1124]
[1125]
[1126]
[1127]
[1128]
[1129]
[1130]
[1131]
[1132]
[1133]
[1134]
[1135]
[1136]
[1137]
[1138]
[1139]
[1140]
[1141]
[1142]
[1143]
[1144]
[1145]
[1146]
[1147]
[1148]
[1149]
[1150]
[1151]
[1152]
[1153]
[1154]
[1155]
[1156]
[1157]
[1158]
[1159]
[1160]
[1161]
[1162]
[1163]
[1164]
[1165]
[1166]
[1167]
[1168]
[1169]
[1170]
[1171]
[1172]
[1173]
[1174]
[1175]
[1176]
[1177]
[1178]
[1179]
[1180]
[1181]
[1182]
[1183]
[1184]
[1185]
[1186]
[1187]
[1188]
[1189]
[1190]
[1191]
[1192]
[1193]
[1194]
[1195]
[1196]
[1197]
[1198]
[1199]
[1200]
[1201]
[1202]
[1203]
[1204]
[1205]
[1206]
[1207]
[1208]
[1209]
[1210]
[1211]
[1212]
[1213]
[1214]
[1215]
[1216]
[1217]
[1218]
[1219]
[1220]
[1221]
[1222]
[1223]
[1224]
[1225]
[1226]
[1227]
[1228]
[1229]
/*****************************************************************************/
/*
HTTP2request.c
Conjure up a request structure, populate the dictionary with its request
headers, supply it with a request body if required, execute the request,
populate the (HTTP/2) response header with response header fields and then
run-down the request. There are obviously life-cycle parallels with its
companion HTTP/1.1 processing.
VERSION HISTORY
---------------
17-AUG-2020 MGD Http2RequestData() reduce memory consumption
09-AUG-2020 MGD bugfix; Http2RequestCancel() cancel and abort
29-JUN-2020 MGD bugfix; Http2RequestData() flow control
06-FEB-2020 MGD Http2RequestData() reworked from list to simple buffer
31-JAN-2020 MGD fiddle with the code (perhaps optimisations, even bugfixes)
18-JAN-2019 MGD status code 418 (teapot) forces connection drop
to bugfix; Http2RequestEnd() copy tally rx/tx to request
20-APR-2018 MGD bugfix; Http2RequestDictHeader() keep accounting abreast
12-MAR-2018 MGD refactor Http2RequestCancel() into Http2RequestCancelRead()
and Http2RequestCancelWrite()
23-DEC-2017 MGD bugfix; window update and flow control management
15-MAR-2017 MGD bugfix; Http2RequestEnd() end-of-request (control) frame
independent of request itself
06-AUG-2016 MGD Http2RequestBegin() ensure stream ident not reused
bugfix; Http2RequestData() always deliver via NetIoReadAst()
16-AUG-2015 MGD initial
*/
/*****************************************************************************/
#ifdef WASD_VMS_V7
# undef __VMS_VER
# define __VMS_VER 70000000
# undef __CRTL_VER
# define __CRTL_VER 70000000
#else
# ifdef WASD_VMS_V7
# undef _VMS__V6__SOURCE
# define _VMS__V6__SOURCE
# undef __VMS_VER
# define __VMS_VER 70000000
# undef __CRTL_VER
# define __CRTL_VER 70000000
# endif
#endif
#include <stdio.h>
#include <ctype.h>
#include "wasd.h"
#include "hpack.h"
#define WASD_MODULE "HTTP2REQUEST"
/******************/
/* global storage */
/******************/
/********************/
/* external storage */
/********************/
extern BOOL HttpdTicking,
NetCurrentProcessing;
extern const int64 Delta01Sec;
extern int ConnectCountTotal,
HttpdTickSecond,
NetReadBufferSize;
extern int ToLowerCase[],
ToUpperCase[];
extern char ErrorSanityCheck[];
#define acptr AccountingPtr
extern ACCOUNTING_STRUCT *AccountingPtr;
extern CONFIG_STRUCT Config;
extern HTTPD_GBLSEC *HttpdGblSecPtr;
extern LIST_HEAD RequestList;
extern WATCH_STRUCT Watch;
/*****************************************************************************/
/*
A HEADERS frame has been received from the client and HpackProcess() calls
this function to initiate request processing. There are obvious parallels
between the processing in this and Http2RequestBegin2(), and in RequestBegin().
*/
REQUEST_STRUCT* Http2RequestBegin
(
HTTP2_STRUCT *h2ptr,
uint ident
)
{
REQUEST_STRUCT *rqptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (h2ptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_MOD_HTTP2,
"Http2RequestBegin()");
if (h2ptr->NetIoPtr->VmsStatus)
{
/* refuse streams on a connection with an explicit status */
if (WATCHING (h2ptr, WATCH_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_HTTP2, "HTTP/2 status !&S",
h2ptr->NetIoPtr->VmsStatus);
return (NULL);
}
if (h2ptr->GoAwayLastStreamIdent)
{
/* refuse streams on a connection told to goaway! */
if (WATCHING (h2ptr, WATCH_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_HTTP2, "HTTP/2 goaway ident !UL",
h2ptr->GoAwayLastStreamIdent);
return (NULL);
}
if (LIST_GET_COUNT (&h2ptr->StreamList) > h2ptr->ServerMaxConcStreams)
{
/* refuse streams exceeding the connection maximum */
if (WATCHING (h2ptr, WATCH_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_HTTP2, "HTTP/2 stream exceeds !UL",
h2ptr->ServerMaxConcStreams);
return (NULL);
}
if (ident <= h2ptr->LastStreamIdent)
{
/* refuse a stream ident that is less than that already established */
if (WATCHING (h2ptr, WATCH_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_HTTP2,
"HTTP/2 stream !UL less than !UL",
ident, h2ptr->LastStreamIdent);
return (NULL);
}
/* note the most recent stream ident */
h2ptr->LastStreamIdent = ident;
/* create a request structure */
rqptr = VmGetRequest (++ConnectCountTotal);
/* add entry to the top of the request list */
ListAddHead (&RequestList, rqptr, LIST_ENTRY_TYPE_REQUEST);
/* timestamp the request */
sys$gettim (&rqptr->rqTime.BeginTime64);
sys$numtim (&rqptr->rqTime.BeginTime7, &rqptr->rqTime.BeginTime64);
HttpGmTimeString (rqptr->rqTime.GmDateTime, &rqptr->rqTime.BeginTime64);
Http2RequestBegin2 (rqptr, h2ptr, ident);
return (rqptr);
}
/*****************************************************************************/
/*
Take the the supplied request and attach it to the supplied HTTP/2 stream.
Called from Http2RequestBegin() and Http2SwitchResponse().
*/
void Http2RequestBegin2
(
REQUEST_STRUCT *rqptr,
HTTP2_STRUCT *h2ptr,
uint ident
)
{
HTTP2_STREAM_STRUCT *s2ptr;
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (h2ptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_MOD_HTTP2, "Http2RequestBegin2()");
rqptr->NetworkHttp = 2;
rqptr->RequestState = REQUEST_STATE_HEADER;
#if SESOLA_MEMORY
SesolaMemoryControl (-1, FI_LI);
#endif SESOLA_MEMORY
/* create network I/O structure (see NetIoBegin()) */
ioptr = VmGet (sizeof(NETIO_STRUCT));
/* populate request structure */
rqptr->NetIoPtr = ioptr;
rqptr->ClientPtr = h2ptr->ClientPtr;
rqptr->ServicePtr = h2ptr->ServicePtr;
rqptr->rqDictPtr = DictCreate (rqptr, -1);
/* add request (stream) to HTTP/2 list and populate stream structure */
s2ptr = &rqptr->Http2Stream;
ListAddHead (&h2ptr->StreamList, s2ptr, LIST_ENTRY_TYPE_REQUEST);
s2ptr->RequestPtr = rqptr;
s2ptr->Http2Ptr = h2ptr;
s2ptr->Ident = ident;
/* WASD streams start open, never idle */
s2ptr->State = HTTP2_STATE_OPEN;
/* populate network I/O structure (see NetAccept()) */
ioptr->ClientPtr = h2ptr->ClientPtr;
ioptr->ServicePtr = h2ptr->ServicePtr;
ioptr->Http2StreamPtr = s2ptr;
if (Watch.Category && Watch.Category != WATCH_ONE_SHOT_CAT)
if (Watch.FilterSet)
{
WatchFilterHttpProtocol (rqptr);
WatchFilterClientService (rqptr);
}
else
WatchSetWatch (rqptr, WATCH_NEW_ITEM);
else
if (h2ptr->WatchItem & WATCH_ITEM_HTTP2_FLAG)
WatchSetWatch (rqptr, WATCH_NEW_ITEM);
/* set the initial stream flow-control window size */
s2ptr->ReadWindowSize = h2ptr->ServerInitialWindowSize;
s2ptr->WriteWindowSize = h2ptr->WriteWindowSize;
/* inform the client of this */
Http2WindowUpdate (h2ptr, s2ptr->Ident, s2ptr->ReadWindowSize, NULL, 0);
/* if WATCHing HTTP/2 get a ping from the client to measure RTT */
if (WATCHMOD (h2ptr, WATCH_MOD_HTTP2))
Http2Ping (h2ptr, 0, NULL, 0);
h2ptr->RequestCount++;
h2ptr->RequestCurrent++;
if (h2ptr->RequestCurrent > h2ptr->RequestPeak)
h2ptr->RequestPeak = h2ptr->RequestCurrent;
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
acptr->Http2RequestCount++;
if (h2ptr->RequestPeak > acptr->Http2RequestPeak)
acptr->Http2RequestPeak = h2ptr->RequestPeak;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
/* if it's not already running kick-off the HTTPd ticker */
if (!HttpdTicking) HttpdTick (0);
if (WATCHMOD (h2ptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_MOD_HTTP2, "streams: !UL",
LIST_GET_COUNT (&h2ptr->StreamList));
}
/*****************************************************************************/
/*
After the header has been placed in the dictionary continue processing the
request. Parallels processing performed in RequestParseHttp().
When moving from WATCH report generation back to the WATCH selection request
processing needs to be delayed to allow the WATCHing request to receive the
RST_STREAM frame and shut down WATCHing. Otherwise the HTTP/2 WATCH rabbit
hole interferes with the new request because the previous request often hasn't
yet concluded WATCHing due to frame multiplex ordering and/or transmission
latency. This small delay is obvious to the user.
*/
void Http2RequestProcess (REQUEST_STRUCT *rqptr)
{
int status;
ushort slen;
char string [32];
DICT_ENTRY_STRUCT *denptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_HTTP2))
WatchThis (WATCHALL, WATCH_MOD_HTTP2, "Http2RequestProcess()");
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
NetUpdateProcessing (rqptr, +1);
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
if (Watch.Category && Watch.Category != WATCH_ONE_SHOT_CAT)
WatchFilterRequestHeader (rqptr);
if (rqptr->Http2Stream.Http2Ptr->PingMicroSeconds)
{
FaoToBuffer (string, sizeof(string), &slen, "!UL.!3ZL",
rqptr->Http2Stream.Http2Ptr->PingMicroSeconds / 1000,
rqptr->Http2Stream.Http2Ptr->PingMicroSeconds % 1000);
DictInsert (rqptr->rqDictPtr, DICT_TYPE_INTERNAL,
"http2_ping", 10, string, slen);
}
if (WATCHING (rqptr, WATCH_CONNECT))
WatchThis (WATCHITM(rqptr), WATCH_CONNECT,
"HTTP/2 begin !UL with !AZ,!UL",
rqptr->Http2Stream.Ident,
rqptr->ClientPtr->Lookup.HostName,
rqptr->ClientPtr->IpPort);
if (WATCHING (rqptr, WATCH_REQUEST))
if (!rqptr->rqHeader.WatchNewRequest)
{
rqptr->rqHeader.WatchNewRequest = true;
WatchDataFormatted ("|!#*+\n", 38 + Watch.ItemDigits);
}
if (WATCHING (rqptr, WATCH_REQUEST_HEADER))
if (denptr = RequestDictHeader (rqptr))
{
WatchThis (WATCHITM(rqptr), WATCH_REQUEST_HEADER,
"HEADER !UL bytes", DICT_GET_VALUE_LEN(denptr));
WatchData (DICT_GET_VALUE(denptr), DICT_GET_VALUE_LEN(denptr));
}
if (Watch.RequestPtr &&
Watch.RequestPtr->Http2Stream.Http2Ptr &&
Watch.RequestPtr->Http2Stream.Http2Ptr == rqptr->Http2Stream.Http2Ptr)
{
/* delay request processing when WATCHing on same HTTP/2 connection */
status = sys$setimr (0, &Delta01Sec,
RequestParseDictionary, rqptr, 0);
if (VMSnok (status)) ErrorExitVmsStatus (status, NULL, FI_LI);
}
else
RequestParseDictionary (rqptr);
}
/*****************************************************************************/
/*
Request body PUTed or POSTed by the client.
A simple, single buffer space is used, with additional data appended to any
existing and with partial reads causing the content to be moved down to fill
what's been read. Client data is not buffered if a read I/O with sufficient
space is already queued.
LOTS of memory copying :-{
The client supplying request body data and the server consuming that data are
completely asynchronous. As a result client data can arrive before a request
has attempted to read it (and need to be stored) or after the server initiated
a read. Looking at it the other way, the server can attempt to read data that
hasn't yet been sent by the client (and need to wait for it), or attempt to
read data that has already been received from the client (and been stored).
In addition the request needs to be notified when the data is exhausted
(ENDOFILE).
*/
int Http2RequestData
(
HTTP2_STRUCT *h2ptr,
uint flags,
uint ident,
uchar *BufferPtr,
uint BufferLength
)
{
uint drlength, drsize, padlen, status,
DataLength;
uchar *bptr, *drptr;
HTTP2_STREAM_STRUCT *s2ptr;
NETIO_STRUCT *ioptr;
REQUEST_STRUCT *rqeptr;
/*********/
/* begin */
/*********/
if (WATCH_MODULE(WATCH_MOD_HTTP2))
WatchThis (WATCHALL, WATCH_MOD_HTTP2, "Http2RequestData() !AZ !SL !UL",
BufferPtr ? "DATA" : "REQUEST", BufferPtr, BufferLength);
/* locate the request corresponding to the stream */
for (s2ptr = LIST_GET_HEAD(&h2ptr->StreamList);
s2ptr != NULL;
s2ptr = LIST_GET_NEXT(s2ptr))
{
rqeptr = (REQUEST_STRUCT*)s2ptr->RequestPtr;
if (rqeptr->Http2Stream.Ident == ident) break;
}
if (s2ptr == NULL)
{
if (BufferPtr)
{
/* request shutdown while data in transit? */
return (SS$_CANCEL);
}
/* must be a stream (request) with that ident */
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
/* ensure it looks reset (to start with) */
ioptr = rqeptr->NetIoPtr;
ioptr->ReadIOsb.Count = 0;
ioptr->ReadIOsb.Status = 0;
if (BufferPtr == (void*)-1)
{
/**************/
/* cancel I/O */
/**************/
if (WATCH_MODULE(WATCH_MOD_HTTP2))
WatchThis (WATCHALL, WATCH_MOD_HTTP2, "!&A !&S",
ioptr->ReadAstFunction, ioptr->VmsStatus);
/* remove any previously received and buffered data */
if (s2ptr->DataReadPtr)
{
/* REQUEST MEMORY! */
VmFreeFromHeap (rqeptr, s2ptr->DataReadPtr, FI_LI);
s2ptr->DataReadPtr = NULL;
s2ptr->DataReadLength = s2ptr->DataReadSize = 0;
}
if (ioptr->ReadAstFunction)
{
/* request already waiting */
if (ioptr->VmsStatus)
ioptr->ReadIOsb.Status = ioptr->VmsStatus;
else
ioptr->ReadIOsb.Status = SS$_CANCEL;
/* deliver via the NETIO AST delivery decoupler */
NetIoReadAst (ioptr);
}
return (ioptr->ReadIOsb.Status);
}
/* data received buffer */
drptr = s2ptr->DataReadPtr;
drsize = s2ptr->DataReadSize;
drlength = s2ptr->DataReadLength;
if (bptr = BufferPtr)
{
/***************/
/* client data */
/***************/
/* client data being made available */
if (flags & HTTP2_FLAG_DATA_PADDED)
{
HTTP2_GET_8 (bptr, padlen);
DataLength = BufferLength - padlen - 1;
}
else
DataLength = BufferLength;
/* keep the request accounting representative */
ioptr->BlocksRawRx64++;
ioptr->BlocksTallyRx64++;
ioptr->BytesRawRx64 += DataLength;
ioptr->BytesTallyRx64 += DataLength;
if (WATCH_MODULE(WATCH_MOD_HTTP2))
WatchThis (WATCHALL, WATCH_MOD_HTTP2,
"length:!UL size:!UL eof:!&B request:!&B",
DataLength, ioptr->ReadSize,
flags & HTTP2_FLAG_DATA_END_STR,
ioptr->ReadAstFunction);
/****************/
/* flow control */
/****************/
/* stream */
s2ptr->ReadWindowSize -= DataLength;
/* HTTP/2 connection */
h2ptr->ReadWindowSize -= DataLength;
if (h2ptr->ReadWindowSize <= 0)
{
h2ptr->ReadWindowSize = h2ptr->ServerInitialWindowSize *
h2ptr->ServerMaxConcStreams;
Http2WindowUpdate (h2ptr, 0, h2ptr->ReadWindowSize, NULL, 0);
}
if (ioptr->ReadAstFunction)
{
/***************************/
/* request already waiting */
/***************************/
if (WATCH_MODULE(WATCH_MOD_HTTP2))
WatchThis (WATCHALL, WATCH_MOD_HTTP2, "length:!UL size:!UL",
DataLength, ioptr->ReadSize);
if (!drlength)
{
/****************************/
/* no data already buffered */
/****************************/
if (DataLength <= ioptr->ReadSize)
{
/***********************************/
/* data can fit into the I/O space */
/***********************************/
ioptr->ReadIOsb.Status = SS$_NORMAL;
ioptr->ReadIOsb.Count = DataLength;
memcpy (ioptr->ReadPtr, bptr, DataLength);
NetIoReadAst (ioptr);
/* if window needs update */
if (s2ptr->ReadWindowSize <= 0)
{
s2ptr->ReadWindowSize = h2ptr->ServerInitialWindowSize;
Http2WindowUpdate (h2ptr, s2ptr->Ident,
s2ptr->ReadWindowSize, NULL, 0);
}
return (ioptr->ReadIOsb.Status);
}
}
}
if (DataLength)
{
/**************************/
/* buffer REQUEST MEMORY! */
/**************************/
if (!drsize)
{
/* fresh buffer */
drsize = h2ptr->ServerInitialWindowSize;
drptr = VmGetHeap (rqeptr, drsize);
}
else
if (drlength + DataLength > drsize)
{
/* insufficient space in current buffer */
drsize += h2ptr->ServerInitialWindowSize;
drptr = VmReallocHeap (rqeptr, drptr, drsize, FI_LI);
}
if (WATCHING (h2ptr, WATCH_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_HTTP2,
"BUFFER !UL !UL/!UL", DataLength, drlength, drsize);
memcpy (drptr + drlength, bptr, DataLength);
drlength += DataLength;
s2ptr->DataReadPtr = drptr;
s2ptr->DataReadSize = drsize;
s2ptr->DataReadLength = drlength;
}
if (DataLength)
{
/*******************/
/* still possible? */
/*******************/
/* half-closed local can still receive frames (RFC7540 5.1) */
if (s2ptr->State == HTTP2_STATE_CLOSED ||
s2ptr->State == HTTP2_STATE_CLOSED_REM) return (0);
/****************/
/* flow control */
/****************/
/* stream */
s2ptr->ReadWindowSize -= DataLength;
/* HTTP/2 connection */
h2ptr->ReadWindowSize -= DataLength;
if (h2ptr->ReadWindowSize <= 0)
{
h2ptr->ReadWindowSize = h2ptr->ServerInitialWindowSize *
h2ptr->ServerMaxConcStreams;
Http2WindowUpdate (h2ptr, 0, h2ptr->ReadWindowSize, NULL, 0);
}
}
if (flags & HTTP2_FLAG_DATA_END_STR)
s2ptr->State = HTTP2_STATE_CLOSED_REM;
/* if not a request already waiting */
if (!ioptr->ReadAstFunction) return (ioptr->ReadIOsb.Status);
/* otherwise drop through to partially fill the I/O */
}
/***********/
/* request */
/***********/
/* request looking for data (called from Http2NetRead()) */
if (drlength)
{
/* there is buffered data */
ioptr->ReadIOsb.Status = SS$_NORMAL;
if (drlength <= ioptr->ReadSize)
ioptr->ReadIOsb.Count = drlength;
else
ioptr->ReadIOsb.Count = ioptr->ReadSize;
memcpy (ioptr->ReadPtr, drptr, ioptr->ReadIOsb.Count);
s2ptr->DataReadLength -= ioptr->ReadIOsb.Count;
if (s2ptr->DataReadLength)
{
/* inefficient but straightforward - shuffle it down */
memmove (drptr,
drptr + ioptr->ReadIOsb.Count,
drlength - ioptr->ReadIOsb.Count);
}
if (WATCHING (h2ptr, WATCH_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_HTTP2, "UNBUFFER !UL !UL/!UL",
ioptr->ReadIOsb.Count, drlength, drsize);
/* if all the data has been read and the window needs update */
if (!s2ptr->DataReadLength && s2ptr->ReadWindowSize <= 0)
{
s2ptr->ReadWindowSize = h2ptr->ServerInitialWindowSize;
Http2WindowUpdate (h2ptr, s2ptr->Ident, s2ptr->ReadWindowSize, NULL, 0);
}
NetIoReadAst (ioptr);
return (ioptr->ReadIOsb.Status);
}
if (h2ptr->NetIoPtr->VmsStatus)
{
/* HTTP/2 connection (error) status */
ioptr->ReadIOsb.Status = h2ptr->NetIoPtr->VmsStatus;
NetIoReadAst (ioptr);
}
else
if (ioptr->VmsStatus)
{
/* commonly SS$_CANCEL */
ioptr->ReadIOsb.Status = ioptr->VmsStatus;
NetIoReadAst (ioptr);
}
else
if (s2ptr->State == HTTP2_STATE_CLOSED ||
s2ptr->State == HTTP2_STATE_CLOSED_LOC ||
s2ptr->State == HTTP2_STATE_CLOSED_REM)
{
ioptr->ReadIOsb.Status = SS$_ENDOFFILE;
NetIoReadAst (ioptr);
}
return (ioptr->ReadIOsb.Status);
}
/*****************************************************************************/
/*
Cancel any outstanding request I/O (read and write).
Then if recalled ensure an aborted request is rundown and ended.
*/
void Http2RequestCancel (REQUEST_STRUCT *rqptr)
{
HTTP2_STREAM_STRUCT *s2ptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(rqptr), WATCH_MOD_HTTP2, "Http2RequestCancel()");
s2ptr = &rqptr->Http2Stream;
if (s2ptr->State != HTTP2_STATE_CLOSED &&
rqptr->NetIoPtr->VmsStatus != SS$_CANCEL)
{
/**********/
/* cancel */
/**********/
s2ptr->State = HTTP2_STATE_CLOSED;
rqptr->NetIoPtr->VmsStatus = SS$_CANCEL;
Http2NetCancelWrite (rqptr);
Http2RequestData (s2ptr->Http2Ptr, 0, s2ptr->Ident, (void*)-1, 0);
Http2RequestResetStream (rqptr);
}
else
if (rqptr->NetIoPtr->VmsStatus == SS$_CANCEL)
{
/*********/
/* abort */
/*********/
if (rqptr->RequestState >= REQUEST_STATE_ABORT)
if (!NETIO_IN_PROGRESS (rqptr->NetIoPtr))
if (RequestRundown (rqptr))
{
/* only want to do this the once! */
rqptr->NetIoPtr->VmsStatus = SS$_CANCEL | STS$M_INHIB_MSG;
SysDclAst (RequestEnd2, rqptr);
}
}
}
/*****************************************************************************/
/*
Http2ResponseDictHeader() ... yes, I know.
Response HEADERS frame with table based compression.
Called from NetWrite() this function needs to emulate NetIoWrite().
*/
int Http2ResponseDictHeader
(
REQUEST_STRUCT *rqptr,
REQUEST_AST AstFunction
)
{
BOOL headers, indexit;
uint index, length, nlen, nlen2, retval, size, value, vlen;
uchar *bptr, *bzptr, *cptr, *nptr, *nptr2, *vptr;
DICT_ENTRY_STRUCT *denptr;
HPACK_TABLE_STRUCT *tabptr;
HTTP2_STRUCT *h2ptr;
HTTP2_WRITE_STRUCT *w2ptr, *w22ptr;
NETIO_STRUCT *ioptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(rqptr), WATCH_MOD_HTTP2,
"Http2ResponseDictHeader()");
if (rqptr->rqPathSet.ResponseHeaderNone &&
rqptr->rqResponse.HttpStatus / 100 == 2) return (SS$_NORMAL);
h2ptr = rqptr->Http2Stream.Http2Ptr;
/* treat subsequent response header as data (for WASD "Xray" facility) */
if (rqptr->Http2Stream.HeaderSent)
{
denptr = ResponseDictHeader (rqptr);
NetIoWrite (rqptr->NetIoPtr, AstFunction, rqptr,
DICT_GET_VALUE(denptr), DICT_GET_VALUE_LEN(denptr));
return (SS$_NORMAL);
}
rqptr->Http2Stream.HeaderSent = true;
tabptr = &h2ptr->HpackServerTable;
/* with compression this should always be (way more than) enough space */
size = 8;
DictIterate (rqptr->rqDictPtr, NULL);
while ((denptr = DictIterate (rqptr->rqDictPtr, DICT_TYPE_RESPONSE)) != NULL)
size += DICT_GET_KEY_LEN(denptr) + DICT_GET_VALUE_LEN(denptr) + 4;
w2ptr = w22ptr = Http2GetWriteStruct (h2ptr, size, FI_LI);
bzptr = (bptr = w2ptr->payload) + size;
denptr = DictLookup (rqptr->rqDictPtr, DICT_TYPE_INTERNAL,
"response_status", 15);
/* if a header has not been generated */
if (denptr == NULL) return (SS$_ABORT);
*bptr++ = (uchar)0x08; /* static index ":status" without indexing */
*bptr++ = (uchar)DICT_GET_VALUE_LEN(denptr);
for (cptr = DICT_GET_VALUE(denptr); *cptr; *bptr++ = (uchar)*cptr++);
/* set the baseline before these table searches */
HpackFindInTable (tabptr, NULL, 0, NULL, 0);
/* calculate the HTTP/1.n equivalent */
length = sizeof("\r\n")-1;
DictIterate (rqptr->rqDictPtr, NULL);
while ((denptr = DictIterate (rqptr->rqDictPtr, DICT_TYPE_RESPONSE)) != NULL)
{
nptr = DICT_GET_KEY(denptr);
nlen = DICT_GET_KEY_LEN(denptr);
vptr = DICT_GET_VALUE(denptr);
vlen = DICT_GET_VALUE_LEN(denptr);
/* e.g. |set-cookie| field begins with "<integer>:" to allow multiples */
if (isdigit(*nptr))
{
nptr2 = nptr;
nlen2 = nlen;
while ((isdigit(*nptr2)) && nlen2)
{
nptr2++;
nlen2--;
}
if (nlen2 && *nptr2 == ':')
{
nptr = nptr2 + 1;
nlen = nlen2 - 1;
}
/* ignore if somehow just "<integer>:" */
if (!nlen || !nlen2) continue;
}
length += nlen + vlen + sizeof(": \r\n")-1;
/* look for the name plus value entry */
index = HpackFindInTable (tabptr, nptr, nlen, vptr, vlen);
if (index)
{
/* indexed header field, indexed name and value (RFC7541 6.1) */
*bptr = 0x80;
retval = HpackEncodeInt32 (h2ptr, &bptr, bzptr, 7, index);
if (retval < 0) return (SS$_BUGCHECK);
}
else
{
/* if no name plus value entry look for just the name */
index = HpackFindInTable (tabptr, nptr, nlen, NULL, 0);
/* observation has demonstrated these are not worth caching */
if (MATCH15 (nptr, "content-length"))
indexit = false;
else
if (MATCH5 (nptr, "date"))
indexit = false;
else
if (MATCH5 (nptr, "etag"))
indexit = false;
else
if (MATCH14 (nptr, "last-modified"))
indexit = false;
else
indexit = true;
/* if it won't fit into the table! */
if (nlen + vlen + 32 > h2ptr->HpackServerTable.max)
indexit = false;
if (indexit)
{
/* indexed header field, index then value (RFC7541 6.2.1) */
if (index)
{
*bptr = 0x40;
retval = HpackEncodeInt32 (h2ptr, &bptr, bzptr, 6, index);
if (retval < 0) return (SS$_BUGCHECK);
}
else
{
*bptr++ = 0x40;
retval = HpackEncodeString (h2ptr, &bptr, bzptr, nptr, nlen);
if (retval < 0) return (SS$_BUGCHECK);
}
retval = HpackEncodeString (h2ptr, &bptr, bzptr, vptr, vlen);
if (retval < 0) return (SS$_BUGCHECK);
HpackAddToTable (tabptr, nptr, nlen, vptr, vlen);
}
else
{
/* literal header field without indexing (RFC7541 6.2.2) */
if (index)
{
*bptr = 0x00;
retval = HpackEncodeInt32 (h2ptr, &bptr, bzptr, 4, index);
if (retval < 0) return (SS$_BUGCHECK);
}
else
{
*bptr++ = 0x00;
retval = HpackEncodeString (h2ptr, &bptr, bzptr, nptr, nlen);
if (retval < 0) return (SS$_BUGCHECK);
}
retval = HpackEncodeString (h2ptr, &bptr, bzptr, vptr, vlen);
if (retval < 0) return (SS$_BUGCHECK);
}
}
if (bptr > w2ptr->payload + size)
ErrorExitVmsStatus (SS$_BUGCHECK, ErrorSanityCheck, FI_LI);
}
value = bptr - w2ptr->payload;
/* as if it originated from the network */
rqptr->BytesRx64 += value;
h2ptr->HpackServerInputCount += length;
h2ptr->HpackServerOutputCount += value;
if (WATCHING (h2ptr, WATCH_HTTP2) &&
!WATCHING1S(h2ptr) && !WATCHING2(h2ptr))
{
WatchThis (WATCHITM(h2ptr), WATCH_HTTP2,
"RESPONSE header !UL->!UL !UL%",
length, value, value * 100 / length);
if (rqptr->rqPathSet.Http2WriteQueue)
{
if (rqptr->rqPathSet.Http2WriteQueue == HTTP2_WRITE_QUEUE_HIGH)
cptr = "high";
else
if (rqptr->rqPathSet.Http2WriteQueue == HTTP2_WRITE_QUEUE_NORMAL)
cptr = "normal";
else
cptr = "low";
WatchThis (WATCHITM(h2ptr), WATCH_HTTP2,
"WRITE queue !AZ", cptr);
}
}
if (WATCHMOD (rqptr, WATCH_MOD_HTTP2))
{
int retval;
retval = HpackHeadersFrame (&h2ptr->HpackServerTable,
(int)-1, rqptr->Http2Stream.Ident,
w2ptr->payload, value);
if (retval < 0)
{
WatchThis (WATCHITM(rqptr), WATCH_MOD_HTTP2,
"HPACK error:!UL \"!AZ\"",
-(retval), Http2ErrorString(-(retval)));
return (SS$_ABORT);
}
WatchData (w2ptr->payload, value);
}
if (WATCHING (rqptr, WATCH_RESPONSE_HEADER))
{
denptr = ResponseDictHeader (rqptr);
WatchThis (WATCHITM(rqptr), WATCH_RESPONSE_HEADER,
"HEADER !UL bytes", DICT_GET_VALUE_LEN(denptr));
WatchData (DICT_GET_VALUE(denptr), DICT_GET_VALUE_LEN(denptr));
}
/* this is the underlying request's I/O structure */
ioptr = rqptr->NetIoPtr;
/* most headers are going to be without continuation */
if (value <= h2ptr->ClientMaxFrameSize)
{
/********************/
/* just one headers */
/********************/
/* use the originally allocate write structure */
HTTP2_PLACE_24 (w2ptr->length, value);
HTTP2_PLACE_8 (w2ptr->type, HTTP2_FRAME_HEADERS);
HTTP2_PLACE_8 (w2ptr->flags, HTTP2_FLAG_HEAD_END_HEAD);
HTTP2_PLACE_32 (w2ptr->ident, rqptr->Http2Stream.Ident);
w2ptr->Http2Ptr = h2ptr;
w2ptr->RequestPtr = rqptr;
w2ptr->HeaderPtr = w2ptr->header;
w2ptr->DataPtr = w2ptr->payload;
w2ptr->DataLength = value;
if (!(w2ptr->AstFunction = AstFunction))
w2ptr->AstFunction = w2ptr->AstParam = Http2Net_WRITE_NO_AST;
else
w2ptr->AstParam = rqptr;
/* called from NetWrite() this needs to emulate NetIoWrite() */
if (ioptr->WriteAstFunction = AstFunction)
ioptr->WriteAstParam = rqptr;
/* let's give response headers a bit of an edge */
w2ptr->WriteQueue = HTTP2_WRITE_QUEUE_HIGH;
if (WATCHMOD (rqptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(rqptr), WATCH_MOD_HTTP2,
"h2ptr:!&X w2ptr:!&X", h2ptr, w2ptr);
Http2NetQueueWrite (h2ptr, w2ptr);
/* keep the request accounting representative */
ioptr->BlocksRawTx64++;
ioptr->BlocksTallyTx64++;
ioptr->BytesRawTx64 += length;
ioptr->BytesTallyTx64 += length;
}
else
{
/*********************/
/* with continuation */
/*********************/
/* the "original" write structure payload will be cannibalised */
cptr = w22ptr->payload;
headers = true;
while (value)
{
if (value <= h2ptr->ClientMaxFrameSize)
length = value;
else
length = h2ptr->ClientMaxFrameSize;
value -= length;
w2ptr = Http2GetWriteStruct (h2ptr, length, FI_LI);
HTTP2_PLACE_24 (w2ptr->length, length);
if (headers)
HTTP2_PLACE_8 (w2ptr->type, HTTP2_FRAME_HEADERS)
else
HTTP2_PLACE_8 (w2ptr->type, HTTP2_FRAME_CONTINUATION)
headers = false;
if (!value) HTTP2_PLACE_8 (w2ptr->flags, HTTP2_FLAG_HEAD_END_HEAD);
HTTP2_PLACE_32 (w2ptr->ident, rqptr->Http2Stream.Ident);
memcpy (w2ptr->payload, cptr, length);
cptr += length;
w2ptr->Http2Ptr = h2ptr;
w2ptr->RequestPtr = rqptr;
w2ptr->HeaderPtr = w2ptr->header;
w2ptr->DataPtr = w2ptr->payload;
w2ptr->DataLength = length;
if (headers)
w2ptr->AstFunction = w2ptr->AstParam = Http2Net_WRITE_NO_AST;
else
{
if (!(w2ptr->AstFunction = AstFunction))
w2ptr->AstFunction = w2ptr->AstParam = Http2Net_WRITE_NO_AST;
else
w2ptr->AstParam = rqptr;
/* called from NetWrite() this needs to emulate NetIoWrite() */
if (ioptr->WriteAstFunction = AstFunction)
ioptr->WriteAstParam = rqptr;
}
/* let's give response headers a bit of an edge */
w2ptr->WriteQueue = HTTP2_WRITE_QUEUE_HIGH;
if (WATCHMOD (rqptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(rqptr), WATCH_MOD_HTTP2,
"h2ptr:!&X w2ptr:!&X", h2ptr, w2ptr);
Http2NetQueueWrite (h2ptr, w2ptr);
/* keep the request accounting representative */
ioptr->BlocksRawTx64++;
ioptr->BlocksTallyTx64++;
ioptr->BytesRawTx64 += length;
ioptr->BytesTallyTx64 += length;
}
/* free the cannibalised write structure */
Http2FreeWriteStruct (h2ptr, w22ptr, FI_LI);
}
return (SS$_NORMAL);
}
/*****************************************************************************/
/*
Reset the stream associated with this request.
*/
int Http2RequestResetStream (REQUEST_STRUCT *rqptr)
{
int retval;
uint error, ident;
HTTP2_STRUCT *h2ptr;
/*********/
/* begin */
/*********/
h2ptr = rqptr->Http2Stream.Http2Ptr;
ident = rqptr->Http2Stream.Ident;
error = HTTP2_ERROR_CANCEL;
if (WATCHMOD (h2ptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_MOD_HTTP2,
"Http2RequestResetStream()");
retval = Http2ResetStream (h2ptr, ident, error, NULL, 0);
return (retval);
}
/*****************************************************************************/
/*
Called from RequestEnd2() and Http2NetWriteDataAst() during request run-down.
*/
void Http2RequestEnd2 (REQUEST_STRUCT *rqptr)
{
HTTP2_STRUCT *h2ptr;
HTTP2_STREAM_STRUCT *s2ptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(rqptr), WATCH_MOD_HTTP2,
"Http2RequestEnd2() !&F ident:!UL state:!UL read:!UL/!UL write:!UL",
Http2RequestEnd2,
rqptr->Http2Stream.Ident,
rqptr->Http2Stream.State,
rqptr->Http2Stream.DataReadLength,
rqptr->Http2Stream.DataReadSize,
rqptr->Http2Stream.QueuedWriteCount);
s2ptr = &rqptr->Http2Stream;
h2ptr = s2ptr->Http2Ptr;
/* cancel request data being read */
Http2RequestData (h2ptr, 0, s2ptr->Ident, (void*)-1, 0);
if (!s2ptr->RequestEnd)
{
s2ptr->RequestEnd = true;
if (!(s2ptr->State == HTTP2_STATE_CLOSED ||
s2ptr->State == HTTP2_STATE_CLOSED_LOC))
Http2NetWriteEnd (rqptr);
}
if (s2ptr->DataReadSize ||
s2ptr->QueuedWriteCount ||
NETIO_IN_PROGRESS (rqptr->NetIoPtr)) return;
rqptr->NetIoPtr->BytesRawRx64 += s2ptr->Http2Ptr->BytesRawTallyRx64;
rqptr->NetIoPtr->BytesRawTx64 += s2ptr->Http2Ptr->BytesRawTallyTx64;
RequestEnd2 (rqptr);
}
/*****************************************************************************/
/*
Final stage of request run-down corresponding to RequestEnd5().
*/
void Http2RequestEnd5 (REQUEST_STRUCT *rqptr)
{
int HttpStatus;
HTTP2_STRUCT *h2ptr;
/*********/
/* begin */
/*********/
if (WATCHMOD (rqptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(rqptr), WATCH_MOD_HTTP2,
"Http2RequestEnd5() chan:!UL ident:!UL",
rqptr->Http2Stream.Http2Ptr->NetIoPtr->Channel,
rqptr->Http2Stream.Ident);
if (WATCHING (rqptr, WATCH_CONNECT))
WatchThis (WATCHITM(rqptr), WATCH_CONNECT,
"HTTP/2 end !UL with !AZ,!UL",
rqptr->Http2Stream.Ident,
rqptr->ClientPtr->Lookup.HostName,
rqptr->ClientPtr->IpPort);
/* dispose of the network I/O structure */
NetIoEnd (rqptr->NetIoPtr);
h2ptr = rqptr->Http2Stream.Http2Ptr;
ListRemove (&h2ptr->StreamList, &rqptr->Http2Stream);
if (h2ptr->RequestCurrent) h2ptr->RequestCurrent--;
rqptr->Http2Stream.Ident = 0;
rqptr->Http2Stream.Http2Ptr = NULL;
InstanceMutexLock (INSTANCE_MUTEX_HTTPD);
acptr->Http2FrameCountRx64 += h2ptr->FrameTallyRx;
acptr->Http2FrameCountTx64 += h2ptr->FrameTallyTx;
acptr->Http2FrameRequestCountRx64 += h2ptr->FrameRequestTallyRx;
acptr->Http2FrameRequestCountTx64 += h2ptr->FrameRequestTallyTx;
acptr->Http2FlowFrameCount64 += h2ptr->FlowFrameTally;
acptr->Http2FlowControlCount64 += h2ptr->FlowControlTally;
h2ptr->FlowFrameCount += h2ptr->FlowFrameTally;
h2ptr->FlowFrameTally = 0;
h2ptr->FlowControlCount += h2ptr->FlowControlTally;
h2ptr->FlowControlTally = 0;
acptr->BytesRawRx64[HTTP2] += h2ptr->BytesRawTallyRx64;
acptr->BytesRawTx64[HTTP2] += h2ptr->BytesRawTallyTx64;
InstanceMutexUnLock (INSTANCE_MUTEX_HTTPD);
h2ptr->FrameTallyRx = 0;
h2ptr->FrameTallyTx = 0;
h2ptr->FrameRequestTallyRx = 0;
h2ptr->FrameRequestTallyTx = 0;
h2ptr->BytesRawTallyRx64 = 0;
h2ptr->BytesRawTallyTx64 = 0;
if (WATCHMOD (h2ptr, WATCH_MOD_HTTP2))
WatchThis (WATCHITM(h2ptr), WATCH_MOD_HTTP2, "streams: !UL",
LIST_GET_COUNT (&h2ptr->StreamList));
/* if WATCHing the HTTP/2 connection then reset the request item */
if (h2ptr->WatchItem & WATCH_ITEM_HTTP2_FLAG) rqptr->WatchItem = 0;
#if SESOLA_MEMORY
SesolaMemoryControl (-1, FI_LI);
#endif SESOLA_MEMORY
HttpStatus = rqptr->rqResponse.HttpStatus;
RequestEnd5 (rqptr);
/* 418 can be used to drop a connection using a "standard" code */
if (h2ptr->GoAwayLastStreamIdent || HttpStatus == 418)
Http2CloseConnection (h2ptr);
}
/*****************************************************************************/