Subversion Repositories Applications.annuaire

Rev

Rev 566 | Rev 576 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
559 aurelien 1
<?php
2
 
3
// composer
4
require_once '../vendor/autoload.php';
5
 
6
/**
7
 * Tentative de service d'authentification / SSO bien organisé
566 mathias 8
 * SSO - Mettez un tigre dans votre annuaire !
559 aurelien 9
 * @author mathias
10
 * © Tela Botanica 2015
11
 *
12
 * @TODO se baser sur autre chose que JRest qui est obsolète
13
 */
14
class Auth extends JRestService {
15
 
16
	/** Clef utilisée pour signer les jetons JWT */
17
	private $clef;
18
 
19
	/** Si true, refusera une connexion non-HTTPS */
20
	protected $forcerSSL = true;
21
 
22
	/** Durée en secondes du jeton (doit être faible en l'absence de mécanisme d'invalidation) */
23
	protected $dureeJeton = 900;
24
 
25
	/** Durée en secondes du cookie */
26
	protected $dureeCookie = 31536000; // 3600 * 24 * 365
27
 
28
	/** Nom du cookie */
29
	protected $nomCookie = "this_is_not_a_good_cookie_name";
30
 
31
	public function __construct($config, $demarrer_session = true) {
32
		parent::__construct($config, $demarrer_session);
33
		$this->clef = file_get_contents("clef-auth.ini");
34
		if (strlen($this->clef) < 16) {
35
			throw new Exception("Clef trop courte - placez une clef d'au moins 16 caractères dans configurations/clef-auth.ini");
36
		}
37
		$this->forcerSSL = ($this->config['auth']['forcer_ssl'] == "1");
38
		$this->dureeJeton = $this->config['auth']['duree_jeton'];
39
		$this->dureeCookie = $this->config['auth']['duree_cookie'];
40
		$this->nomCookie = $this->config['auth']['nom_cookie'];
41
	}
42
 
43
	/**
44
	 * Notice d'utilisation succincte
45
	 * @TODO essayer de choisir entre anglais et français
46
	 */
47
	protected function infosService() {
48
		$uri = $this->config['settings']['baseAlternativeURL'];
49
		if ($uri == '') {
50
			$uri = $this->config['settings']['baseURL'];
51
		}
52
		$uri = $uri . "auth/";
53
 
54
		$infos = array(
55
			'service' => 'TelaBotanica/annuaire/auth',
56
			'methodes' => array(
57
				'connexion' => array(
58
					"uri" => $uri . "connexion",
59
					"parametres" => array(
60
						"login" => "adresse email (ex: name@domain.com)",
61
						"password" => "mot de passe"
62
					),
63
					"alias" => $uri . "login",
64
					"description" => "connexion avec login et mot de passe; renvoie un jeton et un cookie " . $this->nomCookie
65
				),
66
				'deconnexion' => array(
67
					"uri" => $uri . "deconnexion",
68
					"parametres" => null,
69
					"alias" => $uri . "logout",
70
					"description" => "déconnexion; renvoie un jeton null et supprime le cookie " . $this->nomCookie
71
				),
72
				'identite' => array(
73
					"uri" => $uri . "identite",
74
					"parametres" => array(
75
						"token" => "jeton JWT (facultatif)",
76
					),
77
					"alias" => array(
78
						$uri . "identity",
79
						$uri . "rafraichir",
80
						$uri . "refresh"
81
					),
82
					"description" => "confirme l'authentification et la session; rafraîchit le jeton fourni (dans le cookie " . $this->nomCookie . ", le header Authorization ou en paramètre)"
83
				),
84
				'verifierjeton' => array(
85
					"uri" => $uri . "verifierjeton",
86
					"parametres" => array(
87
						"token" => "jeton JWT",
88
					),
89
					"alias" => $uri . "verifytoken",
90
					"description" => "retourne true si le jeton fourni en paramètre ou dans le header Authorization est valide, une erreur sinon"
91
				)
92
			)
93
		);
94
		$this->envoyerJson($infos);
95
	}
96
 
97
	/**
98
	 * Lorsqu'appelé sans éléments d'URL (service:annuaire:auth);
99
	 * les paramètres GET sont ignorés
100
	 */
101
	public function getRessource() {
102
		//echo "get ressource\n";
103
		$this->infosService();
104
	}
105
 
106
	/**
107
	 * Lorsqu'appelé avec des éléments d'URL (service:annuaire:auth/machin/chose);
108
	 * les paramètres GET sont ignorés
109
	 *
110
	 * @param array $ressources les éléments d'URL
111
	 */
112
	public function getElement($ressources) {
113
		// Achtétépéèch portouguech lolch
114
		$this->verifierSSL();
115
		// le premier paramètre d'URL définit la méthode (non-magique)
116
		if (count($ressources) > 0) {
117
			switch ($ressources[0]) {
118
				case 'login':
119
				case 'connexion':
120
					$this->connexion($ressources);
121
					break;
122
				case 'logout':
123
				case 'deconnexion':
124
					$this->deconnexion();
125
					break;
126
				case 'identity':
127
				case 'identite':
128
				case 'rafraichir':
129
				case 'refresh':
130
					$this->identite();
131
					break;
132
				case 'verifytoken':
133
				case 'verifierjeton':
134
					$this->verifierJeton();
135
					break;
136
				case 'info':
137
				default:
138
					$this->infosService();
139
			}
140
		}
141
	}
142
 
143
	/**
144
	 * Lors d'un POST avec au moins une donnée dans le body (data);
145
	 * les paramètres GET sont ignorés
146
	 * @TODO faire un point d'entrée POST qui renvoie vers les méthodes GET
147
	 *
148
	 * @param array $ressources les éléments d'URL
149
	 * @param array $pairs les paramètres POST
150
	 */
151
	public function updateElement($ressources, $pairs) {
152
		//echo "update element\n";
153
		$this->nonImplemente();
154
	}
155
 
156
	/**
157
	 * Lors d'un PUT (les éléments d'URL sont ignorés) ou d'un POST avec au moins
158
	 * un élément d'URL; dans tous les cas les paramètres GET sont ignorés
159
	 *
160
	 * @param array $pairs les paramètres POST
161
	 */
162
	public function createElement($pairs) {
163
		//echo "create element\n";
164
		$this->nonImplemente();
165
	}
166
 
167
	/**
168
	 * Lors d'un DELETE avec au moins un élément d'URL
169
	 * @TODO utiliser pour invalider un jeton (nécessite stockage)
170
	 *
171
	 * @param array $ressources les éléments d'URL
172
	 */
173
	public function deleteElement($ressources) {
174
		//echo "delete element\n";
175
		$this->nonImplemente();
176
	}
177
 
178
	/**
179
	 * Vérifie l'identité d'un utilisateur à partir de son courriel et son
180
	 * mot de passe ou d'un cookie; lui accorde un jeton et un cookie si
181
	 * tout va bien, sinon renvoie une erreur et détruit le cookie
182
	 * @WARNING si vous n'utilisez pas urlencode() pour fournir le mot de passe,
183
	 * le caractère "&" posera problème en GET
184
	 *
185
	 * @param array $ressources non utilisé
186
	 */
187
	protected function connexion($ressources) {
188
		$login = $this->getParam('login');
189
		$password = $this->getParam('password', null);
190
		if ($login == '' || $password == '') {
191
			$this->erreur("parameters <login> and <password> required");
192
		}
193
		// vérification login / password
194
		$acces = $this->verifierAcces($login, $password);
195
		if ($acces === false) {
196
			$this->detruireCookie();
563 mathias 197
			// redirection si demandée - se charge de sortir du script en cas de succès
198
			$this->rediriger();
199
			// si la redirection n'a pas eu lieu
200
			$this->erreur("authentication failed", 401);
559 aurelien 201
		}
202
		// infos utilisateur
203
		$util = new Utilisateur($this->config);
204
		$infos = $util->getIdentiteParCourriel($login);
205
		if (count($infos) == 0 || empty($infos[$login])) {
563 mathias 206
			// redirection si demandée - se charge de sortir du script en cas de succès
207
			$this->rediriger();
208
			// si la redirection n'a pas eu lieu
209
			$this->erreur("could not get user info");
559 aurelien 210
		}
211
		// nom Wiki
212
		$infos[$login]['nomWiki'] = $util->formaterNomWiki($infos[$login], "UnknownWikiName");
213
		// date de dernière modification du profil
214
		$dateDerniereModif = $util->getDateDerniereModifProfil($infos[$login]['id'], true);
215
		$infos[$login]['dateDerniereModif'] = $dateDerniereModif;
216
		// création du jeton
217
		$jwt = $this->creerJeton($login, $infos[$login]);
218
		// création du cookie
219
		$this->creerCookie($jwt);
563 mathias 220
		// redirection si demandée - se charge de sortir du script en cas de succès
221
		$this->rediriger($jwt);
222
		// envoi
223
		$this->envoyerJson(array(
224
			"session" => true,
225
			"token" => $jwt,
226
			"duration" => intval($this->dureeJeton),
227
			"token_id" => $this->nomCookie,
228
			"last_modif" => $infos[$login]['dateDerniereModif']
229
		));
559 aurelien 230
	}
231
 
232
	/**
233
	 * Détruit le cookie et renvoie un jeton vide ou NULL - le client
234
	 * devrait toujours remplacer son jeton par celui renvoyé par les
235
	 * méthodes de l'annuaire
236
	 */
237
	protected function deconnexion() {
238
		// suppression du cookie
239
		$this->detruireCookie();
240
		// envoi d'un jeton null
241
		$jwt = null;
563 mathias 242
		// redirection si demandée - se charge de sortir du script en cas de succès
243
		$this->rediriger();
244
		// si la redirection n'a pas eu lieu
245
		$this->envoyerJson(array(
246
				"session" => false,
247
				"token" => $jwt,
248
				"token_id" => $this->nomCookie
249
		));
559 aurelien 250
	}
251
 
252
	/**
253
	 * Renvoie un jeton rafraîchi (durée de validité augmentée de $this->dureeJeton
254
	 * si l'utilisateur est reconnu comme détenteur d'une session active (cookie valide,
255
	 * header HTTP "Authorization" ou jeton valide); renvoie une erreur si le cookie
256
	 * et/ou le jeton sont expirés;
257
	 * cela permet en théorie de forger des cookies avec des jetons expirés pour se les
258
	 * faire rafraîchir frauduleusement, mais le canal HTTPS fait qu'un client ne peut
259
	 * être en possession que de ses propres jetons... au pire on peut se faire prolonger
260
	 * à l'infini même si on n'est plus inscrit à l'annuaire... @TODO faire mieux un jour
261
	 * Priorité : cookie > header "Authorization" > paramètre "token" @TODO vérifier cette
262
	 * stratégie, l'inverse est peut-être plus malin
263
	 */
264
	protected function identite() {
265
		$cookieAvecJetonValide = false;
266
		$jetonRetour = null;
267
		$erreur = '';
268
		// lire cookie
269
		if (isset($_COOKIE[$this->nomCookie])) {
270
			$jwt = $_COOKIE[$this->nomCookie];
271
			try {
272
				// rafraîchir jeton quelque soit son état - "true" permet
273
				// d'ignorer les ExpiredException (on rafraîchit le jeton
274
				// expiré car le cookie est encore valide)
275
				$jetonRetour = $this->rafraichirJeton($jwt, true);
276
				// on ne tentera pas de lire un jeton fourni en paramètre
277
				$cookieAvecJetonValide = true;
278
			} catch (Exception $e) {
279
				// si le rafraîchissement a échoué (jeton invalide - hors expiration - ou vide)
280
				// on ne fait rien et on tente la suite (jeton fourni hors cookie ?)
281
				$erreur = "invalid token in cookie";
282
			}
283
		}
284
		// si le cookie n'existait pas ou ne contenait pas un jeton
285
		if (! $cookieAvecJetonValide) {
286
			// lire jeton depuis header ou paramètre
287
			$jwt = $this->lireJetonDansHeader();
288
			if ($jwt == null) {
289
				// dernière chance
290
				$jwt = $this->getParam('token');
291
			}
292
			// toutes les possibilités ont été essayées
293
			if ($jwt != null) {
294
				try {
295
					// rafraîchir jeton si non expiré
296
					$jetonRetour = $this->rafraichirJeton($jwt);
297
				} catch (Exception $e) {
298
					// si le rafraîchissement a échoué (jeton invalide, expiré ou vide)
299
					$erreur = "invalid or expired token in Authorization header or parameter <token>";
300
				}
301
			} else {
302
				// pas de jeton valide passé en paramètre
303
				$erreur = ($erreur == "" ? "no token or cookie" : "invalid token in cookie / invalid or expired token in Authorization header or parameter <token>");
304
			}
563 mathias 305
		}
306
		// redirection si demandée - se charge de sortir du script en cas de succès
307
		$this->rediriger($jetonRetour);
308
		// renvoi jeton
309
		if ($jetonRetour === null) {
310
			$this->erreur($erreur);
559 aurelien 311
		} else {
563 mathias 312
			$this->envoyerJson(array(
313
					"session" => true,
314
					"token" => $jetonRetour,
315
					"duration" => intval($this->dureeJeton),
316
					"token_id" => $this->nomCookie
317
			));
559 aurelien 318
		}
319
	}
563 mathias 320
 
321
	/**
322
	 * Si $_GET['redirect_url'] est non-vide, redirige vers l'URL qu'il contient et sort du programme;
323
	 * sinon, ne fait rien et passe la main
324
	 *
574 mathias 325
	 * @param string $jetonRetour jeton JWT à passer à l'URL de destination
326
	 * en GET; par défaut null
563 mathias 327
	 */
328
	protected function rediriger($jetonRetour=null) {
329
		if (!empty($_GET['redirect_url'])) {
330
			// dans le cas où une url de redirection est précisée,
574 mathias 331
			// on précise le jeton dans le get
559 aurelien 332
			$url_redirection = $_GET['redirect_url'];
574 mathias 333
 
334
			// même si le jeton est vide, on ajoute un paramètre GET Authorization
335
			// pour spécifier à la cible qu'on a bien traité sa requête - permet
336
			// aussi de gérer les déconnexions en renvoyant un jeton vide
337
			$separateur = (parse_url($url_redirection, PHP_URL_QUERY) == NULL) ? '?' : '&';
338
			$url_redirection .= $separateur.'Authorization='.$jetonRetour;
339
 
340
			// retour à l'envoyeur !
563 mathias 341
			header('Location: '.$url_redirection);
342
			exit;
559 aurelien 343
		}
344
	}
345
 
346
	/**
347
	 * Vérifie si un jeton est valide; retourne true si oui, une erreur avec
348
	 * des détails si non;
349
	 * Priorité : header "Authorization" > paramètre "token"
350
	 */
351
	protected function verifierJeton() {
352
		// vérifie que le jeton provient bien d'ici,
353
		// et qu'il est encore valide (date)
354
		$jwt = $this->lireJetonDansHeader();
355
		if ($jwt == null) {
356
			$jwt = $this->getParam('token');
357
			if ($jwt == '') {
358
				$this->erreur("parameter <token> or Authorization header required");
359
			}
360
		}
361
		try {
362
			$jeton = JWT::decode($jwt, $this->clef, array('HS256'));
363
			$jeton = (array) $jeton;
364
		} catch (Exception $e) {
365
			$this->erreur($e->getMessage());
366
			exit;
367
		}
368
		$this->envoyerJson(true);
369
	}
370
 
371
	/**
372
	 * Reçoit un jeton JWT, et s'il est non-vide ("sub" != null), lui redonne
373
	 * une période de validité de $this->dureeJeton; si $ignorerExpiration
374
	 * vaut true, rafraîchira le jeton même s'il a expiré
375
	 * (attention à ne pas appeler cette méthode n'importe comment !);
376
	 * jette une exception si le jeton est vide, mal signé ou autre erreur,
377
	 * ou s'il a expiré et que $ignorerExpiration est différent de true
378
	 *
379
	 * @param string $jwt le jeton JWT
380
	 * @return string le jeton rafraîchi
381
	 */
382
	protected function rafraichirJeton($jwt, $ignorerExpiration=false) /* throws Exception */ {
383
		$infos = array();
384
		// vérification avec lib JWT
385
		try {
386
			$infos = JWT::decode($jwt, $this->clef, array('HS256'));
387
			$infos = (array) $infos;
388
		} catch (ExpiredException $e) {
389
			if ($ignorerExpiration === true) {
390
				// on se fiche qu'il soit expiré
391
				// décodage d'un jeton expiré
392
				// @WARNING considère que la lib JWT jette ExpiredException en dernier (vrai 12/05/2015),
393
				// ce qui signifie que la signature et le domaine sont tout de même valides - à surveiller !
394
				$infos = $this->decoderJetonExpireManuellement($jwt);
395
			} else {
396
				// on renvoie l'exception plus haut
397
				throw $e;
398
			}
399
		}
400
		// vérification des infos
401
		if (empty($infos['sub'])) {
402
			// jeton vide (wtf?)
403
			throw new Exception("empty token (no <sub>)");
404
		}
405
		// rafraîchissement
406
		$infos['exp'] = time() + $this->dureeJeton;
407
		$jwtSortie = JWT::encode($infos, $this->clef);
408
 
409
		return $jwtSortie;
410
	}
411
 
412
	/**
413
	 * Décode manuellement un jeton JWT, SANS VÉRIFIER SA SIGNATURE OU
414
	 * SON DOMAINE ! @WARNING ne pas utiliser hors du cas d'un jeton
415
	 * correct (vérifié avec la lib JWT) mais expiré !
416
	 *
417
	 * @param string $jwt un jeton vérifié comme valide, mais expiré
418
	 */
419
	protected function decoderJetonExpireManuellement($jwt) {
420
		$parts = explode('.', $jwt);
421
		$payload = $parts[1];
422
		$payload = base64_decode($payload);
423
		$payload = json_decode($payload, true);
424
 
425
		return $payload;
426
	}
427
 
428
	/**
429
	 * Crée un jeton JWT signé avec la clef
430
	 *
431
	 * @param mixed $sub subject: l'id utilisateur du détenteur du jeton si authentifié, null sinon
432
	 * @param string $exp la date d'expiration du jeton, par défaut la date actuelle plus $this->dureeJeton
433
	 * @param array $donnees les données à ajouter au jeton (infos utilisateur)
434
	 *
435
	 * @return string un jeton JWT signé
436
	 */
437
	protected function creerJeton($sub, $donnees=array(), $exp=null) {
438
		if ($exp === null) {
439
			$exp = time() + $this->dureeJeton;
440
		}
441
		$jeton = array(
442
			"iss" => "https://www.tela-botanica.org",
443
			"token_id" => $this->nomCookie,
444
			//"aud" => "http://example.com",
445
			"sub" => $sub,
446
			"iat" => time(),
447
			"exp" => $exp,
448
			//"nbf" => time() + 60,
449
			"scopes" => array("tela-botanica.org")
450
		);
451
		if (! empty($donnees)) {
452
			$jeton = array_merge($jeton, $donnees);
453
		}
454
		$jwt = JWT::encode($jeton, $this->clef);
455
 
456
		return $jwt;
457
	}
458
 
459
	/**
460
	 * Essaye de trouver un jeton JWT non vide dans l'entête HTTP $nomHeader (par
461
	 * défaut "Authorization")
462
	 *
463
	 * @param string $nomHeader nom de l'entête dans lequel chercher le jeton
464
	 * @return String un jeton JWT ou null
465
	 */
466
	protected function lireJetonDansHeader($nomHeader="Authorization") {
467
		$jwt = null;
468
		$headers = apache_request_headers();
469
		if (isset($headers[$nomHeader]) && ($headers[$nomHeader] != "")) {
470
			$jwt = $headers[$nomHeader];
471
		}
472
		return $jwt;
473
	}
474
 
475
	/**
476
	 * Crée un cookie de durée $this->dureeCookie, nommé $this->nomCookie et
477
	 * contenant $valeur
478
	 *
479
	 * @param string $valeur le contenu du cookie (de préférence un jeton JWT)
480
	 */
481
	protected function creerCookie($valeur) {
482
		setcookie($this->nomCookie, $valeur, time() + $this->dureeCookie, '/', null, true);
483
	}
484
 
485
	/**
486
	 * Renvoie le cookie avec une valeur vide et une date d'expiration dans le
487
	 * passé, afin que le navigateur le détruise au prochain appel
488
	 * @TODO envisager l'envoi d'un jeton vide plutôt que la suppression du cookie
489
	 *
490
	 * @param string $valeur la valeur du cookie, par défaut ""
491
	 */
492
	protected function detruireCookie() {
493
		setcookie($this->nomCookie, "", -1, '/', null, true);
494
	}
495
 
496
	// ---------------- Méthodes à génériciser ci-dessous ----------------------------------
497
 
498
	/**
499
	 * Message succinct pour méthodes / actions non implémentées
500
	 */
501
	protected function nonImplemente() {
502
		$this->erreur("not implemented");
503
	}
504
 
505
	/**
506
	 * Si $this->forcerSSL vaut true, envoie une erreur et termine le programme si SSL n'est pas utilisé
507
	 */
508
	protected function verifierSSL() {
509
		if ($this->forcerSSL === true) {
510
			if (empty($_SERVER['HTTPS']) || $_SERVER['HTTPS'] == 'off') {
511
				$this->erreur("HTTPS required");
512
				exit;
513
			}
514
		}
515
	}
516
 
517
	protected function getParamChain($names) {
518
		if (! is_array($names)) {
519
			// Hou ? (cri de chouette solitaire)
520
		}
521
	}
522
 
523
	/**
524
	 * Capture un paramètre de requête ($_REQUEST)
525
	 *
526
	 * @param string $name nom du paramètre à capturer
527
	 * @param string $default valeur par défaut si le paramètre n'est pas défini (ou vide, voir ci-dessous)
528
	 * @param bool $traiterVideCommeDefaut si le paramètre est défini mais vide (''), le considèrera comme non défini
529
	 *
530
	 * @return string la valeur du paramètre si défini, sinon la valeur par défaut
531
	 */
532
	protected function getParam($name, $default=null, $traiterVideCommeDefaut=false) {
533
		$ret = $default;
534
		if (isset($_REQUEST[$name])) {
535
			if ($traiterVideCommeDefaut === false || $_REQUEST[$name] !== '') {
536
				$ret = $_REQUEST[$name];
537
			}
538
		}
539
		return $ret;
540
	}
541
 
542
	/**
543
	 * Capture un paramètre GET
544
	 *
545
	 * @param string $name nom du paramètre GET à capturer
546
	 * @param string $default valeur par défaut si le paramètre n'est pas défini (ou vide, voir ci-dessous)
547
	 * @param bool $traiterVideCommeDefaut si le paramètre est défini mais vide (''), le considèrera comme non défini
548
	 *
549
	 * @return string la valeur du paramètre si défini, sinon la valeur par défaut
550
	 */
551
	protected function getGetParam($name, $default=null, $traiterVideCommeDefaut=false) {
552
		$ret = $default;
553
		if (isset($_GET[$name])) {
554
			if ($traiterVideCommeDefaut === false || $_GET[$name] !== '') {
555
				$ret = $_GET[$name];
556
			}
557
		}
558
		return $ret;
559
	}
560
 
561
	/**
562
	 * Capture un paramètre POST
563
	 *
564
	 * @param string $name nom du paramètre POST à capturer
565
	 * @param string $default valeur par défaut si le paramètre n'est pas défini (ou vide, voir ci-dessous)
566
	 * @param bool $traiterVideCommeDefaut si le paramètre est défini mais vide (''), le considèrera comme non défini
567
	 *
568
	 * @return string la valeur du paramètre si défini, sinon la valeur par défaut
569
	 */
570
	protected function getPostParam($name, $default=null, $traiterVideCommeDefaut=false) {
571
		$ret = $default;
572
		if (isset($_POST[$name])) {
573
			if ($traiterVideCommeDefaut === false || $_POST[$name] !== '') {
574
				$ret = $_POST[$name];
575
			}
576
		}
577
		return $ret;
578
	}
579
 
580
	/**
581
	 * Envoie une erreur HTTP $code (400 par défaut) avec les données $data en JSON
582
	 *
583
	 * @param mixed $data données JSON de l'erreur - généralement array("error" => "raison de l'erreur") - si
584
	 * 		seule une chaîne est transmise, sera convertie en array("error" => $data)
585
	 * @param number $code code HTTP de l'erreur, par défaut 400 (bad request)
586
	 * @param boolean $exit si true (par défaut), termine le script après avoir envoyé l'erreur
587
	 */
588
	protected function erreur($data, $code=400, $exit=true) {
589
		if (! is_array($data)) {
590
			$data = array(
591
				"error" => $data
592
			);
593
		}
594
		http_response_code($code);
595
		$this->envoyerJson($data);
596
		if ($exit === true) {
597
			exit;
598
		}
599
	}
600
}
601
 
602
/**
603
 * Mode moderne pour PHP < 5.4
604
 */
605
if (!function_exists('http_response_code')) {
606
	function http_response_code($code = NULL) {
607
		if ($code !== NULL) {
608
			switch ($code) {
609
				case 100: $text = 'Continue'; break;
610
				case 101: $text = 'Switching Protocols'; break;
611
				case 200: $text = 'OK'; break;
612
				case 201: $text = 'Created'; break;
613
				case 202: $text = 'Accepted'; break;
614
				case 203: $text = 'Non-Authoritative Information'; break;
615
				case 204: $text = 'No Content'; break;
616
				case 205: $text = 'Reset Content'; break;
617
				case 206: $text = 'Partial Content'; break;
618
				case 300: $text = 'Multiple Choices'; break;
619
				case 301: $text = 'Moved Permanently'; break;
620
				case 302: $text = 'Moved Temporarily'; break;
621
				case 303: $text = 'See Other'; break;
622
				case 304: $text = 'Not Modified'; break;
623
				case 305: $text = 'Use Proxy'; break;
624
				case 400: $text = 'Bad Request'; break;
625
				case 401: $text = 'Unauthorized'; break;
626
				case 402: $text = 'Payment Required'; break;
627
				case 403: $text = 'Forbidden'; break;
628
				case 404: $text = 'Not Found'; break;
629
				case 405: $text = 'Method Not Allowed'; break;
630
				case 406: $text = 'Not Acceptable'; break;
631
				case 407: $text = 'Proxy Authentication Required'; break;
632
				case 408: $text = 'Request Time-out'; break;
633
				case 409: $text = 'Conflict'; break;
634
				case 410: $text = 'Gone'; break;
635
				case 411: $text = 'Length Required'; break;
636
				case 412: $text = 'Precondition Failed'; break;
637
				case 413: $text = 'Request Entity Too Large'; break;
638
				case 414: $text = 'Request-URI Too Large'; break;
639
				case 415: $text = 'Unsupported Media Type'; break;
640
				case 500: $text = 'Internal Server Error'; break;
641
				case 501: $text = 'Not Implemented'; break;
642
				case 502: $text = 'Bad Gateway'; break;
643
				case 503: $text = 'Service Unavailable'; break;
644
				case 504: $text = 'Gateway Time-out'; break;
645
				case 505: $text = 'HTTP Version not supported'; break;
646
				case 666: $text = 'Couscous overheat'; break;
647
				default:
648
					exit('Unknown http status code "' . htmlentities($code) . '"');
649
					break;
650
			}
651
 
652
			$protocol = (isset($_SERVER['SERVER_PROTOCOL']) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.0');
653
			header($protocol . ' ' . $code . ' ' . $text);
654
			$GLOBALS['http_response_code'] = $code;
655
		} else {
656
			$code = (isset($GLOBALS['http_response_code']) ? $GLOBALS['http_response_code'] : 200);
657
		}
658
		return $code;
659
	}
536 mathias 660
}