Receiving a WebSocket connection in vanilla PHP involves creating a server that listens for incoming connections, handles the WebSocket handshake, and then processes the incoming data frames. This requires a deeper understanding of the WebSocket protocol than typical HTTP requests.
Here's a breakdown of the key steps: Create a Socket Server.
Utilize PHP's socket functions to create a server socket that listens on a specific IP address and port.
Code

   <?php
   $host = '127.0.0.1'; // Localhost
   $port = 8080; // Choose an available port

   $socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
   socket_set_option($socket, SOL_SOCKET, SO_REUSEADDR, 1);
   socket_bind($socket, $host, $port);
   socket_listen($socket);

   $clients = array(); // Array to hold connected clients
   ?>

Accept Client Connections and Handle Handshake.
Continuously listen for incoming connections and, when a client connects, perform the WebSocket handshake. This involves receiving the client's handshake request, generating the appropriate server response, and sending it back.
Code

   <?php
   // ... (previous code) ...

   while (true) {
       $newSocket = socket_accept($socket);
       if ($newSocket) {
           // Perform WebSocket handshake
           $header = socket_read($newSocket, 1024);
           // ... (Implement doHandshake function to process header and send response) ...
           $clients[] = $newSocket;
           echo "Client connected.\n";
       }

       // Handle data from existing clients (not shown in detail here)
       // You would iterate through $clients and use socket_select to check for data
       // and then socket_read to receive it.
   }
   ?>

Decode Incoming WebSocket Frames.
Once the handshake is complete, incoming messages from the client will be encapsulated in WebSocket frames. You need to implement a function to unmask and decode these frames to extract the actual message content.
Code

   <?php
   // ... (previous code) ...

   function unseal($socketData) {
       // ... (Implementation to unmask and decode WebSocket frame data) ...
       // This involves reading the length, masking key, and unmasking the payload.
       return $decodedData;
   }
   ?>

Process Received Messages.
After decoding, you can process the received message content according to your application's logic. This might involve broadcasting the message to other connected clients, storing it in a database, or triggering other actions.

   Encode and Send WebSocket Frames (for outgoing messages):

If your server needs to send messages back to clients, you'll need to encapsulate them in WebSocket frames.
Code

   <?php
   // ... (previous code) ...

   function seal($socketData) {
       // ... (Implementation to encode data into a WebSocket frame) ...
       // This involves adding the appropriate headers and potentially masking (for client-side, not server-side).
       return $encodedFrame;
   }
   ?>

Important Considerations:

   Blocking vs. Non-blocking Sockets:
   For a robust WebSocket server, you'll typically need to use non-blocking sockets and socket_select to efficiently manage multiple client connections without blocking the server process.
   Error Handling:
   Implement comprehensive error handling for socket operations.
   Security:
   Be mindful of security considerations, especially regarding input validation and potential denial-of-service attacks.
   Persistent Process:
   A vanilla PHP WebSocket server needs to be run as a continuously running script (e.g., via the command line) rather than a typical web server request, as it maintains persistent connections.
   Complexities:
   Implementing a full-featured WebSocket server in vanilla PHP can be complex due to the intricacies of the protocol and managing multiple concurrent connections. Libraries like Ratchet or Swoole can significantly simplify this process.