@Vanker

Are you remembering to add udp:// in front of the server address?
http://php.net/manual/en/function.fsockopen.php#example-5028

@Vanker

It’s really dependent on what you’re passing as $host. I’ll use 111.222.33.44 as our fake IP.

Instead of using something such as:

$this->fp = fsockopen('111.222.33.44', 29070, $this->errno, $this->errstr, 5);

… then it most likely will fail or cause problems. Instead, I’d recommend prefixing the IP with udp.

$this->fp = fsockopen('udp://111.222.33.44', 29070, $this->errno, $this->errstr, 5);

I created a very basic function to test fsockopen, this is what I used.

function udpStatus( $host, $port )
{
    $fp = fsockopen( "udp://" . $host, $port, $errNum, $errStr, 1.0 );

    if ( ! $fp )
    {
        return false;
    }
    else
    {
        fclose( $fp );

        return true;
    }
}

In the function, you can see that $host is prefixed with udp://. We can then run a conditional check using:

if ( udpStatus( 'HOST_OR_IP', 29070 ) )
{
    echo 'Connection Status: Success';
}
else
{
    echo 'Connection Status: Failed';
}

Replace HOST_OR_IP with the host or IP you’re connecting to.

With the udp:// prefix, the result from one Droplet connecting to another is Success. If we remove the prefix from the function, it fails.

@Vanker

Doing a little more digging :-). On the same two NYC 3 Droplets, I setup one droplet as a sender and the other as a receiver for UDP.

One the first droplet, I created a file called udp.php and within it, I used the core example that PHP provides for socket_create.

<?php
$sock = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);

$msg = "Ping!";
$len = strlen($msg);

socket_sendto($sock, $msg, $len, 0, 'REMOTE_IP', 29070);
socket_close($sock);

Where REMOTE_IP is the IP of the second Droplet that is supposed to receive the message. All the above is going to do is send a message “Ping!”.

On the second Droplet, I created a PHP file called receiver.php and within it, I placed:

<?php
//Create socket.
$socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
if (!$socket) { die("socket_create failed.\n"); }

//Set socket options.
socket_set_nonblock($socket);
socket_set_option($socket, SOL_SOCKET, SO_BROADCAST, 1);
socket_set_option($socket, SOL_SOCKET, SO_REUSEADDR, 1);
if (defined('SO_REUSEPORT'))
    socket_set_option($socket, SOL_SOCKET, SO_REUSEPORT, 1);

//Bind to any address & port 29070.
if(!socket_bind($socket, '0.0.0.0', 29070))
    die("socket_bind failed.\n");

//Wait for data.
$read = array($socket); $write = NULL; $except = NULL;
while(socket_select($read, $write, $except, NULL)) {

    //Read received packets with a maximum size of 5120 bytes.
    while(is_string($data = socket_read($socket, 5120))) {
        echo $data;
    }

}

That snippet came from here

On the second droplet, to start the receiver, all I did was run php receiver.php from the command line. Since it’s within a while loop, it’ll keep running until I exit the script.

I then went to the other droplet and ran php udp.php and “Ping!” shows up on the other end, as was expected.

So you may want to look in to the Sockets Library instead of using fsockopen in this particular case.

http://php.net/manual/en/book.sockets.php

@Vanker

In the second example, you shouldn’t need to set a timeout – socket_sendto is either going to send the message and return the number of bytes sent, or return false. The issue is, with UDP, you’re not going to see false returned since it’s one-way – so it’ll send the message or nothing at all.

I tested the second example with socket_sendto with ufw active on both. It successfully sent the message when port 29070 was open on the receiving server and, as expected, sent nothing if the port was blocked. Back to the nature of UDP, even with it blocked and the mindset we should see a failure, it doesn’t fail so to speak, just nothing is echo'ed or received.

…

As for ufw, what I would recommend is starting fresh. You may have something that is blocking the connection in the rules, even if you don’t see it in the status listing.

So let’s try this first.

1). Disable ufw

ufw disable

2). Reset ufw

ufw reset

3). Setup default rules. We’ll deny incoming, allow outgoing.

ufw default deny incoming

ufw default allow outgoing

At this point, if you enabled ufw, you’d be locked out as no incoming connections are being allowed at this point. We need to fix that.

First, let’s make sure SSH is allowed through.

ufw allow 22/tcp

Now we need to add any other ports to the rule set that you need to listen on, that means, any ports you need to accept connections on.

For the server that I was sending the UDP message from, only SSH is open. I enabled ufw after that first allow.

One the second server, I allowed SSH using the above, and then I opened port 29070 by specifying udp:

ufw allow 29070/udp

That means only udp connections are allowed on 29070 – TCP won’t work.

I prefer to be explicit when opening ports, which is why I use port/protocol – ufw allows other ways, but they don’t always work as expected. When I use this method, I know it works.

Once you’ve done all the above, enable ufw

ufw enable

@Vanker

As another test, we could use something like this to bounce between two servers.

client.php

<?php
$sock = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);

$msg = "Ping!" . PHP_EOL;
$len = strlen($msg);

if ( ! socket_sendto( $sock, $msg, $len, 0, 'REMOTE_IP', 29070 ) )
{
    $errorcode = socket_last_error();
    $errormsg  = socket_strerror( $errorcode );

    die( "Could not send data: [$errorcode] $errormsg" . PHP_EOL );
}

if ( socket_recv( $sock , $reply , 2045 , MSG_WAITALL ) === FALSE )
{
    $errorcode = socket_last_error();
    $errormsg  = socket_strerror( $errorcode );

    die( "Could not receive data: [$errorcode] $errormsg" . PHP_EOL );
}

echo "Reply: $reply";

socket_close($sock);

server.php

<?php
/**
 * Create UDP Socket
 */
if( ! ( $sock = socket_create( AF_INET, SOCK_DGRAM, 0 ) ) )
{
    $errorcode = socket_last_error();
    $errormsg  = socket_strerror( $errorcode );

    die( "Couldn't create socket: [$errorcode] $errormsg" . PHP_EOL );
}

echo 'Socket created' . PHP_EOL;

/**
 * Bind to Source Address
 */
if( ! socket_bind( $sock, '0.0.0.0' , 29070 ) )
{
    $errorcode = socket_last_error();
    $errormsg  = socket_strerror( $errorcode );

    die( "Could not bind socket : [$errorcode] $errormsg" . PHP_EOL );
}

echo 'Socket Bind: OK' . PHP_EOL;

while(1)
{
    echo "Waiting for data ..." . PHP_EOL;

    /**
     * Receive Data
     */
    $r = socket_recvfrom( $sock, $buf, 512, 0, $remote_ip, $remote_port );

    echo "$remote_ip : $remote_port -- " . $buf;

    /**
     * Send Data Back to Client
     */
    socket_sendto( $sock, "OK " . $buf , 100 , 0 , $remote_ip , $remote_port );
}

socket_close( $sock );

You’ll want to change REMOTE_IP on line 7 of client.php to match the IP you’re trying to connect to.

On the remote server, we would run php server.php. Then on the client, we’ll run php client.php.

client.php sends Ping! and server.php responds with OK Ping! which shows on the client server.

…

This is confirmation of sorts when it comes to whether the message was actually sent. Now, in this example, if the server you’re trying to send to has the port blocked, it will hang, but there’s way around that as well.

We can use socket_set_option, like so:

socket_set_option( $sock, SOL_SOCKET, SO_RCVTIMEO, [ "sec" => 10, "usec" => 0 ] );

You’d change sec from 10 to however many seconds you want to allow the connection attempt to run. So our new client.php script would look like:

<?php
$sock = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);

socket_set_option( $sock, SOL_SOCKET, SO_RCVTIMEO, [ "sec" => 10, "usec" => 0 ] );

$msg = "Ping!" . PHP_EOL;
$len = strlen($msg);

if ( ! socket_sendto( $sock, $msg, $len, 0, 'REMOTE_IP', 29070 ) )
{
    $errorcode = socket_last_error();
    $errormsg  = socket_strerror( $errorcode );

    die( "Could not send data: [$errorcode] $errormsg" . PHP_EOL );
}

if ( socket_recv( $sock , $reply , 2045 , MSG_WAITALL ) === FALSE )
{
    $errorcode = socket_last_error();
    $errormsg  = socket_strerror( $errorcode );

    die( "Could not receive data: [$errorcode] $errormsg" . PHP_EOL );
}

echo "Reply: $reply";

socket_close($sock);

In the above, if it doesn’t connect and send in 10 seconds, you’ll receive something like:

Could not receive data: [11] Resource temporarily unavailable

@jtittle For some reason I couldn’t reply to your last comment.

I got your point now, will test with the code you specified although I already destroyed the second droplet (was just testing anyways) so it will take some time.

Let’s say it work the way we expect it to, what could be the case then?

Is there any chance that the game host (amazon) could block certain ips or range of ips or anything like that?

It’s been a week now since I’m trying to figure this problem out and even my hair is turning gray already.

Also, I’d try to deploy on another hosting service to check if it works there, I’m just a programmer so I don’t know a lot about setting up a server from ground, so I MAY have fucked up somewhere (read tutorials on how to set-up) but every host that I found does not allow incoming and/or outgoing udp connections.

@Vanker

I would deploy a basic AWS instance for testing purposes. I wouldn’t use that script on a production game server since you’d need to install PHP on the server to run it.

On the AWS test instance, you’d run the server.php script and test the connection to it as well as it’s response from a DigitalOcean Droplet that has the client.php file. That way you’re testing across both networks.

Without setting up a test instance on AWS and testing the connection between DigitalOcean and the AWS instance, the only conclusion I can come to is that the issue is on the game server. The cause is hard to determine since I don’t know anything about the game server or how it was setup.