wtrmln/libs/url.php

   1 <?php
   2 /********************************************************************
   3
   4   Watermelon CMS
   5
   6 Copyright 2008 Radosław Pietruszewski
   7
   8 This program is free software; you can redistribute it and/or
   9 modify it under the terms of the GNU General Public License
  10 version 2 as published by the Free Software Foundation.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 ********************************************************************/
  22
  23 /*
  24  * Lib URL
  25  * wersja 1.8.5
  26  *
  27  * Parsowanie URL-i etc.
  28  *
  29  */
  30
  31 class URL
  32 {
  33    /*
  34     * public static string[] $segments
  35     *
  36     * segmenty URL-a (np. foo/bar == array('foo', 'bar'))
  37     *
  38     * $segments = array($segment[, $segment[, ... ]])
  39     *   $segment - pojedynczy segment
  40     */
  41    public static $segments = array();
  42
  43    /*
  44     * public static string $class
  45     *
  46     * nazwa kontrolera do wykonania
  47     */
  48
  49    static public $class = '';
  50
  51    /*
  52     * public static string $method
  53     *
  54     * nazwa funkcji składowej (metody) kontrolera do wykonania
  55     */
  56
  57    public static $method = '';
  58
  59    /*
  60     * public static string $message
  61     *
  62     * nazwa wiadomości do wykonania (gdy pusta: null)
  63     */
  64
  65    public static $message = null;
  66
  67    /*
  68     * private static bool $inited
  69     *
  70     * true,  jeśli biblioteka została już zainicjalizowana
  71     * false, jeśli nie
  72     */
  73
  74    private static $inited = false;
  75
  76    /*
  77     * public static bool $onesegment = false
  78     *
  79     * true,  jeśli w URL-u jest tylko jeden segment
  80     * false, jeśli w URL-u jest więcej niż jeden segment
  81     */
  82
  83    public static $onesegment = false;
  84
  85    /*
  86     * public void URL(string $default)
  87     *
  88     * Konstruktor. Inicjalizuje bibliotekę uzupełniając pole 'segments'
  89     * Zwraca false jeśli już była wcześniej zainicjalizowana
  90     * Wywala błąd krytyczny, jeśli nie podano argumentu $default
  91     * i nie była jeszcze zainicjalizowana.
  92     *
  93     * string $default - nazwa domyślnego kontrolera
  94     *
  95     */
  96
  97    public function URL($default = null)
  98    {
  99       // jeśli klasa została już zainicjalizowana, nie kontynuujemy działania
 100       // tej funkcji składowej
 101
 102       if(self::$inited === true)
 103       {
 104          return false;
 105       }
 106
 107       // żeby klasa mogła funkcjonować poprawnie, nie można pozwolić na
 108       // nie podanie domyślnego kontrolera. Tutaj musi być to zrobione "ręcznie"
 109       // dlatego, że funkcja jest (jako konstruktor) wykonywana wielokrotnie w
 110       // kodzie, już po inicjalizacji biblioteki.
 111
 112       if($default === null)
 113       {
 114          panic('Lib URL: 0');
 115       }
 116
 117       // pobieramy dane o URL-u
 118
 119       $URL  = (isset($_SERVER['PATH_INFO']) ? $_SERVER['PATH_INFO'] : @getenv('PATH_INFO'));
 120       $URL2 = array();
 121
 122       // parsujemy segmenty URL-a (ze względów bezpieczeństwa pozwalam
 123       // tylko na znaki 0-9A-Za-z+-._)
 124
 125       foreach(explode('/', $URL) as $segment)
 126       {
 127          $segment2 = '';
 128          foreach(str_split($segment) as $char)
 129          {
 130             $char = ord($char); // char -> int
 131
 132             // pozwalam tylko na znaki takie jak:
 133
 134             // cyfry
 135
 136             if($char >= 48 && $char <= 57)
 137             {
 138                $segment2 .= chr($char);
 139             }
 140
 141             // duże litery
 142
 143             if($char >= 65 && $char <= 90)
 144             {
 145                $segment2 .= chr($char);
 146             }
 147
 148             // małe litery
 149
 150             if($char >= 97 && $char <= 122)
 151             {
 152                $segment2 .= chr($char);
 153             }
 154
 155             // plus (+)
 156
 157             if($char == 43)
 158             {
 159                $segment2 .= chr($char);
 160             }
 161
 162             // minus (-)
 163
 164             if($char == 45)
 165             {
 166                $segment2 .= chr($char);
 167             }
 168
 169             // kropka (.)
 170
 171             if($char == 46)
 172             {
 173                $segment2 .= chr($char);
 174             }
 175
 176             // dwukropek (:)
 177
 178             if($char == 58)
 179             {
 180                $segment2 .= chr($char);
 181             }
 182
 183             // podkreślenie (_)
 184
 185             if($char == 95)
 186             {
 187                $segment2 .= chr($char);
 188             }
 189          }
 190
 191          // jeśli ktoś zrobił wielokrotne slashe, wywalamy pusty segment
 192          if(!empty($segment2))
 193          {
 194             $URL2[] = $segment2;
 195          }
 196       }
 197
 198       // sprawdzamy czy jest ustawiona wiadomość
 199
 200       if(isset($URL2[0]))
 201       {
 202          if(substr($URL2[0], 0, 4) == 'msg:')
 203          {
 204             $message = substr($URL2[0], 4);
 205             array_shift($URL2);
 206
 207             $seg   = strtolower($message);
 208             $seg   = str_split($seg);
 209             $seg_n = '';
 210
 211             // filtruję nazwę (zostawiam tylko litery i znaki podkreślenia
 212
 213             foreach($seg as $char)
 214             {
 215                $char = ord($char);
 216
 217                if($char >= 97 && $char <= 122)
 218                {
 219                   $seg_n .= chr($char);
 220                }
 221
 222                if($char == 95)
 223                {
 224                   $seg_n .= chr($char);
 225                }
 226             }
 227
 228             self::$message = $seg_n;
 229          }
 230       }
 231
 232       // czyszczenie nazwy kontrolera
 233       // (jeśli brak nazwy kontrolera, ustaw na domyślną)
 234
 235
 236       if(isset($URL2[0]))
 237       {
 238          // czyszczenie segmentu z potencjalnie niebezpiecznego syfu
 239          // (nawet nie chodzi o bezpieczeństwo, ale wiadomo, że
 240          // kontroler o nazwie Foo.bar nie ma prawa istnieć
 241          // ze względu na ograniczenia nazewnictwa w PHP)
 242
 243          $seg   = strtolower($URL2[0]);
 244          $seg   = str_split($seg);
 245          $seg_n = '';
 246
 247          // parsujemy nazwę kontrolera (ze względów bezpieczeństwa pozwalam
 248          // tylko na znaki 0-9A-Za-z_)
 249
 250          foreach($seg as $char)
 251          {
 252             $char = ord($char); //char -> int
 253
 254             // pozwalam tylko na znaki takie jak:
 255
 256             // litery
 257
 258             if($char >= 97 && $char <= 122)
 259             {
 260                $seg_n .= chr($char);
 261             }
 262
 263             // cyfry
 264
 265             if($char >= 48 && $char <= 57)
 266             {
 267                $seg_n .= chr($char);
 268             }
 269
 270             // podkreślenie (_)
 271
 272             if($char == 95)
 273             {
 274                $seg_n .= chr($char);
 275             }
 276
 277             // myślnik (-)
 278
 279             if($char == 45)
 280             {
 281                $seg_n .= chr($char);
 282             }
 283          }
 284
 285          $t[0] = $seg_n;
 286       }
 287       else
 288       {
 289          // jeśli nie podano nazwy kontrolera, ustaw na domyślną
 290
 291          $t[0] = $default;
 292       }
 293
 294       // czyszczenie nazwy funkcji składowej/metody kontrolera
 295       // (jeśli brak, ustaw na index)
 296
 297       if(isset($URL2[1]))
 298       {
 299          $seg   = strtolower($URL2[1]);
 300          $seg   = str_split($seg);
 301          $seg_n = '';
 302
 303          // parsujemy nazwę kontrolera (ze względów bezpieczeństwa pozwalam
 304          // tylko na znaki 0-9A-Za-z_)
 305
 306          foreach($seg as $char)
 307          {
 308             $char = ord($char); //char -> int
 309
 310             // pozwalam tylko na znaki takie jak:
 311
 312             // litery
 313
 314             if($char >= 97 && $char <= 122)
 315             {
 316                $seg_n .= chr($char);
 317             }
 318
 319             // cyfry
 320
 321             if($char >= 48 && $char <= 57)
 322             {
 323                $seg_n .= chr($char);
 324             }
 325
 326             // podkreślenie (_)
 327
 328             if($char == 95)
 329             {
 330                $seg_n .= chr($char);
 331             }
 332          }
 333
 334          // niestety nie da się stworzyć metody o nazwie new :/
 335
 336          if($seg_n == 'new')
 337          {
 338             $seg_n = '_new';
 339          }
 340
 341          $t[1] = $seg_n;
 342       }
 343       else
 344       {
 345          // jeśli nie podano nazwy funkcji składowej/metody kontrolera
 346          // ustaw na index (domyślna funkcja składowa)
 347
 348          $t[1] = 'index';
 349
 350          self::$onesegment = true;
 351       }
 352
 353       // usuń dwa pierwsze segmenty (kontroler i jego funkcja składowa)
 354       // jeśli są tylko dwa segmenty lub mniej, oczyść tablicę
 355       // (wychodzi na to samo, ale PHP nie wywala błędu)
 356
 357       if(count($URL2) > 2)
 358       {
 359          $URL2 = array_splice($URL2, -(count($URL2) - 2));
 360       }
 361       else
 362       {
 363          $URL2 = array();
 364       }
 365
 366       // złączenie tablic - tej z oczyszczonymi lub domyślnymi nazwami kontrolera
 367       // i funkcji składowej/metody kontrolera z tą tablicą, która ma pozostałe
 368       // segmenty (lub nie ma, jeśli nie podano)
 369
 370       $URL2 = array_merge($t, $URL2);
 371
 372       // nadanie odpowiednich wartości
 373
 374       self::$segments = $URL2;
 375       self::$class    = self::$segments[0];
 376       self::$method   = self::$segments[1];
 377       self::$inited   = true;
 378    }
 379
 380    /*
 381     * public string segment(int $ID)
 382     *
 383     * Zwraca treść danego [$ID] segmentu.
 384     * Segmenty są liczone od jeden
 385     * (a nie od zera, jak to jest w PHP-owskich tablicach)
 386     *
 387     * Zwraca false w przypadku niepowodzenia
 388     * (tj. jeśli żądany segment nie istnieje)
 389     *
 390     */
 391
 392    public function segment($ID)
 393    {
 394       if(isset(self::$segments[$ID - 1]))
 395       {
 396          return self::$segments[$ID - 1];
 397       }
 398       else
 399       {
 400          return false;
 401       }
 402    }
 403
 404    /*
 405     * public int segments()
 406     *
 407     * Zwraca ilość segmentów
 408     *
 409     */
 410
 411    public function segments()
 412    {
 413       return count(self::$segments);
 414    }
 415 }
 416 ?>