Gutmans_Frontmatter Page i Thursday, September 23, 2004 9:05 AM

1. Power Programming With Rpc Pdf Free Download

Tabtight professional, free when you need it, VPN service.

PHP 5 Power Programming
perens_series_7x9.25.fm Gutmans_Frontmatter Page Page ii Thursday, 1 Wednesday, September September 23, 2004 15, 2004 9:05 10:54 AM AM
BRUCE PERENS’ OPEN SOURCE SERIES http://www.phptr.com/perens
◆ Java Application Development on Linux
Carl Albing and Michael Schwarz
◆ C++ GUI Programming with Qt 3
Jasmin Blanchette, Mark Summerfield
◆ Managing Linux Systems with Webmin: System Administration and
Module Development Jamie Cameron
◆ Understanding the Linux Virtual Memory Manager
Mel Gorman
◆ Implementing CIFS: The Common Internet File System
Christopher Hertel
◆ Embedded Software Development with eCos
Anthony Massa
◆ Rapid Application Development with Mozilla
Nigel McFarlane
◆ The Linux Development Platform: Configuring, Using, and Maintaining a
Complete Programming Environment Rafeeq Ur Rehman, Christopher Paul
◆ Intrusion Detection with SNORT: Advanced IDS Techniques Using SNORT,
Apache, MySQL, PHP, and ACID Rafeeq Ur Rehman
◆ The Official Samba-3 HOWTO and Reference Guide
John H. Terpstra, Jelmer R. Vernooij, Editors
◆ Samba-3 by Example: Practical Exercises to Successful Deployment
John H. Terpstra
Gutmans_Frontmatter Page iii Thursday, September 23, 2004 9:05 AM
PHP 5 Power Programming
Andi Gutmans, Stig Sæther Bakken, and Derick Rethans
PRENTICE HALL Professional Technical Reference Indianapolis, IN 46240 www.phptr.com
Gutmans_Frontmatter Page iv Thursday, September 23, 2004 2:14 PM
The authors and publisher have taken care in the preparation of this book, but make no expressed or implied warranty of any kind and assume no responsibility for errors or omissions. No liability is assumed for incidental or consequential damages in connection with or arising out of the use of the information or programs contained herein. Publisher: John Wait Editor in Chief: Don O’Hagan Acquisitions Editor: Mark L. Taub Editorial Assistant: Noreen Regina Development Editor:Janet Valade Marketing Manager: Robin O'Brien Cover Designer: Nina Scuderi Managing Editor: Gina Kanouse Senior Project Editor: Kristy Hart Copy Editor: Specialized Composition Indexer: Lisa Stumpf Senior Compositor: Gloria Schurick Manufacturing Buyer: Dan Uhrig The publisher offers excellent discounts on this book when ordered in quantity for bulk purchases or special sales, which may include electronic versions and/or custom covers and content particular to your business, training goals, marketing focus, and branding interests. For more information, please contact: U. S. Corporate and Government Sales (800) 382-3419 [email protected] For sales outside the U. S., please contact: International Sales [email protected] Visit us on the Web: www.phptr.com Library of Congress Cataloging-in-Publication Data: 2004107331 Copyright © 2005 Pearson Education, Inc. This material may be distrubuted only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/). Pearson Education, Inc. One Lake Street Upper Saddle River, NJ 07458 Every effort was made to contact and credit all copyright holders. Use of material without proper credit is unintentional. ISBN 0-131-47149-X Text printed in the United States on recycled paper at Phoenix in Hagerstown, Maryland. First printing, [October 2004]
Gutmans_Frontmatter Page v Thursday, September 23, 2004 9:05 AM
To Ifat, my wife and best friend, who has patiently put up with my involement in PHP from the very beginning, and has encouraged and supported me every step of the way. Andi Gutmans To Marianne, for patience and encouragement. Stig Sæther Bakken To my parents, who care for me even when I’m not around; and to 42, the answer to life, the universe of everything. Derick Rethans
Gutmans_Frontmatter Page vi Thursday, September 23, 2004 9:05 AM
Gutmans_Frontmatter Page vii Thursday, September 23, 2004 9:05 AM
vii
Contents Foreword by Zeev Suraski Preface: Introduction and Background Chapter 1: Chapter 2: Chapter 3: Chapter 4: Chapter 5: Chapter 6: Chapter 7: Chapter 8: Chapter 9: Chapter 10: Chapter 11: Chapter 12: Chapter 13: Chapter 14: Chapter 15: Chapter 16: A. B. C. Index
What Is New in PHP 5? PHP 5 Basic Language PHP 5 OO Language PHP 5 Advanced OOP and Design Patterns How to Write a Web Application with PHP Databases with PHP 5 Error Handling XML with PHP 5 Mainstream Extensions Using PEAR Important PEAR Packages Building PEAR Components Making the Move Performance An Introduction to Writing PHP Extensions PHP Shell Scripting PEAR and PECL Package Index phpDocumentor Format Reference Zend Studio Quick Start
Gutmans_Frontmatter Page viii Thursday, September 23, 2004 9:05 AM
Gutmans_TOC Page ix Thursday, September 23, 2004 9:06 AM
Contents Foreword....................................................... xxi Preface ........................................................xxii 1 What Is New in PHP 5? ............................................1 1.1 Introduction .................................................... 1 1.2 Language Features ............................................... 1 1.2.1 New Object-Oriented Model.................................... 1 1.2.2 New Object-Oriented Features.................................. 3 1.2.3 Other New Language Features ................................. 7 1.3 General PHP Changes............................................ 8 1.3.1 XML and Web Services ........................................ 8 1.4 Other New Features in PHP 5 ..................................... 11 1.4.1 New Memory Manager....................................... 11 1.4.2 Dropped Support for Windows 95............................... 11 1.5 Summary...................................................... 11 2 PHP 5 Basic Language ............................................13 2.1 Introduction ................................................... 13 2.2 HTML Embedding .............................................. 14 2.3 Comments ..................................................... 14 2.4 Variables...................................................... 15 2.4.1 Indirect References to Variables ............................... 16 2.4.2 Managing Variables ......................................... 16 2.4.3 Superglobals ............................................... 18 2.5 Basic Data Types ............................................... 18 2.5.1 Integers ................................................... 19 2.5.2 Floating-Point Numbers ...................................... 19 2.5.3 Strings.................................................... 19 2.5.4 Booleans ................................................... 22 2.5.5 Null ...................................................... 23 ix
Gutmans_TOC Page x Thursday, September 23, 2004 9:06 AM
x
Contents
2.5.6 Resources ..................................................23 2.5.7 Arrays.....................................................23 2.5.8 Constants ..................................................30 2.6 Operators......................................................31 2.6.1 Binary Operators ............................................32 2.6.2 Assignment Operators........................................32 2.6.3 Comparison Operators .......................................33 2.6.4 Logical Operators ...........................................34 2.6.5 Bitwise Operators ...........................................35 2.6.6 Unary Operators............................................36 2.6.7 Negation Operators ..........................................36 2.6.8 Increment/Decrement Operators ...............................37 2.6.9 The Cast Operators ..........................................38 2.6.10 The Silence Operator........................................39 2.6.11 The One and Only Ternary Operator ...........................39 2.7 Control Structures ..............................................39 2.7.1 Conditional Control Structures.................................39 2.7.2 Loop Control Structures ......................................42 2.7.3 Code Inclusion Control Structures ..............................45 2.8 Functions ......................................................48 2.8.1 User-Defined Functions ......................................49 2.8.2 Function Scope..............................................49 2.8.3 Returning Values By Value ...................................50 2.8.4 Returning Values By Reference................................51 2.8.5 Declaring Function Parameters................................52 2.8.6 Static Variables .............................................53 2.9 Summary ......................................................54 3 PHP 5 OO Language ............................................. 55 3.1 Introduction....................................................55 3.2 Objects ........................................................55 3.3 Declaring a Class ...............................................57 3.4 The new Keyword and Constructors ................................57 3.5 Destructors ....................................................58 3.6 Accessing Methods and Properties Using the $this Variable............59 3.6.1 public, protected, and private Properties ....................60 3.6.2 public, protected, and private Methods .....................61 3.6.3 Static Properties ............................................62 3.6.4 Static Methods ..............................................64 3.7 Class Constants.................................................65 3.8 Cloning Objects .................................................66 3.9 Polymorphism..................................................67 3.10 parent:: and self::............................................70 3.11 instanceof Operator..........................................71
Gutmans_TOC Page xi Thursday, September 23, 2004 9:06 AM
Contents
xi
3.12 Abstract Methods and Classes .................................... 72 3.13 Interfaces .................................................... 73 3.14 Inheritance of Interfaces ........................................ 75 3.15 final Methods ................................................ 75 3.16 final Classes ................................................. 76 3.17 __toString() Method......................................... 76 3.18 Exception Handling ............................................ 77 3.19 __autoload() ................................................ 80 3.20 Class Type Hints in Function Parameters .......................... 82 3.21 Summary..................................................... 83 4 PHP 5 Advanced OOP and Design Patterns .........................85 4.1 Introduction ................................................... 85 4.2 Overloading Capabilities......................................... 85 4.2.1 Property and Method Overloading .............................. 85 4.2.2 Overloading the Array Access Syntax........................... 88 4.3 Iterators ...................................................... 89 4.4 Design Patterns ................................................ 94 4.4.1 Strategy Pattern............................................ 95 4.4.2 Singleton Pattern ........................................... 97 4.4.3 Factory Pattern ............................................. 98 4.4.4 Observer Pattern ........................................... 101 4.5 Reflection..................................................... 103 4.5.1 Introduction ............................................... 103 4.5.2 Reflection API............................................. 103 4.5.3 Reflection Examples........................................ 106 4.5.4 Implementing the Delegation Pattern Using Reflection............ 107 4.6 Summary..................................................... 109 5 How to Write a Web Application with PHP.........................111 5.1 Introduction .................................................. 111 5.2 Embedding into HTML ......................................... 112 5.3 User Input .................................................... 114 5.4 Safe-Handling User Input....................................... 117 5.4.1 Common Mistakes .......................................... 117 5.5 Techniques to Make Scripts “Safe” ................................ 120 5.5.1 Input Validation ........................................... 120 5.5.2 HMAC Verification......................................... 122 5.5.3 PEAR::Crypt_HMAC........................................ 124 5.5.4 Input Filter ............................................... 127 5.5.5 Working with Passwords .................................... 127 5.5.6 Error Handling ............................................ 129 5.6 Cookies ...................................................... 131 5.7 Sessions ...................................................... 134
Gutmans_TOC Page xii Thursday, September 23, 2004 9:06 AM
xii
Contents
5.8 File Uploads ..................................................137 5.8.1 Handling the Incoming Uploaded File ..........................138 5.9 Architecture...................................................143 5.9.1 One Script Serves All .......................................143 5.9.2 One Script per Function .....................................144 5.9.3 Separating Logic from Layout ................................144 5.10 Summary ....................................................146 6 Databases with PHP 5 ........................................... 149 6.1 Introduction...................................................149 6.2 MySQL.......................................................149 6.2.1 MySQL Strengths and Weaknesses ............................150 6.2.2 PHP Interface .............................................150 6.2.3 Example Data .............................................151 6.2.4 Connections...............................................151 6.2.5 Buffered Versus Unbuffered Queries ...........................153 6.2.6 Queries ...................................................154 6.2.7 Multi Statements...........................................155 6.2.8 Fetching Modes............................................156 6.2.9 Prepared Statements........................................156 6.2.10 BLOB Handling ...........................................158 6.3 SQLite.......................................................160 6.3.1 SQLite Strengths and Weaknesses ............................160 6.3.2 Best Areas of Use...........................................161 6.3.3 PHP Interface .............................................162 6.4 PEAR DB .....................................................176 6.4.1 Obtaining PEAR DB........................................176 6.4.2 Pros and Cons of Database Abstraction .........................177 6.4.3 Which Features Are Abstracted? ..............................177 6.4.4 Database Connections .......................................178 6.4.5 Executing Queries ..........................................180 6.4.6 Fetching Results ...........................................182 6.4.7 Sequences .................................................184 6.4.8 Portability Features ........................................185 6.4.9 Abstracted Errors ..........................................186 6.4.10 Convenience Methods......................................188 6.5 Summary .....................................................190 7 Error Handling................................................. 191 7.1 Introduction...................................................191 7.2 Types of Errors ................................................192 7.2.1 Programming Errors ........................................192 7.2.2 Undefined Symbols.........................................194 7.2.3 Portability Errors ..........................................197
Gutmans_TOC Page xiii Thursday, September 23, 2004 9:06 AM
Contents
xiii
7.2.4 Runtime Errors............................................ 201 7.2.5 PHP Errors ............................................... 201 7.3 PEAR Errors .................................................. 206 7.3.1 The PEAR_Error Class ...................................... 209 7.3.2 Handling PEAR Errors ...................................... 212 7.3.3 PEAR Error Modes......................................... 213 7.3.4 Graceful Handling .......................................... 213 7.4 Exceptions .................................................... 216 7.4.1 What Are Exceptions? ....................................... 216 7.4.2 try, catch, and throw ........................................ 216 7.5 Summary..................................................... 218 8 XML with PHP 5 ................................................219 8.1 Introduction .................................................. 219 8.2 Vocabulary.................................................... 220 8.3 Parsing XML .................................................. 222 8.3.1 SAX ..................................................... 222 8.3.2 DOM ..................................................... 226 8.4 SimpleXML ................................................... 231 8.4.1 Creating a SimpleXML Object................................ 232 8.4.2 Browsing SimpleXML Objects ................................ 233 8.4.3 Storing SimpleXML Objects .................................. 234 8.5 PEAR ........................................................ 234 8.5.1 XML_Tree ................................................ 235 8.5.2 XML_RSS................................................. 236 8.6 Converting XML ............................................... 239 8.6.1 XSLT .................................................... 239 8.7 Communicating with XML....................................... 244 8.7.1 XML-RPC................................................. 244 8.7.2 SOAP.................................................... 252 8.8 Summary..................................................... 259 9 Mainstream Extensions ..........................................261 9.1 Introduction .................................................. 261 9.2 Files and Streams .............................................. 261 9.2.1 File Access ................................................ 262 9.2.2 Program Input/Output ...................................... 264 9.2.3 Input/Output Streams....................................... 267 9.2.4 Compression Streams ....................................... 268 9.2.5 User Streams .............................................. 270 9.2.6 URL Streams .............................................. 271 9.2.7 Locking .................................................. 276 9.2.8 Renaming and Removing Files................................ 277 9.2.9 Temporary Files ........................................... 278
Gutmans_TOC Page xiv Thursday, September 23, 2004 9:06 AM
xiv
Contents
9.3 Regular Expressions ............................................279 9.3.1 Syntax ...................................................279 9.3.2 Functions.................................................293 9.4 Date Handling .................................................301 9.4.1 Retrieving Date and Time Information .........................301 9.4.2 Formatting Date and Time ...................................305 9.4.3 Parsing Date Formats .......................................313 9.5 Graphics Manipulation with GD..................................314 9.5.1 Case 1: Bot-Proof Submission Forms ...........................315 9.5.2 Case 2: Bar Chart ..........................................320 9.5.3 Exif.....................................................326 9.6 Multi-Byte Strings and Character Sets .............................329 9.6.1 Character Set Conversions...................................330 9.6.2 Extra Functions Dealing with Multi-Byte Character Sets ..........335 9.6.3 Locales...................................................340 9.7 Summary .....................................................343 10 Using PEAR.................................................... 345 10.1 Introduction..................................................345 10.2 PEAR Concepts ...............................................346 10.2.1 Packages.................................................346 10.2.2 Releases.................................................346 10.2.3 Version Numbers ..........................................347 10.3 Obtaining PEAR..............................................349 10.3.1 Installing with UNIX / Linux PHP Distribution .................350 10.3.2 Installing with PHP Windows Installer ........................351 10.3.3 go-pear.org ...............................................351 10.4 Installing Packages ............................................354 10.4.1 Using the pear Command ..................................354 10.5 Configuration Parameters ......................................358 10.6 PEAR Commands.............................................364 10.6.1 pear install ...........................................364 10.6.2 pear list ...............................................368 10.6.3 pear info ...............................................369 10.6.4 pear list-all ..........................................370 10.6.5 pear list-upgrades .....................................370 10.6.6 pear upgrade ...........................................371 10.6.7 pear upgrade-all.......................................372 10.6.8 pear uninstall .........................................373 10.6.9 pear search ............................................373 10.6.10 pear remote-list......................................374 10.6.11 pear remote-info......................................375 10.6.12 pear download .........................................375 10.6.13 pear config-get .......................................376
Gutmans_TOC Page xv Thursday, September 23, 2004 9:06 AM
Contents
xv
10.6.14 pear config-set ....................................... 376 10.6.15 pear config-show ...................................... 376 10.6.16 Shortcuts............................................... 377 10.7 Installer Front-Ends........................................... 378 10.7.1 CLI (Command Line Interface) Installer ....................... 378 10.7.2 Gtk Installer ............................................. 378 10.8 Summary.................................................... 381 11 Important PEAR Packages .......................................383 11.1 Introduction ................................................. 383 11.2 Database Queries............................................. 383 11.3 Template Systems............................................. 383 11.3.1 Template Terminology ..................................... 384 11.3.2 HTML_Template_IT ....................................... 384 11.3.3 HTML_Template_Flexy .................................... 387 11.4 Authentication ............................................... 392 11.4.1 Overview ................................................ 392 11.4.2 Example: Auth with Password File........................... 393 11.4.3 Example: Auth with DB and User Data ....................... 394 11.4.4 Auth Security Considerations................................ 396 11.4.5 Auth Scalability Considerations.............................. 397 11.4.6 Auth Summary ........................................... 398 11.5 Form Handling............................................... 398 11.5.1 HTML_QuickForm......................................... 398 11.5.2 Example: Login Form...................................... 399 11.5.3 Receiving Data............................................ 399 11.6 Caching..................................................... 399 11.6.1 Cache_Lite ............................................. 399 11.7 Summary.................................................... 401 12 Building PEAR Components .....................................403 12.1 Introduction ................................................. 403 12.2 PEAR Standards.............................................. 403 12.2.1 Symbol Naming ........................................... 403 12.2.2 Indentation .............................................. 406 12.3 Release Versioning............................................ 408 12.4 CLI Environment............................................. 408 12.5 Fundamentals ................................................ 410 12.5.1 When and How to Include Files.............................. 410 12.5.2 Error Handling ........................................... 411 12.6 Building Packages ............................................ 411 12.6.1 PEAR Example: HelloWorld ................................. 411 12.6.2 Building the Tarball....................................... 414 12.6.3 Verification .............................................. 414 12.6.4 Regression Tests.......................................... 416
Gutmans_TOC Page xvi Thursday, September 23, 2004 9:06 AM
xvi
Contents
12.7 The package.xml Format .......................................416 12.7.1 Package Information .......................................417 12.7.2 Release Information .......................................419 12.8 Dependencies.................................................423 12.8.1 Element: ..........................................423 12.8.2 Element: ...........................................423 12.8.3 Dependency Types .........................................424 12.8.4 Reasons to Avoid Dependencies..............................425 12.8.5 Optional Dependencies.....................................426 12.8.6 Some Examples...........................................426 12.9 String Substitutions...........................................427 12.9.1 Element: .......................................427 12.9.2 Examples................................................427 12.10 Including C Code.............................................428 12.10.1 Element: ............................428 12.10.2 Element: .............................428 12.11 Releasing Packages ...........................................428 12.12 The PEAR Release Process.....................................429 12.13 Packaging ..................................................430 12.13.1 Source Analysis..........................................430 12.13.2 MD5 Checksum Generation ................................430 12.13.3 Package.xml Update......................................431 12.13.4 Tarball Creation .........................................431 12.14 Uploading ..................................................432 12.14.1 Upload Release ..........................................432 12.14.2 Finished!................................................432 12.15 Summary ...................................................432 13 Making the Move ............................................... 433 13.1 Introduction..................................................433 13.2 The Object Model .............................................433 13.3 Passing Objects to Functions....................................433 13.4 Compatibility Mode............................................435 13.4.1 Casting Objects ...........................................435 13.4.2 Comparing Objects ........................................436 13.5 Other Changes ...............................................437 13.5.1 Assigning to $this ........................................437 13.5.2 get_class ...............................................440 13.6 E_STRICT ...................................................441 13.6.1 Automagically Creating Objects ..............................441 13.6.2 var and public ..........................................441 13.6.3 Constructors..............................................442 13.6.4 Inherited Methods .........................................442 13.6.5 Define Classes Before Usage.................................443
Gutmans_TOC Page xvii Thursday, September 23, 2004 9:06 AM
Contents
xvii
13.7 Other Compatibility Problems ................................... 443 13.7.1 Command-Line Interface ................................... 443 13.7.2 Comment Tokens.......................................... 443 13.7.3 MySQL .................................................. 445 13.8 Changes in Functions .......................................... 445 13.8.1 array_merge() .......................................... 445 13.8.2 strrpos() and strripos()................................ 446 13.9 Summary.................................................... 447 14 Performance ....................................................449 14.1 Introduction ................................................. 449 14.2 Design for Performance ........................................ 449 14.2.1 PHP Design Tip #1: Beware of State .......................... 450 14.2.2 PHP Design Tip #2: Cache!.................................. 451 14.2.3 PHP Design Tip #3: Do Not Over Design!...................... 456 14.3 Benchmarking................................................ 457 14.3.1 Using ApacheBench ....................................... 457 14.3.2 Using Siege .............................................. 458 14.3.3 Testing Versus Real Traffic ................................. 459 14.4 Profiling with Zend Studio's Profiler .............................. 459 14.5 Profiling with APD............................................ 461 14.5.1 Installing APD............................................ 461 14.5.2 Analyzing Trace Data ...................................... 462 14.6 Profiling with Xdebug.......................................... 465 14.6.1 Installing Xdebug ......................................... 466 14.6.2 Tracing Script Execution ................................... 466 14.6.3 Using KCachegrind ........................................ 468 14.7 Using APC (Advanced PHP Cache) ............................... 470 14.8 Using ZPS (Zend Performance Suite) ............................. 470 14.8.1 Automatic Optimization.................................... 471 14.8.2 Compiled Code Caching .................................... 472 14.8.3 Dynamic Content Caching .................................. 473 14.8.4 Content Compression ...................................... 476 14.9 Optimizing Code .............................................. 477 14.9.1 Micro-Benchmarks ........................................ 477 14.9.2 Rewrite in C.............................................. 479 14.9.3 OO Versus Procedural Code ................................. 480 14.10 Summary................................................... 481 15 An Introduction to Writing PHP Extensions.......................483 15.1 Introduction ................................................. 483 15.2 Quickstart ................................................... 484 15.2.1 Memory Management ...................................... 489 15.2.2 Returning Values from PHP Functions ........................ 490 15.2.3 Completing self-concat()................................ 490 15.2.4 Summary of Example...................................... 492 15.2.5 Wrapping Third-Party Extensions ............................ 492
Gutmans_TOC Page xviii Thursday, September 23, 2004 9:06 AM
xviii
Contents
15.2.6 Global Variables ..........................................501 15.2.7 Adding Custom INI Directives...............................503 15.2.8 Thread-Safe Resource Manager Macros........................504 15.3 Summary ....................................................505 16 PHP Shell Scripting ............................................. 507 16.1 Introduction..................................................507 16.2 PHP CLI Shell Scripts .........................................508 16.2.1 How CLI Differs From CGI ..................................508 16.2.2 The Shell-Scripting Environment.............................510 16.2.3 Parsing Command-Line Options .............................512 16.2.4 Good Practices............................................515 16.2.5 Process Control ...........................................516 16.2.6 Examples................................................520 16.3 Summary ....................................................526 A PEAR and PECL Package Index .................................. 527 A.1 Authentication ................................................527 A.2 Benchmarking ................................................530 A.3 Caching ......................................................530 A.4 Configuration .................................................531 A.5 Console ......................................................531 A.6 Database .....................................................533 A.7 Date and Time ................................................542 A.8 Encryption ...................................................543 A.9 File Formats..................................................545 A.10 File System ..................................................548 A.11 Gtk Components ..............................................550 A.12 HTML......................................................550 A.13 HTTP.......................................................561 A.14 Images ......................................................563 A.15 Internationalization ...........................................566 A.16 Logging.....................................................568 A.17 Mail ........................................................569 A.18 Math .......................................................571 A.19 Networking ..................................................574 A.20 Numbers....................................................584 A.21 Payment ....................................................585 A.22 PEAR......................................................587 A.23 PHP ........................................................588 A.24 Processing ...................................................594 A.25 Science......................................................594 A.26 Streams .....................................................595 A.27 Structures ...................................................596 A.28 System......................................................598 A.29 Text........................................................599
Gutmans_TOC Page xix Thursday, September 23, 2004 9:06 AM
Contents
xix
A.30 Tools and Utilities ............................................ 600 A.31 Web Services................................................. 603 A.32 XML ....................................................... 604 B phpDocumentor Format Reference ...............................613 B.1 Introduction .................................................. 613 B.2 Documentation Comments ...................................... 613 B.3 Tag Reference ................................................. 615 B.3.1 abstract ................................................ 615 B.3.2 access .................................................. 616 B.3.3 author .................................................. 617 B.3.4 category ................................................ 618 B.3.5 copyright............................................... 618 B.3.6 deprecated.............................................. 618 B.3.7 example ................................................. 619 B.3.8 filesource.............................................. 620 B.3.9 final ................................................... 620 B.3.10 global ................................................ 621 B.3.11 ignore ................................................ 622 B.3.12 inheritdoc (inline) ..................................... 622 B.3.13 internal, internal (inline) ............................ 622 B.3.14 licence ............................................... 623 B.3.15 link .................................................. 623 B.3.16 link (inline) ........................................... 623 B.3.17 name .................................................. 624 B.3.18 package ............................................... 624 B.3.19 param ................................................. 626 B.3.20 return ................................................ 627 B.3.21 see.................................................... 627 B.3.22 since ................................................. 628 B.3.23 static ................................................. 628 B.3.24 staticvar.............................................. 629 B.3.25 subpackage............................................. 629 B.3.26 todo................................................... 630 B.3.27 uses .................................................. 630 B.3.28 var.................................................... 631 B.3.29 version ................................................ 631 B.4 Tag Table..................................................... 632 B.5 Using the phpDocumentor Tool ................................... 633 C Zend Studio Quick Start Guide ..................................643 C.1 Version 3.5.x .................................................. 643 C.2 About the Zend Studio Client Quick Start Guide..................... 643 C.3 About Zend ................................................... 643 C.4 Zend Studio Client: Overview.................................... 644
Gutmans_TOC Page xx Thursday, September 23, 2004 9:06 AM
xx
Contents
C.4.1 Studio Components .........................................644 C.4.2 Client Server Configuration ..................................645 C.4.3 Installation and Registration .................................645 C.5 Editing a File .................................................647 C.5.1 Editing a File..............................................647 C.6 Working with Projects ..........................................648 C.6.1 Advantages of Working with Projects..........................648 C.6.2 How to Create a Project .....................................648 C.7 Running the Debugger .........................................648 C.7.1 Internal Debugger..........................................649 C.7.2 Remote Debugger ..........................................649 C.7.3 Debug URL ...............................................650 C.8 Configure Studio Server for Remote Debugger and Profiling ...........650 C.9 Running the Profiler............................................651 C.10 Product Support..............................................652 C.10.1 Getting Support...........................................653 C.11 Main Features................................................653 Index.......................................................... 655
Gutmans_PrefaceFore Page xxi Thursday, September 23, 2004 9:06 AM
Foreword
Within the last few years, PHP has grown to be the most widespread web platform in the world, operational in more than a third of the web servers across the globe. PHP's growth is not only quantitative but also qualitative. More and more companies, including Fortune companies, rely on PHP to run their business-critical applications, which creates new jobs and increases the demand for PHP developers. Version 5, due to be released in the very near future, holds an even greater promise. While the complexity of starting off with PHP remains unchanged and very low, the features offered by PHP today enable developers to reach far beyond simple HTML applications. The revised object model allows for largescale projects to be written efficiently, using standard object-oriented methodologies. New XML support makes PHP the best language available for processing XML and, coupled with new SOAP support, an ideal platform for creating and using Web Services. This book, written by my colleague, Andi Gutmans, and two very prominent PHP developers, Stig Bakken and Derick Rethans, holds the key to unlocking the riches of PHP 5. It thoroughly covers all of the features of the new version, and is a must-have for all PHP developers who are interested in exploring PHP 5's advanced features.
Zeev Suraski
xxi
Gutmans_PrefaceFore Page xxii Thursday, September 23, 2004 9:06 AM
xxii
Preface
Preface
“The best security against revolution is in constant correction of abuses and the introduction of needed improvements. It is the neglect of timely repair that makes rebuilding necessary.”—Richard Whately
IN THE BEGINNING It was eight years ago, when Rasmus Lerdorf first started developing PHP/FI. He could not have imagined that his creation would eventually lead to the development of PHP as we know it today, which is being used by millions of people. The first version of “PHP/FI,” called Personal Homepage Tools/ Form Interpreter, was a collection of Perl scripts in 1995.1 One of the basic features was a Perl-like language for handling form submissions, but it lacked many common useful language features, such as for loops.
1
http://groups.google.com/[email protected]
Gutmans_PrefaceFore Page xxiii Thursday, September 23, 2004 9:06 AM
In the Beginning
xxiii
PHP/FI 2 A rewrite came with PHP/FI 22 in 1997, but at that time the development was almost solely handled by Rasmus. After its release in November of that year, Andi Gutmans and Zeev Suraski bumped into PHP/FI while looking for a language to develop an e-commerce solution as a university project. They discovered that PHP/FI was not quite as powerful as it seemed, and its language was lacking many common features. One of the most interesting aspects included the way while loops were implemented. The hand-crafted lexical scanner would go through the script and when it hit the while keyword it would remember its position in the file. At the end of the loop, the file pointer sought back to the saved position, and the whole loop was reread and re-executed. PHP 3 Zeev and Andi decided to completely rewrite the scripting language. They then teamed up with Rasmus to release PHP 3, and along also came a new name: PHP: Hypertext Preprocessor, to emphasize that PHP was a different product and not only suitable for personal use. Zeev and Andi had also designed and implemented a new extension API. This new API made it possible to easily support additional extensions for performing tasks such as accessing databases, spell checkers and other technologies, which attracted many developers who were not part of the “core” group to join and contribute to the PHP project. At the time of PHP 3’s release3 in June 1998, the estimated PHP installed base consisted of about 50,000 domains. PHP 3 sparked the beginning of PHP’s real breakthrough, and was the first version to have an installed base of more than one million domains. PHP 4 In late 1998, Zeev and Andi looked back at their work in PHP 3 and felt they could have written the scripting language even better, so they started yet another rewrite. While PHP 3 still continuously parsed the scripts while executing them, PHP 4 came with a new paradigm of “compile first, execute later.” The compilation step does not compile PHP scripts into machine code; it instead compiles them into byte code, which is then executed by the Zend Engine (Zend stands for Zeev & Andi), the new heart of PHP 4. Because of this new way of executing scripts, the performance of PHP 4 was much better than that of PHP 3, with only a small amount of backward compatibility breakage4. Among other improvements was an improved extension API for better run-time performance, a web server abstraction layer allowing PHP 4 to run on most popular web servers, and lots more. PHP 4 was officially released on May 22, 2002, and today its installed base has surpassed 15 million domains. 2 3
http://groups.google.com/groups?selm=Dn1JM9.61t%40gpu.utcc.utoronto.ca.
http://groups.google.com/groups?selm=Pine.WNT.3.96.980606130654.-317675I100000%40shell.lerdorf.on.ca. 4 http://www.php.net/manual/en/migration4.php.
Gutmans_PrefaceFore Page xxiv Thursday, September 23, 2004 9:06 AM
xxiv
Preface
In PHP 3, the minor version number (the middle digit) was never used, and all versions were numbered as 3.0.x. This changed in PHP 4, and the minor version number was used to denote important changes in the language. The first important change came in PHP 4.1.0,5 which introduced superglobals such as $_GET and $_POST. Superglobals can be accessed from within functions without having to use the global keyword. This feature was added in order to allow the register_globals INI option to be turned off. register_globals is a feature in PHP which automatically converts input variables like '?foo=bar' in http:// php.net/?foo=bar to a PHP variable called $foo. Because many people do not check input variables properly, many applications had security holes, which made it quite easy to circumvent security and authentication code. With the new superglobals in place, on April 22, 2002, PHP 4.2.0 was released with the register_globals turned off by default. PHP 4.3.0, the last significant PHP 4 version, was released on December 27, 2002. This version introduced the Command Line Interface (CLI), a revamped file and network I/O layer (called streams), and a bundled GD library. Although most of those additions have no real effect on end users, the major version was bumped due to the major changes in PHP’s core. PHP 5 Soon after, the demand for more common object-oriented features increased immensely, and Andi came up with the idea of rewriting the objected-oriented part of the Zend Engine. Zeev and Andi wrote the “Zend Engine II: Feature Overview and Design” document6 and jumpstarted heated discussions about PHP’s future. Although the basic language has stayed the same, many features were added, dropped, and changed by the time PHP 5 matured. For example, namespaces and multiple inheritance, which were mentioned in the original document, never made it into PHP 5. Multiple inheritance was dropped in favor of interfaces, and namespaces were dropped completely. You can find a full list of new features in Chapter, “What Is New in PHP 5?” PHP 5 is expected to maintain and even increase PHP’s leadership in the web development market. Not only does it revolutionizes PHP’s objectoriented support but it also contains many new features which make it the ultimate web development platform. The rewritten XML functionality in PHP 5 puts it on par with other web technologies in some areas and overtakes them in others, especially due to the new SimpleXML extension which makes it ridiculously easy to manipulate XML documents. In addition, the new SOAP, MySQLi, and variety of other extensions are significant milestones in PHP’s support for additional technologies.
5 6
http://www.php.net/release_4_1_0.php. http://zend.com/engine2/ZendEngine-2.0.pdf.
Gutmans_PrefaceFore Page xxv Thursday, September 23, 2004 9:06 AM
Audience
xxv
AUDIENCE This book is an introduction to the advanced features new to PHP 5. It is written for PHP programmers who are making the move to PHP 5. Although Chapter 2, “PHP 5 Basic Language,” contains an introduction to PHP 5 syntax, it is meant as a refresher for PHP programmers and not as a tutorial for new programmers. However, web developers with experience programming other high-level languages may indeed find that this tutorial is all they need in order to begin working effectively with PHP 5.
CHAPTER OVERVIEW Chapter 1, “What Is New in PHP 5?” discusses the new features in PHP 5. Most of these new features deal with new object-oriented features, including small examples for each feature. It also gives an overview of the new extensions in PHP 5. Most of the topics mentioned in this chapter are explained in more detail in later chapters. Chapter 2, “PHP 5 Basic Language,” introduces the PHP syntax to those readers not familiar with PHP. All basic language constructs and variable types are explained along with simple examples to give the reader the necessary building blocks to build real scripts. Chapter 3, “PHP 5 OO Language,” continues exploring PHP 5's syntax, focusing on its object-oriented functionality. This chapter covers basics, such as properties and methods, and progresses to more complicated subjects, such as polymorphism, interfaces, exceptions, and lots more. Using the previous chapter as a foundation, Chapter 4, “PHP 5 Advanced OOP and Design Patterns,” covers some of the most advanced features of PHP 5’s object model. After learning these features, including four commonly used design patterns and PHP’s reflection capabilities, you will soon become an OO wizard. Now that you are familiar with the syntax and language features of PHP, Chapter 5, “How to Write a Web Application with PHP,” introduces you to the world of writing web applications. The authors show you basics, such as handling input through form variables and safety techniques, but this chapter also includes more advanced topics, such as handling sessions with cookies and PHP's session extension. You also find a few tips on laying out your source code for your web applications. Chapter 6, “Databases with PHP 5,” introduces using MySQL, SQLite, and Oracle from PHP, but focuses primarily on the PHP 5-specific details of database access. For each database, you learn about some of its strong and weak points, as well as the types of applications at which each excels. And of course, you learn how to interface with them using PHP's native functions or using PEAR DB.
Gutmans_PrefaceFore Page xxvi Thursday, September 23, 2004 9:06 AM
xxvi
Preface
All scripts can throw errors, but of course you do not want them to show up on your web site once your application has passed its development state. Chapter 7, “Error Handling,” deals with different types of errors that exist, how to handle those errors with PHP, and how to handle errors with PEAR. As one of the important new features in PHP 5 is its renewed XML support, a chapter on XML features in PHP 5 could not be missed. Chapter 8, “XML with PHP 5,” talks about the different strategies of parsing XML and converting XML to other formats with XSLT. XML-RPC and SOAP are introduced to show you how to implement web services with both techniques. Although not specifically for PHP 5, the five mainstream extensions that Chapter 9,“Mainstream Extensions,” covers are important enough to deserve a place in this book. The first section, “Files and Streams,” explains about handling files and network streams. A stream is nothing more than a way to access external data, such as a file, remote URL, or compressed file. The second section, “Regular Expressions,” explains the syntax of a regular expression engine (PCRE) that PHP uses with numerous examples to show you how these expressions can make your life easier. In “Date Handling,” we explain the different functions used to parse and format date and time strings. In “Graphics Manipulation with GD,” we show you through two real-life scenarios the basic functions of creating and manipulating graphics with PHP. The last section in this chapter, “Multibyte Strings and Character Sets,” explains the different character sets and the functions to convert and handle different ones, including multi-byte strings used in Asian languages. Chapter 10, “Using PEAR,” introduces PEAR, the PHP Extension and Application Repository. Starting with concepts and installation, the chapter shows how to use PEAR and maintain the local installed packages. This chapter also includes a tour of the PEAR web site. Chapter 11, “Important PEAR Packages,” gives an overview of the most important PEAR packages, along with examples. Packages covered include Template Systems, the Auth package to do authentication, form handling with the HTML_QuickForm package, and a package used to simplify caching. Chapter 12, “Building PEAR Components,” explains how to create your own PEAR package. The PEAR Coding Standard and package.xml package definition format, together with tips on including files and package layout, get you on your way to completing your first PEAR package. Chapter 13, “Making the Move,” deals with the few backward-incompatible changes that were introduced between PHP 4 and PHP 5. This chapter tells you which things you need to take care of when making your application work on PHP 5, and provides workarounds wherever possible. Chapter 14, “Performance,” shows you how to make your scripts perform better. The chapter offers tips on standard PHP usage, the use of external utilities (APD and Xdebug) to find problems in your scripts, and PHP accelerators like APC and Zend Performance Suite.
Gutmans_PrefaceFore Page xxvii Thursday, September 23, 2004 9:06 AM
A Note About Coding Styles
xxvii
Chapter 15, “An Introduction to Writing PHP Extensions,” explains how to write your own custom PHP extension. We use a simple example to explain the most important things like parameter parsing and resource management. Chapter 16, “PHP Shell Scripting,” shows you how to write shell scripts in PHP, because PHP is useful for more than just web applications. We carefully explain the differences between the CLI and CGI executables in which PHP comes, including command-line parameter parsing and process control. This book also includes three appendices. Appendix A, “PEAR and PECL Package Index,” provides an overview of all important packages, with descriptions and dependencies on other packages. Appendix B, “phpDocument Format Reference,” explains the syntax as understood by the PHP Documenter tool to generate API documentation from source code. Appendix C, “Zend Studio Quick Start,” is an introduction to working in the Zend Studio IDE.
A NOTE ABOUT CODING STYLES There are almost as many coding styles as there are programmers. The PHP examples in this book follow the PEAR coding standard, with the opening curly bracket on the line below the function name. In some cases, we’ve placed the curly bracket on the same line as the function name. We encourage you to adopt the style you are most comfortable with. Note: A code continuation character, ➥, appears at the beginning of code lines that have wrapped down from the line above it.
ABOUT THE SOFTWARE Included in the back of this book is a special link to Zend.com, where you can download a fully functional, 90-day trial version of the Zend Studio IDE. Be sure to use the license key printed on the inside back cover of this book when you install Zend Studio. The Zend Development Environment (ZDE) is a convenient tool that integrates an editor, debugger, and project manager to help you develop, manage, and debug your code. It can connect to your own installed server or directly to the Zend Studio server component. It is a powerful tool that allows you to debug your code in its natural environment.
UPDATES AND ERRATA AND DOWNLOADS Updates, errata, and copies of the sample programs used in this book can be found at the following URL: http//php5powerprogramming.com. We encourage you to visit this site.
Gutmans_PrefaceFore Page xxviii Thursday, September 23, 2004 9:06 AM
xxviii
Preface
ACKNOWLEDGEMENTS This book could not have been written without feedback from our technical reviewers; therefore, we would like to thank Marcus Börger, Steph Fox, Martin Jansen, and Rob Richards for their excellent comments and feedback. Besides these four reviewers, there are a few more people who helped answer several questions during the writing of this book, more specifically Christian Stocker for helping with the XML chapter, Wez Furlong and Sara Golemon for answering questions about the streams layer, Pierre-Alain Joye for providing some insights in the inner workings of the GD library, and less specifically the PEAR community for their support and dedication to a great repository of usable PEAR components. Some sections in this book were contributed by co-authors; Georg Richter contributed the MySQLi section of the database chapter, and Zeev Suraski added the section on Zend's Performance Suite. We would also like to thank Mark L. Taub and the editorial team of Pearson PTR for the things they are good at doing: organizing, planning, and marketing this book, and making sure everything fits together. Thanks to Janet Valade, for helpful developmental editing support, and our project editor Kristy Hart, who helped us wrap up the book under pressure and put the final touches on it. Enjoy! Andi, Stig, and Derick
Gutmans_Ch01 Page 1 Thursday, September 23, 2004 2:35 PM
C
H
A
P
T
E
R
1
What Is New in PHP 5? “The best way to be ready for the future is to invent it.”— John Sculley
1.1 INTRODUCTION Only time will tell if the PHP 5 release will be as successful as its two predecessors (PHP 3 and PHP 4). The new features and changes aim to rid PHP of any weaknesses it may have had and make sure that it stays in the lead as the world’s best web-scripting language. This book details PHP 5 and its new features. However, if you are familiar with PHP 4 and are eager to know what is new in PHP 5, this chapter is for you. When you finish reading this chapter, you will have learned ☞ The new language features ☞ News concerning PHP extensions ☞ Other noteworthy changes to PHP’s latest version
1.2 LANGUAGE FEATURES 1.2.1 New Object-Oriented Model When Zeev Suraski added the object-oriented syntax back in the days of PHP 3, it was added as “syntactic sugar for accessing collections.” The OO model also had support for inheritance and allowed a class (and object) to aggregate both methods and properties, but not much more. When Zeev and Andi Gutmans rewrote the scripting engine for PHP 4, it was a completely new engine; it ran much faster, was more stable, and boasted more features. However, the OO model first introduced in PHP 3 was barely touched. Although the object model had serious limitations, it was used extensively around the world, often in large PHP applications. This impressive use of the OOP paradigm with PHP 4, despite its weaknesses, led to it being the main focus for the PHP 5 release.
1
Gutmans_Ch01 Page 2 Thursday, September 23, 2004 2:35 PM
2
What Is New in PHP 5? Chap. 1
So, what were some of the limitations in PHP 3 and 4? The biggest limitation (which led to further limitations) was the fact that the copy semantics of objects were the same as for native types. So, how did this actually affect the PHP developer? When assigning a variable (that points to an object) to another variable, a copy of the object would be created. Not only did this impact performance, but it also usually led to obscure behavior and bugs in PHP 4 applications because many developers thought that both variables would point at the same object, which was not the case. The variables were instead pointing at separate copies of the same object. Changing one would not change the other. For example: class Person { var $name; function getName() { return $this->name; } function setName($name) { $this->name = $name; } function Person($name) { $this->setName($name); } } function changeName($person, $name) { $person->setName($name); } $person = new Person('Andi'); changeName($person, 'Stig'); print $person->getName();
In PHP 4, this code would print out 'Andi'. The reason is that we pass the object $person to the changeName() function by-value, and thus, $person is copied and changeName() works on a copy of $person. This behavior is not intuitive, as many developers would expect the Javalike behavior. In Java, variables actually hold a handle (or pointer) to the object, and therefore, when it is copied, only the handle (and not the entire object) is duplicated. There were two kinds of users in PHP 4: the ones who were aware of this problem and the ones who were not. The latter would usually not notice this problem and their code was written in a way where it did not really matter if the problem existed. Surely some of these people had sleepless nights trying to track down weird bugs that they could not pinpoint. The former group dealt with this problem by always passing and assigning objects by reference. This would prevent the engine from copying their objects, but it would be a headache because the code included numerous & signs.
Gutmans_Ch01 Page 3 Thursday, September 23, 2004 2:35 PM
1.2 Language Features
The old object model not only led to the afore-mentioned problems, but also to fundamental problems that prevented implementing some additional features on top of the existing object model. In PHP 5, the infrastructure of the object model was rewritten to work with object handles. Unless you explicitly clone an object by using the clone keyword, you never create behind-the-scenes duplicates of your objects. In PHP 5, you don’t need a need to pass objects by reference or assign them by reference. Note: Passing by reference and assigning by reference are still supported, in case you want to actually change a variable’s content (whether object or other type). 1.2.2 New Object-Oriented Features The new OO features are too numerous to give a detailed description in this section. Chapter 3, “PHP 5 OO Language,” details each feature. The following list provides the main new features: ☞ public/private/protected access modifiers for methods and properties.
Allows the use of common OO access modifiers to control access to methods and properties: class MyClass { private $id = 18; public function getId() { return $this->id; } }
☞ Unified constructor name __construct().
Instead of the constructor being the name of the class, it is now declared as __construct(), which makes it easier to shift classes inside class hierarchies: class MyClass { function __construct() { print 'Inside constructor'; } }
☞ Object destructor support by defining a __destructor() method.
Allows defining a destructor function that runs when an object is destroyed: class MyClass { function __destruct() { print ”Destroying object”; } }
3
Gutmans_Ch01 Page 4 Thursday, September 23, 2004 2:35 PM
4
What Is New in PHP 5? Chap. 1
☞ Interfaces.
Gives the ability for a class to fulfill more than one is-a relationships. A class can inherit only from one class, but may implement as many interfaces as it wants: interface Display { function display(); } class Circle implements Display { function display() { print 'Displaying circlen'; } }
☞ instanceof operator.
Language-level support for is-a relationship checking. The PHP 4 is_a() function is now deprecated: if ($obj instanceof Circle) { print '$obj is a Circle'; }
☞ Final methods.
The final keyword allows you to mark methods so that an inheriting class cannot overload them: class MyClass { final function getBaseClassName() { return __CLASS__; } }
☞ Final classes.
After declaring a class as would error out.
final,
it cannot be inherited. The following example
final class FinalClass { }
class BogusClass extends FinalClass { }
☞ Explicit object cloning.
To clone an object, you must use the clone keyword. You may declare a __clone() method, which will be called during the clone process (after the properties have been copied from the original object):
Gutmans_Ch01 Page 5 Thursday, September 23, 2004 2:35 PM
1.2 Language Features
5
class MyClass { function __clone() { print 'Object is being cloned'; } } $obj = new MyClass(); $obj_copy = clone $obj;
☞ Class constants.
Class definitions can now include constant values and are referenced using the class: class MyClass { const SUCCESS = 'Success'; const FAILURE = 'Failure'; } print MyClass::SUCCESS;
☞ Static methods.
You can now define methods as static by allowing them to be called from non-object context. Static methods do not define the $this variable because they are not bound to any specific object: class MyClass { static function helloWorld() { print 'Hello, world'; } } MyClass::helloWorld();
☞ Static members.
Class definitions can now include static members (properties) that are accessible via the class. Common usage of static members is in the Singleton pattern: class Singleton { static private $instance = NULL; private function __construct() { } static public function getInstance() { if (self::$instance NULL) { self::$instance = new Singleton(); } return self::$instance; } }
Gutmans_Ch01 Page 6 Thursday, September 23, 2004 2:35 PM
6
What Is New in PHP 5? Chap. 1
☞ Abstract classes.
A class may be declared abstract to prevent it from being instantiated. However, you may inherit from an abstract class: abstract class MyBaseClass { function display() { print 'Default display routine being called'; } }
☞ Abstract methods.
A method may be declared abstract, thereby deferring its definition to an inheriting class. A class that includes abstract methods must be declared abstract: abstract class MyBaseClass { abstract function display(); }
☞ Class type hints.
Function declarations may include class type hints for their parameters. If the functions are called with an incorrect class type, an error occurs: function expectsMyClass(MyClass $obj) { }
☞ Support for dereferencing objects that are returned from methods.
In PHP 4, you could not directly dereference objects that were returned from methods. You had to first assign the object to a dummy variable and then dereference it. PHP 4: $dummy = $obj->method(); $dummy->method2();
PHP 5: $obj->method()->method2();
☞ Iterators.
PHP 5 allows both PHP classes and PHP extension classes to implement an Iterator interface. After you implement this interface, you can iterate instances of the class by using the foreach() language construct: $obj = new MyIteratorImplementation(); foreach ($obj as $value) { print '$value'; }
Gutmans_Ch01 Page 7 Thursday, September 23, 2004 2:35 PM
1.2 Language Features
7
For a more complete example, see Chapter 4, “PHP 5 Advanced OOP and Design Patterns.”
☞ __autoload().
Many developers writing object-oriented applications create one PHP source file per class definition. One of the biggest annoyances is having to write a long list of needed inclusions at the beginning of each script (one for each class). In PHP 5, this is no longer necessary. You may define an __autoload() function that is automatically called in case you are trying to use a class that has not been defined yet. By calling this function, the scripting engine offers one last chance to load the class before PHP bails out with an error: function __autoload($class_name) { include_once($class_name . 'php'); } $obj = new MyClass1(); $obj2 = new MyClass2();
1.2.3 Other New Language Features ☞ Exception handling.
PHP 5 adds the ability for the well-known try/throw/catch structured exception-handling paradigm. You are only allowed to throw objects that inherit from the Exception class: class SQLException extends Exception { public $problem; function __construct($problem) { $this->problem = $problem; } } try { .. throw new SQLException('Couldn't connect to database'); .. } catch (SQLException $e) { print 'Caught an SQLException with problem $obj->problem'; } catch (Exception $e) { print 'Caught unrecognized exception'; }
Currently for backward-compatibility purposes, most internal functions do not throw exceptions. However, new extensions make use of this capability, and you can use it in your own source code. Also, similar to the already existing set_error_handler() , you may use set_exception_handler() to catch an unhandled exception before the script terminates.
Gutmans_Ch01 Page 8 Thursday, September 23, 2004 2:35 PM
8
What Is New in PHP 5? Chap. 1
☞ foreach with references.
In PHP 4, you could not iterate through an array and modify its values. PHP 5 supports this by enabling you to mark the foreach() loop with the & (reference) sign, which makes any values you change affect the array over which you are iterating: foreach ($array as &$value) { if ($value 'NULL') { $value = NULL; } }
☞ Default values for by-reference parameters.
In PHP 4, default values could be given only to parameters, which are passed by-values. PHP 5 now supports giving default values to byreference parameters: function my_func(&$arg = null) { if ($arg NULL) { print '$arg is empty'; } } my_func();
1.3 GENERAL PHP CHANGES 1.3.1 XML and Web Services Following the changes in the language, the XML updates in PHP 5 are probably the most significant and exciting. The enhanced XML functionality in PHP 5 puts it on par with other web technologies in some areas and overtakes them in others. 1.3.1.1 The Foundation XML support in PHP 4 was implemented using a variety of underlying XML libraries. SAX support was implemented using the old Expat library, XSLT was implemented using the Sablotron library (or using libxml2 via the DOM extension), and DOM was implemented using the more powerful libxml2 library by the GNOME project. Using a variety of libraries did not make PHP 4 excel when it came to XML support. Maintenance was poor, new XML standards were not always supported, performance was not as good as it could have been, and interoperability between the various XML extensions did not exist. In PHP 5, all XML extensions have been rewritten to use the superb libxml2 XML toolkit (http://www.xmlsoft.org/). It is a feature-rich, highly maintained, and efficient implementation of the XML standards that brings cuttingedge XML technology to PHP.
Gutmans_Ch01 Page 9 Thursday, September 23, 2004 2:35 PM
1.3 General PHP Changes
9
All the afore-mentioned extensions (SAX, DOM, and XSLT) now use libxml2, including the new additional extensions SimpleXML and SOAP. 1.3.1.2 SAX As previously mentioned, the new SAX implementation has switched from using Expat to libxml2. Although the new extension should be compatible, some small subtle differences might exist. Developers who still want to work with the Expat library can do so by configuring and building PHP accordingly (which is not recommended). 1.3.1.3 DOM Although DOM support in PHP 4 was also based on the libxml2 library, it had bugs, memory leaks, and in many cases, the API was not W3Ccompliant. The DOM extension went through a thorough facelift for PHP 5. Not only was the extension mostly rewritten, but now, it is also W3C-compliant. For example, function names now use studlyCaps as described by the W3C standard, which makes it easier to read general W3C documentation and implement what you have learned right away in PHP. In addition, the DOM extension now supports three kinds of schemas for XML validation: DTD, XML schema, and RelaxNG. As a result of these changes, PHP 4 code using DOM will not always run in PHP 5. However, in most cases, adjusting the function names to the new standard will probably do the trick. 1.3.1.4 XSLT In PHP 4, two extensions supported XSL Transformations: the Sablotron extension and the XSLT support in the DOM extension. PHP 5 features a new XSL extension and, as previously mentioned, it is based on the libxml2 extension. As in PHP 5, the XSL Transformation does not take the XSLT stylesheet as a parameter, but depends on the DOM extension to load it. The stylesheet can be cached in memory and may be applied to many documents, which saves execution time. 1.3.1.5 SimpleXML When looking back in a year or two, it will be clear that SimpleXML revolutionized the way PHP developers work with XML files. Instead of having to deal with DOM or—even worse—SAX, SimpleXML represents your XML file as a native PHP object. You can read, write, or iterate over your XML file with ease, accessing elements and attributes. Consider the following XML file: John Doe 87234838 Janet Smith 72384329
Gutmans_Ch01 Page 10 Thursday, September 23, 2004 2:35 PM
10
What Is New in PHP 5? Chap. 1
The following code prints each client’s name and account number: $clients = simplexml_load_file('clients.xml'); foreach ($clients->client as $client) { print '$client->name has account number $client ➥>account_numbern'; }
It is obvious how simple SimpleXML really is. In case you need to implement an advanced technique in your SimpleXML object that is not supported in this lightweight extension, you can convert it to a DOM tree by calling it dom_import_simplexml(), manipulate it in DOM, and convert it to SimpleXML using simplexml_import_dom(). Thanks to both extensions using the same underlying XML library, switching between them is now a reality. 1.3.1.6 SOAP PHP 4 lacked official native SOAP support. The most commonly used SOAP implementation was PEARs, but because it was implemented entirely in PHP, it could not perform as well as a built-in C extension. Other available C extensions never reached stability and wide adoption and, therefore, were not included in the main PHP 5 distribution. SOAP support in PHP 5 was completely rewritten as a C extension and, although it was only completed at a very late stage in the beta process, it was incorporated into the default distribution because of its thorough implementation of most of the SOAP standard. The following calls SomeFunction() defined in a WSDL file: $client = new SoapClient('some.wsdl'); $client->SomeFunction($a, $b, $c);
1.3.1.7 New MySQLi (MySQL Improved) Extension For PHP 5, MySQL AB (http://www.mysql.com) has written a new MySQL extension that enables you to take full advantage of the new functionality in MySQL 4.1 and later. As opposed to the old MySQL extension, the new one gives you both a functional and an OO interface so that you can choose what you prefer. New features supported by this extension include prepared statements and variable binding, SSL and compressed connections, transaction control, replication support, and more. 1.3.1.8 SQLite Extension Support for SQLite (http://www.sqlite.org) was first introduced in the PHP 4.3.x series. It is an embedded SQL library that does not require an SQL server, so it is suitable for applications that do not require the scalability of SQL servers or, if you deploy at an ISP that does not
Gutmans_Ch01 Page 11 Thursday, September 23, 2004 2:35 PM
1.4 Other New Features in PHP 5
offer access to an SQL server. Contrary to what its name implies, SQLite has many features and supports transactions, sub-selects, views, and large database files. It is mentioned here as a PHP 5 feature because it was introduced so late in the PHP 4 series, and because it takes advantage of PHP 5 by providing an OO interface and supporting iterators. 1.3.1.9 Tidy Extension PHP 5 includes support for the useful Tidy (http:// tidy.sf.net/) library. It enables PHP developers to parse, diagnose, clean, and repair HTML documents. The Tidy extension supports both a functional and an OO interface, and its API uses the PHP 5 exception mechanism. 1.3.1.10 Perl Extension Although not bundled in the default PHP 5 package, the Perl extension allows you to call Perl scripts, use Perl objects, and use other Perl functionality natively from within PHP. This new extension sits within the PECL (PHP Extension Community Library) repository at http:// pecl.php.net/package/perl.
1.4 OTHER NEW FEATURES IN PHP 5 This section discusses new features introduced in PHP 5. 1.4.1 New Memory Manager The Zend Engine features a new memory manager. The two main advantages are better support for multi-threaded environments (allocations do not need to perform any mutual exclusion locks), and after each request, freeing the allocated memory blocks is more efficient. Because this is an underlying infrastructure change, you will not notice it directly as the end user. 1.4.2 Dropped Support for Windows 95 Running PHP on the Windows 95 platform is not supported anymore due to Windows 95 does not support the functionality that PHP uses. Because Microsoft officially stopped supporting it in 2002, the PHP development community decided that dropping the support was a wise decision.
1.5 SUMMARY You must surely be impressed by the amount of improvements in PHP 5. As previously mentioned, this chapter does not cover all the improvements, but only the main ones. Other improvements include additional features, many bug fixes, and a much-improved infrastructure. The following chapters cover PHP 5 and give you in-depth coverage of the named new features and others that were not mentioned in this chapter.
11
Gutmans_Ch01 Page 12 Thursday, September 23, 2004 2:35 PM
Gutmans_ch02 Page 13 Thursday, September 23, 2004 2:37 PM
C
H
A
P
T
E
R
2
PHP 5 Basic Language “A language that doesn’t have everything is actually easier to program in than some that do.”—Dennis M. Ritchie
2.1 INTRODUCTION PHP borrows a bit of its syntax from other languages such as C, shell, Perl, and even Java. It is really a hybrid language, taking the best features from other languages and creating an easy-to-use and powerful scripting language. When you finish reading this chapter, you will have learned ☞ The basic language structure of PHP ☞ How PHP is embedded in HTML ☞ How to write comments ☞ Managing variables and basic data types ☞ Defining constants for simple values ☞ The most common control structures, most of which are available in
other programming languages ☞ Built-in or user-defined functions
If you are an experienced PHP 4 developer, you might want to skip to the next chapter, which covers object-oriented support of the language that has changed significantly in PHP 5.
13
Gutmans_ch02 Page 14 Thursday, September 23, 2004 2:37 PM
14
PHP 5 Basic Language Chap. 2
2.2 HTML EMBEDDING The first thing you need to learn about PHP is how it is embedded in HTML: Sample PHP Script The following prints 'Hello, World':
In this example, you see that your PHP code sits embedded in your HTML. Every time the PHP interpreter reaches a PHP open tag marker. PHP then replaces that PHP code with its output (if there is any) while any non-PHP text (such as HTML) is passed through as-is to the web client. Thus, running the mentioned script would lead to the following output: Sample PHP Script The following prints 'Hello, World': Hello, World
Tip: You may also use a shorter $num is negative $num is zero $num is positive
As you can see, HTML blocks can be used just like any other statement. Here, only one of the HTML blocks are displayed, depending on the value of $num. Note: No variable substitution is performed in the HTML blocks. They are always printed as is. 2.7.1.2 switch Statements Statement
Statement List
switch (expr){ case expr: statement list case expr: statement list .. default: statement list }
switch (expr): case expr: statement list case expr: statement list .. default: statement list endswitch;
You can use the switch construct to elegantly replace certain lengthy if/ constructs. It is given an expression and compares it to all possible case expressions listed in its body. When there’s a successful match, the following code is executed, ignoring any further case lines (execution does not stop when the next case is reached). The match is done internally using the regular equality operator (), not the identical operator (). You can use the break statement to end execution and skip to the code following the switch construct.
elseif
Gutmans_ch02 Page 42 Thursday, September 23, 2004 2:37 PM
42
PHP 5 Basic Language Chap. 2
Usually, break statements appear at the end of a case statement list, although it is not mandatory. If no case expression is met and the switch construct contains default, the default statement list is executed. Note that the default case must appear last in the list of cases or not appear at all: switch ($answer) { case 'y': case 'Y': print 'The answer was yesn'; break; case 'n': case 'N': print 'The answer was non'; break; default: print 'Error: $answer is not a valid answern'; break; }
2.7.2 Loop Control Structures Loop control structures are used for repeating certain tasks in your program, such as iterating over a database query result set. 2.7.2.1 while loops Statement while (expr) statement
Statement List while (expr): statement list endwhile;
while loops are the simplest kind of loops. In the beginning of each iteration, the while’s truth expression is evaluated. If it evaluates to true, the loop keeps on running and the statements inside it are executed. If it evaluates to false, the loop ends and the statement(s) inside the loop is skipped. For example, here’s one possible implementation of factorial, using a while loop (assuming $n contains the number for which we want to calculate the factorial):
$result = 1; while ($n > 0) { $result *= $n--; } print 'The result is $result';
Gutmans_ch02 Page 43 Thursday, September 23, 2004 2:37 PM
2.7 Control Structures
43
2.7.2.2 Loop Control: break and continue break; break expr; continue; continue expr;
Sometimes, you want to terminate the execution of a loop in the middle of an iteration. For this purpose, PHP provides the break statement. If break appears alone, as in break;
the innermost loop is stopped. break accepts an optional argument of the amount of nesting levels to break out of, break n;
which will break from the n innermost loops (break 1; is identical to break;). n can be any valid expression. In other cases, you may want to stop the execution of a specific loop iteration and begin executing the next one. Complimentary to break, continue provides this functionality. continue alone stops the execution of the innermost loop iteration and continues executing the next iteration of that loop. continue n can be used to stop execution of the n innermost loop iterations. PHP goes on executing the next iteration of the outermost loop. As the switch statement also supports break, it is counted as a loop when you want to break out of a series of loops with break n. 2.7.2.3 do..while Loops do statement while (expr);
The do..while loop is similar to the previous while loop, except that the truth expression is checked at the end of each iteration instead of at the beginning. This means that the loop always runs at least once. do..while loops are often used as an elegant solution for easily breaking out of a code block if a certain condition is met. Consider the following example: do { statement list if ($error) { break; }
Gutmans_ch02 Page 44 Thursday, September 23, 2004 2:37 PM
44
PHP 5 Basic Language Chap. 2
statement list } while (false);
Because do..while loops always iterate at least one time, the statements inside the loop are executed once, and only once. The truth expression is always false. However, inside the loop body, you can use the break statement to stop the execution of the statements at any point, which is convenient. Of course, do..while loops are also often used for regular iterating purposes. 2.7.2.4 for Loops Statement for (expr, expr, …; expr, expr, …; expr, expr, …) statement
Statement List for (expr, expr, …; expr, expr, …; expr, expr, …): statement list endfor;
PHP provides C-style for loops. The for loop accepts three arguments: for (start_expressions; truth_expressions; increment_expressions)
Most commonly, for loops are used with only one expression for each of the start, truth, and increment expressions, which would make the previous syntax table look slightly more familiar.
Statement for (expr; expr; expr) statement
Statement List for (expr; expr; expr): statement list endfor;
The start expression is evaluated only once when the loop is reached. Usually it is used to initialize the loop control variable. The truth expression is evaluated in the beginning of every loop iteration. If true, the statements inside the loop will be executed; if false, the loop ends. The increment expression is evaluated at the end of every iteration before the truth expression is evaluated. Usually, it is used to increment the loop control variable, but it can be used for any other purpose as well. Both break and continue behave the same way as they do with while loops. continue causes evaluation of the increment expression before it re-evaluates the truth expression.
Gutmans_ch02 Page 45 Thursday, September 23, 2004 2:37 PM
2.7 Control Structures
45
Here’s an example: for ($i = 0; $i < 10; $i++) { print 'The square of $i is ' . $i*$i . 'n'; }
The result of running this code is The square of 0 is 0 The square of 1 is 1 .. The square of 9 is 81
Like in C, it is possible to supply more than one expression for each of the three arguments by using commas to delimit them. The value of each argument is the value of the rightmost expression. Alternatively, it is also possible not to supply an expression with one or more of the arguments. The value of such an empty argument will be true. For example, the following is an infinite loop: for (;;) { print 'I'm infiniten'; }
Tip: PHP doesn’t know how to optimize many kinds of loop invariants. For example, in the following for loop, count($array) will not be optimized to run only once. for ($i = 0; $i
Running this script echoes the following link: ➥err!
However, this URL is still vulnerable. An attacker can modify both the variables and the hash. We must do something better. We’re not the first ones with this problem, so there is an existing solution: HMAC (Keyed-Hashing for Message Authentication). The HMAC method is proven to be stronger cryptographically, and should be used instead of home-cooked validation algorithms. The HMAC algorithm uses a secret key in a two-step hashing of plain text (in our case, the string containing the key/value pairs) with the following steps: 1. If the key length is smaller than 64 bytes (the block size that most hashing algorithms use), we pad the key to 64 bytes with 0s; if the key length is larger than 64, we first use the hash function on the key and then pad it to 64 bytes with 0s. 2. We construct opad (the 64-byte key XORed with 0x5C) and ipad (the 64byte key XORed with 0x36). 3. We create the “inner” hash by running the hash function with the parameter ipad . plain text. (Because we use an “iterative” hash function, like md5() or sha1(), we don’t need to seed the hash function with our key and then run the seeded hash function over our plain text. Internally, the hash will do the same anyway, which is the reason we padded the key up to 64 bytes). 4. We create the “outer” hash by running the hash function over opad . inner_result — that is, using the result obtained in step 3. Here is the formula to calculate HMAC, which should help you understand the calculation: H(K XOR opad, H(K XOR ipad, text))
With ☞ H. The hash function to use ☞ K. The key padded to 64 bytes with zeroes (0x0) ☞ opad. The 64 bytes of 0x5Cs
Gutmans_ch05 Page 124 Thursday, September 23, 2004 2:41 PM
124
How to Write a Web Application with PHP
Chap. 5
☞ ipad. The 64 bytes of 0x36s ☞ text. The plain text for which we are calculating the hash
Great—so much for the boring theory. Now let’s see how we can use it with a PEAR class that was developed to calculate the hashes.
5.5.3 PEAR::Crypt_HMAC The Crypt_HMAC class implements the algorithm as described in RFC 2104 and can be installed with pear install crypt_hmac. Let’s look at it: class Crypt_HMAC { /** * Constructor * Pass method as first parameter * * @param string method - Hash function used for the calculation * @return void * @access public */ function Crypt_HMAC($key, $method = 'md5') { if (!in_array($method, array('sha1', 'md5'))) { die('Unsupported hash function '$method'.'); } $this->_func = $method; /* Pad the key as the RFC wishes (step 1) */ if (strlen($key) > 64) { $key = pack('H32', $method($key)); } if (strlen($key) < 64) { $key = str_pad($key, 64, chr(0)); } /* Calculate the padded keys and save them (step 2 & 3) */ $this->_ipad = substr($key, 0, 64) ^ str_repeat(chr(0x36), ➥64); $this->_opad = substr($key, 0, 64) ^ str_repeat(chr(0x5C), ➥64); }
First, we make sure that the requested underlying hash function is actually supported (for now, only the built-in PHP functions md5() and sha1() are supported). Then, we create a key, according to steps 1 and 2, as previously
Gutmans_ch05 Page 125 Thursday, September 23, 2004 2:41 PM
5.5 Techniques to Make Scripts “Safe”
125
described. Finally, in the constructor, we pre-pad and XOR the key so that the hash() method can be used several times without losing performance by padding the key every time a hash is requested: /** * Hashing function * * @param string data - string that will hashed (step 4) * @return string * @access public */ function hash($data) { $func = $this->_func; $inner = pack('H32', $func($this->_ipad . $data)); $digest = $func($this->_opad . $inner); return $digest; } } ?>
In the hash function, we use the pre-padded key. First, we hash the inner result. Then, we hash the outer result, which is the digest (a different name for hash) that we return. Back to our original problem. We want to verify that no one tampered with our precious $_GET variables. Here is the second, more secure, version of our create_parameters() function:
The output is ➥err!
To verify the parameters passed to the script, we can use this script:
We didn’t use addslashes() around the $email and $password variables earlier. We will do that in the script that calls the methods of this class:
After the user is added to the database, something like this appears in your table: +--------+------------------------------------------+ user password +--------+------------------------------------------+ derick 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8 +--------+------------------------------------------+
The first person who receives the correct password back from this sha1() hash can ask me for a crate of Kossu. 5.5.6 Error Handling During development, you probably want to code with error_reporting set to E _ A L L & E _ S T R I C T . Doing so helps you catch some bugs. If you have error_reporting set to E_ALL & E_STRICT , the executed script will show you errors like this: Warning: Call-time pass-by-reference has been deprecated - argument passed by value; If you would like to pass it by reference, modify the declaration of sanitize_vars(). If you would like to enable call-time pass-by-reference, you can set allow_call_time_pass_reference to true in your INI file. However, future versions may not support this any longer.
Gutmans_ch05 Page 130 Thursday, September 23, 2004 2:41 PM
130
How to Write a Web Application with PHP
Chap. 5
The reason for this is that we prefixed $_POST in the call to sanitize with the reference operator, which is no longer supported. The correct line is: sanitize_vars($_POST, $sigs);
However, you definitely do not want to see error messages like these on your production sites, especially not your cusomers. Not only is it unsightly, but some debuggers show the full parameters, including username and password, which is information that should be kept private. PHP has features that make the experience much nicer for you, your customers, and visitors to the site. With the php.ini directives 'log_errors' and 'display_errors', you can control where the errors appear. If you set the log_errors directive to 1, all errors are recorded in a file that you specify with the error_log directive. You can set error_log to syslog or to a file name. In some cases, recording errors in a file (rather than displaying them to the user) may not make the experience nicer for the visitors. Instead, it may result in an empty or broken page. In such cases, you may want to tell visitors that something went wrong, or you may want to hide the problem from visitors. PHP supports a customized error handler that can be set with set_error_handler(). This function accepts one parameter that can be either a string containing the function name for the error-handling function or an array containing a classname/methodname combination. The error-handling function should be defined like error_function($type, $error, $file, $line)
The $type is the type of error that is caught and can be either E_NOTICE, E_WARNING, E_USER_NOTICE, E_USER_WARNING, or E_USER_ERROR. No additional errors should be possible because the PHP code and the extensions are not supposed to emit other errors except parse errors or other low-level error messages. $error is the textual error message. $file and $line are the file name and line number on which the error occurred. By using the error handler, you can tell the user in a nice way that something went wrong (for instance, in the layout of your site) or you can redirect the user to the main page (to hide the fact that something went wrong). The redirect, of course, will only work if no output was sent before the redirect, or if you have output_buffering turned on. Note that a user-defined error handler captures all errors, even if the error_reporting level tells PHP that not all errors should be shown.
Gutmans_ch05 Page 131 Thursday, September 23, 2004 2:41 PM
5.6 Cookies
131
5.6 COOKIES The simple registration we used earlier in this chapter does not make data persistent across requests. If you go to the next page (such as by clicking a link or by entering a different URL in your browser’s address bar), the posted data is gone. One simple way to maintain data between the different pages in a web application is with cookies. Cookies are sent by PHP through the web server with the setcookie() function and are stored in the browser. If a time-out is set for the cookie, the browser will even remember the cookie when you reset your computer; without the time-out set, the browser forgets the cookie as soon as the browser closes. You can also set a cookie to be valid only for a specific subdomain, rather than having the cookie sent by the browser to the script whenever the domain of the script is the same as the domain where the cookie was set (the default). In the next example, we set a cookie when a user has successfully logged in with the login form: Login Log-in

E-mail address:

Password:

Gutmans_ch05 Page 132 Thursday, September 23, 2004 2:41 PM
132
How to Write a Web Application with PHP
Chap. 5
The check_auth() function checks whether the username and password match with the stored data and returns either the user id that belongs to the user or 0 when an error occurred. The setcookie('uid', $uid, time() + 14400, '/'); line tells the web server to add a cookie header to send to the browser. uid is the name of cookie to be set and $uid has the value of the uid cookie. The expression time() + 14400 sets the expiry time of the cookie to the current time plus 14,400 seconds, which is 4 hours. The time on the server must be correct because the time() function is the base for calculating the expiry time. Notice that the ob_start() function is the first line of the script. ob_start() turns on output buffering, which is needed to send cookies (or other headers) after you output data. Without this call to ob_start(), the output to the browser would have started at the line of the script, making it impossible to send any headers, and resulting in the following error when trying to add another header (with setcookie() or header()):
Instead of using output buffering (which is memory-intensive), you can, of course, change your script so that data is not output until after you set any headers. Cookies are sent by the script/web server to the browser. The browser is then responsible for sending the cookie, via HTTP request headers, to all successive pages that belong to your web application. With the third and fourth parameters of the setcookie() function, you can control which sections of your web site receive the specific cookie headers. The third parameter is /, which means that all pages in the domain (the root and all subdirectories) should receive the cookie data. The fourth parameter controls which domains receive the cookie header. For instance, if you use .example.com, the cookie is available to all subdomains of example.com. Or, you could use admin.example.com , restricting the cookies to the admin part of your application. In this case, we did not specify a domain, so all pages in the web application receive the cookie. After the line with the setcookie() call, a line issues a redirect header to the browser. This header requires the full path to the destination page. After the header line, we terminate the script with exit() so that no headers can be set from later parts of the code. The browser redirects to the given URL by requesting the new page and discarding the content of the current one. On any web page requested after the script that called set_cookie(), the cookie data is available in your script in a manner similar to the GET and POST data. The superglobal to read cookies is $_COOKIE . The following index.php script shows the use of cookies to authenticate a user. The first line of the page checks whether the cookie with the user id is set. If it’s set, we display our index.php page, echoing the user id set in the cookie. If it’s not set, we redirect to the login page:
Gutmans_ch05 Page 133 Thursday, September 23, 2004 2:41 PM
5.6 Cookies
133
Index page Logged in with UID: Log out.
Using this user id for important items, such as remembering authentication data (as we do in this script), is not wise, because it’s easy to fake cookies. (For most browsers, it is enough to edit a simple text field.) A better solution— using PHP sessions—follows in a bit. Deleting a cookie is almost the same as setting one. To delete it, you use the same parameters that you used when you set the cookie, except for the value, which needs to be an empty string, and the expiry date, which needs to be set in the past. On our logout page, we delete the cookie this way:
The time() - 86400 is exactly one day ago, which is sufficiently in the past for our browser to forget the cookie data. Figure 5.3 shows the way our scripts can be tied together. As previously mentioned, putting authentication data into cookies (as we did in the previous examples) is not secure because cookies are so easily faked. PHP has, of course, a better solution: sessions.
Gutmans_ch05 Page 134 Thursday, September 23, 2004 2:41 PM
134
How to Write a Web Application with PHP
Chap. 5
index.php
logout link clicked
correct username/password entered / cookie set
cookie ‘uid’ not set redirect
logout.php
redirect cookie unset
login.php
wrong username/password entered
Fig. 5.3 Scripts tied together.
5.7 SESSIONS A PHP session allows an application to store information for the current “session,” which can be defined as one user being logged in to your application. A session is identified by a unique session ID. PHP creates a session ID that is an MD5 hash of the remote IP address, the current time, and some extra randomness represented in a hexadecimal string. This session ID can be passed in a cookie or added to all URLs to navigate your application. For security reasons, it’s better to force the user to have cookies enabled than to pass the session ID on the URL (which normally can be done manually by adding ?PHP_SESSID=, or by turning on session.use_trans_sid in php.ini) where it might end up in web server’s logs as a HTTP_REFERER or be found by some evil person monitoring your traffic. That evil person can still see the session cookie data, of course, so you might want to use an SSL-enabled server to be really safe. But, to continue discussing sessions, we’re going to rewrite the previous cookie example using sessions. We create a file called session.inc that sets some session values, as shown in the following example, and include this file at the beginning of any script that is part of the session:
Gutmans_ch05 Page 135 Thursday, September 23, 2004 2:41 PM
5.7 Sessions
135
On the first line, the configuration parameter 'session.use_cookies' is set to 1, which means that cookies will be used for propagation of the session ID. On the second line, 'session.use_only_cookies' is set to 1, which means that a session ID passed in the URL to the script will be discarded. The second setting requires that users have cookies enabled to use sessions. If you cannot rely on people having cookies enabled, you can either remove this line, or you can change the value to 0, which ensures that there is no global setting for this configuration parameter in php.ini or another place. Tip: You can configure the place where PHP will store session files with the session.save_path configuration setting. The session_start() function must come after any session-related settings are done with ini_set(). Session_start() initializes the session module, setting some headers (such as the session ID cookie and some caching-prevention headers), requiring its placement before any output has been sent to the browser. If no session ID is available at the time, session_start() is called, a new session ID is created, and the session is initialized with an empty $_SESSION array. Adding elements to the $_SESSION array is easy, as shown in the following example. This modified version of our login page shows the changed lines in bold: Login /* HTML form comes here */
Gutmans_ch05 Page 136 Thursday, September 23, 2004 2:41 PM
136
How to Write a Web Application with PHP
Chap. 5
Tip: You can call session_name('NAME') before calling session_start() in your script to change the default PHP_SESSID name of the session ID cookie. We first include our session.inc file. Adding the session variable 'uid' to the session is done easily by setting the uid element of the $_SESSION superglobal to the value of $uid . Unsetting a session variable can be done with unset($_SESSION['uid']). Tip: If you need to process a lot of data after modifying your session variables, you might want to call session_write_close(), which is normally done automatically at the end of the script. This writes the session file to disk and unlocks the file from the operating system so that other scripts may use the session file. (You will notice that pages in a frame set might load serially if they use frames because the session file is locked by PHP.) Tip: The locking described here will not always work on NFS, so scripts in a frame set might still get the old non-updated session data. Avoid using NFS to store session files. Logging out is the same as destroying the session and its associated data, as we see in the logout script:
We still need to initialize the session with session_start(), after which we can clear the session by setting the $_SESSION superglobal to an empty array. Then, we destroy the session and its associated data by calling session_destroy(). Session variables are accessed from the $_SESSION superglobal. Each element contains a session variable, using the session-variable name as key. In our index.php script, we moved the if statement that checks whether a user is logged in to a special function that we place in the session.inc file: function check_login() { if (!isset ($_SESSION['uid']) !$_SESSION['uid']) { /* If no UID is in the cookie, we redirect to the login page */ header('Location: http://kossu/session/login.php'); } }
Gutmans_ch05 Page 137 Thursday, September 23, 2004 2:41 PM
5.8 File Uploads
137
In this function, we check whether the 'uid' session variable exists and whether the value of the 'uid' session variable is not 0. If one of the checks fail, we redirect users to the login page; otherwise, we do nothing and let the calling script handle it from there. We call the check_login() function on every page where we require a user to be logged in. We need to make sure the session.inc file is included before any output is produced because it may need to send headers to the browser. Here is a snippet from the modified index.php script:
Using sessions can be as simple as what’s shown here. Or, you can tweak some more parameters. Check out the php.ini-dist file that accompanies the PHP distributions.
5.8 FILE UPLOADS We haven’t yet covered one type of input-uploading files. You can use the file upload feature of PHP to upload images or related materials, for example. Because the browser needs to do a little bit more than just send a POST with the relevant data, you need to use a specially crafted form for file uploads. Here is an example of such a special form: Send this file:
The differences between file upload forms and normal forms are bold in the code listing. First, an enctype attribute, included in the form tag, instructs the browser to send a different type of POST request. Actually, it’s a normal POST request, except the body containing the encoded files (and other form fields) is completely different. Instead of the simple field=var&field2=var2 syntax, something resembling a “text and HTML” email is sent in the body, with each part being a form field. The file upload field itself is the type file, which displays an input field and a browse button that allows a user to browse through the file system to find a file. The text on the browse button can’t be changed, so it is usually localized.
Gutmans_ch05 Page 138 Thursday, September 23, 2004 2:41 PM
138
How to Write a Web Application with PHP
Chap. 5

Power Programming With Rpc Pdf Free Download

(Mozilla in English uses “Browse,” IE in Dutch uses “Bladeren,” and so on.) The hidden input field sends a MAX_FILE_SIZE to the browser, setting the maximum allowable size of the file being uploaded. However, most browsers ignore this extra field, so it’s up to you in the handler script to accept or deny the file. 5.8.1 Handling the Incoming Uploaded File The $_FILES array contains an array of information about each file that is uploaded. The handler script can access the information using the name of the uploaded file as the key. The $_FILES['book_image'] variable contains the following information for the uploaded file. Key
Value
name
string(8) 'p5pp.jpg'
type
string(10) 'image/jpeg'
tmp_name
string(14) '/tmp/phpyEXxWp'
error
int(0)
size
int(2045)
Description The original name of the file on the file system of the user who uploaded it. The MIME type of the file. For a JPG image, this can be either image/jpeg or image/pjpeg and all other types have their dedicated MIME type. The temporary file name on the server’s file system. PHP will clean up after the request has finished, so you are required to do something with it inside the script that handles the request (either delete or move it). The error code. See the next paragraph for an explanation. The size in bytes of the uploaded file.
A few possible errors can occur during a file upload. Most errors relate to the size of the uploaded file. Each error code has an associated constant. The following table shows the error conditions. # 0 1
UPLOAD_ERR_OK
Constant
2
UPLOAD_ERR_FORM_SIZE
3
UPLOAD_ERR_PARTIAL
4
UPLOAD_ERR_NO_FILE
UPLOAD_ERR_INI_SIZE
Description The file was uploaded successfully and no errors occurred. The size of the uploaded files exceeded the value of the upload_max_file setting from php.ini. The size of the uploaded files exceeded the value of the special form field MAX_FILE_SIZE. Because users can easily fake the size, you cannot rely on this one, and you always have to check the sizes yourself in the script by using $_FILES ['book_image']['size'];. There was a problem uploading the file because only a partial file was received. There was no file uploaded at all because the user did not select any in the upload form. This is not always an error; this field might not be required.
Gutmans_ch05 Page 139 Thursday, September 23, 2004 2:41 PM
5.8 File Uploads
139
After learning all this theory, we now examine the script that uploads a file. In this script, we check if the size is acceptable (we don’t want more than 50KB for the uploaded images) and if the uploaded file is of the correct type (we only want JPEG and PNG files). Of course, we also check the error codes shown in the previous table and use the correct way of moving it to our uploaded images directory: XML Example

Moved to example.org. foo & bar

The first line is the XML declaration; it specifies the XML version and the XML file encoding. Notice that the line starts with

People

All A-Z

• Tolga Acar

  Principal Software Eng Lead

• Logan Adams

  Hardware Engineer

• Alekh Agarwal

  Senior Researcher

• Ronald Aigner

  Principal SDE

• Miltos Allamanis

  Researcher

• Zeyuan Allen-Zhu

  Researcher

• Saleema Amershi

  Researcher

• Sean Andrist

  Researcher

• Carl Anselmi

  Senior Xbox Research Operations PM Procharged c7 installation instructions.

• Andrey Antipov

  Researcher Computational Physics and Condensed Matter Theory

• Kapil Arya

  Senior Research SDE

• Pavel Aseev

  Material Scientist

• B. Ashok

  Senior Director of Applied Sciences and Engineering

Microsoft Research Alumni Network

If you were formerly an employee or intern at Microsoft Research, join the newly formed LinkedIn Microsoft Research Alumni Network group. Share, reconnect and network with colleagues who were and are pivotal to driving innovation that empowers every person on the planet.

Join us

Change lives and tackle technology’s biggest challenges with a team of world-class researchers.

Awards

Microsoft researchers have received a myriad of prestigious national and international honors, including the ACM A.M. Turing Award, considered the highest distinction in computer science. Learn more about our award-winning research