Subversion Repositories Sites.tela-botanica.org

Rev

Rev 609 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4 david 1
<?php
2
 
3
/***************************************************************************\
4
 *  SPIP, Systeme de publication pour l'internet                           *
5
 *                                                                         *
6
 *  Copyright (c) 2001-2005                                                *
7
 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
8
 *                                                                         *
9
 *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
10
 *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
11
\***************************************************************************/
12
 
13
 
14
//
15
// Fonctions de spip_image.php3
16
 
17
//
18
// Ce fichier ne sera execute qu'une fois
19
if (defined("_ECRIRE_INC_GETDOCUMENT")) return;
20
define("_ECRIRE_INC_GETDOCUMENT", "1");
21
 
22
 
23
// Creer IMG/pdf/
24
function creer_repertoire_documents($ext) {
25
	$rep = _DIR_DOC . creer_repertoire(_DIR_DOC, $ext);
26
 
27
	if (!$ext OR !$rep) {
28
		spip_log("creer_repertoire_documents interdit");
29
		exit;
30
	}
31
 
32
	if (lire_meta("creer_htaccess") == 'oui') {
33
		include_ecrire('inc_acces.php3');
34
		verifier_htaccess($rep);
35
	}
36
 
37
	return $rep;
38
}
39
 
40
// Efface le repertoire de maniere recursive !
41
function effacer_repertoire_temporaire($nom) {
42
	$d = opendir($nom);
43
	while ($f = readdir($d)) {
44
		if (is_file("$nom/$f"))
45
			@unlink("$nom/$f");
46
		else if ($f <> '.' AND $f <> '..'
47
		AND is_dir("$nom/$f"))
48
			effacer_repertoire_temporaire("$nom/$f");
49
	}
50
	@rmdir($nom);
51
}
52
 
53
function copier_document($ext, $orig, $source) {
54
 
55
	$dir = creer_repertoire_documents($ext);
56
	$dest = $dir .
57
		ereg_replace("[^.a-zA-Z0-9_=-]+", "_",
58
			translitteration(ereg_replace("\.([^.]+)$", "",
59
						      ereg_replace("<[^>]*>", '', basename($orig)))));
60
 
61
	// Si le document "source" est deja au bon endroit, ne rien faire
62
	if ($source == ($dest . '.' . $ext))
63
		return $source;
64
 
65
	// sinon tourner jusqu'a trouver un numero correct
66
	$n = 0;
67
	while (@file_exists($newFile = $dest.($n++ ? '-'.$n : '').'.'.$ext));
68
 
69
	$newFile = preg_replace('/[.]+/', '.', $newFile);
70
 
71
	if ($r = deplacer_fichier_upload($source, $newFile))
72
		return $newFile;
73
}
74
 
75
//
76
// Deplacer un fichier
77
//
78
 
79
function deplacer_fichier_upload($source, $dest) {
80
	// Securite
81
	if (strstr($dest, "..")) {
82
		spip_log("stop deplacer_fichier_upload: '$dest'");
83
		exit;
84
	}
85
 
86
	$ok = @copy($source, $dest);
87
	if (!$ok) $ok = @move_uploaded_file($source, $dest);
88
	if ($ok)
89
		@chmod($dest, 0666);
90
	else {
91
		$f = @fopen($dest,'w');
92
		if ($f) {
93
			fclose ($f);
94
		} else {
95
			redirige_par_entete("spip_test_dirs.php3?test_dir=".
96
				dirname($dest));
97
		}
98
		@unlink($dest);
99
	}
100
	return $ok;
101
}
102
 
103
 
104
// Erreurs d'upload
105
// renvoie false si pas d'erreur
106
// et true si erreur = pas de fichier
107
// pour les autres erreurs affiche le message d'erreur et meurt
108
function check_upload_error($error, $msg='') {
109
	switch ($error) {
110
		case 0:
111
			return false;
112
		case 4: /* UPLOAD_ERR_NO_FILE */
113
			return true;
114
 
115
		# on peut affiner les differents messages d'erreur
116
		case 1: /* UPLOAD_ERR_INI_SIZE */
117
			$msg = _T('upload_limit',
118
			array('max' => ini_get('upload_max_filesize')));
119
			break;
120
		case 2: /* UPLOAD_ERR_FORM_SIZE */
121
			$msg = _T('upload_limit',
122
			array('max' => ini_get('upload_max_filesize')));
123
			break;
124
		case 3: /* UPLOAD_ERR_PARTIAL  */
125
			$msg = _T('upload_limit',
126
			array('max' => ini_get('upload_max_filesize')));
127
			break;
128
	}
129
 
130
	spip_log ("erreur upload $error");
131
 
132
	include_ecrire('inc_presentation.php3');
133
	install_debut_html(_T('forum_titre_erreur'));
134
	echo "<p>$msg</p>\n";
135
 
136
	install_fin_html(_DIR_RESTREINT_ABS . $GLOBALS['redirect']);
137
	exit;
138
}
139
 
140
 
141
//
142
// Gestion des fichiers ZIP
143
//
144
function accepte_fichier_upload ($f) {
145
	if (!ereg(".*__MACOSX/", $f)
146
	AND !ereg("^\.", basename($f))) {
147
		$ext = substr(strrchr($f, "."), 1);
148
		$result = spip_query("SELECT * FROM spip_types_documents
149
		WHERE extension='"
150
		. corriger_extension(addslashes(strtolower($ext)))
151
		. "' AND upload='oui'");
152
		if ($row = @spip_fetch_array($result))
153
			return true;
154
	}
155
}
156
 
157
# callback pour le deballage dans spip_image.php3
158
# http://www.phpconcept.net/pclzip/man/en/?options-pclzip_cb_pre_extractfunction
159
function callback_deballe_fichier($p_event, &$p_header) {
160
	if (accepte_fichier_upload($p_header['filename'])) {
161
		$p_header['filename'] = _tmp_dir . basename($p_header['filename']);
162
		return 1;
163
	} else {
164
		return 0;
165
	}
166
}
167
 
168
function verifier_compactes($zip) {
169
	if ($list = $zip->listContent()) {
170
	// si pas possible de decompacter: installer comme fichier zip joint
171
	// Verifier si le contenu peut etre uploade (verif extension)
172
		$aff_fichiers = array();
173
		foreach ($list as $file) {
174
			if (accepte_fichier_upload($f = $file['stored_filename']))
175
				$aff_fichiers[]= $f;
176
			else
177
				spip_log("chargement de $f interdit");
178
		}
179
		sort($aff_fichiers);
180
		return $aff_fichiers;
181
	}
182
}
183
 
184
function afficher_compactes($image_name /* not used */, $fichiers, $link) {
185
// presenter une interface pour choisir si fichier joint ou decompacter
186
// passer ca en squelette un de ces jours.
187
 
188
	include_ecrire ("inc_presentation.php3");
189
	install_debut_html(_T('upload_fichier_zip'));
190
	echo "<p>",
191
		_T('upload_fichier_zip_texte'),
192
		"</p>",
193
		"<p>",
194
		_T('upload_fichier_zip_texte2'),
195
		"</p>",
196
		$link->getForm('POST'),
197
		"<div><input type='radio' checked name='action_zip' value='telquel'>",
198
		_T('upload_zip_telquel'),
199
		"</div>",
200
		"<div><input type='radio' name='action_zip' value='decompacter'>",
201
		_T('upload_zip_decompacter'),
202
		"</div>",
203
		"<ul><li>" ,
204
		 join("</li>\n<li>",$fichiers) ,
205
		 "</li></ul>",
206
		"<div>&nbsp;</div>",
207
		"<div style='text-align: right;'><input class='fondo' style='font-size: 9px;' type='submit' value='",
208
		_T('bouton_valider'),
209
		"'></div>",
210
		"</form>";
211
	install_fin_html();
212
}
213
 
214
// Si on doit conserver une copie locale des fichiers distants, autant que ca
215
// soit a un endroit canonique -- si ca peut etre bijectif c'est encore mieux,
216
// mais la tout de suite je ne trouve pas l'idee, etant donne les limitations
217
// des filesystems
218
function nom_fichier_copie_locale($source, $extension) {
219
	$dir = _DIR_IMG. creer_repertoire(_DIR_IMG, 'distant'); # IMG/distant/
220
	$dir2 = $dir . creer_repertoire($dir, $extension); 		# IMG/distant/pdf/
221
	return $dir2 . substr(basename($source).'-'.md5($source),0,12).
222
		substr(md5($source),0,4).'.'.$extension;
223
}
224
 
225
//
226
// Donne le nom de la copie locale de la source
227
//
228
function fichier_copie_locale($source) {
229
	// Si c'est une image de IMG/ pas de souci
230
	if (preg_match(',^'._DIR_IMG.',', $source))
231
		return $source;
232
 
233
	// Si l'extension n'est pas precisee, aller la chercher dans la table
234
	// des documents -- si la source n'est pas dans la table des documents,
235
	// on ne fait rien
236
	if ($t = spip_fetch_array(spip_query("SELECT * FROM spip_documents
237
	WHERE fichier='".addslashes($source)."' AND distant='oui'")))
238
		list($extension) = spip_fetch_array(spip_query("SELECT extension
239
		FROM spip_types_documents WHERE id_type=".$t['id_type']));
240
 
241
	if ($extension)
242
		return nom_fichier_copie_locale($source, $extension);
243
}
244
 
245
 
246
// Recuperer les infos d'un document distant, sans trop le telecharger
247
function recuperer_infos_distantes($source, $max=0) {
248
	include_ecrire('inc_sites.php3');
249
 
250
	$a = array();
251
 
252
	// On va directement charger le debut des images et des fichiers html,
253
	// de maniere a attrapper le maximum d'infos (titre, taille, etc). Si
254
	// ca echoue l'utilisateur devra les entrer...
255
	if ($headers = recuperer_page($source, false, true, $max)) {
256
		list($headers, $a['body']) = split("\n\n", $headers, 2);
257
		if (preg_match(",\nContent-Type: *([^[:space:];]*),i",
258
			"\n$headers", $regs)
259
		AND $mime_type = addslashes(trim($regs[1]))
260
		AND $s = spip_query("SELECT id_type,extension FROM spip_types_documents
261
			WHERE mime_type='$mime_type'")
262
		AND $t = spip_fetch_array($s)) {
263
			spip_log("mime-type $mime_type ok");
264
			$a['id_type'] = $t['id_type'];
265
			$a['extension'] = $t['extension'];
266
		} else {
267
			# par defaut on retombe sur '.bin' si c'est autorise
268
			spip_log("mime-type $mime_type inconnu");
269
			$t = spip_fetch_array(spip_query(
270
				"SELECT id_type,extension FROM spip_types_documents
271
				WHERE extension='bin'"));
272
			if (!$t) return false;
273
			$a['id_type'] = $t['id_type'];
274
			$a['extension'] = $t['extension'];
275
		}
276
 
277
		if (preg_match(",\nContent-Length: *([^[:space:]]*),i",
278
			"\n$headers", $regs))
279
			$a['taille'] = intval($regs[1]);
280
	}
281
 
282
	// Echec avec HEAD, on tente avec GET
283
	if (!$a AND !$max) {
284
	spip_log("tente $source");
285
		$a = recuperer_infos_distantes($source, 1024*1024);
286
	}
287
 
288
	// S'il s'agit d'une image pas trop grosse ou d'un fichier html, on va aller
289
	// recharger le document en GET et recuperer des donnees supplementaires...
290
	if (preg_match(',^image/(jpeg|gif|png|swf),', $mime_type)) {
291
		if ($max == 0
292
		AND $taille < 1024*1024
293
		AND ereg(",".$a['extension'].",",
294
		','.lire_meta('formats_graphiques').',')){
295
			$a = recuperer_infos_distantes($source, 1024*1024);
296
		}
297
		else if ($a['body']) {
298
			$a['fichier'] = nom_fichier_copie_locale($source, $a['extension']);
299
			ecrire_fichier($a['fichier'], $a['body']);
300
			$size_image = @getimagesize($a['fichier']);
301
			$a['largeur'] = intval($size_image[0]);
302
			$a['hauteur'] = intval($size_image[1]);
303
			$a['type_image'] = true;
304
		}
305
	}
306
 
307
	if ($mime_type == 'text/html') {
308
		$page = recuperer_page($source, true, false, 1024*1024);
309
		if(preg_match(',<title>(.*?)</title>,ims', $page, $regs))
310
			$a['titre'] = corriger_caracteres(trim($regs[1]));
311
			if (!$a['taille']) $a['taille'] = strlen($page); # a peu pres
312
	}
313
 
314
	return $a;
315
}
316
 
317
 
318
//
319
// Ajouter un document (au format $_FILES)
320
//
321
function ajouter_un_document ($source, $nom_envoye, $type_lien, $id_lien, $mode, $id_document, &$documents_actifs) {
322
 
323
	// Documents distants : pas trop de verifications bloquantes, mais un test
324
	// via une requete HEAD pour savoir si la ressource existe (non 404), si le
325
	// content-type est connu, et si possible recuperer la taille, voire plus.
326
	if ($mode == 'distant') {
327
		if ($a = recuperer_infos_distantes($source)) {
328
			# fichier local pour creer la vignette (!!),
329
			# on retablira la valeur de l'url a la fin
330
			$fichier = $a['fichier'];
331
 
332
			$id_type = $a['id_type'];
333
			$taille = $a['taille'];
334
			$titre = $a['titre'];
335
			$largeur = $a['largeur'];
336
			$hauteur = $a['hauteur'];
337
			$ext = $a['extension'];
338
			$type_image = $a['type_image'];
339
 
340
			$distant = 'oui';
341
			$mode = 'document';
342
		}
343
		else {
344
			spip_log("Echec du lien vers le document $source, abandon");
345
			return;
346
		}
347
	}
348
 
349
	else {
350
 
351
		$distant = 'non';
352
 
353
		// tester le type de document :
354
		// - interdit a l'upload ?
355
		// - quel numero dans spip_types_documents ?  =-(
356
		// - est-ce "inclus" comme une image ?
357
		ereg("\.([^.]+)$", $nom_envoye, $match);
358
		$ext = addslashes(corriger_extension(strtolower($match[1])));
359
 
360
		// Si le fichier est de type inconnu, on va le stocker en .zip
361
		if (!$row = spip_fetch_array(spip_query(
362
		"SELECT * FROM spip_types_documents
363
		WHERE extension='$ext' AND upload='oui'"))) {
364
 
365
/* STOCKER LES DOCUMENTS INCONNUS AU FORMAT .BIN */
366
/*			$ext = 'bin';
367
			$nom_envoye .= '.bin';
368
			spip_log("Extension $ext");
369
			if (!$row = spip_fetch_array(spip_query(
370
			"SELECT * FROM spip_types_documents
371
			WHERE extension='bin' AND upload='oui'"))) {
372
				spip_log("Extension $ext interdite a l'upload");
373
				return;
374
			}
375
*/
376
 
377
/* STOCKER LES DOCUMENTS INCONNUS AU FORMAT .ZIP */
378
			$ext = 'zip';
379
			spip_log("Extension $ext");
380
			if (!$row = spip_fetch_array(spip_query(
381
			"SELECT * FROM spip_types_documents
382
			WHERE extension='zip' AND upload='oui'"))) {
383
				spip_log("Extension $ext interdite a l'upload");
384
				return;
385
			}
386
			if (!$tmp_dir = tempnam(_DIR_SESSIONS, 'tmp_upload')) return;
387
			@unlink($tmp_dir); @mkdir($tmp_dir);
388
			if (!is_dir(_DIR_IMG.'tmp')) @mkdir(_DIR_IMG.'tmp');
389
			$tmp = $tmp_dir.'/'.translitteration($nom_envoye);
390
			$nom_envoye .= '.zip'; # conserver l'extension dans le nom de fichier, par exemple toto.js => toto.js.zip
391
			$fichier = deplacer_fichier_upload($source, $tmp);
392
			require_once(_DIR_RESTREINT . 'pclzip.lib.php');
393
			$source = _DIR_IMG.'tmp/archive.zip';
394
			$archive = new PclZip($source);
395
			$v_list = $archive->create($tmp,
396
				PCLZIP_OPT_REMOVE_PATH, $tmp_dir,
397
				PCLZIP_OPT_ADD_PATH, '');
398
			effacer_repertoire_temporaire($tmp_dir);
399
			if (!$v_list) {
400
				spip_log("Echec creation du zip ");
401
				return;
402
			}
403
		}
404
		$id_type = $row['id_type'];	# numero du type dans spip_types_documents:(
405
		$type_inclus_image = ($row['inclus'] == 'image');
406
 
407
		// Recopier le fichier a son emplacement definitif
408
		$fichier = copier_document($ext, $nom_envoye, $source);
409
		if (!$fichier) {
410
			spip_log("Impossible de copier_document($ext, $nom_envoye, $source)");
411
			return;
412
		}
413
 
414
		// Quelques infos sur le fichier
415
		if (!@file_exists($fichier)
416
		OR !$taille = @filesize($fichier)) {
417
			spip_log ("Echec copie du fichier $fichier");
418
			return;
419
		}
420
 
421
		// Si c'est une image, recuperer sa taille et son type (detecte aussi swf)
422
		$size_image = @getimagesize($fichier);
423
		$largeur = intval($size_image[0]);
424
		$hauteur = intval($size_image[1]);
425
		$type_image = decoder_type_image($size_image[2]);
426
 
427
		// Si on veut uploader une vignette, il faut qu'elle ait ete bien lue
428
		if ($mode == 'vignette' AND !($largeur * $hauteur)) {
429
			@unlink($fichier);
430
			return;
431
		}
432
	}
433
 
434
	// regler l'ancre du retour
435
	if (!$GLOBALS['ancre']) {
436
		if ($mode=='vignette')
437
			$GLOBALS['ancre'] = 'images';
438
		else if ($type_image)
439
			$GLOBALS['ancre'] = 'portfolio';
440
		else
441
			$GLOBALS['ancre'] = 'documents';
442
	}
443
 
444
	// Preparation vignette du document $id_document
445
	$id_document=intval($id_document);
446
	if ($mode == 'vignette' AND $id_document_lie = $id_document) {
447
		# on force le statut "document" de ce fichier (inutile ?)
448
		spip_query("UPDATE spip_documents
449
			SET mode='document'
450
			WHERE id_document=$id_document");
451
		$id_document = 0;
452
	}
453
 
454
	// Installer le document dans la base
455
	// attention piege semantique : les images s'installent en mode 'vignette'
456
	// note : la fonction peut "mettre a jour un document" si on lui
457
	// passe "mode=document" et "id_document=.." (pas utilise)
458
	if (!$id_document) {
459
		// Inserer le nouveau doc et recuperer son id_
460
		$id_document = spip_abstract_insert("spip_documents",
461
		"(id_type, titre, date, distant)",
462
		"($id_type, '".texte_script($titre)."', NOW(), '$distant')");
463
 
464
		if ($id_lien
465
		AND preg_match('/^[a-z0-9_]+$/i', $type_lien) # securite
466
		)
467
			spip_query("INSERT INTO spip_documents_".$type_lien."s
468
				(id_document, id_".$type_lien.")
469
				VALUES ($id_document, $id_lien)");
470
 
471
		// par defaut (upload ZIP ou ftp) integrer
472
		// les images en mode 'vignette' et le reste en mode document
473
		if (!$mode)
474
			if ($type_image AND $type_inclus_image)
475
				$mode = 'vignette';
476
			else
477
				$mode = 'document';
478
		$update = "mode='$mode', ";
479
	}
480
 
481
	// Mise a jour des donnees
482
	spip_query("UPDATE spip_documents
483
		SET $update
484
		taille='$taille', largeur='$largeur', hauteur='$hauteur',
485
		fichier='$fichier'
486
		WHERE id_document=$id_document");
487
 
488
	if ($id_document_lie) {
489
		spip_query ("UPDATE spip_documents
490
		SET id_vignette=$id_document
491
		WHERE id_document=$id_document_lie");
492
		// hack pour que le retour vers ecrire/ active le bon doc.
493
		$documents_actifs[] = $id_document_lie;
494
	}
495
	else
496
		$documents_actifs[] = $id_document;
497
 
498
/**
499
	DESACTIVE CAR UTILISATION PAR DEFAUT DES IMAGES REDUITES
500
 
501
	// Creer la vignette des images
502
	if (ereg(",$ext,", ','.lire_meta('formats_graphiques').',')
503
	AND $mode == 'document'
504
	AND $type_image)
505
		creer_fichier_vignette($fichier);
506
 
507
**/
508
 
509
	// Pour les fichiers distants remettre l'URL de base
510
	if ($distant == 'oui')
511
		spip_query("UPDATE spip_documents SET fichier='".addslashes($source)."'
512
		WHERE id_document = $id_document");
513
 
514
	// Demander l'indexation du document
515
	include_ecrire('inc_index.php3');
516
	marquer_indexer('document', $id_document);
517
 
518
	return true;
519
}
520
 
521
 
522
 
523
 
524
//
525
// Convertit le type numerique retourne par getimagesize() en extension fichier
526
//
527
 
528
function decoder_type_image($type, $strict = false) {
529
	switch ($type) {
530
	case 1:
531
		return "gif";
532
	case 2:
533
		return "jpg";
534
	case 3:
535
		return "png";
536
	case 4:
537
		return $strict ? "" : "swf";
538
	case 5:
539
		return "psd";
540
	case 6:
541
		return "bmp";
542
	case 7:
543
	case 8:
544
		return "tif";
545
	default:
546
		return "";
547
	}
548
}
549
 
550
 
551
//
552
// Corrige l'extension du fichier dans quelques cas particuliers
553
//
554
 
555
function corriger_extension($ext) {
556
	switch ($ext) {
557
	case 'htm':
558
		return 'html';
559
	case 'jpeg':
560
		return 'jpg';
561
	case 'tiff':
562
		return 'tif';
563
	default:
564
		return $ext;
565
	}
566
}
567
 
568
 
569
//
570
// Ajouter un logo
571
//
572
 
573
// $source = $_FILES[0]
574
// $dest = arton12.xxx
575
function ajout_logo($source, $dest) {
576
 
577
	// Intercepter une erreur d'upload
578
	if (check_upload_error($source['error'])) return;
579
 
580
	// analyse le type de l'image (on ne fait pas confiance au nom de
581
	// fichier envoye par le browser : pour les Macs c'est plus sur)
582
	$f =_DIR_DOC . $dest . '.tmp';
583
	deplacer_fichier_upload($source['tmp_name'], $f);
584
	$size = @getimagesize($f);
585
	$type = decoder_type_image($size[2], true);
586
 
587
	if ($type) {
588
		$poids = filesize($f);
589
		if (_LOGO_MAX_SIZE > 0
590
		AND $poids > _LOGO_MAX_SIZE*1024) {
591
			@unlink ($f);
592
			check_upload_error(6,
593
			_T('info_logo_max_poids',
594
				array('maxi' => taille_en_octets(_LOGO_MAX_SIZE*1024),
595
				'actuel' => taille_en_octets($poids))));
596
		}
597
 
598
		if (_LOGO_MAX_WIDTH * _LOGO_MAX_HEIGHT
599
		AND ($size[0] > _LOGO_MAX_WIDTH
600
		OR $size[1] > _LOGO_MAX_HEIGHT)) {
601
			@unlink ($f);
602
			check_upload_error(6,
603
			_T('info_logo_max_taille',
604
				array(
605
				'maxi' =>
606
					_T('info_largeur_vignette',
607
						array('largeur_vignette' => _LOGO_MAX_WIDTH,
608
						'hauteur_vignette' => _LOGO_MAX_HEIGHT)),
609
				'actuel' =>
610
					_T('info_largeur_vignette',
611
						array('largeur_vignette' => $size[0],
612
						'hauteur_vignette' => $size[1]))
613
			)));
614
		}
615
		@rename ($f, _DIR_DOC . $dest . ".$type");
616
	}
617
	else {
618
		@unlink ($f);
619
		check_upload_error(6,
620
			_T('info_logo_format_interdit',
621
			array ('formats' => 'GIF, JPG, PNG'))
622
		);
623
	}
624
}
625
 
626
 
627
function effacer_logo($nom) {
628
	if (!strstr($nom, ".."))
629
		@unlink(_DIR_IMG . $nom);
630
}
631
 
632
 
633
 
634
//
635
// Creation automatique de vignette
636
//
637
 
638
// Tester nos capacites
639
function tester_vignette ($test_vignette) {
640
	global $pnmscale_command;
641
 
642
	// verifier les formats acceptes par GD
643
	if ($test_vignette == "gd1") {
644
		// Si GD est installe et php >= 4.0.2
645
		if (function_exists('imagetypes')) {
646
 
647
			if (imagetypes() & IMG_GIF) {
648
				$gd_formats[] = "gif";
649
			} else {
650
				# Attention GD sait lire le gif mais pas forcement l'ecrire
651
				if (function_exists('ImageCreateFromGIF')) {
652
					$srcImage = @ImageCreateFromGIF(_DIR_IMG . "test.gif");
653
					if ($srcImage) {
654
						$gd_formats_read_gif = ",gif";
655
						ImageDestroy( $srcImage );
656
					}
657
				}
658
			}
659
 
660
			if (imagetypes() & IMG_JPG)
661
				$gd_formats[] = "jpg";
662
			if (imagetypes() & IMG_PNG)
663
				$gd_formats[] = "png";
664
		}
665
 
666
		else {	# ancienne methode de detection des formats, qui en plus
667
				# est bugguee car elle teste les formats en lecture
668
				# alors que la valeur deduite sert a identifier
669
				# les formats disponibles en ecriture... (cf. inc_logos.php3)
670
 
671
			$gd_formats = Array();
672
			if (function_exists('ImageCreateFromJPEG')) {
673
				$srcImage = @ImageCreateFromJPEG(_DIR_IMG . "test.jpg");
674
				if ($srcImage) {
675
					$gd_formats[] = "jpg";
676
					ImageDestroy( $srcImage );
677
				}
678
			}
679
			if (function_exists('ImageCreateFromGIF')) {
680
				$srcImage = @ImageCreateFromGIF(_DIR_IMG . "test.gif");
681
				if ($srcImage) {
682
					$gd_formats[] = "gif";
683
					ImageDestroy( $srcImage );
684
				}
685
			}
686
			if (function_exists('ImageCreateFromPNG')) {
687
				$srcImage = @ImageCreateFromPNG(_DIR_IMG . "test.png");
688
				if ($srcImage) {
689
					$gd_formats[] = "png";
690
					ImageDestroy( $srcImage );
691
				}
692
			}
693
		}
694
 
695
		if ($gd_formats) $gd_formats = join(",", $gd_formats);
696
		ecrire_meta("gd_formats_read", $gd_formats.$gd_formats_read_gif);
697
		ecrire_meta("gd_formats", $gd_formats);
698
		ecrire_metas();
699
	}
700
 
701
	// verifier les formats netpbm
702
	else if ($test_vignette == "netpbm"
703
	AND $pnmscale_command) {
704
		$netpbm_formats= Array();
705
 
706
		$jpegtopnm_command = str_replace("pnmscale",
707
			"jpegtopnm", $pnmscale_command);
708
		$pnmtojpeg_command = str_replace("pnmscale",
709
			"pnmtojpeg", $pnmscale_command);
710
 
711
		$vignette = _DIR_IMG . "test.jpg";
712
		$dest = _DIR_IMG . "test-jpg.jpg";
713
		$commande = "$jpegtopnm_command $vignette | $pnmscale_command -width 10 | $pnmtojpeg_command > $dest";
714
		spip_log($commande);
715
		exec($commande);
716
		if ($taille = @getimagesize($dest)) {
717
			if ($taille[1] == 10) $netpbm_formats[] = "jpg";
718
		}
719
		$giftopnm_command = ereg_replace("pnmscale", "giftopnm", $pnmscale_command);
720
		$pnmtojpeg_command = ereg_replace("pnmscale", "pnmtojpeg", $pnmscale_command);
721
		$vignette = _DIR_IMG . "test.gif";
722
		$dest = _DIR_IMG . "test-gif.jpg";
723
		$commande = "$giftopnm_command $vignette | $pnmscale_command -width 10 | $pnmtojpeg_command > $dest";
724
		spip_log($commande);
725
		exec($commande);
726
		if ($taille = @getimagesize($dest)) {
727
			if ($taille[1] == 10) $netpbm_formats[] = "gif";
728
		}
729
 
730
		$pngtopnm_command = ereg_replace("pnmscale", "pngtopnm", $pnmscale_command);
731
		$vignette = _DIR_IMG . "test.png";
732
		$dest = _DIR_IMG . "test-gif.jpg";
733
		$commande = "$pngtopnm_command $vignette | $pnmscale_command -width 10 | $pnmtojpeg_command > $dest";
734
		spip_log($commande);
735
		exec($commande);
736
		if ($taille = @getimagesize($dest)) {
737
			if ($taille[1] == 10) $netpbm_formats[] = "png";
738
		}
739
 
740
 
741
		if ($netpbm_formats)
742
			$netpbm_formats = join(",", $netpbm_formats);
743
		else
744
			$netpbm_formats = '';
745
		ecrire_meta("netpbm_formats", $netpbm_formats);
746
		ecrire_metas();
747
	}
748
 
749
	// et maintenant envoyer la vignette de tests
750
	if (ereg("^(gd1|gd2|imagick|convert|netpbm)$", $test_vignette)) {
751
		include_ecrire('inc_logos.php3');
752
		//$taille_preview = lire_meta("taille_preview");
753
		if ($taille_preview < 10) $taille_preview = 150;
754
		if ($preview = creer_vignette(_DIR_IMG . 'test_image.jpg', $taille_preview, $taille_preview, 'jpg', '', "test_$test_vignette", $test_vignette, true))
755
 
756
			return ($preview['fichier']);
757
	}
758
 
759
	return _DIR_IMG_PACK . 'puce-rouge-anim.gif';	# image echec
760
}
761
 
762
// Creation
763
function creer_fichier_vignette($vignette, $test_cache_only=false) {
764
	if ($vignette && lire_meta("creer_preview") == 'oui') {
765
		eregi('\.([a-z0-9]+)$', $vignette, $regs);
766
		$ext = $regs[1];
767
		$taille_preview = lire_meta("taille_preview");
768
		if ($taille_preview < 10) $taille_preview = 120;
769
		include_ecrire('inc_logos.php3');
770
 
771
		if ($preview = creer_vignette($vignette, $taille_preview, $taille_preview, $ext, 'vignettes', basename($vignette).'-s', 'AUTO', false, $test_cache_only))
772
		{
773
			inserer_vignette_base($vignette, $preview['fichier']);
774
			return $preview['fichier'];
775
		}
776
		include_ecrire('inc_documents.php3');
777
		return vignette_par_defaut($ext ? $ext : 'txt', false);
778
	}
779
}
780
 
781
// Insertion d'une vignette dans la base
782
function inserer_vignette_base($image, $vignette) {
783
 
784
	$taille = @filesize($vignette);
785
 
786
	$size = @getimagesize($vignette);
787
	$largeur = $size[0];
788
	$hauteur = $size[1];
789
	$type = $size[2];
790
 
791
	if ($type == "2") $format = 1;			# spip_types_documents
792
	else if ($type == "3") $format = 2;
793
	else if ($type == "1") $format = 3;
794
	else return;
795
 
796
	$vignette = str_replace('../', '', $vignette);
797
 
798
	spip_log("creation vignette($image) -> $vignette");
799
 
800
	if ($t = spip_query("SELECT id_document FROM spip_documents
801
	WHERE fichier='".addslashes($image)."'")) {
802
		if ($row = spip_fetch_array($t)) {
803
			$id_document = $row['id_document'];
804
			$id_vignette = spip_abstract_insert("spip_documents",
805
				"(mode)",
806
				"('vignette')");
807
			spip_query("UPDATE spip_documents
808
				SET id_vignette=$id_vignette WHERE id_document=$id_document");
809
			spip_query("UPDATE spip_documents SET
810
				id_type = '$format',
811
				largeur = '$largeur',
812
				hauteur = '$hauteur',
813
				taille = '$taille',
814
				fichier = '$vignette',
815
				date = NOW()
816
				WHERE id_document = $id_vignette");
817
			spip_log("(document=$id_document, vignette=$id_vignette)");
818
		}
819
	}
820
}
821
 
822
 
823
// Effacer un doc (et sa vignette)
824
function supprime_document_et_vignette($doc_supp) {
825
 
826
	$result = spip_query("SELECT id_vignette, fichier
827
		FROM spip_documents
828
		WHERE id_document=$doc_supp");
829
	if ($row = spip_fetch_array($result)) {
830
		$fichier = $row['fichier'];
831
		$id_vignette = $row['id_vignette'];
832
		spip_query("DELETE FROM spip_documents
833
			WHERE id_document=$doc_supp");
834
		spip_query("UPDATE spip_documents SET id_vignette=0
835
			WHERE id_vignette=$doc_supp");
836
		spip_query("DELETE FROM spip_documents_articles
837
			WHERE id_document=$doc_supp");
838
		spip_query("DELETE FROM spip_documents_rubriques
839
			WHERE id_document=$doc_supp");
840
		spip_query("DELETE FROM spip_documents_breves
841
			WHERE id_document=$doc_supp");
842
		@unlink($fichier);
843
 
844
		if ($id_vignette > 0) {
845
			$query = "SELECT id_vignette, fichier FROM spip_documents
846
				WHERE id_document=$id_vignette";
847
			$result = spip_query($query);
848
			if ($row = spip_fetch_array($result)) {
849
				$fichier = $row['fichier'];
850
				@unlink($fichier);
851
			}
852
			spip_query("DELETE FROM spip_documents
853
				WHERE id_document=$id_vignette");
854
			spip_query("DELETE FROM spip_documents_articles
855
				WHERE id_document=$id_vignette");
856
			spip_query("DELETE FROM spip_documents_rubriques
857
				WHERE id_document=$id_vignette");
858
			spip_query("DELETE FROM spip_documents_breves
859
				WHERE id_document=$id_vignette");
860
		}
861
	}
862
}
863
 
864
 
865
 
866
/////////////////////////////////////////////////////////////////////
867
//
868
// Faire tourner une image
869
//
870
function gdRotate ($imagePath,$rtt){
871
	if(preg_match("/\.(png|gif|jpe?g|bmp)$/i", $imagePath, $regs)) {
872
		switch($regs[1]) {
873
			case 'png':
874
				$src_img=ImageCreateFromPNG($imagePath);
875
				$save = 'imagepng';
876
				break;
877
			case 'gif':
878
				$src_img=ImageCreateFromGIF($imagePath);
879
				$save = 'imagegif';
880
				break;
881
			case 'jpeg':
882
			case 'jpg':
883
				$src_img=ImageCreateFromJPEG($imagePath);
884
				$save = 'Imagejpeg';
885
				break;
886
			case 'bmp':
887
				$src_img=ImageCreateFromWBMP($imagePath);
888
				$save = 'imagewbmp';
889
				break;
890
			default:
891
				return false;
892
		}
893
	}
894
 
895
	if (!$src_img) {
896
		spip_log("gdrotate: image non lue, $imagePath");
897
		return false;
898
	}
899
 
900
	$size=@getimagesize($imagePath);
901
	if (!($size[0] * $size[1])) return false;
902
 
903
	if (function_exists('imagerotate')) {
904
		$dst_img = imagerotate($src_img, -$rtt, 0);
905
	} else {
906
 
907
	// Creer l'image destination (hauteur x largeur) et la parcourir
908
	// pixel par pixel (un truc de fou)
909
	$process = lire_meta('image_process');
910
	if ($process == "gd2")
911
		$dst_img=ImageCreateTrueColor($size[1],$size[0]);
912
	else
913
		$dst_img=ImageCreate($size[1],$size[0]);
914
 
915
	if($rtt==90){
916
		$t=0;
917
		$b=$size[1]-1;
918
		while($t<=$b){
919
			$l=0;
920
			$r=$size[0]-1;
921
			while($l<=$r){
922
				imagecopy($dst_img,$src_img,$t,$r,$r,$b,1,1);
923
				imagecopy($dst_img,$src_img,$t,$l,$l,$b,1,1);
924
				imagecopy($dst_img,$src_img,$b,$r,$r,$t,1,1);
925
				imagecopy($dst_img,$src_img,$b,$l,$l,$t,1,1);
926
				$l++;
927
				$r--;
928
			}
929
			$t++;
930
			$b--;
931
		}
932
	}
933
	elseif($rtt==-90){
934
		$t=0;
935
		$b=$size[1]-1;
936
		while($t<=$b){
937
			$l=0;
938
			$r=$size[0]-1;
939
			while($l<=$r){
940
				imagecopy($dst_img,$src_img,$t,$l,$r,$t,1,1);
941
				imagecopy($dst_img,$src_img,$t,$r,$l,$t,1,1);
942
				imagecopy($dst_img,$src_img,$b,$l,$r,$b,1,1);
943
				imagecopy($dst_img,$src_img,$b,$r,$l,$b,1,1);
944
				$l++;
945
				$r--;
946
			}
947
			$t++;
948
			$b--;
949
		}
950
	}
951
	}
952
	ImageDestroy($src_img);
953
	ImageInterlace($dst_img,0);
954
 
955
	# obligatoire d'enregistrer dans le meme format, puisque c'est
956
	# dans le fichier de depart...
957
	$save($dst_img,$imagePath);
958
}
959
 
960
function tourner_document($var_rot, $doc_rotate, $convert_command) {
961
 
962
	$var_rot = intval($var_rot);
963
 
964
	$query = "SELECT id_vignette, fichier FROM spip_documents WHERE id_document=$doc_rotate";
965
	$result = spip_query($query);
966
	if ($row = spip_fetch_array($result)) {
967
		$id_vignette = $row['id_vignette'];
968
		$image = $row['fichier'];
969
 
970
		$process = lire_meta('image_process');
971
 
972
		 // imagick (php4-imagemagick)
973
		 if ($process == 'imagick') {
974
			$handle = imagick_readimage($image);
975
			imagick_rotate($handle, $var_rot);
976
			imagick_write($handle, $image);
977
			if (!@file_exists($image)) return;	// echec imagick
978
		}
979
		else if ($process == "gd2") { // theoriquement compatible gd1, mais trop forte degradation d'image
980
			if ($var_rot == 180) { // 180 = 90+90
981
				gdRotate ($image, 90);
982
				gdRotate ($image, 90);
983
			} else {
984
				gdRotate ($image, $var_rot);
985
			}
986
		}
987
		else if ($process = "convert") {
988
			$commande = "$convert_command -rotate $var_rot ./"
989
				. escapeshellcmd($image).' ./'.escapeshellcmd($image);
990
#			spip_log($commande);
991
			exec($commande);
992
		}
993
 
994
		$size_image = @getimagesize($image);
995
		$largeur = $size_image[0];
996
		$hauteur = $size_image[1];
997
 
998
/*
999
	A DESACTIVER PEUT-ETRE ? QUE SE PASSE--IL SI JE TOURNE UNE IMAGE AYANT UNE VGNETTE "MANUELLE" -> NE PAS CREER DE VIGNETTE TOURNEE -- EN VERITE IL NE FAUT PAS PERMETTRE DE TOURNER UNE IMAGE AYANT UNE VIGNETTE MANUELLE
1000
		if ($id_vignette > 0) {
1001
			creer_fichier_vignette($image);
1002
		}
1003
*/
1004
 
1005
		spip_query("UPDATE spip_documents SET largeur=$largeur, hauteur=$hauteur WHERE id_document=$doc_rotate");
1006
 
1007
	}
1008
}
1009
 
1010
?>