A brief analysis of streams in PHP, a brief analysis of phpstreams_PHP tutorial

A brief analysis of streams in PHP, a brief analysis of phpstreams

Overview

Streams are a feature introduced in PHP 4.3, mainly to unify the working methods of files, sockets and other similar resources. PHP 4.3 has been around for a long time, but many programmers seem to be unable to use streams in PHP correctly, including me of course. I have encountered the use of streams in some programs before, such as php://input, but I have never had a chance to sort it out. Today I will sort out this part of the knowledge.

Streams are resources provided by PHP that can be used transparently by us, and streams are a very powerful tool. Proper use of streams in programs can take our programs to a new level.

Convection is described in the PHP manual as follows:
Copy code The code is as follows:
Streams were introduced with PHP 4.3.0 as a way of generalizing file, network, data compression, and other operations which share a common set of functions and uses. In its simplest definition, a stream is a resource object which exhibits streamable behavior. That is, it can be read from or written to in a linear fashion, and may be able to fseek() to an arbitrary locations within the stream.

Each stream implements a wrapper, which contains some additional code to handle special protocols and encodings. PHP provides some built-in wrappers, and we can also easily create and register custom wrappers. We can even use contexts and filters to alter and enhance wrappers.

Streaming Basics

The form of stream in PHP is: ://. is the name of the wrapper, and the content of depends on the different wrapper syntax.
The default wrapper is file://, which means a stream is used every time we access the file system. For example, we can use the following two methods to read files: readfile('/path/to/somefile.txt') and readfile('file:///path/to/somefile.txt'). Use these two way to read the file, you can get the same result.

As mentioned earlier, PHP provides some built-in wrappers, protocols and filters. To see which wrappers are installed on our machine, we can use the following functions:
Copy code The code is as follows:
var_dump(stream_get_transports());
var_dump(stream_get_wrappers());
var_dump(stream_get_filters());
?>

My local environment output is as follows:
Copy code The code is as follows:
array (size=8)
0 => string 'tcp' (length=3)
1 => string 'udp' (length=3)
2 => string 'unix' (length=4)
3 => string 'udg' (length=3)
4 => string 'ssl' (length=3)
5 => string 'sslv3' (length=5)
6 => string 'sslv2' (length=5)
7 => string 'tls' (length=3)
array (size=12)
0 => string 'https' (length=5)
1 => string 'ftps' (length=4)
2 => string 'compress.zlib' (length=13)
3 => string 'compress.bzip2' (length=14)
4 => string 'php' (length=3)
5 => string 'file' (length=4)
6 => string 'glob' (length=4)
7 => string 'data' (length=4)
8 => string 'http' (length=4)
9 => string 'ftp' (length=3)
10 => string 'phar' (length=4)
11 => string 'zip' (length=3)
array (size=12)
0 => string 'zlib.*' (length=6)
1 => string 'bzip2.*' (length=7)
2 => string 'convert.iconv.*' (length=15)
3 => string 'string.rot13' (length=12)
4 => string 'string.toupper' (length=14)
5 => string 'string.tolower' (length=14)
6 => string 'string.strip_tags' (length=17)
7 => string 'convert.*' (length=9)
8 => string 'consumed' (length=8)
9 => string 'dechunk' (length=7)
10 => string 'mcrypt.*' (length=8)
11 => string 'mdecrypt.*' (length=10)

In addition, we can customize or use third-party streams.

php://wrapper

PHP has its own wrapper for accessing input/output (I/O) streams. PHP has basic php://stdin, php://stdout, php://stderr wrappers corresponding to the default I/O resources. There is also a php://input stream, which is a read-only stream, and the content of the stream is the data requested by the post. This stream is especially useful when we put data in the body of a post request to request a remote service.

Because php://input is the most commonly used stream, here are some knowledge points:
Copy code The code is as follows:
1.php://input can read unprocessed POST data. Compared to $HTTP_RAW_POST_DATA, it puts less pressure on memory and does not require special php.ini settings. php://input cannot be used for enctype=multipart/form-data
2. Only when the Content-Type is application/x-www-form-urlencoded and the submission method is the POST method, the $_POST data and the php://input data are "consistent" (with quotation marks, indicating that their formats and contents are inconsistent) consistent). In other cases, they are inconsistent
3.php://input cannot read GET data. This is because the _GET data is written as query_path in the PATH field of the http request header (header), rather than in the body part of the http request.

Stream Contexts

This part of the content has almost never been encountered in programming, and it is difficult for me to research it. If you are interested, you can search it yourself.

Summary

Streams are not used much in daily programming. When using xml-rpc, the server side obtains client data, mainly through the PHP input stream input. This is a common scenario. Hackers may also use this part of the content when they invade the website.

http://www.bkjia.com/PHPjc/1026058.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/1026058.htmlTechArticleA brief analysis of streams in PHP, a brief analysis of phpstreams Overview Streams were introduced in PHP 4.3 version A feature of , mainly to unify the working methods of files, sockets and other similar resources. ...