Connection error never emitted on iOS

[mi-mazouz]

Description

Hello!!

I'm trying to create a tcp connection to an incorrect host (the ip is unreachable).

Here is my code:

...
private _device = null

private async openConnection(
        host,
        dataListenerCallback,
    ): Promise<void> {
        if (this._device) {
              this._device.destroy();
        }

        return new Promise((resolve, reject) => {
            this._device = net.createConnection({
                port: 53333,
                host,
                timeout: 1000,
            }, (socket) => {
                console.log('connected');
                resolve();
            });

            this._device.on('connect', () => {
                console.log('connect');
            });

            this._device.on('connection', () => {
                console.log('connnection');
            });

            this._device.on('error', (error) => {
                console.log('Error', error);
                reject();
            });

            this._device.on('data', dataListener);

            this._device.on('close', () => {
                console.log('Connection closed!');
            });
        });

Current behavior

this function never rejects or resolves.

Expected behavior

I expected to catch a connection error in the error event listener.

Relevant information

| react-native | 0.61.5 |
| react-native-tcp-socket | 3.7.1 |

[Rapsssito]

@mi-mazouz, thanks for the feedback! Currently, there is not official timeout support. I am working on it. There is JS code that acts as a timeout listener/event, but it is not fully tested and might not work in all circumstances. In the meantime, this is a possible workaround:

function connect(options) {
       return new Promise((resolve, reject) => {
            const tcpTimeout = setTimeout(() => {
                     reject('Timeout');
            }, 1000);
            const tcpSocket = net.createConnection(options, () => {
                    clearTimeout(tcpTimeout);
                    resolve();
                }
            );
      });
}

[mi-mazouz]

ok for the timeout but what about the connection error? What should happen if the connection fails?

[Rapsssito]

@mi-mazouz, if you are setting an "incorrect" IP, you should get an 'error' event with a message along the lines of "Host unreachable".

[mi-mazouz]

That's what I expected but I don't get this error

[Rapsssito]

@mi-mazouz, can you reproduce the bug using the example code?

[mi-mazouz]

@Rapsssito Yes you should be able to reproduce it using my code

[Rapsssito]

@mi-mazouz, I meant if you could reproduce the issue using the example code provided in the repository. You can comment out all the server references and test the client with your "incorrect" IP.

[mi-mazouz]

same with this code, nothing happened:

import React from 'react';
import {
    ScrollView,
    StyleSheet,
    Text,
    View,
} from 'react-native';
import TcpSocket from 'react-native-tcp-socket';

class App extends React.Component {
    constructor(props) {
        super(props);

        this.updateChatter = this.updateChatter.bind(this);
        this.state = { chatter: [] };
    }

    updateChatter(msg) {
        this.setState({
            chatter: this.state.chatter.concat([msg]),
        });
    }

    componentDidMount() {
        const serverPort = 53333;
        const serverHost = '192.1.1.1';
        // let server;
        let client;

        // server = TcpSocket.createServer((socket) => {
        //     this.updateChatter(`server connected on ${JSON.stringify(socket.address())}`);

        //     socket.on('data', (data) => {
        //         this.updateChatter(`Server Received: ${data}`);
        //         socket.write('Echo server\r\n');
        //     });

        //     socket.on('error', (error) => {
        //         this.updateChatter(`server client error ${error}`);
        //     });

        //     socket.on('close', (error) => {
        //         this.updateChatter(`server client closed ${error || ''}`);
        //     });
        // }).listen({ port: serverPort, host: serverHost, reuseAddress: true }, (address) => {
        //     this.updateChatter(`opened server on ${JSON.stringify(address)}`);
        // });

        // server.on('error', (error) => {
        //     this.updateChatter(`Server error ${error}`);
        // });

        // server.on('close', () => {
        //     this.updateChatter('server close');
        // });

        client = TcpSocket.createConnection({
            port: serverPort,
            host: serverHost,
        }, (address) => {
            this.updateChatter(`opened client on ${JSON.stringify(address)}`);
            client.write('Hello, server! Love, Client.');
        });

        client.on('data', (data) => {
            this.updateChatter(`Client Received: ${data}`);
            this.client.destroy(); // kill client after server's response
        });

        client.on('error', (error) => {
            this.updateChatter(`client error ${error}`);
        });

        client.on('close', () => {
            this.updateChatter('client close');
        });

        this.client = client;
    }

    componentWillUnmount() {
        this.client = null;
    }

    render() {
        return (
            <View style={styles.container}>
                <ScrollView>
                    {this.state.chatter.map((msg, index) => (
                        <Text key={index} style={styles.welcome}>
                            {msg}
                        </Text>
                    ))}
                </ScrollView>
            </View>
        );
    }
}

const styles = StyleSheet.create({
    container: {
        flex: 1,
        justifyContent: 'center',
        alignItems: 'center',
        backgroundColor: '#F5FCFF',
    },
    welcome: {
        fontSize: 20,
        textAlign: 'center',
        margin: 10,
    },
    instructions: {
        textAlign: 'center',
        color: '#333333',
        marginBottom: 5,
    },
});

export default App;

anyway, the setTimeout does the job!

[Rapsssito]

@mi-mazouz, glad it works with setTimeout()! I am not able to reproduce the issue, the device on your 192.168.1.1 may be accepting the TCP connection and keeping it on hold forever (that's why you don't get any error).

I will be releasing a setTimeout() update soon (#56), it should work in all scenarios.