[php5] Headers correct versturen vanuit PHP

[Verwijderd]

Hoi, ik wil graag correct (wat begreft seo/google/rfc's) binnen php een 404 header versturen.

De op forums vaak gesuggereerde code:

PHP:

header("Status: 404 Not Found");

gaat anno 2010 natuurlijk niet werken, omdat volgens de ontwikkelaars van php deze code ENKEL onder PHP3 werkt MITS deze als Apache-Module gecompileerd is!!

Dat is jammer, want nu moet je dus het 'server_protocol' weten (zoals "HTTP/1.0" of "HTTP/1.1" of "HTTPS" of ...?), zodat je die header bijvoorbeeld als volgt kunt versturen:

PHP:

header("HTTP/1.1 404 Not Found");

Hier ligt 'n probleem: wat als de user/browser om HTTP/1.0 of HTTPS vraagt?
Dus is er de $_SERVER["SERVER_PROTOCOL"] variabele die je als volgt zou kunnen gebruiken:

PHP:

header($_SERVER["SERVER_PROTOCOL"]." 404 Not Found");

Maarrrrr ik begrijp dat je die waarde niet kunt vertrouwen (ik DENK dat 't 'user submitted data' is en dus gevoelig voor header injection/spoofing) EN dat deze variabele (volgens wat ik las) leeg is als het HTTPS is.

Een uitgebreide case/if/switch waarin alle huidig bekende opties worden gecontroleerd zie ik niet zo zitten, er moet toch 'n 'betere/correcte' manier zijn (die ik gewoon niet vind of over 't hoofd zie?).
Ik heb echt mijn best gedaan om 't juiste antwoord te vinden, maar ik vind 't echt niet.

Hoe moet het nu dus wel???

Extra vraag: Wie weet 'n betrouwbare lijst waaruit blijkt welke variabelen je nu wel of niet mag vertrouwen? Ik geloof namelijk dat in $_SERVER ook variabelen zitten die je wel kunt vertrouwen (zoals bijvoorbeeld SERVER_SIGNATURE)?

Vast hartelijk bedankt!

[Sebazzz]

Maarrrrr ik begrijp dat je die waarde niet kunt vertrouwen (ik DENK dat 't 'user submitted data' is en dus gevoelig voor header injection/spoofing) EN dat deze variabele (volgens wat ik las) leeg is als het HTTPS is.

Nouja, waarschijnlijk zegt de webserver al van 'doei, die http versie ondersteun ik niet' of 'ongeldige aanvraag' voordat het bij PHP komt als de client in plaats van HTTP1/1 iets als AppleInternet4/1 invult.

[mithras]

Hiervoor heb je frameworks

Klinkt als een stomme opmerking, maar dit zijn zaken die veel moeite kosten om uit te zoeken. Verschillende php omgevingen zorgen voor verschillende inhoud van $_SERVER. HTTPS omgeving staat meestal met $_SERVER['HTTPS'] = 'on' gedefinieerd, maar ook dat weer niet altijd.

Verder hoef je je geen zorgen te maken over HTTP/1.1 headers in een HTTPS omgeving. HTTPS is een combinatie van HTTP en SSL/TLS waarbij HTTP headers (en response codes) gewoon gelden. Je kan dus óók gewoon dit gebruiken in een HTTPS environment:

PHP:

header("HTTP/1.1 404 Not Found");

En tot slot hoef je je al helemaal geen zorgen te maken over HTTP/1.0. Zelfs Internet Explorer 3.0 ondersteunt HTTP/1.1

[Ealanrian]

Verwijderd schreef op zondag 20 juni 2010 @ 19:38:


De op forums vaak gesuggereerde code:

PHP:

header("Status: 404 Not Found");

gaat anno 2010 natuurlijk niet werken, omdat volgens de ontwikkelaars van php deze code ENKEL onder PHP3 werkt MITS deze als Apache-Module gecompileerd is!!

ik denk dat je de uitleg verkeerd hebt begrepen. dit werkt in php4 en hoger en in php3 wanneer deze als apache module is gecompileerd. niet alleen in php3

[MueR]

Daarnaast heeft de header functie meer parameters. De derde is voor jou interessant.

void header ( string $string [, bool $replace = true [, int $http_response_code ]] )

mithras schreef op zondag 20 juni 2010 @ 19:55:
Hiervoor heb je frameworks

He ja, een kanon gebruiken om op een mug te schieten

[ Voor 33% gewijzigd door MueR op 20-06-2010 19:59 ]

[GlowMouse]

Draai eens wat testjes. Hier met Apache2.2 en PHP5 wordt een en ander nog wel herschreven, vermoedelijk door Apache.

PHP:

header('http/0.9 404 not found');

die geeft netjes HTTP/1.1 404 Not Found

PHP:

header("Status: 404 Not Found");

die geeft
HTTP/1.1 200 OK
status: 404 Not Found

[Voutloos]

MueR schreef op zondag 20 juni 2010 @ 19:58:
He ja, een kanon gebruiken om op een mug te schieten

TJa, of mithras bedoelt dat je in een Framework kan spieken. Alleen jammer dat bijvoorbeeld Zend Framework ook op een aantal punten maar wat aanklooit en niet de rfc's volgt.

Overigens zijn de 2e en 3e parameters van header() wat mij betreft een grote WTF: Voor replace moet je gewoon een gedrag kiezen en lekker die optie weglaten, en voor de 3e parameter had gewoon een losse set_response_code(int $http_response_code) moet zijn, zodat je het probleem van dit topic uberhaupt niet hebt.

[/stomme-optionele-parameters-en-neveneffect-PHP-functies-rant]

[ Voor 12% gewijzigd door Voutloos op 20-06-2010 20:11 ]

[mithras]

MueR schreef op zondag 20 juni 2010 @ 19:58:
He ja, een kanon gebruiken om op een mug te schieten

offtopic:
Nu steeds meer mensen met php werken en tegelijkertijd de frameworks steeds beter van kwaliteit worden snap ik niet meer waarom mensen nog zelf aanklooien.

Inderdaad: voor een response code hoef je geen framework in te zetten. Maar het bestaan ervan heeft twee voordelen:
1) het is al onderzocht. Vind niet het wiel opnieuw uit en kijk hoe anderen het doen. Zorgt ook nog eens voor een meer stabiele applicatie (als het goed is);
2) zo'n probleempje is vast niet het eerste. Tig keer zelf puzzelstukjes bouwen is vandaag de dag niet meer efficient en leerzaam evenmin. Kijken naar een groter geheel is juist met een taal die zo toegankelijk is belangrijk.

Daarom noem ik het bestaan van frameworks liefst elke keer dat iemand zo'n vraag stelt. Om op z'n minst te zorgen dat het bewustzijn er is

[Verwijderd]

@Iedereen: Wauw, wat gaat dat snel mensen! Super!!!

@Ealanrian:
Als ik de test van Glow-mouse (super bedankt, spaart me tijd ) goed lees, komt er dus inderdaad een 200 response en geen 404. Ik neem dus aan dat ik die uitleg correct heb begrepen?

@Sebazzz:
Ik weet toevallig dat "ooit lang geleden" Apache 1.nogiets een directory-list gaf als je als SERVER_PROTOCOL de waarde "*" opgaf.

Kunnen we dat testen OF is er ergens 'n goede lijst met welke variabelen je wel en niet kunt vertrouwen?

@Mithras:
Uit de test van Glow-mouse zie ik dat ie een HTTP/0.9 vroeg en 'n HTTP/1.1 kreeg. Dat zou betekenen samen met je uitleg dat je misschien inderdaad gewoon HTTP/1.1 kunt hard-coden.

@Muer: Die $http_response_code ga ik snel even over googlen

[MueR]

Verwijderd schreef op zondag 20 juni 2010 @ 20:31:
@Muer: Die $http_response_code ga ik snel even over googlen

Zal ik je de moeite besparen? http://php.net/header

[Verwijderd]

Ok, 'k was 'm al aan 't lezen/testen.

Ik vond hier deze post waarin wordt vermeld dat als je 'n 'n header verstuurt met de 3e parameter dat deze beiden verstuurd worden.

PHP:

<?php header('',true,404); ?>

geeft:
HTTP/1.1 200 OK

Dus dan maar die niet-werkende (dummy) waarde erin, kijken of er dan wat gebeurt:

PHP:

<?php header('Status: 404 Not Found',true,404); ?>

Geeft:
HTTP/1.1 404 Not Found
Status: 404 Not Found

Hmm, op de goede weg zo...
Als ik 't dus goed begrijp krijg je die 404 op deze manier bij elke header-string, als je er maar een opgeeft?
Dus, wat zetten we als 1e parameter? Of is er nog een andere manier?

[Mike-RaWare]

Volgens deze reactie moet je gewoon iets totaal nutteloos als 'x' als parameter gebruiken.

[ Voor 3% gewijzigd door Mike-RaWare op 20-06-2010 21:43 ]

[Verwijderd]

@Mike-RaWare: hey, thx, ik zie 'm.


Dus als 'Status: 404 Not Found' in 'n huidige php/apache omgeving niets 'magisch' meer doet en gewoon als (nutteloze) string in de header wordt geplaats, evenals de dummy-waarde 'X'...
dan misschien iets nuttigers hier plaatsen (dat wel bestaat) zoals misschien:

PHP:

<?php header('Cache-Control: no-cache',true,404); ?>

Een 404 (en nog zo wat van die pagina's) lijken mij sowiso niet de bedoeling om te cachen?

Hebben we dan zo met z'n allen de 'juiste'/'beste'/'goede' manier?

[Sebazzz]

Verwijderd schreef op zondag 20 juni 2010 @ 23:45:
@Mike-RaWare: hey, thx, ik zie 'm.

Een 404 (en nog zo wat van die pagina's) lijken mij sowieso niet de bedoeling om te cachen?

Dat gedrag is in de HTTP specificatie vastgelegd, of een client dan een pagina opnieuw mag opvragen of niet. Voor permanent verdwenen pagina's heb je bijvoorbeeld HTTP 410 Gone.

10.4.5 404 Not Found

The server has not found anything matching the Request-URI. No indication is given of whether the condition is temporary or permanent. The 410 (Gone) status code SHOULD be used if the server knows, through some internally configurable mechanism, that an old resource is permanently unavailable and has no forwarding address. This status code is commonly used when the server does not wish to reveal exactly why the request has been refused, or when no other response is applicable.

10.4.11 410 Gone

The requested resource is no longer available at the server and no forwarding address is known. This condition is expected to be considered permanent. Clients with link editing capabilities SHOULD delete references to the Request-URI after user approval. If the server does not know, or has no facility to determine, whether or not the condition is permanent, the status code 404 (Not Found) SHOULD be used instead. This response is cacheable unless indicated otherwise.

The 410 response is primarily intended to assist the task of web maintenance by notifying the recipient that the resource is intentionally unavailable and that the server owners desire that remote links to that resource be removed. Such an event is common for limited-time, promotional services and for resources belonging to individuals no longer working at the server's site. It is not necessary to mark all permanently unavailable resources as "gone" or to keep the mark for any length of time -- that is left to the discretion of the server owner.

Zie ook: http://www.w3.org/Protoco...2616-sec10.html#sec10.3.3

[Verwijderd]

This response is cacheable unless indicated otherwise.

Als de 404 pagina nu statisch is en de locatie van die statische pagina wordt doorgegeven naar de browser zou 't cachen van die 404 pagina wel handig zijn.

Bijvoorbeeld:

PHP:

<?php header('Location: /404.shtml',true,307); ?>

geeft keurig een: HTTP/1.1 307 Temporary Redirect
Hierna vraagt de browser weer 404.shtml aan de server die dit bestand samen met een 200 OK verstuurt.

Maar dit is niet wat er normaal bij een 404 gebeurt. Dan krijg je de 404 status SAMEN met het 404 document OP de gevraagde locatie (alsof het dus de gevraagde resource is, maar de 404 geeft aan dat 't dat niet is). Zo zeg ik 't toch goed?

Helaas werkt 't volgende kennelijk niet:

PHP:

<?php header('Location: /404.shtml',true,404); ?>

Dat was wel mooi geweest omdat Apache niet automatisch een bijpassend bestaand error-document meestuurt na een header vanuit php.
Of doe ik iets fout?

Wat betreft 'voorbeelden' (frameworks) vond ik toevallig iets over WordPress, daar waren ze zo'n 3 jaar geleden ook met dit vraagstuk bezig. Kennelijk gebruiken sommige proxy's ed nog HTTP/1.0 terwijl WordPress altijd 1.1 antwoordde. Dat leidde tot problemen. Als ik 't goed begrijp is dat daar met $_SERVER["SERVER_PROTOCOL"] opgelost? Wat zou betekenen dat die variabele veilig is, want ze zouden toch niet zo'n header-injection/spoofing gat creëren in hun pakket?

[MueR]

Je wil nooit redirecten bij een 404. Je krijgt die 404 op een bepaalde request URI, dan moet ook duidelijk zijn voor bots en bezoekers dat het om die URI gaat.

[mithras]

Als je 404 stuurt en wil redirecten: voorkom problemen en lees alvast de oplossing voor een probleem wat ik een tijd geleden had: Spider.007 in "[Apache2]ErrorDocument in mod_rewrite"

De ErrorDocument directive in de .htaccess samen met het versturen van 404 headers vanuit php kan je anders een hoop kopzorgen opleveren.

[Sebazzz]

MueR schreef op maandag 21 juni 2010 @ 10:24:
Je wil nooit redirecten bij een 404. Je krijgt die 404 op een bepaalde request URI, dan moet ook duidelijk zijn voor bots en bezoekers dat het om die URI gaat.

Lijkt me sterk dat producten zoals ASP.NET dan zo slecht zijn ontworpen omdat je bij ASP.NET in het web.config alleen kan aangeven dat ie moet redirecten bij een 404.

[Verwijderd]

Verwijderd schreef op maandag 21 juni 2010 @ 05:23:
[...]Maar dit is niet wat er normaal bij een 404 gebeurt. Dan krijg je de 404 status SAMEN met het 404 document OP de gevraagde locatie (alsof het dus de gevraagde resource is, maar de 404 geeft aan dat 't dat niet is). Zo zeg ik 't toch goed?

"klinkt als:"

MueR schreef op maandag 21 juni 2010 @ 10:24:
Je wil nooit redirecten bij een 404. Je krijgt die 404 op een bepaalde request URI, dan moet ook duidelijk zijn voor bots en bezoekers dat het om die URI gaat.

Dat is inderdaad beter geformuleerd

Wel blijkt dus dat je binnen PHP NIET ALLES als header-string kunt gebruiken (zoals dus Location: ...) icm een 404 (of 4xx) als 3e header()-parameter.
(En dat is misschien toch wel handig -voor anderen- om in dit topic te vermelden).

---

beetje offtopic:

Sebazzz schreef op maandag 21 juni 2010 @ 15:17:
[...]omdat je bij ASP.NET in het web.config alleen kan aangeven dat ie moet redirecten bij een 404.

Grappig dat je 't daarover hebt, ik was net met .htaccess aan 't spelen:

code:

RedirectMatch 404 .*inc_.*\..*$

dit geeft een keurige 'HTTP/1.1 404 Not Found' met de in apache gedefinieerde standaard error-pagina (hier 404.shtml) voor alle bestanden die eindigen met '*inc_*.*' (in DOS-stijl )
Misschien kan de regex wel sterker/beter en misschien is dit beter/makkelijker via de <Files> in .htaccess. Daar ben ik nog wat mee aan 't stoeien. Maar dit werkt perfect (volgens mij)...

offtopic:
dat is... zodra je hebt uitgevogeld dat IE naar de Content-Length in de responce-header kijkt om te bepalen of 'het document groter is' dan de (standaard instelling in register) 512 bytes die een 'goede pagina' volgens IE (en ik geloof tegenwoordig ook Chrome) MOET hebben. (Zelfs bij MS geen melding in hun 'friendly HTTP-status error messages' documentatie..)

MAAR: als het bestand INGEPAKT verstuurd wordt (zoals met gzip), heeft het dus GEEN ZIN om een hoop enters/spaties (al dan niet in commentaar) in de error-doc te plaatsen zodat het bestand groter is dan die 512 bytes.
Als het compressie-algoritme 100 keer een losse spatie tegenkomt zal die daar (als het ware) zeggen: 100*spatie (wat 'n stuk minder tekens zijn dan 100 losse spaties).
Het eind-resultaat van de compressie is de content die uiteindelijk verstuurd gaat worden en diens grootte is dus de grootte die als 'Content-Length' in de responce-header wordt mee-gegeven.

Na 'n middag weet ik nu eindelijk waarom de standaard 404.shtml (op 'n lamp-server) die standaard 515 kb groot is (standaard aangevuld met 'n zooi enters achter de </html>-tag) toch niet in IE worden weergegeven..
(ook niet met nog meer enters/spaties of zelfs 1000 keer de text 'bogus' in 'n commentaar... echter 50 verschillende woorden (zoals uit 'n lorum ipsum) gaat perfect). Lang leve Ethereal

---

Weer ontopic:
@Mithras:
Bedankt voor die link met waarschuwing/uitleg! Hij bracht ook op het idee van virtual() (zodat de shtml geparsed wordt):

PHP:

<?php header('Cache-Control: no-cache',true,404); die(virtual('/404.shtml')); ?>

Lijkt ook aardig te werken, maar waar nu die '1' (als laatste character van de gegenereerde html) vandaan komt.. hmmz, 'ns even stoeien.

Nou weten wel wel nog niet of die $_SERVER["SERVER_PROTOCOL"] nu WEL of NIET VEILIG IS..
Of is hier nog misschien 'n andere (wel veilige) functie/methode/waarde/iets voor?

[WouZz]

RedirectMatch 404 .*inc_.*\..*$

dit geeft een keurige 'HTTP/1.1 404 Not Found' met de in apache gedefinieerde standaard error-pagina (hier 404.shtml) voor alle bestanden die eindigen met '*inc_*.*' (in DOS-stijl )

Als dit het hele doel van dit topic is zou ik toch prefereren je includes gewoon buiten je web-root te zetten.

maar waar nu die '1' (als laatste character van de gegenereerde html) vandaan komt..

Dat is waarschijnlijk de return waarde van virtual?

[Freeaqingme]

Voutloos schreef op zondag 20 juni 2010 @ 20:11:
[...]

TJa, of mithras bedoelt dat je in een Framework kan spieken. Alleen jammer dat bijvoorbeeld Zend Framework ook op een aantal punten maar wat aanklooit en niet de rfc's volgt.

Op wat voor punten dan?

[Voutloos]

In ZF doen ze een aantal bewerkingen op HTTP headers, maar ondertussen staat nergens (en conflicteert het met) de regex van wat uberhaupt een geldige header naam is. Op dat soort plekken zou ook een comment richting RFC niet misstaan, maar dan moet je hem wel volgen.

[Freeaqingme]

Het is inmiddels enigzins offtopic, maar zou je daar wellicht een issue over kunnen toevoegen in de zf issue tracker? ( http://framework.zend.com/issues/ ) Dan zorg ik ervoor dat 't asap gefixed wordt...

[frickY]

Grote kans dat je site onder HTTP/1.0 niet eens bereikbaar is, of heb jij hedendaags nog een volledig eigen IP?
Hardcoded "HTTP/1.1 404 Not Found" is niet gek veel mee mis.

Vind het wel een goede eigenschap dat je op dergelijke details let, en vooral niet hapt op de Framework-opmerking; Eerst weten hoe iets werkt, daarna misschien tools inzetten om de oplossing te vereenvoudigen.

[ Voor 45% gewijzigd door frickY op 21-06-2010 23:31 ]

[Verwijderd]

freakingme schreef op maandag 21 juni 2010 @ 23:01:
Dan zorg ik ervoor dat 't asap gefixed wordt...

Wat gaaf dat dit topic hiertoe de aanleiding vormt

WouZz schreef op maandag 21 juni 2010 @ 21:15:
[...]
Als dit het hele doel van dit topic is zou ik toch prefereren je includes gewoon buiten je web-root te zetten.

zeker een uitstekend advies, maar het is zeker niet het doel van dit topic. Daarom heb ik mijn best gedaan om de topic-start breed maar concreet te proberen maken.

Want voor (bijvoorbeeld) diegenen die alle verkeer omleiden naar 1 'applicatie' die vandaaruit dus ook status/error documenten moet kunnen versturen is dit topic (volgens mij) toch wel interessant.

@FrickY:
Thx man!
Veiligheid eerst!
Maar.. Hoe zit 't 'dadelijk' met bv HTTP/2.0?
Ik begrijp uit de eerder gegeven WordPress link dat er toch wel degelijk (niet zo lang geleden vind ik) problemen waren met proxy's die naar HTTP1.0 schakelden.
Dus met verleden, heden en toekomst! in gedachte, blijft de kernvraag:
is $_SERVER["SERVER_PROTOCOL"] veilig (tegenwoordig?). Zeg bijvoorbeeld vanaf Apache 2.0 en PHP 5.0? Of is er 'n andere weg als je zelfs helemaal (om een of andere reden) een header wilt construeren?

[ Voor 28% gewijzigd door Verwijderd op 21-06-2010 23:49 ]

[CoolGamer]

Van HTTP/2.0 heb ik nog niet gehoord, dus ik neem aan dat het nog wel even duurt voordat die komt.

$_SERVER["SERVER_PROTOCOL"] is volgens mij gewoon veilig. Ik zou niet weten hoe dat problemen kan geven of hoe dat misbruikt kan worden.

[WouZz]

Want voor (bijvoorbeeld) diegenen die alle verkeer omleiden naar 1 'applicatie' die vandaaruit dus ook status/error documenten moet kunnen versturen is dit topic (volgens mij) toch wel interessant.

Mee eens. Wat dat betreft, je hebt ook mensen die gewoon beide headers dumpen:

PHP:

header("HTTP/1.0 404 Not Found");
header("Status: 404 Not Found")

Blijkbaar maakt Apache er dan toch nog wat moois van. Maar goed, waarom dan niet gewoon:

PHP:

header('xxx', true, 404);

..hoef je er helemaal niet meer druk om te maken. Extra (cache) headers stuur je gewoon met een extra call.

Heb je trouwens al eens via FireBug / WebKit developer / telnet gechecked wat Apache uiteindelijk terug geeft?

Trouwens, denk ook eens aan usability. Stuur een 404 header voor alle bots / crawlers e.d., maar render wel een mooie "Oeps pagina niet gevonden / Tip de redactie / Doorzoek de site etc" pagina.

Verder kan je ook nog aan je/je opdrachtgevers portemonnaie denken. Ik ken sites die zoveel 404's hebben dat ze die gewoon vol gehangen hebben met ads

[ Voor 18% gewijzigd door WouZz op 22-06-2010 00:30 ]

[Olaf van der Spek]

Verwijderd schreef op zondag 20 juni 2010 @ 19:38:
omdat volgens de ontwikkelaars van php deze code ENKEL onder PHP3 werkt MITS deze als Apache-Module gecompileerd is!!

Grappig om na vijf jaar m'n bug report weer tegen te komen.

[Verwijderd]

WouZz schreef op dinsdag 22 juni 2010 @ 00:16:
Heb je trouwens al eens via FireBug / WebKit developer / telnet gechecked wat Apache uiteindelijk terug geeft?

Oldskool: Ethereal (ik geloof dat dat tegenwoordig zelfs 'n andere naam heeft).
Edit: ik vond ook nog http://web-sniffer.net/ waar je dit soort dingen ook online kunt uit-testen (en kunt kiezen bij de request uit HTTP/1.0(met en zonder host) en HTTP/1.1).

De response van (LET OP, FF 3.6.3 vroeg een HTTP/1.1 !!):

PHP:

header("HTTP/1.0 404 Not Found");
header("Status: 404 Not Found")

geeft:
HTTP/1.0 404 Not Found
Server: Apache/2
X-Powered-By: PHP/5.2.12
Status: 404 Not Found

Dit is lichtelijk tegen de verwachting in van Glowmouse's test (die een HTTP/0.9 stuurde maar een HTTP/1.1 kreeg) maar verder wel in overeenstemming met de rest van de info hier op 't topic (zie ook deze test) EN een mooie onderbouwing dat Apache toch wel luistert naar de door php verstuurde HTTP/versie (en er niet sowiso HTTP/1.1 van had gemaakt). (Denk ook aan de genoemde bug waarbij bij WordPress niet correct door sommige proxy's zoals Squid of Novell Bordermanager kwam.) -1 voor 't hard-coden...

Dus (zoals ik 't tot nu toe begrijp) sturen die 'mensen' met "Status: 404 Not Found" een nutteloze header (net als de genoemde 'x' of door jouw 'xxx').

Maar we hebben hier 'n super-luxe op 't forum :
@Olaf van der Spek: (cool, wat 'n kleine wereld is 't toch)..
ik kan me weinig mensen voorstellen die beter gequalificeerd zijn dan jij om hier voor eens en altijd te bevestigen dat "Status: 404 Not Found" tegenwoordig in een nutteloze text-string in de header resulteert (op z'n best 'n 'soft 404' te noemen icm de bijbehorende html), of dat ik die bug-report verkeerd heb begrepen...
Zo krijgen we efficiënt wat van die hardnekkige (forum-)mythes de wereld uit geholpen!

[ Voor 10% gewijzigd door Verwijderd op 22-06-2010 07:12 . Reden: zie text ]

[WouZz]

Dus (zoals ik 't tot nu toe begrijp) sturen die 'mensen' met "Status: 404 Not Found" een nutteloze header (net als de genoemde 'x' of door jouw 'xxx').

Ja, die Status: ... is inderdaad nutteloos. Die notatie lijkt echter een erfenis uit het CGI tijdperk. Maar ik heb het gevoel dat je het jezelf erg ingewikkeld maakt.

Doe gewoon (herhaling):

PHP:

header('whateveryoulike', true, 404);

en je bent klaar. Dat je een eerste argument moet opgeven die 'geen empty string is' is gewoon een flaw in PHP. Er wordt echter niets mee gedaan zodra je een derde argument meegeeft. Daarmee laat je de rest wel over aan Apache, of wellicht een andere webserver.

Wil je echt weten hoe het zit, check de HTTP 1.0 en 1.1 specs.

[Verwijderd]

@WouZz: Ik heb telkens over 'een kleinigheidje' heen gekeken whoops,
namelijk dat die dummy-string ('x' of 'xxx' of 'whateveryoulike') in de header-functie (icm de 3e parameter) NIET GEVOLGD wordt door: " : waarde" !
En 't lijkt erop (wat ik zo snel even testte) dat die string dan inderdaad niet in de response-header komt. Het hoe/waarom (Apache of php of 'de bedoeling'...) is me nog niet duidelijk..
Edit: maar in een hardcoded "HTTP/1.1 404 Not Found" staat ook geen ":"... Daarom DACHT ik dat elke string ook braaf in de header kwam... Assumption is the mother of alle fuck-up's

---

Ik heb maar 's 'n praktijk-testje gedaan hoe diverse monster-sites tegenwoordig eigenlijk op diverse requests reageren (ook met 404's):

google.nl & yahoo.com & ask.com & bing.com 
& nu.nl & youtube.com & facebook.com & thepiratebay.org: 
REQUEST: HTTP/1.0   ->   RESPONSE: HTTP/1.0 
REQUEST: HTTP/1.1   ->   RESPONSE: HTTP/1.1 

wikipedia.org:
REQUEST: HTTP/1.0   ->   RESPONSE: HTTP/1.0 
REQUEST: HTTP/1.1   ->   RESPONSE: HTTP/1.0 

microsoft.com & msn.com & live.com & hotmail.com 
& altavista.com & w3.org & apache.org & twitter.com 
& photobucket.com & myspace.com & tweakers.net: 
REQUEST: HTTP/1.0   ->   RESPONSE: HTTP/1.1
REQUEST: HTTP/1.1   ->   RESPONSE: HTTP/1.1

Wat opvalt is dat:
1-vrijwel alle sites die niet 'keurig' naar de request luisteren dus 'altijd' een HTTP/1.1 geven,
2-bing.com de enige microsoft-telg is die 'keurig' antwoordt in de gevraagde protocol-versie.


De server waarop ik aan 't testen ben (Apache/2 & PHP/5.2.12) gaf standaard (dus buiten php-code) net als de laatste groep ook in alle gevallen een HTTP/1.1
Hmm, dat ruikt als iets van de httpd... Dus de Apache-doc's erbij en eureka:
onder de Special Purpose Environment Variables vind je:

downgrade-1.0
This forces the request to be treated as a HTTP/1.0 request even if it was in a later dialect.
...
force-response-1.0
This forces an HTTP/1.0 response to clients making an HTTP/1.0 request. It was originally implemented as a result of a problem with AOL's proxies. Some HTTP/1.0 clients may not behave correctly when given an HTTP/1.1 response, and this can be used to interoperate with them.

En niet veel verder op dezelfde pagina staan wat geadviseerde 'Voorbeelden' hiervan (maar 't zijn defaults in httpd.conf):

...
BrowserMatch "MSIE 4\.0b2;" nokeepalive downgrade-1.0 force-response-1.0
...
BrowserMatch "RealPlayer 4\.0" force-response-1.0
BrowserMatch "Java/1\.0" force-response-1.0
BrowserMatch "JDK/1\.0" force-response-1.0

Conclusie: een standaard/default apache (van 'tegenwoordig') beantwoordt (buiten gedefinieerde uitzonderingen) altijd in HTTP/1.1 op een HTTP/1.0 request!!


DUS... met (bijvoorbeeld) de volgende regel in .htaccess:

code:

SetEnv force-response-1.0

kunnen we ervoor zorgen dat over de hele site de bij elke request de gevraagde protocol-versie wordt geleverd (net als bij Google.com ed..).
(Dit heb ik uitgebreid getest met normale html/php/txt documenten
en default error/status-docs (zoals access denied) en in httaccess "RedirectMatch 404 ...".
Dus zonder dat ik zelf vanuit php (op welke wijze dan ook) zelf 'n header heb verstuurd!)

Met dit als achtergrond info/kennis lijkt het me erg interessant om nu (met en zonder 'force-response-1.0') te testen wat de hier gegeven opties voor 'headers-vanuit-php' als resultaat naar de client geven.
Maar dat is voor morgen

[Olaf van der Spek]

Verwijderd schreef op dinsdag 22 juni 2010 @ 06:38:
Maar we hebben hier 'n super-luxe op 't forum :
@Olaf van der Spek: (cool, wat 'n kleine wereld is 't toch)..
ik kan me weinig mensen voorstellen die beter gequalificeerd zijn dan jij om hier voor eens en altijd te bevestigen dat "Status: 404 Not Found" tegenwoordig in een nutteloze text-string in de header resulteert (op z'n best 'n 'soft 404' te noemen icm de bijbehorende html), of dat ik die bug-report verkeerd heb begrepen...
Zo krijgen we efficiënt wat van die hardnekkige (forum-)mythes de wereld uit geholpen!

Haha, zoveel weet ik er ook weer niet vanaf hoor. In FastCGI (C++) apps gebruik ik Status: 404. In PHP gebruik ik nooit een HTTP status. Ik zou header('x', false, 404); gebruiken en een PHP bug report posten.

[Verwijderd]

Pfft. 't is laat, en deze tests en tabel waren stiekum iets meer werk dan verwacht, dus ik doe dit alvast posten (voor iets vast-loopt.. nee doet ie normaal nooit, ....maar de wet van Murphy... )

Ik verwacht dat in deze tabel nog wat in ge-edit (en toegevoegd) gaat worden, dus.. als iemand suggesties heeft...
Edit 1: ik ben de tests maar gaan nummeren, dat verwijst makkelijker. Test 9, 10, 11 en 12 zijn toegevoegd.

Test No & PHP code	Request Protocol	Response ZONDER force-response-1.0	Response MET force-response-1.0
1: <?php header("HTTP/1.0 404 Not Found"); ?>
=	HTTP/1.0	HTTP/1.0 404 Not Found	HTTP/1.0 404 Not Found
=	HTTP/1.1	HTTP/1.0 404 Not Found	HTTP/1.0 404 Not Found
2: <?php header("HTTP/1.1 404 Not Found"); ?>
=	HTTP/1.0	HTTP/1.1 404 Not Found	HTTP/1.1 404 Not Found
=	HTTP/1.1	HTTP/1.1 404 Not Found	HTTP/1.1 404 Not Found
3: <?php header($_SERVER["SERVER_PROTOCOL"]." 404 Not Found"); ?>
=	HTTP/1.0	HTTP/1.0 404 Not Found	HTTP/1.0 404 Not Found
=	HTTP/1.1	HTTP/1.1 404 Not Found	HTTP/1.1 404 Not Found
4: <?php header('Status: 404 Not Found',true,404); ?>
=	HTTP/1.0	HTTP/1.1 404 Not Found Status: 404 Not Found	HTTP/1.0 404 Not Found Status: 404 Not Found
=	HTTP/1.1	HTTP/1.1 404 Not Found Status: 404 Not Found	HTTP/1.1 404 Not Found Status: 404 Not Found
5: <?php header('Cache-Control: no-cache',true,404); ?>
=	HTTP/1.0	HTTP/1.1 404 Not Found Cache-Control: no-cache	HTTP/1.0 404 Not Found Cache-Control: no-cache
=	HTTP/1.1	HTTP/1.1 404 Not Found Cache-Control: no-cache	HTTP/1.1 404 Not Found Cache-Control: no-cache
6: <?php header('bogus',true,404); ?>
=	HTTP/1.0	HTTP/1.1 404 Not Found	HTTP/1.0 404 Not Found
=	HTTP/1.1	HTTP/1.1 404 Not Found	HTTP/1.1 404 Not Found
7: <?php header('bogus: zo dus niet',true,404); ?>
=	HTTP/1.0	HTTP/1.1 404 Not Found bogus: zo dus niet	HTTP/1.0 404 Not Found bogus: zo dus niet
=	HTTP/1.1	HTTP/1.1 404 Not Found bogus: zo dus niet	HTTP/1.1 404 Not Found bogus: zo dus niet
8: <?php header('Location: /temp_redir.html',true,307); ?>
=	HTTP/1.0	HTTP/1.1 307 Temporary Redirect Location: /temp_redir.html	HTTP/1.0 307 Temporary Redirect Location: /temp_redir.html
=	HTTP/1.1	HTTP/1.1 307 Temporary Redirect Location: /temp_redir.html	HTTP/1.1 307 Temporary Redirect Location: /temp_redir.html
9: <?php header("HTTP/1.0 404 Pietje Puk"); ?>
=	HTTP/1.0	HTTP/1.0 404 Pietje Puk	HTTP/1.0 404 Pietje Puk
=	HTTP/1.1	HTTP/1.0 404 Pietje Puk	HTTP/1.0 404 Pietje Puk
10: <?php header("HTTP/1.0 404 Pietje Puk",true,404); ?>
=	HTTP/1.0	HTTP/1.0 404 Pietje Puk	HTTP/1.0 404 Pietje Puk
=	HTTP/1.1	HTTP/1.0 404 Pietje Puk	HTTP/1.0 404 Pietje Puk
11: <?php header('HTTP',true,404); ?>
=	HTTP/1.0	HTTP/1.1 404 Not Found	HTTP/1.0 404 Not Found
=	HTTP/1.1	HTTP/1.1 404 Not Found	HTTP/1.1 404 Not Found
12: <?php header(NULL,true,404); ?>
=	HTTP/1.0	HTTP/1.1 200 OK	HTTP/1.0 200 OK
=	HTTP/1.1	HTTP/1.1 200 OK	HTTP/1.1 200 OK

Voor de compleetheid: Getest met Ethereal, Browsers IE6 & FF3.6.3, Apache/2 & PHP/5.2.12

Wat als mij als eerste opvalt:

• hard-coden=hardcoden (althans zonder 2e en 3e parameter)
• $_SERVER["SERVER_PROTOCOL"] geeft altijd de gevraagde HTTP-versie (en dus samen met hard-coden de gevraagde http-versie ongeacht 'force-response-1.0' instelling)
• de 3e parameter van de header-functie luistert/kijkt WEL naar die 'force-response-1.0' instelling

Of anders bekeken, wil je...

• Niet luisteren naar server-instelling en niet luisteren naar de request: hardcoden
• Niet luisteren naar server-instelling en wel luisteren naar request: hardcoden met $_SERVER["SERVER_PROTOCOL"] (blijft de interessante vraag: wel / niet veilige variabele?)
• Wel luisteren naar de serverinstelling die bepaalt of er naar de request wordt geluisterd: 3e parameter van de header-functie gebruiken (blijft de vraag, als je nu een 404 wilt versturen... moet je dan 'officieel' echt 'n dummy-string-zonder-waarde gebruiken?)

Let wel: ik heb dus nog niet gespeeld met die 2e parameter van de header-functie..

Suggesties, fouten of verkeerde aan-names? POST ZE!!! (al is 't voor toekomstige leergierigen! )

Ik ga 't even laten bezinken

[ Voor 13% gewijzigd door Verwijderd op 01-07-2010 03:44 ]

[Verwijderd]

Ik vond ook nog RFC2145. Dit is 'n korte eenvoudige uitleg/verheldering wat nu precies de basisregels zijn voor het gebruik en interpretatie van HTTP versie-nummers.

Olaf van der Spek schreef op woensdag 23 juni 2010 @ 15:35:
[...]
Ik zou header('x', false, 404); gebruiken en een PHP bug report posten.

Via deze google query vind ik 2 interesante links:

Bij zend hebben ze over de vraagstelling van dit topic 'ns gepraat in 2007.
En volgens mij heb ik hier de bijbehorende e-mails.

Eerste indruk is dat er mogelijk gewoon (nog) geen officieel antwoord is (misschien omdat er mogelijk nog geen echt bug-report -die goed getest en onderbouwd is- ingediend is?). Althans niet wat betreft bv een 404 en aanverwanten.

Ik ga ze nog 'n 2e keer lezen, maar hieruit heb ik nog de volgende codes gevonden die ik nog ff test op resultaat en toevoeg aan bovenstaande tabel:
header('HTTP/1.0 301 X'); (er is bepaald dat waar de X staat een 'human readable message' moet staan. Maar NIET WAT er PRECIES moet staan. Apache geeft dus bij 404: 'Not Found' terwijl IIS weer 'Object not found' geeft. Als we in php de header-functie met de 3e parameter gebruiken, waar komt dan de 'Not Found' text vandaan.. php of apache?)
header(null, true, 404); (vanuit php zou dat ook wel 'n mooie zijn, zoals voorgesteld) Edit: resultaat zie test 12.
header('HTTP', true, 404); Edit: resultaat zie test 11.
header('status', true, 404); Edit: resultaat lijkt mij gelijk aan test 6 en test 11

frickY schreef op maandag 21 juni 2010 @ 23:28:
Grote kans dat je site onder HTTP/1.0 niet eens bereikbaar is, of heb jij hedendaags nog een volledig eigen IP?

Uhh.. als ik die bepaalde site als default of primary (of ik geloof zelfs, eerste virtuele) host op 'n machine laat draaien (was dat niet ook nodig voor ssl volgens de rfc's?). Kunnen andere sites evengoed als virtuele host draaien op dezelfde machine. Of thuis op de adsl bijvoorbeeld ?

Maar ik neem aan dat je bedoelt dat 'officieel' volgens de rfc's geen "Host: "-naam identificatie bestaat bij HTTP/1.0 (alhoewel de meeste oude browsers dat middels een patch/extensie wel schijnen te ondersteunen ivbm de eenvoud en noodzaak van "Name-based Virtual Host" ondersteuning)?

---

offtopic:
via pm werd 'n aantal keer gesuggereerd dat niet iedereen een sniffer zoals Ethereal heeft/kent, en dat via web-sniffer.net niet de Accept-Lang of andere parameters (of HTTP/0.9) getest kan worden. En dat het soms 'te veel' werk is om de instellingen van de browser te veranderen, dus om dit topic voor nog meer mensen toegankelijk te maken:
Mini tutorial telnet: (voor onder windows)

1. START>Uitvoeren> cmd
2. cmd_prompt> telnet
   
   (Als je al weet dat de instellingen van telnet goed staan kun je natuurlijk ook meteen:
   
   cmd_prompt> telnet (www.)domain.tld 80 intypen en doorgaan met stap 5.)
3. telnet_prompt> display
   Kijk even of de instellingen van telnet goed staan:
   
   als er 'LOCAL_ECHO off' staat, dan: telnet_prompt> set LOCAL_ECHO
   
   als er 'Sending only CR' staat, dan: telnet_prompt> set CRLF
4. telnet_prompt> open (www.)domain.tld 80
5. nu ben je (als alles goed ging) verbonden met de host en elke toets die je nu indrukt wordt naar de host verstuurd. Dus ook 'n backspace. Je kunt dus niet een typo aanpassen. Maak dus nu geen fouten tijdens typen OF zet ff in notepad/kladblok wat je wilt sturen en doe dat nu copy pasten. Let op: de crlf na een lege regel 'voltooit' de request, ofwel, na je laatste regel moeten er 2 'enters' komen.
   
   GET /index.html HTTP/1.1 (CRLF)
   
   Host: (www.)domain.tld 80 (CRLF)
   
   (CRLF)

Als alles goed gaat, krijg je nu het antwoord van de server, beginnend met de header.
Als je nu alleen in die header geinteresseert bent, kun je ipv GET of POST ook een HEAD vragen (de server verstuurt dan 't bijbehorende html document gewoon niet..):
HEAD /index.html HTTP/1.1 (CRLF)
Host: (www.)domain.tld 80 (CRLF)
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0) (CRLF) (voorbeeldje van browser type).
(CRLF)

---

[ Voor 4% gewijzigd door Verwijderd op 01-07-2010 04:05 ]

[Verwijderd]

@Olaf van der Spek:
Ik wilde net maar 'n documentatie-bug bij bugs.php.net plaatsen, maar ik zie dat jij me 2 dagen voor bent.
Top dat je 't doet, jammer dat je dat hier niet even meldt.

Alleen je bug-omschrijving klopt niet:

If the third parameter is specified, the first one appears to be ignored, but this
isn't documented either.

Dat is in dit voorbeeld absoluut niet het geval:

PHP:

<?php header('Cache-Control: no-cache',true,404); ?>
// en ook dit is duidelijk NIET ignored:
<?php header('Pietje: Puk',true,404); ?>

Laten we de bug en onderbouwing aub goed formuleren zodat er iets mee gedaan kan worden?
Lijkt me duidelijk dat ik daar graag bij wil helpen, zie de moeite die ik al in dit topic heb gestoken. En ik ben vast niet de enige die wil helpen.

---

Op de vraag waar de 'human readable message' vandaan komt als je bijvoorbeeld die <?php header('Cache-Control: no-cache',true,404); ?> doet, vind ik deze geweldige pagina die tevens vanuit de apache broncode dat vraagstuk beantwoordt. Beetje verderop kun je 'n php arry copy-pasten met alle code's en beschrijvingen. Dat stukje is kennelijk in WordPress 2.8 gekomen.
Heb ook alvast even de testresultaten van 'n paar nieuwe tests (9, 10, 11 en 12 ) in de tabel van bovenstaande post toegevoegd.

Wat betreft Zend Frameworks, daar sprak ik vandaag toevallig een 'mede developer' over, die opduikelde dat Zend dus op dit moment 'n hardcoded "HTTP/1.1" geeft.

[ Voor 39% gewijzigd door Verwijderd op 01-07-2010 03:51 ]

[Verwijderd]

jammer dat die test 12 niet officieel supported is want die zou in de toekomst dan ook in zo'n overgangsfase of backward -compatible (mode) kunnen blijven

+1 vanuit deze kant, ik blijf 't geinteresseerd mee-lezen

[.oisyn]

Verwijderd schreef op dinsdag 29 juni 2010 @ 20:52:
header('HTTP', true, 404); Edit: resultaat zie test 11.
header('status', true, 404); Edit: resultaat lijkt mij gelijk aan test 6 en test 11

6 en 11 zijn ook gewoon equivalent. "HTTP" is net zo'n bogus header als "bogus" dat is. Er bestaat verder ook helemaal geen header met de naam HTTP.

[Verwijderd]

misschien stom, maar is 't geen idee om om naar de broncode van php te kijken? Staat ie ergens zichtbaar (zonder 'downloaden') online?

Ik vond test 10 versus 11 wel weer interessant.

[Olaf van der Spek]

Verwijderd schreef op donderdag 01 juli 2010 @ 00:57:
@Olaf van der Spek:
Ik wilde net maar 'n documentatie-bug bij bugs.php.net plaatsen, maar ik zie dat jij me 2 dagen voor bent.
Top dat je 't doet, jammer dat je dat hier niet even meldt.

Vergeten, sorry.

Alleen je bug-omschrijving klopt niet:

Klopt, het lijkt erop dat de eerste parameter in andere gevallen wordt genegeerd. Misschien als er geen ':' in zit.

[Verwijderd]

Olaf van der Spek schreef op donderdag 01 juli 2010 @ 22:14:
Klopt, het lijkt erop dat de eerste parameter in andere gevallen wordt genegeerd. Misschien als er geen ':' in zit.

volgens mij staat hier al uitgebreid bevestigd, ook in die test-tabel..

hopelijk kijken ze bij php dadelijk wel nog serieus naar 'n 'beter onderbouwde' versie van deze documentatie-bug

[Olaf van der Spek]

Verwijderd schreef op donderdag 01 juli 2010 @ 23:44:
volgens mij staat hier al uitgebreid bevestigd, ook in die test-tabel..

Ik zie niet staan wanneer de eerste parameter genegeerd wordt.
Dat bug report is goed genoeg onderbouwd.

[ Voor 7% gewijzigd door Olaf van der Spek op 02-07-2010 00:05 ]

[RobIII]

Verwijderd schreef op donderdag 01 juli 2010 @ 20:49:
misschien stom, maar is 't geen idee om om naar de broncode van php te kijken? Staat ie ergens zichtbaar (zonder 'downloaden') online?

Knock yourself out ( CTRL-F: SAPI_API int sapi_header_op of regel 517 en verder)

code:

/* 
   +----------------------------------------------------------------------+
   | PHP Version 5                                                        |
   +----------------------------------------------------------------------+
   | Copyright (c) 1997-2010 The PHP Group                                |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.php.net/license/3_01.txt                                  |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | [e-mail] so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | Original design:  Shane Caraveo <[e-mail]>                  |
   | Authors: Andi Gutmans <[e-mail]>                                |
   |          Zeev Suraski <[e-mail]>                                |
   +----------------------------------------------------------------------+
*/

/* $Id: SAPI.c 293036 2010-01-03 09:23:27Z sebastian $ */

#include <ctype.h>
#include <sys/stat.h>

#include "php.h"
#include "SAPI.h"
#include "php_variables.h"
#include "php_ini.h"
#include "ext/standard/php_string.h"
#include "ext/standard/pageinfo.h"
#if (HAVE_PCRE || HAVE_BUNDLED_PCRE) && !defined(COMPILE_DL_PCRE)
#include "ext/pcre/php_pcre.h"
#endif
#ifdef ZTS
#include "TSRM.h"
#endif
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif

#include "rfc1867.h"

#ifdef PHP_WIN32
#define STRCASECMP stricmp
#else
#define STRCASECMP strcasecmp
#endif

#include "php_content_types.h"

#ifdef ZTS
SAPI_API int sapi_globals_id;
#else
sapi_globals_struct sapi_globals;
#endif

static void sapi_globals_ctor(sapi_globals_struct *sapi_globals TSRMLS_DC)
{
    memset(sapi_globals, 0, sizeof(*sapi_globals));
    zend_hash_init_ex(&sapi_globals->known_post_content_types, 5, NULL, NULL, 1, 0);
    php_setup_sapi_content_types(TSRMLS_C);
}

static void sapi_globals_dtor(sapi_globals_struct *sapi_globals TSRMLS_DC)
{
    zend_hash_destroy(&sapi_globals->known_post_content_types);
}

/* True globals (no need for thread safety) */
SAPI_API sapi_module_struct sapi_module;


SAPI_API void sapi_startup(sapi_module_struct *sf)
{
    sf->ini_entries = NULL;
    sapi_module = *sf;

#ifdef ZTS
    ts_allocate_id(&sapi_globals_id, sizeof(sapi_globals_struct), (ts_allocate_ctor) sapi_globals_ctor, (ts_allocate_dtor) sapi_globals_dtor);
#else
    sapi_globals_ctor(&sapi_globals);
#endif

    virtual_cwd_startup(); /* Could use shutdown to free the main cwd but it would just slow it down for CGI */

#ifdef PHP_WIN32
    tsrm_win32_startup();
#endif

    reentrancy_startup();
}

SAPI_API void sapi_shutdown(void)
{
#ifdef ZTS
    ts_free_id(sapi_globals_id);
#else
    sapi_globals_dtor(&sapi_globals);
#endif

    reentrancy_shutdown();

    virtual_cwd_shutdown();

#ifdef PHP_WIN32
    tsrm_win32_shutdown();
#endif
}


SAPI_API void sapi_free_header(sapi_header_struct *sapi_header)
{
    efree(sapi_header->header);
}


SAPI_API void sapi_handle_post(void *arg TSRMLS_DC)
{
    if (SG(request_info).post_entry && SG(request_info).content_type_dup) {
        SG(request_info).post_entry->post_handler(SG(request_info).content_type_dup, arg TSRMLS_CC);
        if (SG(request_info).post_data) {
            efree(SG(request_info).post_data);
            SG(request_info).post_data = NULL;
        }
        efree(SG(request_info).content_type_dup);
        SG(request_info).content_type_dup = NULL;
    }
}

static void sapi_read_post_data(TSRMLS_D)
{
    sapi_post_entry *post_entry;
    uint content_type_length = strlen(SG(request_info).content_type);
    char *content_type = estrndup(SG(request_info).content_type, content_type_length);
    char *p;
    char oldchar=0;
    void (*post_reader_func)(TSRMLS_D) = NULL;


    /* dedicated implementation for increased performance:
     * - Make the content type lowercase
     * - Trim descriptive data, stay with the content-type only
     */
    for (p=content_type; p<content_type+content_type_length; p++) {
        switch (*p) {
            case ';':
            case ',':
            case ' ':
                content_type_length = p-content_type;
                oldchar = *p;
                *p = 0;
                break;
            default:
                *p = tolower(*p);
                break;
        }
    }

    /* now try to find an appropriate POST content handler */
    if (zend_hash_find(&SG(known_post_content_types), content_type,
            content_type_length+1, (void **) &post_entry) == SUCCESS) {
        /* found one, register it for use */
        SG(request_info).post_entry = post_entry;
        post_reader_func = post_entry->post_reader;
    } else {
        /* fallback */
        SG(request_info).post_entry = NULL;
        if (!sapi_module.default_post_reader) {
            /* no default reader ? */
            SG(request_info).content_type_dup = NULL;
            sapi_module.sapi_error(E_WARNING, "Unsupported content type:  '%s'", content_type);
            return;
        }
    }
    if (oldchar) {
        *(p-1) = oldchar;
    }

    SG(request_info).content_type_dup = content_type;

    if(post_reader_func) {
        post_reader_func(TSRMLS_C);
    }

    if(sapi_module.default_post_reader) {
        sapi_module.default_post_reader(TSRMLS_C);
    }
}


SAPI_API SAPI_POST_READER_FUNC(sapi_read_standard_form_data)
{
    int read_bytes;
    int allocated_bytes=SAPI_POST_BLOCK_SIZE+1;

    if (SG(request_info).content_length > SG(post_max_size)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "POST Content-Length of %ld bytes exceeds the limit of %ld bytes",
                    SG(request_info).content_length, SG(post_max_size));
        return;
    }
    SG(request_info).post_data = emalloc(allocated_bytes);

    for (;;) {
        read_bytes = sapi_module.read_post(SG(request_info).post_data+SG(read_post_bytes), SAPI_POST_BLOCK_SIZE TSRMLS_CC);
        if (read_bytes<=0) {
            break;
        }
        SG(read_post_bytes) += read_bytes;
        if (SG(read_post_bytes) > SG(post_max_size)) {
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Actual POST length does not match Content-Length, and exceeds %ld bytes", SG(post_max_size));
            break;
        }
        if (read_bytes < SAPI_POST_BLOCK_SIZE) {
            break;
        }
        if (SG(read_post_bytes)+SAPI_POST_BLOCK_SIZE >= allocated_bytes) {
            allocated_bytes = SG(read_post_bytes)+SAPI_POST_BLOCK_SIZE+1;
            SG(request_info).post_data = erealloc(SG(request_info).post_data, allocated_bytes);
        }
    }
    SG(request_info).post_data[SG(read_post_bytes)] = 0;  /* terminating NULL */
    SG(request_info).post_data_length = SG(read_post_bytes);
}


SAPI_API char *sapi_get_default_content_type(TSRMLS_D)
{
    char *mimetype, *charset, *content_type;

    mimetype = SG(default_mimetype) ? SG(default_mimetype) : SAPI_DEFAULT_MIMETYPE;
    charset = SG(default_charset) ? SG(default_charset) : SAPI_DEFAULT_CHARSET;

    if (strncasecmp(mimetype, "text/", 5) == 0 && *charset) {
        int len = strlen(mimetype) + sizeof("; charset=") + strlen(charset); /* sizeof() includes \0 */
        content_type = emalloc(len);
        snprintf(content_type, len, "%s; charset=%s", mimetype, charset);
    } else {
        content_type = estrdup(mimetype);
    }
    return content_type;
}


SAPI_API void sapi_get_default_content_type_header(sapi_header_struct *default_header TSRMLS_DC)
{
    char *default_content_type = sapi_get_default_content_type(TSRMLS_C);
    int default_content_type_len = strlen(default_content_type);

    default_header->header_len = (sizeof("Content-type: ")-1) + default_content_type_len;
    default_header->header = emalloc(default_header->header_len+1);
    memcpy(default_header->header, "Content-type: ", sizeof("Content-type: "));
    memcpy(default_header->header+sizeof("Content-type: ")-1, default_content_type, default_content_type_len);
    default_header->header[default_header->header_len] = 0;
    efree(default_content_type);
}

/*
 * Add charset on content-type header if the MIME type starts with
 * "text/", the default_charset directive is not empty and
 * there is not already a charset option in there.
 *
 * If "mimetype" is non-NULL, it should point to a pointer allocated
 * with emalloc().  If a charset is added, the string will be
 * re-allocated and the new length is returned.  If mimetype is
 * unchanged, 0 is returned.
 *
 */
SAPI_API size_t sapi_apply_default_charset(char **mimetype, size_t len TSRMLS_DC)
{
    char *charset, *newtype;
    size_t newlen;
    charset = SG(default_charset) ? SG(default_charset) : SAPI_DEFAULT_CHARSET;

    if (*mimetype != NULL) {
        if (*charset && strncmp(*mimetype, "text/", 5) == 0 && strstr(*mimetype, "charset=") == NULL) {
            newlen = len + (sizeof(";charset=")-1) + strlen(charset);
            newtype = emalloc(newlen + 1);
            PHP_STRLCPY(newtype, *mimetype, newlen + 1, len);
            strlcat(newtype, ";charset=", newlen + 1);
            strlcat(newtype, charset, newlen + 1);
            efree(*mimetype);
            *mimetype = newtype;
            return newlen;
        }
    }
    return 0;
}

SAPI_API void sapi_activate_headers_only(TSRMLS_D)
{
    if (SG(request_info).headers_read == 1)
        return;
    SG(request_info).headers_read = 1;
    zend_llist_init(&SG(sapi_headers).headers, sizeof(sapi_header_struct), 
            (void (*)(void *)) sapi_free_header, 0);
    SG(sapi_headers).send_default_content_type = 1;

    /* SG(sapi_headers).http_response_code = 200; */ 
    SG(sapi_headers).http_status_line = NULL;
    SG(sapi_headers).mimetype = NULL;
    SG(read_post_bytes) = 0;
    SG(request_info).post_data = NULL;
    SG(request_info).raw_post_data = NULL;
    SG(request_info).current_user = NULL;
    SG(request_info).current_user_length = 0;
    SG(request_info).no_headers = 0;
    SG(request_info).post_entry = NULL;
    SG(global_request_time) = 0;

    /*
     * It's possible to override this general case in the activate() callback, 
     * if necessary.
     */
    if (SG(request_info).request_method && !strcmp(SG(request_info).request_method, "HEAD")) {
        SG(request_info).headers_only = 1;
    } else {
        SG(request_info).headers_only = 0;
    }
    if (SG(server_context)) {
        SG(request_info).cookie_data = sapi_module.read_cookies(TSRMLS_C);
        if (sapi_module.activate) {
            sapi_module.activate(TSRMLS_C);
        }
    }
}

/*
 * Called from php_request_startup() for every request.
 */

SAPI_API void sapi_activate(TSRMLS_D)
{
    zend_llist_init(&SG(sapi_headers).headers, sizeof(sapi_header_struct), (void (*)(void *)) sapi_free_header, 0);
    SG(sapi_headers).send_default_content_type = 1;

    /*
    SG(sapi_headers).http_response_code = 200;
    */
    SG(sapi_headers).http_status_line = NULL;
    SG(sapi_headers).mimetype = NULL;
    SG(headers_sent) = 0;
    SG(read_post_bytes) = 0;
    SG(request_info).post_data = NULL;
    SG(request_info).raw_post_data = NULL;
    SG(request_info).current_user = NULL;
    SG(request_info).current_user_length = 0;
    SG(request_info).no_headers = 0;
    SG(request_info).post_entry = NULL;
    SG(request_info).proto_num = 1000; /* Default to HTTP 1.0 */
    SG(global_request_time) = 0;

    /* It's possible to override this general case in the activate() callback, if
     * necessary.
     */
    if (SG(request_info).request_method && !strcmp(SG(request_info).request_method, "HEAD")) {
        SG(request_info).headers_only = 1;
    } else {
        SG(request_info).headers_only = 0;
    }
    SG(rfc1867_uploaded_files) = NULL;

    /* handle request mehtod */
    if (SG(server_context)) {
        if ( SG(request_info).request_method) {
            if(!strcmp(SG(request_info).request_method, "POST")
               && (SG(request_info).content_type)) {
                /* HTTP POST -> may contain form data to be read into variables
                   depending on content type given
                */
                sapi_read_post_data(TSRMLS_C);
            } else {
                /* any other method with content payload will fill 
                   $HTTP_RAW_POST_DATA if enabled by always_populate_raw_post_data 
                   it is up to the webserver to decide whether to allow a method or not
                */
                SG(request_info).content_type_dup = NULL;
                if(sapi_module.default_post_reader) {
                    sapi_module.default_post_reader(TSRMLS_C);
                }
            }
        } else {
            SG(request_info).content_type_dup = NULL;
        }

        /* Cookies */
        SG(request_info).cookie_data = sapi_module.read_cookies(TSRMLS_C);
        if (sapi_module.activate) {
            sapi_module.activate(TSRMLS_C);
        }
    }
}


static void sapi_send_headers_free(TSRMLS_D)
{
    if (SG(sapi_headers).http_status_line) {
        efree(SG(sapi_headers).http_status_line);
        SG(sapi_headers).http_status_line = NULL;
    }
}
    
SAPI_API void sapi_deactivate(TSRMLS_D)
{
    zend_llist_destroy(&SG(sapi_headers).headers);
    if (SG(request_info).post_data) {
        efree(SG(request_info).post_data);
    }  else     if (SG(server_context)) {
        if(sapi_module.read_post) { 
            /* make sure we've consumed all request input data */
            char dummy[SAPI_POST_BLOCK_SIZE];
            int read_bytes;

            while((read_bytes = sapi_module.read_post(dummy, sizeof(dummy)-1 TSRMLS_CC)) > 0) {
                SG(read_post_bytes) += read_bytes;
            }
        }
    }
    if (SG(request_info).raw_post_data) {
        efree(SG(request_info).raw_post_data);
    } 
    if (SG(request_info).auth_user) {
        efree(SG(request_info).auth_user);
    }
    if (SG(request_info).auth_password) {
        efree(SG(request_info).auth_password);
    }
    if (SG(request_info).auth_digest) {
        efree(SG(request_info).auth_digest);
    }
    if (SG(request_info).content_type_dup) {
        efree(SG(request_info).content_type_dup);
    }
    if (SG(request_info).current_user) {
        efree(SG(request_info).current_user);
    }
    if (sapi_module.deactivate) {
        sapi_module.deactivate(TSRMLS_C);
    }
    if (SG(rfc1867_uploaded_files)) {
        destroy_uploaded_files_hash(TSRMLS_C);
    }
    if (SG(sapi_headers).mimetype) {
        efree(SG(sapi_headers).mimetype);
        SG(sapi_headers).mimetype = NULL;
    }
    sapi_send_headers_free(TSRMLS_C);
    SG(sapi_started) = 0;
    SG(headers_sent) = 0;
    SG(request_info).headers_read = 0;
    SG(global_request_time) = 0;
}


SAPI_API void sapi_initialize_empty_request(TSRMLS_D)
{
    SG(server_context) = NULL;
    SG(request_info).request_method = NULL;
    SG(request_info).auth_digest = SG(request_info).auth_user = SG(request_info).auth_password = NULL;
    SG(request_info).content_type_dup = NULL;
}


static int sapi_extract_response_code(const char *header_line)
{
    int code = 200;
    const char *ptr;

    for (ptr = header_line; *ptr; ptr++) {
        if (*ptr == ' ' && *(ptr + 1) != ' ') {
            code = atoi(ptr + 1);
            break;
        }
    }
    
    return code;
}


static void sapi_update_response_code(int ncode TSRMLS_DC)
{
    /* if the status code did not change, we do not want
       to change the status line, and no need to change the code */
    if (SG(sapi_headers).http_response_code == ncode) {
        return;
    }

    if (SG(sapi_headers).http_status_line) {
        efree(SG(sapi_headers).http_status_line);
        SG(sapi_headers).http_status_line = NULL;
    }
    SG(sapi_headers).http_response_code = ncode;
}

static int sapi_find_matching_header(void *element1, void *element2)
{
    return strncasecmp(((sapi_header_struct*)element1)->header, (char*)element2, strlen((char*)element2)) == 0;
}

SAPI_API int sapi_add_header_ex(char *header_line, uint header_line_len, zend_bool duplicate, zend_bool replace TSRMLS_DC)
{
    sapi_header_line ctr = {0};
    int r;
    
    ctr.line = header_line;
    ctr.line_len = header_line_len;

    r = sapi_header_op(replace ? SAPI_HEADER_REPLACE : SAPI_HEADER_ADD,
            &ctr TSRMLS_CC);

    if (!duplicate)
        efree(header_line);

    return r;
}

SAPI_API int sapi_header_op(sapi_header_op_enum op, void *arg TSRMLS_DC)
{
    int retval;
    sapi_header_struct sapi_header;
    char *colon_offset;
    long myuid = 0L;
    char *header_line;
    uint header_line_len;
    zend_bool replace;
    int http_response_code;
    
    if (SG(headers_sent) && !SG(request_info).no_headers) {
        char *output_start_filename = php_get_output_start_filename(TSRMLS_C);
        int output_start_lineno = php_get_output_start_lineno(TSRMLS_C);

        if (output_start_filename) {
            sapi_module.sapi_error(E_WARNING, "Cannot modify header information - headers already sent by (output started at %s:%d)",
                output_start_filename, output_start_lineno);
        } else {
            sapi_module.sapi_error(E_WARNING, "Cannot modify header information - headers already sent");
        }
        return FAILURE;
    }

    switch (op) {
        case SAPI_HEADER_SET_STATUS:
            sapi_update_response_code((int)(zend_intptr_t) arg TSRMLS_CC);
            return SUCCESS;

        case SAPI_HEADER_REPLACE:
        case SAPI_HEADER_ADD: {
                sapi_header_line *p = arg;

                if (!p->line || !p->line_len) {
                    return FAILURE;
                }
                header_line = p->line;
                header_line_len = p->line_len;
                http_response_code = p->response_code;
                replace = (op == SAPI_HEADER_REPLACE);
                break;
            }

        default:
            return FAILURE;
    }

    header_line = estrndup(header_line, header_line_len);

    /* cut of trailing spaces, linefeeds and carriage-returns */
    while(header_line_len && isspace(header_line[header_line_len-1])) 
          header_line[--header_line_len]='\0';
    
    /* new line safety check */
    {
        char *s = header_line, *e = header_line + header_line_len, *p;
        while (s < e && (p = memchr(s, '\n', (e - s)))) {
            if (*(p + 1) == ' ' || *(p + 1) == '\t') {
                s = p + 1;
                continue;
            }
            efree(header_line);
            sapi_module.sapi_error(E_WARNING, "Header may not contain more than a single header, new line detected.");
            return FAILURE;
        }
    }

    sapi_header.header = header_line;
    sapi_header.header_len = header_line_len;
    sapi_header.replace = replace;

    /* Check the header for a few cases that we have special support for in SAPI */
    if (header_line_len>=5 
        && !strncasecmp(header_line, "HTTP/", 5)) {
        /* filter out the response code */
        sapi_update_response_code(sapi_extract_response_code(header_line) TSRMLS_CC);
        /* sapi_update_response_code doesn't free the status line if the code didn't change */
        if (SG(sapi_headers).http_status_line) {
            efree(SG(sapi_headers).http_status_line);
        }
        SG(sapi_headers).http_status_line = header_line;
        return SUCCESS;
    } else {
        colon_offset = strchr(header_line, ':');
        if (colon_offset) {
            *colon_offset = 0;
            if (!STRCASECMP(header_line, "Content-Type")) {
                char *ptr = colon_offset+1, *mimetype = NULL, *newheader;
                size_t len = header_line_len - (ptr - header_line), newlen;
                while (*ptr == ' ') {
                    ptr++;
                    len--;
                }

                /* Disable possible output compression for images */
                if (!strncmp(ptr, "image/", sizeof("image/")-1)) {
                    zend_alter_ini_entry("zlib.output_compression", sizeof("zlib.output_compression"), "0", sizeof("0") - 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
                }

                mimetype = estrdup(ptr);
                newlen = sapi_apply_default_charset(&mimetype, len TSRMLS_CC);
                if (!SG(sapi_headers).mimetype){
                    SG(sapi_headers).mimetype = estrdup(mimetype);
                }

                if (newlen != 0) {
                    newlen += sizeof("Content-type: ");
                    newheader = emalloc(newlen);
                    PHP_STRLCPY(newheader, "Content-type: ", newlen, sizeof("Content-type: ")-1);
                    strlcat(newheader, mimetype, newlen);
                    sapi_header.header = newheader;
                    sapi_header.header_len = newlen - 1;
                    efree(header_line);
                }
                efree(mimetype);
                SG(sapi_headers).send_default_content_type = 0;
            } else if (!STRCASECMP(header_line, "Location")) {
                if ((SG(sapi_headers).http_response_code < 300 ||
                    SG(sapi_headers).http_response_code > 307) &&
                    SG(sapi_headers).http_response_code != 201) {
                    /* Return a Found Redirect if one is not already specified */
                    if (http_response_code) { /* user specified redirect code */
                        sapi_update_response_code(http_response_code TSRMLS_CC);
                    } else if (SG(request_info).proto_num > 1000 && 
                       SG(request_info).request_method && 
                       strcmp(SG(request_info).request_method, "HEAD") &&
                       strcmp(SG(request_info).request_method, "GET")) {
                        sapi_update_response_code(303 TSRMLS_CC);
                    } else {
                        sapi_update_response_code(302 TSRMLS_CC);
                    }
                }
            } else if (!STRCASECMP(header_line, "WWW-Authenticate")) { /* HTTP Authentication */

                sapi_update_response_code(401 TSRMLS_CC); /* authentication-required */

                if(PG(safe_mode)) 
#if (HAVE_PCRE || HAVE_BUNDLED_PCRE) && !defined(COMPILE_DL_PCRE)
                {
                    zval *repl_temp;
                    char *ptr = colon_offset+1, *result, *newheader;
                    int ptr_len=0, result_len = 0, newlen = 0;

                    /* skip white space */
                    while (isspace(*ptr)) {
                        ptr++;
                    }

                    myuid = php_getuid();

                    ptr_len = strlen(ptr);
                    MAKE_STD_ZVAL(repl_temp);
                    Z_TYPE_P(repl_temp) = IS_STRING;
                    Z_STRLEN_P(repl_temp) = spprintf(&Z_STRVAL_P(repl_temp), 0, "realm=\"\\1-%ld\"", myuid);
                    /* Modify quoted realm value */
                    result = php_pcre_replace("/realm=\"(.*?)\"/i", 16,
                                             ptr, ptr_len,
                                             repl_temp,
                                             0, &result_len, -1, NULL TSRMLS_CC);
                    if(result_len==ptr_len) {
                        efree(result);
                        efree(Z_STRVAL_P(repl_temp));
                        Z_STRLEN_P(repl_temp) = spprintf(&Z_STRVAL_P(repl_temp), 0, "realm=\\1-%ld\\2", myuid);
                        /* modify unquoted realm value */
                        result = php_pcre_replace("/realm=([^\\s]+)(.*)/i", 21, 
                                                ptr, ptr_len,
                                                repl_temp,
                                                0, &result_len, -1, NULL TSRMLS_CC);
                        if(result_len==ptr_len) {
                            char *lower_temp = estrdup(ptr);    
                            char conv_temp[32];
                            int conv_len;

                            php_strtolower(lower_temp,strlen(lower_temp));
                            /* If there is no realm string at all, append one */
                            if(!strstr(lower_temp,"realm")) {
                                efree(result);
                                conv_len = slprintf(conv_temp, sizeof(conv_temp), " realm=\"%ld\"",myuid);
                                result = emalloc(ptr_len+conv_len+1);
                                result_len = ptr_len+conv_len;
                                memcpy(result, ptr, ptr_len);   
                                memcpy(result+ptr_len, conv_temp, conv_len);
                                *(result+ptr_len+conv_len) = '\0';
                            }
                            efree(lower_temp);
                        }
                    }
                    newlen = spprintf(&newheader, 0, "WWW-Authenticate: %s", result);
                    efree(header_line);
                    sapi_header.header = newheader;
                    sapi_header.header_len = newlen;
                    efree(result);
                    efree(Z_STRVAL_P(repl_temp));
                    efree(repl_temp);
                } 
#else
                {
                    myuid = php_getuid();
                    efree(header_line);
                    sapi_header.header_len = spprintf(&sapi_header.header, 0, "WWW-Authenticate: Basic realm=\"%ld\"", myuid);
                }
#endif
            }
            if (sapi_header.header==header_line) {
                *colon_offset = ':';
            }
        }
    }
    if (http_response_code) {
        sapi_update_response_code(http_response_code TSRMLS_CC);
    }
    if (sapi_module.header_handler) {
        retval = sapi_module.header_handler(&sapi_header, &SG(sapi_headers) TSRMLS_CC);
    } else {
        retval = SAPI_HEADER_ADD;
    }
    if (retval & SAPI_HEADER_DELETE_ALL) {
        zend_llist_clean(&SG(sapi_headers).headers);
    }
    if (retval & SAPI_HEADER_ADD) {
        /* in replace mode first remove the header if it already exists in the headers llist */
        if (replace) {
            colon_offset = strchr(sapi_header.header, ':');
            if (colon_offset) {
                char sav;
                colon_offset++;
                sav = *colon_offset;
                *colon_offset = 0;
                zend_llist_del_element(&SG(sapi_headers).headers, sapi_header.header, (int(*)(void*, void*))sapi_find_matching_header);
                *colon_offset = sav;
            }
        }

        zend_llist_add_element(&SG(sapi_headers).headers, (void *) &sapi_header);
    }
    return SUCCESS;
}


SAPI_API int sapi_send_headers(TSRMLS_D)
{
    int retval;
    int ret = FAILURE;

    if (SG(headers_sent) || SG(request_info).no_headers) {
        return SUCCESS;
    }

    /* Success-oriented.  We set headers_sent to 1 here to avoid an infinite loop
     * in case of an error situation.
     */
    if (SG(sapi_headers).send_default_content_type && sapi_module.send_headers) {
        sapi_header_struct default_header;
        sapi_get_default_content_type_header(&default_header TSRMLS_CC);
        sapi_add_header_ex(default_header.header, default_header.header_len, 0, 0 TSRMLS_CC);
    }

    SG(headers_sent) = 1;

    if (sapi_module.send_headers) {
        retval = sapi_module.send_headers(&SG(sapi_headers) TSRMLS_CC);
    } else {
        retval = SAPI_HEADER_DO_SEND;
    }

    switch (retval) {
        case SAPI_HEADER_SENT_SUCCESSFULLY:
            ret = SUCCESS;
            break;
        case SAPI_HEADER_DO_SEND: {
                sapi_header_struct http_status_line;
                char buf[255];

                if (SG(sapi_headers).http_status_line) {
                    http_status_line.header = SG(sapi_headers).http_status_line;
                    http_status_line.header_len = strlen(SG(sapi_headers).http_status_line);
                } else {
                    http_status_line.header = buf;
                    http_status_line.header_len = slprintf(buf, sizeof(buf), "HTTP/1.0 %d X", SG(sapi_headers).http_response_code);
                }
                sapi_module.send_header(&http_status_line, SG(server_context) TSRMLS_CC);
            }
            zend_llist_apply_with_argument(&SG(sapi_headers).headers, (llist_apply_with_arg_func_t) sapi_module.send_header, SG(server_context) TSRMLS_CC);
            if(SG(sapi_headers).send_default_content_type) {
                sapi_header_struct default_header;

                sapi_get_default_content_type_header(&default_header TSRMLS_CC);
                sapi_module.send_header(&default_header, SG(server_context) TSRMLS_CC);
                sapi_free_header(&default_header);
            }
            sapi_module.send_header(NULL, SG(server_context) TSRMLS_CC);
            ret = SUCCESS;
            break;
        case SAPI_HEADER_SEND_FAILED:
            SG(headers_sent) = 0;
            ret = FAILURE;
            break;
    }

    sapi_send_headers_free(TSRMLS_C);

    return ret;
}


SAPI_API int sapi_register_post_entries(sapi_post_entry *post_entries TSRMLS_DC)
{
    sapi_post_entry *p=post_entries;

    while (p->content_type) {
        if (sapi_register_post_entry(p TSRMLS_CC) == FAILURE) {
            return FAILURE;
        }
        p++;
    }
    return SUCCESS;
}


SAPI_API int sapi_register_post_entry(sapi_post_entry *post_entry TSRMLS_DC)
{
    if (SG(sapi_started) && EG(in_execution)) {
        return FAILURE;
    }
    return zend_hash_add(&SG(known_post_content_types),
            post_entry->content_type, post_entry->content_type_len+1,
            (void *) post_entry, sizeof(sapi_post_entry), NULL);
}

SAPI_API void sapi_unregister_post_entry(sapi_post_entry *post_entry TSRMLS_DC)
{
    if (SG(sapi_started) && EG(in_execution)) {
        return;
    }
    zend_hash_del(&SG(known_post_content_types), post_entry->content_type,
            post_entry->content_type_len+1);
}


SAPI_API int sapi_register_default_post_reader(void (*default_post_reader)(TSRMLS_D))
{
    TSRMLS_FETCH();
    if (SG(sapi_started) && EG(in_execution)) {
        return FAILURE;
    }
    sapi_module.default_post_reader = default_post_reader;
    return SUCCESS;
}


SAPI_API int sapi_register_treat_data(void (*treat_data)(int arg, char *str, zval *destArray TSRMLS_DC))
{
    TSRMLS_FETCH();
    if (SG(sapi_started) && EG(in_execution)) {
        return FAILURE;
    }
    sapi_module.treat_data = treat_data;
    return SUCCESS;
}

SAPI_API int sapi_register_input_filter(unsigned int (*input_filter)(int arg, char *var, char **val, unsigned int val_len, unsigned int *new_val_len TSRMLS_DC))
{
    TSRMLS_FETCH();
    if (SG(sapi_started) && EG(in_execution)) {
        return FAILURE;
    }
    sapi_module.input_filter = input_filter;
    return SUCCESS;
}

SAPI_API int sapi_flush(TSRMLS_D)
{
    if (sapi_module.flush) {
        sapi_module.flush(SG(server_context));
        return SUCCESS;
    } else {
        return FAILURE;
    }
}

SAPI_API struct stat *sapi_get_stat(TSRMLS_D)
{
    if (sapi_module.get_stat) {
        return sapi_module.get_stat(TSRMLS_C);
    } else {
        if (!SG(request_info).path_translated || (VCWD_STAT(SG(request_info).path_translated, &SG(global_stat)) == -1)) {
            return NULL;
        }
        return &SG(global_stat);
    }
}

SAPI_API char *sapi_getenv(char *name, size_t name_len TSRMLS_DC)
{
    if (sapi_module.getenv) { 
        char *value, *tmp = sapi_module.getenv(name, name_len TSRMLS_CC);
        if (tmp) {
            value = estrdup(tmp);
        } else {
            return NULL;
        }
        sapi_module.input_filter(PARSE_ENV, name, &value, strlen(value), NULL TSRMLS_CC);
        return value;
    }
    return NULL;
}

SAPI_API int sapi_get_fd(int *fd TSRMLS_DC)
{
    if (sapi_module.get_fd) {
        return sapi_module.get_fd(fd TSRMLS_CC);
    } else {
        return FAILURE;
    }
}

SAPI_API int sapi_force_http_10(TSRMLS_D)
{
    if (sapi_module.force_http_10) {
        return sapi_module.force_http_10(TSRMLS_C);
    } else {
        return FAILURE;
    }
}


SAPI_API int sapi_get_target_uid(uid_t *obj TSRMLS_DC)
{
    if (sapi_module.get_target_uid) {
        return sapi_module.get_target_uid(obj TSRMLS_CC);
    } else {
        return FAILURE;
    }
}

SAPI_API int sapi_get_target_gid(gid_t *obj TSRMLS_DC)
{
    if (sapi_module.get_target_gid) {
        return sapi_module.get_target_gid(obj TSRMLS_CC);
    } else {
        return FAILURE;
    }
}

SAPI_API time_t sapi_get_request_time(TSRMLS_D)
{
    if(SG(global_request_time)) return SG(global_request_time);

    if (sapi_module.get_request_time && SG(server_context)) {
        SG(global_request_time) = sapi_module.get_request_time(TSRMLS_C);
    } else {
        SG(global_request_time) = time(0);
    }
    return SG(global_request_time);
}

/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 * vim600: sw=4 ts=4 fdm=marker
 * vim<600: sw=4 ts=4
 */

Met code-highlighting werd de uiteindelijke post 93k ofzo te groot

[ Voor 105% gewijzigd door RobIII op 02-07-2010 00:48 ]

[Verwijderd]

HINT: die broncode die RobIII gepost heeft wordt zichtbaar als je met een normale enkele linker-muis-klik op die "Knok yourself out" link klikt. Dus NIET: rechts-klikken, openen in nieuw tabblad/venster!!
Ik had dat dus even niet door, macht der gewoonte..

RobIII schreef op vrijdag 02 juli 2010 @ 00:25:
[...]
Knock yourself out ( CTRL-F: SAPI_API int sapi_header_op of regel 517 en verder)

Met code-highlighting werd de uiteindelijke post 93k ofzo te groot

Wauw, dat heb jij vet gefixt! Super!
Zoek-string: "SAPI.c 293036 2010-01-03 09:23:27Z sebastian" leverde maar 4 resultaten op, 1 stond php6 boven, en de rest was een dode link. Dus dat was kennelijk lastig zoeken geweest met google.

Wil je aub voor de compleetheid misschien nog vermelden van welke (minor-)versie deze php source is?
(Ik zie wel 5 bovenin, maar geen decimalen). Thx!


Voor mensen met 'n crappy browser, of die iets van code-highlighting en word-wrap willen heb ik de door RobIII geposte code (zoals de bron werd weergegeven als ik zijn bericht quote, dus met tabs ipv spaties) even op slexy.org gezet.
Met 't oog op de toekomst (van dit draadje) heb ik die code op 'no-expire' gezet, 'real tabs' aangevinkt en de highlighting op de taal C gezet.

Het is in elk geval aardig wat uhhm.. leesvoer.

.oisyn schreef op donderdag 01 juli 2010 @ 18:48:
[...]
6 en 11 zijn ook gewoon equivalent. "HTTP" is net zo'n bogus header als "bogus" dat is. Er bestaat verder ook helemaal geen header met de naam HTTP.

True, maar ik was inderdaad nieuwsgierig naar 10 versus 11 (beginnen beide met http) en omdat die in die document-bug mail-wisseling geopperd was. Assumption is the mother of all fuckups.

Edit: met 'n pilsje erbij
Kijk 'ns in die SAPI.c source-code op regel 590. Daar staat wat ik met 10 versus 11 wilde testen (ik had nog zonder 'human readable message' willen doen). Laat ik straks ook 's kijken wat gebeurt als ik header("HTTP/",true,404); zou doen

Edit 2: he, vlak daarna op regel 600 zie ik ik 'm zoeken naar ':'

@trensperent: die broncode was zo'n gek idee nog niet

[ Voor 10% gewijzigd door Verwijderd op 02-07-2010 07:52 ]