haserl - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

haserl - ഉൾച്ചേർത്ത പരിതസ്ഥിതികൾക്കുള്ള ഒരു cgi സ്ക്രിപ്റ്റിംഗ് പ്രോഗ്രാം

സിനോപ്സിസ്

#!/usr/bin/haserl [--ഷെൽ=പാത്ത്സ്പെക്ക്] [--upload-dir=വ്യക്തമായി] [--upload-handler=ഹാൻഡ്ലർ]
[--upload-limit=പരിധി] [--എല്ലാം സ്വീകരിക്കുക] [--ഒന്നും സ്വീകരിക്കരുത്] [--നിശബ്ദ] [--ഡീബഗ്]

[ ടെക്സ്റ്റ് ] [ <% ഷെൽ സ്ക്രിപ്റ്റ് %> ] [ ടെക്സ്റ്റ് ] ...

വിവരണം

"PHP" ശൈലിയിലുള്ള cgi പ്രോഗ്രാമിംഗ് അനുവദിക്കുന്ന ഒരു ചെറിയ cgi റാപ്പറാണ് Haserl, എന്നാൽ ഒരു UNIX ഉപയോഗിക്കുന്നു
പ്രോഗ്രാമിംഗ് ഭാഷയായി ബാഷ് പോലെയുള്ള ഷെൽ അല്ലെങ്കിൽ ലുവാ. ഇത് വളരെ ചെറുതാണ്, അതിനാൽ ഇത് ഉപയോഗിക്കാം
ഉൾച്ചേർത്ത പരിതസ്ഥിതികളിൽ, അല്ലെങ്കിൽ PHP പോലെയുള്ള ഒന്ന് വളരെ വലുതാണ്.

ഇത് ഒരു ചെറിയ സിജിഐ എഞ്ചിനിലേക്ക് മൂന്ന് സവിശേഷതകൾ സംയോജിപ്പിക്കുന്നു:

ഇത് POST, GET അഭ്യർത്ഥനകൾ പാഴ്‌സ് ചെയ്യുന്നു, ഫോം ഘടകങ്ങൾ നെയിം=മൂല്യ ജോഡികളായി സ്ഥാപിക്കുന്നു.
CGI സ്ക്രിപ്റ്റ് ഉപയോഗിക്കാനുള്ള അന്തരീക്ഷം. ഇത് കുറച്ച് പോലെയാണ് uncgi റാപ്പർ.

ഇത് ഒരു ഷെൽ തുറക്കുന്നു, കൂടാതെ എല്ലാ വാചകങ്ങളും അച്ചടിക്കാവുന്ന പ്രസ്താവനകളിലേക്ക് വിവർത്തനം ചെയ്യുന്നു. എല്ലാ ടെക്സ്റ്റ്
<% ... %> എന്നതിനുള്ളിൽ നിർമ്മിതികൾ ഷെല്ലിലേക്ക് പദാനുപദമായി കൈമാറുന്നു. ഇത് ഒരു പരിധിവരെ
എഴുത്ത് പോലെ PHP സ്ക്രിപ്റ്റുകൾ.

സ്ക്രിപ്റ്റിന്റെ ഉടമയ്ക്ക് അതിന്റെ അനുമതികൾ നൽകുന്നതിന് ഇത് ഓപ്ഷണലായി ഇൻസ്റ്റാൾ ചെയ്യാവുന്നതാണ്,
യുടെ ചില സുരക്ഷാ സവിശേഷതകൾ നൽകുന്നു suexec or cgiwrapper.

ഓപ്ഷനുകൾ സംഗ്രഹം

ഇത് കമാൻഡ്-ലൈൻ ഓപ്ഷനുകളുടെ ഒരു സംഗ്രഹമാണ്. ദയവായി കാണുക ഓപ്ഷനുകൾ വിഭാഗത്തിന് കീഴിലാണ്
പൂർണ്ണമായ വിവരണത്തിനുള്ള നീണ്ട ഓപ്ഷന്റെ പേര്.

-എ --എല്ലാം സ്വീകരിക്കുക
-n --ഒന്നും സ്വീകരിക്കരുത്
-d --ഡീബഗ്
-s, --ഷെൽ
-എസ്, --നിശബ്ദത
-U, --upload-dir
-u, --upload-limit
-H, --അപ്‌ലോഡ്-ഹാൻഡ്‌ലർ

ഓപ്ഷനുകൾ

--എല്ലാം സ്വീകരിക്കുക
REQUEST_METHOD POST ആയിരിക്കുമ്പോൾ മാത്രമേ പ്രോഗ്രാം സാധാരണയായി POST ഡാറ്റ സ്വീകരിക്കുകയുള്ളൂ
REQUEST_METHOD GET ആയിരിക്കുമ്പോൾ മാത്രമേ URL ഡാറ്റയിലെ ഡാറ്റ സ്വീകരിക്കുകയുള്ളൂ. ഈ ഓപ്ഷൻ
REQUEST_METHOD പരിഗണിക്കാതെ തന്നെ POST, URL ഡാറ്റ സ്വീകരിക്കാൻ അനുവദിക്കുന്നു.
ഈ ഓപ്‌ഷൻ സജ്ജീകരിക്കുമ്പോൾ, REQUEST_METHOD ന് മുൻഗണന ലഭിക്കുന്നു (ഉദാ. രീതി ആണെങ്കിൽ
POST ആണ്, FORM_variables എന്നത് COOKIE ഡാറ്റ, GET ഡാറ്റ, POST ഡാറ്റ എന്നിവയിൽ നിന്നാണ് എടുത്തത്.
ആ ഉത്തരവ്. രീതി GET ആണെങ്കിൽ, FORM_variables COOKIE ഡാറ്റയിൽ നിന്ന് എടുത്തതാണ്, POST
ഡാറ്റ, കൂടാതെ ഡാറ്റ നേടുക.) എല്ലാ ഇൻപുട്ട് രീതികളും സ്വീകരിക്കുക എന്നതല്ല ഡിഫോൾട്ട് - വെറും
COOKIE ഡാറ്റയും REQUEST_METHOD ഉം.

--അംഗീകരിക്കുക-ഒന്നുമില്ല
നൽകിയിട്ടുണ്ടെങ്കിൽ, പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ് ഹാസർൽ സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് http ഉള്ളടക്കമായി പാഴ്‌സ് ചെയ്യില്ല
തിരക്കഥ. മറ്റൊരു ഹാസർൽ സ്ക്രിപ്റ്റിൽ നിന്ന് ഒരു ഹാസർൽ സ്ക്രിപ്റ്റ് വിളിക്കുകയാണെങ്കിൽ ഇത് ഉപയോഗപ്രദമാണ്.

--ഡീബഗ്
സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുപകരം, എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്ന സ്ക്രിപ്റ്റ് പ്രിന്റ് ചെയ്യുക. എങ്കിൽ
പരിസ്ഥിതി വേരിയബിൾ 'REQUEST_METHOD' സജ്ജീകരിച്ചിരിക്കുന്നു, ഡാറ്റ അയയ്‌ക്കുന്നു
പ്ലെയിൻ/ടെക്സ്റ്റ് ഉള്ളടക്ക തരം. അല്ലെങ്കിൽ, ഷെൽ സ്ക്രിപ്റ്റ് പദാനുപദമായി അച്ചടിക്കുന്നു.

--ഷെൽ=പാത്ത്സ്പെക്ക്
ഉപയോഗിക്കുന്നതിന് ഒരു ബദൽ ബാഷ് പോലുള്ള ഷെൽ വ്യക്തമാക്കുക. സ്ഥിരസ്ഥിതികൾ "/ bin / sh"

ഷെൽ പാരാമീറ്ററുകൾ ഉൾപ്പെടുത്തുന്നതിന് --shell= ഉപയോഗിക്കരുത്/ bin / sh ഫോർമാറ്റ്. പകരം, ഉപയോഗിക്കുക
"=" ഇല്ലാതെ ഇതര ഫോർമാറ്റ്, --ഷെൽ" പോലെ/ ബിൻ / ബാഷ് --norc". ഉറപ്പാക്കുക
ഏതെങ്കിലും പ്രത്യേക പ്രതീകങ്ങൾ പരിരക്ഷിക്കുന്നതിന് ഓപ്‌ഷൻ സ്‌ട്രിംഗ് ഉദ്ധരിക്കുക.

ലുവാ ലൈബ്രറികൾ ഉപയോഗിച്ചാണ് സമാഹരിച്ചതെങ്കിൽ, സംയോജിതമായി ഉപയോഗിക്കുന്നതിന് "lua" എന്ന സ്ട്രിംഗ് ഉപയോഗിക്കുന്നു
ലുവാ വിഎം. ഈ സ്ട്രിംഗ് കേസ് സെൻസിറ്റീവ് ആണ്. ഉദാഹരണം: --ഷെൽ=lua

ഒരു ബദൽ "luac" ആണ്. ഇത് ഹാസർ, ലുവ പാഴ്‌സറുകൾ പ്രവർത്തനരഹിതമാക്കുന്നതിന് കാരണമാകുന്നു,
കൂടാതെ സ്ക്രിപ്റ്റ് മുൻകൂട്ടി തയ്യാറാക്കിയ ലുവാ ചങ്ക് ആണെന്ന് അനുമാനിക്കപ്പെടുന്നു. കാണുക LUAC കൂടുതൽ കാര്യങ്ങൾക്ക് താഴെ
വിവരങ്ങൾ.

--നിശബ്ദത
Haserl സാധാരണയായി പിശക് അവസ്ഥകളിൽ ഒരു വിവര സന്ദേശം പ്രിന്റ് ചെയ്യുന്നു. ഈ
പിശക് സന്ദേശം അടിച്ചമർത്തുന്നു, അങ്ങനെ haserl-ന്റെ ഉപയോഗം പരസ്യപ്പെടുത്തില്ല.

--upload-dir=വ്യക്തമായി
സ്ഥിരസ്ഥിതികൾ "/ tmp". അപ്‌ലോഡ് ചെയ്‌ത എല്ലാ ഫയലുകളും ഇതിൽ താൽക്കാലിക ഫയൽ നാമത്തിൽ സൃഷ്‌ടിച്ചതാണ്
ഡയറക്ടറി HASERL_xxx_path താൽക്കാലിക ഫയലിന്റെ പേര് അടങ്ങിയിരിക്കുന്നു. FORM_xxx_name
ക്ലയന്റ് വ്യക്തമാക്കിയ ഫയലിന്റെ യഥാർത്ഥ പേര് അടങ്ങിയിരിക്കുന്നു.

--upload-handler=പാത്ത്സ്പെക്ക്
വ്യക്തമാക്കുമ്പോൾ, ഫയൽ അപ്‌ലോഡുകൾ എഴുതുന്നതിന് പകരം ഈ ഹാൻഡ്‌ലറാണ് കൈകാര്യം ചെയ്യുന്നത്
താൽക്കാലിക ഫയലുകൾ. മുഴുവൻ പാത്ത്‌സ്പെക്കും നൽകണം (പാത്ത് തിരഞ്ഞിട്ടില്ല), കൂടാതെ
അപ്‌ലോഡ്-ഹാൻഡ്‌ലറിന് ഒരു കമാൻഡ്-ലൈൻ പാരാമീറ്റർ നൽകിയിരിക്കുന്നു: FIFO-ന്റെ പേര്
ഏത് അപ്‌ലോഡ് ഫയൽ അയയ്ക്കും. കൂടാതെ, ഹാൻഡ്ലർക്ക് 3 ലഭിച്ചേക്കാം
പരിസ്ഥിതി വേരിയബിളുകൾ: ഉള്ളടക്ക തരം, ഫയലിന്റെ പേര്, ഒപ്പം NAME. ഇവ MIME-നെ പ്രതിഫലിപ്പിക്കുന്നു
ഉള്ളടക്കത്തിനായുള്ള ഉള്ളടക്ക-വ്യവഹാര തലക്കെട്ടുകൾ. ഹാസർൽ ഓരോന്നിനും ഹാൻഡ്‌ലർ ഫോർക്ക് ചെയ്യും
ഫയൽ അപ്‌ലോഡ് ചെയ്‌തു, കൂടാതെ അപ്‌ലോഡ് ഫയലിന്റെ ഉള്ളടക്കം നിർദ്ദിഷ്ട FIFO-ലേക്ക് അയയ്ക്കും.
ഹാൻഡർ അവസാനിപ്പിക്കുന്നത് വരെ Haserl തടയും. ഈ രീതി വിദഗ്ധർക്കുള്ളതാണ്
മാത്രം.

--upload-limit=പരിധി
വരെ മൈം-എൻകോഡ് ചെയ്ത ഫയൽ അനുവദിക്കുക പരിധി KB അപ്ലോഡ് ചെയ്യേണ്ടത്. സ്ഥിരസ്ഥിതിയാണ് 0KB (ഇല്ല
അപ്‌ലോഡുകൾ അനുവദനീയമാണ്). മൈം-എൻകോഡിംഗ് ഡാറ്റയുടെ വലുപ്പത്തിൽ 33% ചേർക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക.

ചുരുക്കവിവരണത്തിനുള്ള OF പ്രവർത്തനം

പൊതുവേ, വെബ് സെർവർ നിരവധി പരിസ്ഥിതി വേരിയബിളുകൾ സജ്ജീകരിക്കുന്നു, തുടർന്ന് ഉപയോഗിക്കുന്നു ഫോർക്ക് or
CGI സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള മറ്റൊരു രീതി. സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ ഹാസർൽ വ്യാഖ്യാതാവ്, ദി
ഇനിപ്പറയുന്നവ സംഭവിക്കുന്നു:

If ഹാസർൽ suid റൂട്ട് ഇൻസ്റ്റാൾ ചെയ്തു, തുടർന്ന് uid/gid സ്ക്രിപ്റ്റിന്റെ ഉടമയായി സജ്ജീകരിച്ചിരിക്കുന്നു.

പരിസ്ഥിതി സ്കാൻ ചെയ്യുന്നു HTTP_COOKIE, ഇത് വെബ് സജ്ജമാക്കിയിരിക്കാം
സെർവർ. അത് നിലവിലുണ്ടെങ്കിൽ, പാഴ്സ് ചെയ്ത ഉള്ളടക്കങ്ങൾ പ്രാദേശിക പരിതസ്ഥിതിയിൽ സ്ഥാപിക്കും.

പരിസ്ഥിതി സ്കാൻ ചെയ്യുന്നു REQUEST_METHOD, വെബ് സെർവർ സജ്ജമാക്കിയതാണ്.
അഭ്യർത്ഥന രീതിയെ അടിസ്ഥാനമാക്കി, സാധാരണ ഇൻപുട്ട് വായിക്കുകയും പാഴ്‌സ് ചെയ്യുകയും ചെയ്യുന്നു. പാഴ്‌സ് ചെയ്‌തത്
ഉള്ളടക്കങ്ങൾ പ്രാദേശിക പരിതസ്ഥിതിയിൽ സ്ഥാപിച്ചിരിക്കുന്നു.

സ്ക്രിപ്റ്റ് ടോക്കണൈസ്ഡ്, പാഴ്സിംഗ് ഹാസർൽ റോ ടെക്‌സ്‌റ്റിൽ നിന്നുള്ള കോഡ് ബ്ലോക്കുകൾ. റോ ടെക്സ്റ്റ് ആണ്
"എക്കോ" പ്രസ്താവനകളാക്കി മാറ്റി, തുടർന്ന് എല്ലാ ടോക്കണുകളും സബ്-ഷെല്ലിലേക്ക് അയയ്ക്കും.

ഹാസർൽ ഫോർക്കുകളും ഒരു സബ് ഷെല്ലും (സാധാരണയായി / bin / sh) ആരംഭിച്ചു.

എല്ലാ ടോക്കണുകളും ഒരു ട്രെയിലിംഗ് സഹിതം സബ്-ഷെല്ലിന്റെ STDIN-ലേക്ക് അയയ്ക്കുന്നു പുറത്ത് കമാൻഡ്.

സബ്-ഷെൽ അവസാനിക്കുമ്പോൾ, ദി ഹാസർൽ വ്യാഖ്യാതാവ് അന്തിമ വൃത്തിയാക്കൽ നടത്തുന്നു
പിന്നീട് അവസാനിപ്പിക്കുന്നു.

ഉപയോക്താവ് സൈഡ് ഇൻപുട്ട്

ദി ഹാസർൽ HTTP_COOKIE എൻവയോൺമെന്റ് വേരിയബിൾ വഴി അയച്ച ഡാറ്റ വ്യാഖ്യാതാവ് ഡീകോഡ് ചെയ്യും, കൂടാതെ
ക്ലയന്റിൽനിന്നുള്ള GET അല്ലെങ്കിൽ POST രീതി, കൂടാതെ അവയെ പരിസ്ഥിതി വേരിയബിളുകളായി സംഭരിക്കുക
haserl വഴി ആക്സസ് ചെയ്യാവുന്നതാണ്. വേരിയബിളിന്റെ പേര് ഉറവിടത്തിൽ നൽകിയിരിക്കുന്ന പേരിനെ പിന്തുടരുന്നു,
ഒരു ഉപസർഗ്ഗം ഒഴികെ ( FORM_) മുൻകൂട്ടി തയ്യാറാക്കിയതാണ്. ഉദാഹരണത്തിന്, ക്ലയന്റ് "foo=bar" അയയ്ക്കുകയാണെങ്കിൽ,
പരിസ്ഥിതി വേരിയബിൾ ആണ് FORM_foo=ബാർ.

HTTP_COOKIE രീതിക്കായി, വേരിയബിളുകളും പ്രിഫിക്‌സിനൊപ്പം ( കുക്കി_) ചേർത്തു.
ഉദാഹരണത്തിന്, HTTP_COOKIE-ൽ "foo=bar" ഉൾപ്പെടുന്നുവെങ്കിൽ, പരിസ്ഥിതി വേരിയബിൾ ആണ്
COOKIE_foo=ബാർ.

GET രീതിക്കായി, %xx എന്ന രൂപത്തിൽ അയച്ച ഡാറ്റ അവ പ്രതീകങ്ങളാക്കി വിവർത്തനം ചെയ്യുന്നു
പ്രതിനിധീകരിക്കുന്നു, കൂടാതെ വേരിയബിളുകളും പ്രിഫിക്സിൽ സൂക്ഷിക്കുന്നു ( നേടുക_) ചേർത്തു. ഉദാഹരണത്തിന്, എങ്കിൽ
QUERY_STRING എന്നതിൽ "foo=bar" ഉൾപ്പെടുന്നു, പരിസ്ഥിതി വേരിയബിൾ ആണ് GET_foo=ബാർ.

POST രീതിക്കായി, വേരിയബിളുകളും പ്രിഫിക്‌സിനൊപ്പം ( പോസ്റ്റ്_) ചേർത്തു. വേണ്ടി
ഉദാഹരണത്തിന്, പോസ്റ്റ് സ്ട്രീമിൽ "foo=bar" ഉൾപ്പെടുന്നുവെങ്കിൽ, പരിസ്ഥിതി വേരിയബിൾ ആണ് POST_foo=ബാർ.

കൂടാതെ, POST രീതിക്ക്, ഡാറ്റ ഉപയോഗിച്ചാണ് അയച്ചതെങ്കിൽ മൾട്ടിപാർട്ട്/ഫോം-ഡാറ്റ എൻകോഡിംഗ്, ദി
ഡാറ്റ സ്വയമേ ഡീകോഡ് ചെയ്യപ്പെടുന്നു. വെബിൽ നിന്ന് ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യുമ്പോൾ ഇത് സാധാരണയായി ഉപയോഗിക്കുന്നു
ഉപയോഗിക്കുന്ന ക്ലയന്റ് .

കുറിപ്പ് വെബ് സെർവറിലേക്ക് ഒരു ഫയൽ അപ്‌ലോഡ് ചെയ്യുമ്പോൾ, അത് സംഭരിക്കപ്പെടും അപ്ലോഡ്-ദിയർ
ഡയറക്ടറി. FORM_variable_name= അപ്‌ലോഡ് ചെയ്ത ഫയലിന്റെ പേര് അടങ്ങിയിരിക്കുന്നു (അതുപോലെ
ക്ലയന്റ് വ്യക്തമാക്കിയത്.) HASERL_variable_path= എന്നതിലെ ഫയലിന്റെ പേര് അടങ്ങിയിരിക്കുന്നു
അപ്ലോഡ്-ദിയർ അത് അപ്‌ലോഡ് ചെയ്ത ഉള്ളടക്കം സൂക്ഷിക്കുന്നു. ക്ഷുദ്രകരമായ ക്ലയന്റുകളെ തടയുന്നതിന്
നിറച്ചു കൊണ്ടിരിക്കുന്നു അപ്ലോഡ്-ദിയർ നിങ്ങളുടെ വെബ് സെർവറിൽ, ഫയൽ അപ്‌ലോഡ് ചെയ്യുമ്പോൾ മാത്രമേ അനുവദിക്കൂ
--അപ്‌ലോഡ്-പരിധി എത്ര വലിയ ഫയൽ അപ്‌ലോഡ് ചെയ്യാമെന്ന് വ്യക്തമാക്കാൻ ഓപ്ഷൻ ഉപയോഗിക്കുന്നു. ഹാസർൽ
സ്ക്രിപ്റ്റ് പൂർത്തിയാകുമ്പോൾ താൽക്കാലിക ഫയൽ സ്വയമേവ ഇല്ലാതാക്കുന്നു. സൂക്ഷിക്കാൻ
ഫയൽ, അത് നീക്കുക അല്ലെങ്കിൽ സ്ക്രിപ്റ്റിൽ എവിടെയെങ്കിലും പേരുമാറ്റുക.

ഫയലിന്റെ പേര് സംഭരിച്ചിരിക്കുന്നുവെന്നത് ശ്രദ്ധിക്കുക HASERL_വേരിയബിൾ_പാത്ത് ഇത് കാരണം FORM_,
GET_, കൂടാതെ POST_ വേരിയബിളുകൾ ക്ലയന്റിനു പരിഷ്‌ക്കരിക്കാവുന്നവയാണ്, ക്ഷുദ്രകരമായ ഒരു ക്ലയന്റിനു കഴിയും
പേരിനൊപ്പം രണ്ടാമത്തെ വേരിയബിൾ സജ്ജമാക്കുക വേരിയബിൾ_പാത്ത്=/ etc / passwd. മുൻ പതിപ്പുകൾ
പാത്ത്‌സ്പെക്ക് സംഭരിച്ചില്ല HASERL നെയിംസ്‌പെയ്‌സ്. ലേക്ക് നിലനിർത്തുക പിന്നിലേക്ക്
പൊരുത്തപ്പെടുത്തൽ, The പേര് of The താൽക്കാലികം ഫയല് is ഇതും സംഭരിച്ചു in FORM_variable= ഒപ്പം
POST_variable=. ഈ is പരിഗണിക്കുന്നു സുരക്ഷിതമല്ലാത്തത് ഒപ്പം വേണം അല്ല be ഉപയോഗിച്ചു.

ക്ലയന്റ് ഡാറ്റ അയയ്ക്കുകയാണെങ്കിൽ രണ്ടും POST, GET രീതികൾ വഴി, തുടർന്ന് ഹാസർൽ മാത്രം പാഴ്സ് ചെയ്യും
എന്നതുമായി പൊരുത്തപ്പെടുന്ന ഡാറ്റ REQUEST_METHOD വെബ് സെർവർ സജ്ജീകരിച്ച വേരിയബിൾ, ഒഴികെ
എല്ലാം സ്വീകരിക്കുക ഓപ്ഷൻ സജ്ജമാക്കി. ഉദാഹരണത്തിന്, POST രീതി വഴി വിളിക്കുന്ന ഒരു ഫോം, എന്നാൽ ഉള്ളത്
ചിലതിന്റെ URI.cgi?foo=bar&otherdata=എന്തെങ്കിലും POST ഡാറ്റ പാഴ്‌സ് ചെയ്തിരിക്കും, കൂടാതെ ഫൂ
ഒപ്പം മറ്റ് ഡാറ്റ വേരിയബിളുകൾ അവഗണിക്കപ്പെടുന്നു.

വെബ് സെർവർ നിർവ്വചിക്കുകയാണെങ്കിൽ a HTTP_COOKIE പരിസ്ഥിതി വേരിയബിൾ, കുക്കി ഡാറ്റ പാഴ്‌സ് ചെയ്‌തു.
കുക്കി ഡാറ്റ പാഴ്‌സ് ചെയ്‌തു മുമ്പ് GET അല്ലെങ്കിൽ POST ഡാറ്റ, അതിനാൽ രണ്ട് വേരിയബിളുകൾ ഉണ്ടായാൽ
അതേ പേര്, GET അല്ലെങ്കിൽ POST ഡാറ്റ കുക്കി വിവരങ്ങൾ പുനരാലേഖനം ചെയ്യുന്നു.

ഒരേ വേരിയബിളിന്റെ ഒന്നിലധികം സംഭവങ്ങൾ വ്യത്യസ്ത ഉറവിടങ്ങളിൽ നിന്ന് അയയ്‌ക്കുമ്പോൾ, the
വേരിയബിളുകൾ പ്രോസസ്സ് ചെയ്യുന്ന ക്രമം അനുസരിച്ച് FORM_variable സജ്ജീകരിക്കും.
HTTP_COOKIE എല്ലായ്‌പ്പോഴും ആദ്യം പ്രോസസ്സ് ചെയ്യുന്നു, തുടർന്ന് REQUEST_METHOD. സ്വീകരിക്കുകയാണെങ്കിൽ-എല്ലാം
ഓപ്‌ഷൻ സജ്ജമാക്കി, തുടർന്ന് HTTP_COOKIE ആദ്യം പ്രോസസ്സ് ചെയ്യുന്നു, തുടർന്ന് അല്ല എന്ന രീതി
REQUEST_METHOD വ്യക്തമാക്കിയിരിക്കുന്നു, തുടർന്ന് REQUEST_METHOD. യുടെ അവസാന ഉദാഹരണം
FORM_variable സജ്ജമാക്കാൻ വേരിയബിൾ ഉപയോഗിക്കും. വേരിയബിളുകളും വെവ്വേറെയാണെന്ന് ശ്രദ്ധിക്കുക
COOKIE_variable, GET_variable, POST_variable എന്നിങ്ങനെ സൃഷ്ടിക്കുന്നു. ഇത് ഉപയോഗിക്കാൻ അനുവദിക്കുന്നു
ഓരോ ഉറവിടത്തിൽ നിന്നും ഓവർലാപ്പുചെയ്യുന്ന പേരുകൾ.

ഒരേ വേരിയബിളിന്റെ ഒന്നിലധികം സംഭവങ്ങൾ ഒരേ ഉറവിടത്തിൽ നിന്ന് അയയ്ക്കുമ്പോൾ, അവസാനത്തേത് മാത്രം
ഒരാൾ രക്ഷിക്കപ്പെട്ടു. എല്ലാ പകർപ്പുകളും സൂക്ഷിക്കാൻ (മൾട്ടി-സെലക്ടുകൾക്കായി, ഉദാഹരണത്തിന്), അവസാനം വരെ "[]" ചേർക്കുക
വേരിയബിൾ നാമത്തിന്റെ. എല്ലാ ഫലങ്ങളും പുതിയ ലൈനുകളാൽ വേർതിരിച്ച് തിരികെ നൽകും. ഉദാഹരണത്തിന്,
host=Enoch&host=Esther&host=ജോഷ്വ ഫലം "FORM_host=Joshua".
host[]=Enoch&host[]Esther&host[]=ജോഷ്വ ഫലം "FORM_host=Enoch\nEsther\nJoshua"

LANGUAGE എന്ന

ഇനിപ്പറയുന്ന ഭാഷാ ഘടനകൾ അംഗീകരിച്ചിരിക്കുന്നു ഹാസർൽ.

RUN
<% [ഷെൽ സ്ക്രിപ്റ്റ്] %>

<% %> ടാഗുകളാൽ ചുറ്റപ്പെട്ട എന്തും നിർവ്വഹണത്തിനായി സബ്-ഷെല്ലിലേക്ക് അയയ്ക്കും. വാചകം
അക്ഷരാർത്ഥത്തിൽ അയക്കുന്നു.

ഉൾപ്പെടുന്നു
<%പാത്ത്സ്പെക്കിൽ %>

ഈ സ്ക്രിപ്റ്റിൽ മറ്റൊരു ഫയൽ പദാനുപദമായി ഉൾപ്പെടുത്തുക. സ്ക്രിപ്റ്റ് ആയിരിക്കുമ്പോൾ ഫയൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്
തുടക്കത്തിൽ പാഴ്‌സ് ചെയ്യുന്നു.

EVAL
<%= എക്സ്പ്രഷൻ %>

ഷെൽ എക്സ്പ്രഷൻ പ്രിന്റ് ചെയ്യുക. "echo expr" എന്നതിനുള്ള വാക്യഘടന പഞ്ചസാര.

വിധം
<%# അഭിപ്രായം %>

കമന്റ് ബ്ലോക്ക്. ഒരു കമന്റ് ബ്ലോക്കിലെ ഒന്നും പാഴ്‌സ് ചെയ്‌തിട്ടില്ല. അഭിപ്രായങ്ങൾ നെസ്റ്റ് ചെയ്യാം
കൂടാതെ മറ്റ് ഹാസെർൽ ഘടകങ്ങൾ അടങ്ങിയിരിക്കാം.

ഉദാഹരണങ്ങൾ

മുന്നറിയിപ്പ്
എങ്ങനെ ഉപയോഗിക്കണമെന്ന് കാണിക്കുന്നതിന് ചുവടെയുള്ള ഉദാഹരണങ്ങൾ ലളിതമാക്കിയിരിക്കുന്നു ഹാസർൽ. നിങ്ങൾ തീർച്ചയായും
ഉപയോഗിക്കുന്നതിന് മുമ്പ് അടിസ്ഥാന വെബ് സ്ക്രിപ്റ്റിംഗ് സുരക്ഷ പരിചിതമാണ് ഹാസർൽ (അല്ലെങ്കിൽ ഏതെങ്കിലും സ്ക്രിപ്റ്റിംഗ്
ഭാഷ) ഒരു ഉൽപാദന അന്തരീക്ഷത്തിൽ.

ലഘുവായ കമാൻഡ്
#!/usr/local/bin/haserl
ഉള്ളടക്ക-തരം: ടെക്സ്റ്റ്/പ്ലെയിൻ

<%# ഇതൊരു സാമ്പിൾ "env" സ്ക്രിപ്റ്റ് ആണ് %>
<% env %>

യുടെ ഫലങ്ങൾ അച്ചടിക്കുന്നു അയക്കുക ഒരു mime-type "text/plain" പ്രമാണമായി കമാൻഡ് ചെയ്യുക. ഇതാണ്
The ഹാസർൽ പൊതുവായ പതിപ്പ് പ്രിന്റൻവി cgi

വീണ്ടും ലോപ്പിംഗ് കൂടെ ചലനാത്മകം ഔട്ട്പുട്ട്
#!/usr/local/bin/haserl
ഉള്ളടക്ക തരം: വാചകം/html




<% ഒരു ചുവന്ന നീല മഞ്ഞ സിയാൻ; %> ചെയ്യുക
"><% echo -n "$a" %>
<% ചെയ്തു %>




എന്നതിന്റെ ഒരു html പട്ടിക സഹിതം ഒരു മൈം-ടൈപ്പ് "ടെക്‌സ്റ്റ്/html" പ്രമാണം ക്ലയന്റിലേക്ക് അയയ്ക്കുന്നു.
പശ്ചാത്തല വർണ്ണം ഉപയോഗിച്ച് ലേബൽ ചെയ്ത ഘടകങ്ങൾ.

ഉപയോഗം ഷെൽ നിർവചിച്ചിരിക്കുന്നത് പ്രവർത്തനങ്ങൾ.
#!/usr/local/bin/haserl
ഉള്ളടക്ക തരം: വാചകം/html

<% # ഒരു ഉപയോക്തൃ പ്രവർത്തനം നിർവ്വചിക്കുക
table_element() {
പ്രതിധ്വനി " $1 "
}
%>



<% ഒരു ചുവന്ന നീല മഞ്ഞ സിയാൻ; %> ചെയ്യുക
<% table_element $a %>
<% ചെയ്തു %>




മുകളിൽ പറഞ്ഞതുപോലെ തന്നെ, എന്നാൽ എംബഡഡ് html-ന് പകരം ഒരു ഷെൽ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു.

സ്വയം പരാമർശിക്കുന്നു CGI കൂടെ a രൂപം
#!/usr/local/bin/haserl
ഉള്ളടക്ക തരം: വാചകം/html


മാതൃകാ ഫോം
" method="GET">
<% # FORM_textfield-ന്റെ ചില അടിസ്ഥാന മൂല്യനിർണ്ണയം നടത്തുക
# സാധാരണ വെബ് ആക്രമണങ്ങൾ തടയാൻ
FORM_textfield=$( echo "$FORM_textfield" | sed "s/[^A-Za-z0-9 ]//g" )
%>
<ഇൻപുട്ട് തരം=ടെക്‌സ്‌റ്റ് നാമം=ടെക്‌സ്‌റ്റ്ഫീൽഡ്
Value="<% echo -n "$FORM_textfield" | tr az AZ %>" cols=20>




ഒരു ഫോം പ്രിന്റ് ചെയ്യുന്നു. ക്ലയന്റ് ഫോമിൽ വാചകം നൽകിയാൽ, CGI വീണ്ടും ലോഡുചെയ്യപ്പെടും (നിർവചിച്ചിരിക്കുന്നത്
by $SCRIPT_NAME) കൂടാതെ വെബ് ആക്രമണങ്ങൾ തടയുന്നതിനായി ടെക്സ്റ്റ്ഫീൽഡ് അണുവിമുക്തമാക്കുന്നു, തുടർന്ന്
ഉപയോക്താവ് നൽകിയ ടെക്‌സ്‌റ്റ് ഉപയോഗിച്ച് ഫോം വീണ്ടും പ്രദർശിപ്പിച്ചിരിക്കുന്നു. വാചകം വലിയക്ഷരത്തിലാണ്.

അപ്‌ലോഡുചെയ്യുന്നു a ഫയല്
#!/usr/local/bin/haserl --upload-limit=4096 --upload-dir=/ tmp
ഉള്ളടക്ക തരം: വാചകം/html


" method=POST enctype="multipart/form-data" >



<% if test -n "$HASERL_uploadfile_path"; തുടർന്ന് %>

നിങ്ങൾ <% echo -n $FORM_uploadfile_name %> എന്ന പേരിൽ ഒരു ഫയൽ അപ്‌ലോഡ് ചെയ്തു, അത്
. താൽക്കാലികമായി സെർവറിൽ ആയി സംഭരിച്ചിരിക്കുന്നു. ദി
ഫയൽ <% cat $HASERL_uploadfile_path | ആയിരുന്നു wc -c %> ബൈറ്റുകൾ നീളം.
<% rm -f $HASERL_uploadfile_path %> വിഷമിക്കേണ്ട, ഫയൽ ഇപ്പോൾ ഇല്ലാതാക്കി
വെബ് സെർവറിൽ നിന്ന്.
<% വേറെ %>
നിങ്ങൾ ഇതുവരെ ഒരു ഫയൽ അപ്‌ലോഡ് ചെയ്‌തിട്ടില്ല.
<% fi %>



ഫയൽ അപ്‌ലോഡ് ചെയ്യാൻ അനുവദിക്കുന്ന ഒരു ഫോം പ്രദർശിപ്പിക്കുന്നു. ഉപയോഗിച്ചാണ് ഇത് നടപ്പിലാക്കുന്നത്
--അപ്‌ലോഡ്-പരിധി ഫോം സജ്ജീകരിക്കുന്നതിലൂടെയും എൻക്‌ടൈപ്പ് ലേക്ക് മൾട്ടിപാർട്ട്/ഫോം-ഡാറ്റ. എങ്കില്
ക്ലയന്റ് ഒരു ഫയൽ അയയ്‌ക്കുന്നു, തുടർന്ന് ഫയലിനെക്കുറിച്ചുള്ള ചില വിവരങ്ങൾ അച്ചടിക്കുന്നു, തുടർന്ന്
ഇല്ലാതാക്കി. അല്ലെങ്കിൽ, ക്ലയന്റ് ഒരു ഫയൽ അപ്‌ലോഡ് ചെയ്തിട്ടില്ലെന്ന് ഫോം പറയുന്നു.

ആർഎഫ്സി -2616 അനുരൂപീകരണം
#!/usr/local/bin/haserl
<% echo -en "content-type: text/html\r\n\r\n" %>

...


എച്ച്ടിടിപി സ്പെസിഫിക്കേഷൻ പൂർണ്ണമായും അനുസരിക്കുന്നതിന്, തലക്കെട്ടുകൾ ഉപയോഗിച്ച് അവസാനിപ്പിക്കണം
സാധാരണ unix LF ലൈൻ അവസാനിപ്പിക്കുന്നതിനുപകരം CR+LF. മുകളിലുള്ള വാക്യഘടനയ്ക്ക് കഴിയും
RFC 2616 കംപ്ലയിന്റ് ഹെഡറുകൾ നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്നു.

ENVIRONMENT

വെബ് സെർവറിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്ന പരിസ്ഥിതി വേരിയബിളുകൾക്ക് പുറമേ, ഇനിപ്പറയുന്നവയും
എൻവയോൺമെന്റ് വേരിയബിളുകൾ എപ്പോഴും സ്റ്റാർട്ടപ്പിൽ നിർവചിക്കപ്പെടുന്നു:

ഹാസർൾവർ
ഹാസർൽ പതിപ്പ് - ഒരു വിവര ടാഗ്.

സെഷൻ ഐഡി
CGI-യുടെ ജീവിതത്തിന് സവിശേഷമായ ഒരു ഹെക്‌സാഡെസിമൽ ടാഗ് (അത് ജനറേറ്റുചെയ്യുമ്പോൾ
cgi ആരംഭിക്കുന്നു; മറ്റൊരു POST അല്ലെങ്കിൽ GET അന്വേഷണം ഉണ്ടാകുന്നത് വരെ മാറില്ല.)

HASERL_ACCEPT_ALL
എങ്കില് --എല്ലാം സ്വീകരിക്കുക പതാക സ്ഥാപിച്ചു, -1, അല്ലെങ്കിൽ 0.

HASERL_SHELL
ഷെൽ ഹാസർലിന്റെ പേര് സബ്-ഷെൽ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാൻ തുടങ്ങി.

HASERL_UPLOAD_DIR
അപ്‌ലോഡ് ചെയ്ത ഫയലുകൾ സംഭരിക്കുന്നതിന് ഡയറക്ടറി ഹാസെർൽ ഉപയോഗിക്കും.

HASERL_UPLOAD_LIMIT
ക്ലയന്റിൽനിന്ന് സെർവറിലേക്ക് അയയ്‌ക്കാൻ അനുവദിച്ചിരിക്കുന്ന കെബിയുടെ എണ്ണം.

ഈ വേരിയബിളുകൾ സ്ക്രിപ്റ്റിനുള്ളിൽ തന്നെ പരിഷ്ക്കരിക്കുകയോ തിരുത്തിയെഴുതുകയോ ചെയ്യാം
"HASERL_" എന്നതിൽ ആരംഭിക്കുന്നത് വിവരദായകമാണ്, കൂടാതെ പ്രവർത്തിക്കുന്ന സ്ക്രിപ്റ്റിനെ ബാധിക്കില്ല.

സുരക്ഷിതത്വം സവിശേഷതകൾ

CGI സ്ക്രിപ്റ്റുകൾ പ്രോഗ്രാം ചെയ്യാൻ ഷെൽ ഉപയോഗിക്കുന്നതിന്റെ അപകടങ്ങളെക്കുറിച്ച് ധാരാളം സാഹിത്യങ്ങളുണ്ട്.
ഹാസർൽ അടങ്ങിയിരിക്കുന്നു കുറെ ഈ അപകടസാധ്യത ലഘൂകരിക്കാനുള്ള സംരക്ഷണം.

പരിസ്ഥിതി വേരിയബിളുകൾ
എൻവയോൺമെന്റ് വേരിയബിളുകൾ പോപ്പുലേറ്റ് ചെയ്യുന്നതിനുള്ള കോഡ് ഉപ-യുടെ പരിധിക്ക് പുറത്താണ്
ഷെൽ. ഇത് കഥാപാത്രങ്ങളെ വിശകലനം ചെയ്യുന്നുണ്ടോ? കൂടാതെ &, അതിനാൽ ഒരു ക്ലയന്റിന് ഇത് ചെയ്യാൻ പ്രയാസമാണ്
"ഇഞ്ചക്ഷൻ" ആക്രമണങ്ങൾ. ഒരു ഉദാഹരണം എന്ന നിലക്ക്, foo.cgi?a=test;cat / etc / passwd കാരണമാകാം
ഒരു വേരിയബിളിന് മൂല്യം നൽകുന്നു പരിശോധന തുടർന്ന് ഓട്ടത്തിന്റെ ഫലങ്ങൾ പൂച്ച
/ etc / passwd ക്ലയന്റിലേക്ക് അയയ്ക്കുന്നു. ഹാസർൽ വേരിയബിളിനെ പൂർണ്ണമായി നിയോഗിക്കും
മൂല്യം: ടെസ്റ്റ്;പൂച്ച / etc / passwd

ഷെൽ സ്ക്രിപ്റ്റുകളിൽ ഈ "അപകടകരമായ" വേരിയബിൾ ഉപയോഗിക്കുന്നത് സുരക്ഷിതമാണ്
ഉദ്ധരണികൾ; എല്ലാ ഇൻപുട്ട് ഫീൽഡുകളിലും മൂല്യനിർണ്ണയം നടത്തേണ്ടതുണ്ടെങ്കിലും.

പ്രിവിലേജ് ഉപേക്ഷിക്കുന്നു
ഒരു സൂയിഡ് സ്ക്രിപ്റ്റായി ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ, ഹാസർൽ അതിന്റെ uid/gid ഉടമയുടേതായി സജ്ജീകരിക്കും
തിരക്കഥ. വ്യത്യസ്തമായ CGI സ്ക്രിപ്റ്റുകളുടെ ഒരു കൂട്ടം ഉണ്ടായിരിക്കാൻ ഇത് ഉപയോഗിക്കാം
പദവി. എങ്കിൽ ഹാസർൽ ബൈനറി suid ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ല, അപ്പോൾ CGI സ്ക്രിപ്റ്റുകൾ ചെയ്യും
വെബ് സെർവറിന്റെ uid/gid ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കുക.

നിരസിക്കുക കമാൻഡ് വര പാരാമീറ്ററുകൾ നൽകപ്പെട്ട on The യുആർഎൽ
URL-ൽ എൻകോഡ് ചെയ്യാത്ത "=" ഇല്ലെങ്കിൽ, CGI സ്പെസിഫിക്കേഷൻ ഓപ്ഷനുകൾ പ്രസ്താവിക്കുന്നു
പ്രോഗ്രാമിന്റെ കമാൻഡ്-ലൈൻ പാരാമീറ്ററുകളായി ഉപയോഗിക്കേണ്ടതാണ്. ഉദാഹരണത്തിന്, അനുസരിച്ച്
CGI സ്പെസിഫിക്കിലേക്ക്: http://192.168.0.1/test.cgi?--upload-limit%3d2000&foo%3dbar
"Foo=bar" സജ്ജീകരിക്കുന്നതിന് പുറമേ അപ്‌ലോഡ്-പരിധി 2000KB ആയി സജ്ജീകരിക്കണം. സംരക്ഷിക്കാൻ
ക്ലയന്റുകൾ അവരുടെ സ്വന്തം അപ്‌ലോഡുകൾ പ്രവർത്തനക്ഷമമാക്കുന്നതിനെതിരെ, ഹാസർൽ ഏതെങ്കിലും കമാൻഡ്-ലൈൻ ഓപ്ഷനുകൾ നിരസിക്കുന്നു
ആർജിവിക്ക് അപ്പുറം[2]. # ആയി വിളിച്ചാൽ! സ്ക്രിപ്റ്റ്, വ്യാഖ്യാതാവ് argv[0] ആണ്, എല്ലാം
#-ൽ ലിസ്റ്റ് ചെയ്തിരിക്കുന്ന കമാൻഡ്-ലൈൻ ഓപ്ഷനുകൾ! വരികൾ argv[1] ആയി സംയോജിപ്പിച്ചിരിക്കുന്നു
സ്ക്രിപ്റ്റ് പേര് argv[2].

ലുഅ

lua പിന്തുണയോടെ സമാഹരിച്ചാൽ, --shell=lua പകരം സ്ക്രിപ്റ്റ് ഭാഷയായി lua പ്രവർത്തനക്ഷമമാക്കും
ബാഷ് ഷെല്ലിന്റെ. പരിസ്ഥിതി വേരിയബിളുകൾ (SCRIPT_NAME, SERVER_NAME, മുതലായവ) സ്ഥാപിച്ചിരിക്കുന്നു
ENV പട്ടികയും ഫോം വേരിയബിളുകളും ഫോം ടേബിളിൽ സ്ഥാപിച്ചിരിക്കുന്നു. ഉദാഹരണത്തിന്, ദി
മുകളിലുള്ള സ്വയം റഫറൻസിംഗ് ഫോം ഇതുപോലെ എഴുതാം:

#!/usr/local/bin/haserl --shell=lua
ഉള്ളടക്ക തരം: വാചകം/html


മാതൃകാ ഫോം
" രീതി="GET">
<% # FORM_textfield-ന്റെ ചില അടിസ്ഥാന മൂല്യനിർണ്ണയം നടത്തുക
# സാധാരണ വെബ് ആക്രമണങ്ങൾ തടയാൻ
FORM.textfield=string.gsub(FORM.textfield, "[^%a%d]", "")
%>
<ഇൻപുട്ട് തരം=ടെക്‌സ്‌റ്റ് നാമം=ടെക്‌സ്‌റ്റ്ഫീൽഡ്
മൂല്യം="<% io.write (string.upper(FORM.textfield)) %>" cols=20>




<%= ഓപ്പറേറ്റർ സിന്റാക്‌റ്റിക് ഷുഗർ ആണ് io.write (ടോസ്ട്രിംഗ്( ... )) അതിനാൽ, ഉദാഹരണത്തിന്, ദി
മൂല്യം= മുകളിലെ വരി എഴുതാം: മൂല്യം="<%= string.upper(FORM.textfield) %>" കോളുകൾ=20>

haserl lua സ്ക്രിപ്റ്റുകൾക്ക് ഫംഗ്ഷൻ ഉപയോഗിക്കാം haserl.loadfile(ഫയലിന്റെ പേര്) ഒരു ലക്ഷ്യം പ്രോസസ്സ് ചെയ്യാൻ
സ്ക്രിപ്റ്റ് ഒരു ഹാസെർൽ (ലുവാ) സ്ക്രിപ്റ്റായി. ഫംഗ്ഷൻ ഒരു തരം "ഫംഗ്ഷൻ" നൽകുന്നു.

ഉദാഹരണത്തിന്,

bar.lsp
<% io.write ("ഹലോ വേൾഡ്" ) %>

നിങ്ങളുടെ സന്ദേശം <%= gvar %> ആണ്

-- ഫയൽ ഉൾപ്പെടുത്തുന്നതിന്റെ അവസാനം --

foo.haserl
#!/usr/local/bin/haserl --shell=lua
<% m = haserl.loadfile("bar.lsp")
gvar = "m() ആയി പ്രവർത്തിപ്പിക്കുക"
m ()

gvar = "ഒരു ഘട്ടത്തിൽ ലോഡുചെയ്ത് പ്രവർത്തിപ്പിക്കുക"
haserl.loadfile("bar.lsp")()
%>

പ്രവർത്തിക്കുന്ന ഫൂ ഉൽപ്പാദിപ്പിക്കും:

ഹലോ വേൾഡ്
m() ആയി റൺ ചെയ്യുക എന്നതാണ് നിങ്ങളുടെ സന്ദേശം
-- ഫയൽ ഉൾപ്പെടുത്തുന്നതിന്റെ അവസാനം --
ഹലോ വേൾഡ്
ഒരു ഘട്ടത്തിൽ ലോഡുചെയ്ത് റൺ ചെയ്യുക എന്നതാണ് നിങ്ങളുടെ സന്ദേശം
-- ഫയൽ ഉൾപ്പെടുത്തുന്നതിന്റെ അവസാനം --

ഈ ഫംഗ്‌ഷൻ നെസ്റ്റഡ് ഹാസെർൾ സെർവർ പേജുകൾ - പേജ് സ്‌നിപ്പെറ്റുകൾ സാധ്യമാക്കുന്നു
ഹാസർൽ ടോക്കണൈസർ പ്രോസസ്സ് ചെയ്യുന്നവ.

LUAC

ദി luac "ഷെൽ" എന്നത് മുൻകൂട്ടി തയ്യാറാക്കിയ ലുവാ ചങ്ക് ആണ്, അതിനാൽ സ്ക്രിപ്റ്റുകളുടെ സംവേദനാത്മക എഡിറ്റിംഗും പരിശോധനയും
സാധ്യമല്ല. എന്നിരുന്നാലും, luac പിന്തുണയോടെ മാത്രമേ ഹസെർൾ സമാഹരിക്കാൻ കഴിയൂ, ഇത് അനുവദിക്കുന്നു
ഒരു ചെറിയ മെമ്മറി പരിതസ്ഥിതിയിൽ പോലും lua പിന്തുണ. മുകളിൽ ലിസ്‌റ്റ് ചെയ്‌തിരിക്കുന്ന എല്ലാ ഹസേർൾ ലുവ സവിശേഷതകളും
ഇപ്പോഴും ലഭ്യമാണ്. (haserl-ൽ നിർമ്മിച്ച ഒരേയൊരു ഷെൽ luac ആണെങ്കിൽ, haserl.loadfile ആണ്
ഹാസർൽ പാർസർ കംപൈൽ ചെയ്തിട്ടില്ലാത്തതിനാൽ പ്രവർത്തനരഹിതമാക്കി.)

ഒരു luac cgi സ്ക്രിപ്റ്റിലേക്ക് പരിവർത്തനം ചെയ്ത ഒരു നിസ്സാര സ്ക്രിപ്റ്റിന്റെ ഒരു ഉദാഹരണം ഇതാ:

ഫയൽ test.lua നൽകി:
പ്രിന്റ് ("ഉള്ളടക്ക-തരം: വാചകം/പ്ലെയിൻ0)
പ്രിന്റ് ("ഈ ഓട്ടത്തിനുള്ള നിങ്ങളുടെ UUID ഇതാണ്: " .. ENV.SESSIONID)

ഇത് luac ഉപയോഗിച്ച് സമാഹരിക്കാം:
luac -o test.luac -s test.lua

തുടർന്ന് ഹാസർൽ തലക്കെട്ട് ഇതിലേക്ക് ചേർത്തു:
എക്കോ '#!/usr/bin/haserl --shell=luac' | cat - test.luac >luac.cgi

പകരമായി, സ്റ്റാൻഡേർഡ് ലുവാ ഷെൽ ഉപയോഗിച്ച് ഒരു മുഴുവൻ വെബ്‌സൈറ്റും വികസിപ്പിക്കാൻ കഴിയും,
തുടർന്ന് a യുടെ ഭാഗമായി luac കംപൈലറിനായുള്ള സ്ക്രിപ്റ്റുകൾ haserl തന്നെ പ്രീപ്രോസസ് ചെയ്യാൻ ആവശ്യപ്പെടുക
നിർമ്മാണ പ്രക്രിയ. ഇത് ചെയ്യുന്നതിന്, --shell=lua ഉപയോഗിക്കുക, വെബ്സൈറ്റ് വികസിപ്പിക്കുക. നിർമ്മിക്കാൻ തയ്യാറാകുമ്പോൾ
റൺടൈം എൻവയോൺമെന്റ്, നിങ്ങളുടെ lua സ്ക്രിപ്റ്റുകളിലേക്ക് --debug ലൈൻ ചേർക്കുക, അവ ഔട്ട്പുട്ടിംഗ് പ്രവർത്തിപ്പിക്കുക
ഫലങ്ങൾ .lua ഉറവിട ഫയലുകളിലേക്ക്. ഉദാഹരണത്തിന്:

haserl script test.cgi നൽകിയത്:
#!/usr/bin/haserl --shell=lua --debug
ഉള്ളടക്ക-തരം: ടെക്സ്റ്റ്/പ്ലെയിൻ

ഈ ഓട്ടത്തിനുള്ള നിങ്ങളുടെ UUID <%= ENV.SESSIONID %> ആണ്

മുൻകൂട്ടി കംപൈൽ ചെയ്യുക, കംപൈൽ ചെയ്യുക, കൂടാതെ haserl luac തലക്കെട്ട് ചേർക്കുക:
./test.cgi > test.lua
luac -s -o test.luac test.lua
എക്കോ '#!/usr/bin/haserl --shell=luac' | cat - test.luac >luac.cgi

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് ഹാസർൽ ഓൺലൈനായി ഉപയോഗിക്കുക