Node.js CONNECT હેન્ડલર્સે head બફર જાળવવું આવશ્યક છે
HTTP થી ટનલ સુધીની સીમા પર Node ના CONNECT સોકેટ અને head બફરનું સંચાલન કરો, હેડર્સની બહાર પહેલેથી વાંચેલા બાઇટ્સ જાળવી રાખીને.
Node HTTP સર્વર તેના request callback દ્વારા સામાન્ય પ્રોક્સી વિનંતીનું સંચાલન કરે છે. CONNECT બીજો માર્ગ લે છે: સર્વર વિનંતી, ક્લાયંટ સોકેટ અને head બફર સાથે connect ઉત્સર્જિત કરે છે.
તે ઘટના HTTP પાર્સિંગ અને ટનલ વચ્ચેનું હસ્તાંતરણ છે. ટનલ કરેલા ટ્રાફિક માટે વાપરવાનું ચાલુ રાખવા માટે કોઈ સામાન્ય ServerResponse ઑબ્જેક્ટ નથી.
| દલીલ | તે શું વહન કરે છે |
|---|---|
req | CONNECT વિનંતી, તેના ગંતવ્ય અધિકાર અને હેડર્સ સહિત |
clientSocket | ક્લાયંટ તરફ પાછું જોડાણ |
head | Node એ HTTP હેડર્સની બહાર પહેલેથી વાંચેલો ટનલ ડેટા, કદાચ ખાલી |
બાઇટ્સ રિલે કરતા પહેલાં HTTP નિર્ણય પૂર્ણ કરો
વિનંતી કરેલા હોસ્ટ અને પોર્ટની માન્યતા ચકાસો, પ્રોક્સીની ઍક્સેસ અને પ્રમાણીકરણ નીતિ લાગુ કરો અને અપસ્ટ્રીમ જોડાણ સ્થાપિત કરો. CONNECT service.example:443 જેવા અધિકારને ઓળખે છે; દરેક કોલન પર આંધળા રીતે વિભાજન કરવાને બદલે IPv6 અધિકારોને ધ્યાનમાં રાખીને તે સ્વરૂપનું પાર્સિંગ કરો.
ટનલ સ્વીકારાયા પછી, સફળ HTTP પ્રતિસાદ અને તેની અંતિમ ખાલી લાઇન મોકલો. પછી ક્લાયંટ સોકેટમાંથી પછીના બાઇટ્સ સાથે આગળ વધતા પહેલાં કોઈપણ head બાઇટ્સ અપસ્ટ્રીમ મોકલો. નવું ડેટા લિસનર જોડીને હેન્ડલરને અલગથી પહોંચાડાયેલું બફર પુનઃપ્રાપ્ત કરી શકાતું નથી.
Node નું સત્તાવાર ટનલિંગ ઉદાહરણ બે સ્ટ્રીમ દિશાઓ જોડતા પહેલાં serverSocket.write(head) સાથે તે હસ્તાંતરણ કરે છે. તેનું નાનું ઉદાહરણ સંક્રમણ દર્શાવે છે; તૈનાત પ્રોક્સીને મર્યાદિત જોડાણ પ્રયાસો, ઍક્સેસ નિયંત્રણો અને જીવનચક્ર સંચાલનની પણ જરૂર હોય છે.
સફળતા પછી, બાઇટ્સ સેવા પ્રોટોકોલના છે
સફળ CONNECT પ્રતિસાદ જોડાણને બાઇટ સ્ટ્રીમમાં ફેરવે છે. જો લક્ષ્ય HTTPS સાઇટ હોય, તો તેનું TLS વિનિમય તે સ્ટ્રીમની અંદર પ્રવાસ કરે છે. ફક્ત ટનલ કરવાથી પ્રોક્સીએ બદલીની વેબસાઇટ સર્ટિફિકેટ બહાર પાડવાની જરૂર પડતી નથી.
CONNECT સ્વીકારતા પહેલાં, HTTP ભૂલ કેમ નકારવામાં આવ્યું તે સમજાવી શકે છે. સ્વીકાર પછી, સ્ટ્રીમમાં HTTP 500 લખવાથી ટનલ પ્રોટોકોલમાં બાઇટ્સ ઇન્જેક્ટ થશે. તેના બદલે પછીની નિષ્ફળતાઓ પર યોગ્ય જોડાણો સમાપ્ત કરો અથવા નષ્ટ કરો.
બંને દિશાઓને બેકપ્રેશર-જાગરૂક સ્ટ્રીમ સંચાલન સાથે જોડો, અને end, error અને close ઘટનાઓ સાથીને કેવી રીતે સમાપ્ત કરે તે નક્કી કરો. પ્રારંભિક head બફરને તે જ માલિકી મોડેલના ભાગ રૂપે જાળવો; તે એપ્લિકેશન ડેટા છે, ફેંકી દેવાના વધારાના HTTP હેડર્સ નથી.