Tizen Developers

In fact, I did use the same JS code as in the Tizen Guide, you provided the link to.In 2.3.2 it gave me no error.

The "Server" is a simple Websocket Listener written in C#, running in an UWP App on a PC under Win 10. I took this sample and changed it slightly: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_server

in 2.3.2 it worked, but in 3.0 it never even reaches the line

Console.WriteLine("A client connected.");

Here is the Code that I use for the Server. It never even reaches the Line

Debug.WriteLine('Reading message');

that's why i think it's a problem up to tizen.

using System;
using System.Diagnostics;
using System.Net;
using System.Text;
using System.Net.Sockets;
using System.Text.RegularExpressions;
using System.Security.Cryptography;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.IO;
using System.Threading;

namespace F2FClient
{
    class TcpHelper
    {
        private  TcpListener listener { get; set; }
        public  bool listen { get; private set; } = false;
        private  bool accept { get; set; } = false;
        public bool isSocket { get; private set; } = false;
        private NetworkStream stream { get; set; }
        private string curPort { get; set; }
        public int emptyMessageCounter { get; private set; } = 0;
        public Task listenTask { get; private set; }
        public string lastMessage { get; private set; }

        public TcpHelper()
        {

        }

        ~TcpHelper()
        {
            if (listener != null) {
                StopListening();

            }
        }


        public  string StartServer(int port)
        {
            string ip = "192.168.0.196";
            IPAddress address = IPAddress.Parse(ip);
            listener = new TcpListener(address, port);
            emptyMessageCounter = 0;
            curPort = port.ToString();
            listener.Server.NoDelay = true;
            listener.Server.LingerState = new LingerOption(true, 0);
            listener.Start();
            listen = true;
            accept = true;
            listenTask = new Task(Listen);
            listenTask.Start();

            Debug.WriteLine(string.Format("Server started. Listening to TCP clients at {1}:{0}", port,ip));
            return string.Format("Server started. Listening to TCP clients at {1}:{0}\n", port, ip);
        }

        private async void Listen()
        {
            if (listener != null && accept)
            {
                // Continue listening.  
                while (listen)
                {
                    Debug.WriteLine("Waiting for client.");
                    using (TcpClient client = await listener.AcceptTcpClientAsync())
                    {

                        
                        Debug.WriteLine("Reading message.");
                        stream = client.GetStream();
                        StreamReader reader = new StreamReader(stream, Encoding.UTF8);
                        while (stream != null)
                        {
                            if (isSocket == false)
                            {
                                byte[] buffer = new byte[500];
                                int len = await stream.ReadAsync(buffer, 0, buffer.Length);
                                string handshakeMessage = Encoding.UTF8.GetString(buffer, 0, len);
                                Debug.WriteLine(string.Format("Incoming (handshake) message on {0}: {1} " ,curPort , handshakeMessage));
                                Debug.WriteLine("Length of received data: " + len);

                                if (new Regex("^GET").IsMatch(handshakeMessage))
                                {
                                    byte[] response = Encoding.UTF8.GetBytes("HTTP/1.1 101 Switching Protocols" + "\r\n"
                                        + "Connection: Upgrade" + "\r\n"
                                        + "Upgrade: websocket" + "\r\n"
                                        + "Sec-WebSocket-Accept: " + Convert.ToBase64String(
                                            SHA1.Create().ComputeHash(
                                                Encoding.UTF8.GetBytes(
                                                    new Regex("Sec-WebSocket-Key: (.*)").Match(handshakeMessage).Groups[1].Value.Trim() + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
                                                )
                                            )
                                        ) + "\r\n"
                                        + "\r\n");
                                    isSocket = true;
                                    stream.Write(response, 0, response.Length);
                                }else {
                                    Debug.WriteLine(string.Format(" message on port {0} did not begin with GET", curPort));

                                    string incomingMessage = string.Empty;
                                    if (len > 1)
                                    {
                                        incomingMessage = DecodeMessage(buffer);
                                    }
                                    Debug.WriteLine(string.Format("Incoming Message on port {0}: {1}", curPort, incomingMessage));
                                }
                            }
                            else if (client.Available > 0)
                            {

                                byte[] buffer = new byte[508];
                                int len = await stream.ReadAsync(buffer, 0, buffer.Length);

                                string incomingMessage = string.Empty;
                                if (len > 1)
                                {
                                    incomingMessage = DecodeMessage(buffer);
                                }
                                Debug.WriteLine(string.Format("Incoming Message on port {0}: {1}", curPort, incomingMessage));
                                //letzte empfangene Datenzeile zur Verfügung stellen:
                                lastMessage = incomingMessage.Trim();
                                //Debug.WriteLine("Sending message.");
                                //byte[] message = EncodeMessageToSend("Thank you!");
                                //await stream.WriteAsync(message, 0, message.Length);

                                //if (new Regex("^quit").IsMatch(incomingMessage))
                                //{
                                // stream.Dispose();
                                //isSocket = false;
                                //Debug.WriteLine("Closing connection.");
                                //}


                            }
                        }
                    }
                }
            }
        }
        public async void send(string msg)
        {

            try
            {
                byte[] message = EncodeMessageToSend(msg);
                await stream.WriteAsync(message, 0, message.Length);
            }
            catch (Exception)
            {
                throw;
            }
        }
        public string StopListening()
        {
            listen = false;
            isSocket = false;
            if (listener != null)
            {
                listener.Stop();
                
                listener = null; 
            }
            return "Listening Stopped";
        }
        private string DecodeMessage(byte[] bytes)
        {
            string incomingData = string.Empty;
            byte secondByte = bytes[1];
            int dataLength = secondByte & 127;
            int indexFirstMask = 2;
            if (dataLength == 126)
                indexFirstMask = 4;
            else if (dataLength == 127)
                indexFirstMask = 10;

            IEnumerable<byte> keys = bytes.Skip(indexFirstMask).Take(4);
            int indexFirstDataByte = indexFirstMask + 4;

            byte[] decoded = new byte[bytes.Length - indexFirstDataByte];
            for (int i = indexFirstDataByte, j = 0; i < bytes.Length; i++, j++)
            {
                decoded[j] = (byte)(bytes[i] ^ keys.ElementAt(j % 4));
            }

            return incomingData = Encoding.UTF8.GetString(decoded, 0, decoded.Length);
        }

        private byte[] EncodeMessageToSend(string message)
        {
            byte[] response;
            byte[] bytesRaw = Encoding.UTF8.GetBytes(message);
            byte[] frame = new byte[10];

            int indexStartRawData = -1;
            int length = bytesRaw.Length;

            frame[0] = (byte)129;
            if (length <= 125)
            {
                frame[1] = (byte)length;
                indexStartRawData = 2;
            }
            else if (length >= 126 && length <= 65535)
            {
                frame[1] = (byte)126;
                frame[2] = (byte)((length >> 8) & 255);
                frame[3] = (byte)(length & 255);
                indexStartRawData = 4;
            }
            else
            {
                frame[1] = (byte)127;
                frame[2] = (byte)((length >> 56) & 255);
                frame[3] = (byte)((length >> 48) & 255);
                frame[4] = (byte)((length >> 40) & 255);
                frame[5] = (byte)((length >> 32) & 255);
                frame[6] = (byte)((length >> 24) & 255);
                frame[7] = (byte)((length >> 16) & 255);
                frame[8] = (byte)((length >> 8) & 255);
                frame[9] = (byte)(length & 255);

                indexStartRawData = 10;
            }

            response = new byte[indexStartRawData + length];

            int i, reponseIdx = 0;

            //Add the frame bytes to the reponse
            for (i = 0; i < indexStartRawData; i++)
            {
                response[reponseIdx] = frame[i];
                reponseIdx++;
            }

            //Add the data bytes to the response
            for (i = 0; i < length; i++)
            {
                response[reponseIdx] = bytesRaw[i];
                reponseIdx++;
            }

            return response;
        }
    }
}

That is a problem of your server may be ! or your requesting procedure may be not right. 

if it wasn't right, why should it work on 2.3.2?

another point: when I just type the ip:port of the server to the browser, the server receives a http request (of course not a correct one to upgrade to websocket, but the server can be reached)

In that case please provide the code snippet by which your are trying to hit the server from both 2.3.2 and 3.0 

the code is as I provided in the first post.

you just posted a single line.. And rest of the code is from your server side. So i think if the problem is from your server, Tizen is not related here. 

And if you think previously it worked...then may be this is a bug at new version of Tizen.. 
In that case you can create a bug issue here.. https://bugs.tizen.org/browse/TW-33?jql=project%20%3D%20TW%20AND%20resolution%20%3D%20Unresolved%20ORDER%20BY%20priority%20DESC%2C%20updated%20DESC