Login

Developing an Extensible TCP Server with Sockets in PHP

Are you interested in learning how to manipulate low-level sockets in PHP? Your search has finished. This is the second part of the series “Handling sockets in PHP,” and hopefully you’ll find in it valuable material regarding the creation and manipulation of sockets with PHP, in conjunction with numerous illustrative hands-on examples that will help you build socket servers in a few easy steps.

Introduction

For those who haven’t read my first tutorial yet, let me briefly recapitulate the topics that I treated previously. To begin with, I explained how to create a low-level socket in PHP and perform some key operations with it, such as pushing in and pulling out data streams.

Aside from covering some key points related to handling sockets, I set up a complete example, which focused on developing a simple TCP server and the corresponding client. In this way I demonstrated how they can communicate with each other, introducing some kind of basic processing on the traveling data.

After testing the sample TCP server that I developed in the first article, surely you’ll realize the excellent capabilities that come with PHP for handling sockets, and more generally for addressing common issues associated with network programming. Going deeper into socket manipulation, building end-to-end communication channels as part of an application allows you to understand much better the logic behind the relationship between server and clients. Considering this crucial concept, programming sockets in PHP can be a useful experience.

Now, focusing specifically on this second article of the series, I’ll go one step further in the manipulation of low-level sockets, and show you how to expand the TCP server that was constructed previously, in order to provide it with the ability to attend to multiple requests coming from the same client. Hopefully, this experience will help you to get a more intimate knowledge of socket handling in PHP.

With the preliminaries out of the way, let’s get started.

{mospagebreak title=A quick look at the previous TCP server}

Before I show you how to expand the sample TCP server developed in the first tutorial, first allow me list the full source code that creates it, including the procedural script, the “createSocketServer()” function that I defined before, and finally the “SocketServer” class. Here are the corresponding signatures for each case:

Right, as you can see above, I listed all the source code corresponding to both procedural and object-oriented approaches, in order to create a sample TCP server. However, as you’ll recall, all these examples demonstrate how to build a socket server that processes one request at a time; it is unable to handle multiple petitions.

Bearing in mind this limitation, in the next section I’ll show you how to expand the pertinent TCP server in such a way that it will be able to process multiple client requests.

Once you’ve learned how to create a low-level socket in PHP, in conjunction with reading and writing socket data, expanding the previous TCP server is a fairly standard process. Basically I’m not going to introduce new terms or concepts to achieve the new desired functionality.

In short, what I’ll do next is change the original procedural script and introduce a simple loop structure, in order to provide the server with the ability to keep running over and over again, attending to multiple client requests, until it is deliberately stopped.

Here is the source code for the improved TCP server, now capable of processing many requests:

Even though the script shown above is closely similar to the one I wrote in the first part of this series, it also exposes some differences worth mentioning. First, please notice the inclusion of the “do-while” loop, in order to keep the server listening over and over for incoming client connections.

Second, the server will display a simple welcome message, and will only stop listening for requests when the client sends out the “STOP” command. If this happens, the loop is halted and both the general and communication sockets are properly closed.

Additionally, in this example, I slightly modified the behavior of the server, so each time the client transmits a string, it will be redisplayed to the client. Of course, there’s plenty of room to experiment here, and certainly you may want to change the source code in order to make the server perform a more useful task.

Now, take a look at the following screen shots, which depict the whole client-server interaction process using a Microsoft Telnet client:

As you can see on the above images, after starting the server from the PHP command line, I used a simple Telnet client (like Microsoft’s) and made some requests to it, by entering different strings. In all cases, the server displayed the inputted string in the console, and only stopped working when I entered the “STOP” command.

In this example, hopefully you could see how data comes in and out through the communication channel established between the server and the client. Simple and educational, isn’t it?

At this point, I hope you’ve already grasped the driving logic for creating a TCP server, which now processes multiple requests from a specific client, by using some socket programming PHP functions.

Therefore, come with me and read the last section of the article, in order to learn how to translate the procedural script you saw before into a compact and reusable function, and an additional PHP class.

{mospagebreak title=Defining the createSocketServer() function and the SocketServer class}

Since I already showed you how to use a procedural script for creating a multi-request TCP server, I’ll now list different versions of the same application, just in case you want to work with a reusable function or, specifically in the object-based area, with a PHP class. Here are the respective definitions for both approaches:

In the first case, if you’re going to use the “createSocketServer()” function, this one can be used like this:

// call ‘createSocketServer()” function
createSocketServer();

Or, in case you prefer to work with an object-oriented approach, the “SocketServer” class can be utilized as follows:

// instantiate ‘SocketServer’ object
$sock=&new SocketServer();

To wrap up

That’s all for the moment. In this second part of the series, I’ve shown you how to build an extensible TCP server that handles multiple incoming requests, using the PHP socket-related functions that you learned in the first tutorial. But, do you think that’s all? Nope; in the last article, I’ll demonstrate how to implement a Web server on your own machine, by utilizing a few low-level sockets. You don’t have any excuses to miss it!