Example #1
0
        private void asyncSocket_DidRead(AsyncSocket sender, byte[] data, long tag)
        {
            String msg = null;
            try
            {
                msg = Encoding.UTF8.GetString(data);

            #if IS_MULTITHREADED
                object[] args = { };
                this.BeginInvoke(new LogMessageDelegate(LogMessage), msg, args);
            #else
                LogMessage(msg);
            #endif
            }
            catch(Exception e)
            {
            #if IS_MULTITHREADED
                object[] args = { e };
                this.BeginInvoke(new LogMessageDelegate(LogError), "Error converting received data into UTF-8 String: {0}", args);
            #else
                LogError("Error converting received data into UTF-8 String: {0}", e);
            #endif
            }

            // Even if we were unable to write the incoming data to the log,
            // we're still going to echo it back to the client.
            sender.Write(data, -1, 0);
        }
Example #2
0
        private void asyncSocket_DidClose(AsyncSocket sender)
        {
            LogInfo("Disconnected from host");

            asyncSocket = null;
            CreateAndSetupAsyncSocket();

            fetchButton.Enabled = true;
            sslCheckBox.Enabled = true;
        }
Example #3
0
 private void asyncSocket_DidClose(AsyncSocket sender)
 {
     #if IS_MULTITHREADED
     lock (connectedSockets)
     {
         connectedSockets.Remove(sender);
     }
     #else
     connectedSockets.Remove(sender);
     #endif
 }
        public Client(AsyncSocket sock)
        {
            socket = sock;
            socket.DidRead += new AsyncSocket.SocketDidRead(asyncSocket_DidRead);
            socket.DidWrite += new AsyncSocket.SocketDidWrite(asyncSocket_DidWrite);
            socket.WillClose += new AsyncSocket.SocketWillClose(asyncSocket_WillClose);
            socket.DidClose += new AsyncSocket.SocketDidClose(asyncSocket_DidClose);

            socket.Read(Client.Terminator, 120 * 1000, 1);

            sessionID = DateTime.Now.Ticks;
            uuid = null;
        }
Example #5
0
        public Form1()
        {
            InitializeComponent();

            // Create a new instance of Deusty.Net.AsyncSocket
            listenSocket = new AsyncSocket();

            #if IS_MULTITHREADED
            // Tell AsyncSocket to allow multi-threaded delegate methods
            // Note: Accepted sockets will automatically inherit this setting as well
            listenSocket.AllowMultithreadedCallbacks = true;
            #else
            // Tell AsyncSocket to invoke its delegate methods on our form thread
            // Note: Accepted sockets will automatically inherit this setting as well
            listenSocket.SynchronizingObject = this;
            #endif

            // Register for the events we're interested in
            listenSocket.DidAccept += new AsyncSocket.SocketDidAccept(listenSocket_DidAccept);

            // Initialize list to hold connected sockets
            // We support multiple concurrent connections
            connectedSockets = new List<AsyncSocket>();
        }
 public void StopSocket()
 {
     listenSocket.Close();
     listenSocket = null;
 }
Example #7
0
 bool socket_WillConnect(AsyncSocket sender, System.Net.Sockets.Socket socket)
 {
     return true;
 }
Example #8
0
 void socket_DidWrite(AsyncSocket sender, long tag)
 {
 }
Example #9
0
        /// <summary>
        /// We have a socket connection
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="address"></param>
        /// <param name="port"></param>
        void socket_DidConnect(AsyncSocket sender, System.Net.IPAddress address, ushort port)
        {
            if (autologinKey == null)
            {
                Log("Authenticating with server", "Connected, waiting for welcome message", "Authenticating ...");
            }
            else
            {
                Log("Reconnected to server", "Reconnected with autologin key", "Connected");
            }

            socket.Read(AsyncSocket.CRLFData, -1, 0);
        }
Example #10
0
        /// <summary>
        /// Connect with manually entered info
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonConnect_Click(object sender, EventArgs e)
        {
            if (socket != null)
            {
                socket.Close();
                socket = null;
            }

            Log("Connecting ...", null, "Connecting to server");

            socket = new AsyncSocket();
            socket.WillConnect += new AsyncSocket.SocketWillConnect(socket_WillConnect);
            socket.DidConnect += new AsyncSocket.SocketDidConnect(socket_DidConnect);
            socket.WillClose += new AsyncSocket.SocketWillClose(socket_WillClose);
            socket.DidClose += new AsyncSocket.SocketDidClose(socket_DidClose);
            socket.DidRead += new AsyncSocket.SocketDidRead(socket_DidRead);
            socket.DidWrite += new AsyncSocket.SocketDidWrite(socket_DidWrite);

            ushort thePort;
            bool isValidPort = ushort.TryParse(textBoxPort.Text, out thePort);

            if (!isValidPort || !socket.Connect(textBoxAddress.Text, thePort))
            {
                Log(null, "Could not connect to server: AsyncSocket connect failed", "Could not connect to server");
                MessageBox.Show("Could not connect to server", "Error");
            }
        }
Example #11
0
        /// <summary>
        /// Send a message string
        /// </summary>
        /// <param name="message"></param>
        /// <param name="client"></param>
        public void SendCommand(String message, AsyncSocket client)
        {
            if (message == null)
            {
                logWindow.Log = "SendMessage failed: Message string is null";
                return;
            }

            if (client == null)
            {
                Log(null, "SendMessage aborted: Not connected", "Please connect first!");
                return;
            }

            logWindow.Log = "Sending command: " + message;
            byte[] data = Encoding.UTF8.GetBytes(message + "\r\n");
            client.Write(data, -1, 0);
        }
        /// <summary>
        /// Handle the facade message
        /// </summary>
        /// <param name="message">Message sent from client</param>
        /// <param name="server">Instance of the socket server</param>
        /// <param name="client">Socket that sent the message (for return messages)</param>
        internal static void HandleFacadeMessage(Newtonsoft.Json.Linq.JObject message, SocketServer server, AsyncSocket client)
        {
            String action = (string)message["FacadeAction"];
            GUIWindow currentPlugin = GUIWindowManager.GetWindow(GUIWindowManager.ActiveWindow);

            if (action.Equals("get"))
            {
                MessageFacade returnMessage = new MessageFacade();
                if (currentPlugin.GetType() == typeof(GUIHome))
                {
                    GUIMenuControl menu = (GUIMenuControl)currentPlugin.GetControl(50);
                    List<FacadeItem> items = MpFacadeHelper.GetHomeItems(menu);
                    returnMessage.FacadeItems = items;
                    returnMessage.ViewType = "Home";
                }
                else
                {
                    GUIFacadeControl facade = (GUIFacadeControl)currentPlugin.GetControl(50);
                    if (facade != null)
                    {
                        List<FacadeItem> items = MpFacadeHelper.GetFacadeItems(currentPlugin.GetID, 50);
                        returnMessage.ViewType = facade.CurrentLayout.ToString();
                        returnMessage.FacadeItems = items;
                    }
                }

                returnMessage.WindowId = currentPlugin.GetID;
                server.SendMessageToClient(returnMessage, client);
            }
            else if (action.Equals("setselected"))
            {
                if (currentPlugin.GetType() == typeof(GUIHome))
                {

                }
                else
                {
                    GUIFacadeControl facade = (GUIFacadeControl)currentPlugin.GetControl(50);
                    int selected = (int)message["SelectedIndex"];
                    facade.SelectedListItemIndex = selected;
                }
            }
            else if (action.Equals("getselected"))
            {
                if (currentPlugin.GetType() == typeof(GUIHome))
                {
                    //TODO: find a way to retrieve the currently selected home button
                }
                else
                {
                    GUIFacadeControl facade = (GUIFacadeControl)currentPlugin.GetControl(50);
                    int selected = facade.SelectedListItemIndex;
                }
            }
            else if (action.Equals("getcount"))
            {
                if (currentPlugin.GetType() == typeof(GUIHome))
                {
                    GUIMenuControl menu = (GUIMenuControl)currentPlugin.GetControl(50);
                    int count = menu.ButtonInfos.Count;
                }
                else
                {
                    GUIFacadeControl facade = (GUIFacadeControl)currentPlugin.GetControl(50);
                    int count = facade.Count;
                }
            }
            else if (action.Equals("select"))
            {
                int selected = (int)message["SelectedIndex"];
                if (currentPlugin.GetType() == typeof(GUIHome))
                {
                    GUIMenuControl menu = (GUIMenuControl)currentPlugin.GetControl(50);
                    MenuButtonInfo info = menu.ButtonInfos[selected];
                    GUIMessage msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_GOTO_WINDOW, 0, 0, 0, info.PluginID, 0, null);
                    GUIWindowManager.SendThreadMessage(msg);
                }
                else
                {
                    GUIFacadeControl facade = (GUIFacadeControl)currentPlugin.GetControl(50);
                    //TODO: is there a better way to select a list item

                    facade.SelectedListItemIndex = selected;
                    new Communication().SendCommand("ok");
                }
            }
            else if (action.Equals("context"))
            {
                int selected = (int)message["SelectedIndex"];
                if (currentPlugin.GetType() == typeof(GUIHome))
                {
                    GUIMenuControl menu = (GUIMenuControl)currentPlugin.GetControl(50);
                    MenuButtonInfo info = menu.ButtonInfos[selected];
                    GUIMessage msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_GOTO_WINDOW, 0, 0, 0, info.PluginID, 0, null);
                    GUIWindowManager.SendThreadMessage(msg);
                }
                else
                {
                    GUIFacadeControl facade = (GUIFacadeControl)currentPlugin.GetControl(50);
                    //TODO: is there a better way to select a list item

                    facade.SelectedListItemIndex = selected;
                    new Communication().SendCommand("info");
                }
            }
        }
        /// <summary>
        /// Handle the dialog action
        /// </summary>
        /// <param name="message">Message from Client</param>
        internal static void HandleDialogAction(Newtonsoft.Json.Linq.JObject message, SocketServer server, AsyncSocket client)
        {
            String action = (string)message["ActionType"];
            int dialogId = (int)message["DialogId"];
            int index = (int)message["Index"];

            if (action.Equals("get"))
            {
                if (MpDialogsHelper.IsDialogShown)
                {
                    MessageDialog msg = MpDialogsHelper.GetDialogMessage(MpDialogsHelper.CurrentDialog);
                    server.SendMessageToClient(msg, client);
                }
                else
                {
                    MessageDialog msg = new MessageDialog();
                    msg.DialogShown = false;
                    server.SendMessageToClient(msg, client);
                }
            }
            else
            {
                if (dialogId == (int)GUIWindow.Window.WINDOW_DIALOG_MENU)
                {
                    MpDialogMenu diag = MpDialogsHelper.GetDialogMenu();
                    diag.HandleAction(action, index);
                }
                else if (dialogId == (int)GUIWindow.Window.WINDOW_DIALOG_OK)
                {
                    MpDialogOk diag = MpDialogsHelper.GetDialogOk();
                    diag.HandleAction(action, index);
                }
                else if (dialogId == (int)GUIWindow.Window.WINDOW_DIALOG_YES_NO)
                {
                    MpDialogYesNo diag = MpDialogsHelper.GetDialogYesNo();
                    diag.HandleAction(action, index);
                }
                else if (dialogId == (int)GUIWindow.Window.WINDOW_DIALOG_NOTIFY)
                {
                    MpDialogNotify diag = MpDialogsHelper.GetDialogNotify();
                    diag.HandleAction(action, index);
                }
                else if (dialogId == (int)GUIWindow.Window.WINDOW_DIALOG_PROGRESS)
                {
                    MpDialogProgress diag = MpDialogsHelper.GetDialogProgress();
                    diag.HandleAction(action, index);
                }
                else if (dialogId == (int)GUIWindow.Window.WINDOW_DIALOG_RATING)
                {
                    MpDialogRating diag = MpDialogsHelper.GetDialogRating();
                    diag.HandleAction(action, index);
                }
                else if (dialogId == MpDialogsHelper.TVSERIES_RATING_ID)
                {
                    if (WifiRemote.IsAvailableTVSeries)
                    {
                        MpDialogTvSeriesRating diag = MpDialogsHelper.GetDialogMpTvSeriesRating();
                        diag.HandleAction(action, index);
                    }
                }
                else if (dialogId == MpDialogsHelper.TVSERIES_PIN_ID)
                {
                    if (WifiRemote.IsAvailableTVSeries)
                    {
                        MpDialogTvSeriesPin diag = MpDialogsHelper.GetDialogMpTvSeriesPin();
                        diag.HandleAction(action, index);
                    }
                }
                else if (dialogId == MpDialogsHelper.MOPI_RATING_ID)
                {
                    if (WifiRemote.IsAvailableMovingPictures)
                    {
                        MpDialogMovingPicturesRating diag = MpDialogsHelper.GetDialogMovingPicturesRating();
                        diag.HandleAction(action, index);
                    }
                }
                else if (dialogId == MpDialogsHelper.MOPI_PIN_ID)
                {
                    if (WifiRemote.IsAvailableMovingPictures)
                    {
                        MpDialogMovingPicturesPin diag = MpDialogsHelper.GetDialogMovingPicturesPin();
                        diag.HandleAction(action, index);
                    }
                }
            }
        }
Example #14
0
        private void asyncSocket_DidConnect(AsyncSocket sender, System.Net.IPAddress address, ushort port)
        {
            LogInfo("Connected to {0}:{1}", address, port);

            // The TCP handshake is now complete, meaning we're connected to the remote host.

            if (sslCheckBox.Checked)
            {
                // We want to create a secure SSL/TLS connection.
                // So we need to start the TLS handshake.

                // The StartTLSAsClient method takes 3 parameters.
                // The first is mandatory, the second two are optional.
                // Param 1: The expected server name on the remote certificate.
                // Param 2: Callback to allow you to explicityly check the remote certificate for validation purposes.
                // Param 3: Callback to allow you to choose your own local certificate.

                // The deusty certificate is a self-signed certificate.
                // Self-signed certificates are obviously rejected by default.
                // So we setup a callback in order to accept it.

                RemoteCertificateValidationCallback rcvc =
                    new RemoteCertificateValidationCallback(asyncSocket_RemoteCertificateValidationCallback);

                asyncSocket.StartTLSAsClient(FETCH_SSL_NAME, rcvc, null);
            }
            else
            {
                // Not using TLS, so immediatley send the http request
                SendRequest();
            }
        }
Example #15
0
        private void CreateAndSetupAsyncSocket()
        {
            // Create a new instance of Deusty.Net.AsyncSocket
            asyncSocket = new AsyncSocket();

            // Tell AsyncSocket to invoke its delegate methods on our form thread
            asyncSocket.SynchronizingObject = this;

            // Register for the events we're interested in
            asyncSocket.DidConnect += new AsyncSocket.SocketDidConnect(asyncSocket_DidConnect);
            asyncSocket.DidSecure += new AsyncSocket.SocketDidSecure(asyncSocket_DidSecure);
            asyncSocket.DidWrite += new AsyncSocket.SocketDidWrite(asyncSocket_DidWrite);
            asyncSocket.DidRead += new AsyncSocket.SocketDidRead(asyncSocket_DidRead);
            asyncSocket.DidReadPartial += new AsyncSocket.SocketDidReadPartial(asyncSocket_DidReadPartial);
            asyncSocket.WillClose += new AsyncSocket.SocketWillClose(asyncSocket_WillClose);
            asyncSocket.DidClose += new AsyncSocket.SocketDidClose(asyncSocket_DidClose);
        }
Example #16
0
        private void socket_DidRead(AsyncSocket sender, byte[] data, long tag)
        {
            try
            {
                string msg = Encoding.UTF8.GetString(data);
                // Get json object
                JObject message = JObject.Parse(msg);
                string type = (string)message["Type"];
                if (type != null)
                {
                    switch (type)
                    {
                        // {"Type":"welcome","Server_Version":4,"AuthMethod":0}
                        case "welcome":
                            HandleWelcomeMessage(msg);
                            break;

                        // {"Type":"authenticationresponse","Success":true,"ErrorMessage":null}
                        case "authenticationresponse":
                            HandleAuthenticationResponse(msg);
                            break;
                        case "dialogResult":
                            HandleDialogResult(msg);
                            break;
                        case "dialog":
                            HandleDialogMessage(msg);
                            break;
                    }
                }
            }
            catch (Exception e)
            {
                Log.Error("WifiRemoteClient: Communication error", e);
            }

            // Continue listening
            sender.Read(AsyncSocket.CRLFData, -1, 0);
        }
Example #17
0
        /// <summary>
        /// Send a message object
        /// </summary>
        /// <param name="message"></param>
        /// <param name="client"></param>
        public void SendCommand(IMessage message, AsyncSocket client)
        {
            if (message == null)
            {
                logWindow.Log = "SendMessage failed: IMessage object is null";
                return;
            }

            if (autologinKey != null)
            {
                message.AutologinKey = autologinKey;
            }

            string messageString = JsonConvert.SerializeObject(message);
            SendCommand(messageString, client);
        }
        /// <summary>
        /// Allows invoke options to be inherited from another AsyncSocket.
        /// This is usefull when accepting connections.
        /// </summary>
        /// <param name="fromSocket">
        ///		AsyncSocket object to copy invoke options from.
        ///	</param>
        protected void InheritInvokeOptions(AsyncSocket fromSocket)
        {
            // We set the MultiThreadedCallback property first,
            // as it has the potential to affect the other properties.
            AllowMultithreadedCallbacks = fromSocket.AllowMultithreadedCallbacks;

            AllowApplicationForms = fromSocket.AllowApplicationForms;
            SynchronizingObject = fromSocket.SynchronizingObject;
        }
Example #19
0
        /// <summary>
        /// Connect to server selected in autodetect list
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonConnectDetected_Click(object sender, EventArgs e)
        {
            if (servers.Count <= 0 || listBoxServers.SelectedItem == null)
            {
                return;
            }

            if (socket != null)
            {
                socket.Close();
                socket = null;
            }

            Log("Connecting ...", null, "Connecting to server");

            socket = new AsyncSocket();
            socket.WillConnect += new AsyncSocket.SocketWillConnect(socket_WillConnect);
            socket.DidConnect += new AsyncSocket.SocketDidConnect(socket_DidConnect);
            socket.WillClose += new AsyncSocket.SocketWillClose(socket_WillClose);
            socket.DidClose += new AsyncSocket.SocketDidClose(socket_DidClose);
            socket.DidRead += new AsyncSocket.SocketDidRead(socket_DidRead);
            socket.DidWrite += new AsyncSocket.SocketDidWrite(socket_DidWrite);

            if (!socket.Connect(((NetService)listBoxServers.SelectedItem).HostName, (ushort)((NetService)listBoxServers.SelectedItem).Port))
            {
                Log(null, "Could not connect to server: AsyncSocket connect failed", "Could not connect to server");
                MessageBox.Show("Could not connect to server", "Error");
            }
        }
        // What is going on with the event handler methods below?
        //
        // The asynchronous nature of this class means that we're very multithreaded.
        // But the client may not be. The client may be using a SynchronizingObject,
        // or has requested we use application forms for invoking.
        //
        // A problem arises from this situation:
        // If a client calls the Disconnect method, then he/she does NOT
        // expect to receive any other delegate methods after the
        // call to Diconnect completes.
        //
        // Primitive invoking from a background thread will not solve this problem.
        // So what we do instead is invoke into the same thread as the client,
        // then check to make sure the socket hasn't been closed,
        // and then execute the delegate method.
        protected virtual void OnSocketDidAccept(AsyncSocket newSocket)
        {
            // SYNCHRONOUS
            // This allows the newly accepted socket to register to receive the DidConnect event.

            if (DidAccept != null)
            {
                if (synchronizingObject != null)
                {
                    object[] args = { newSocket };
                    synchronizingObject.Invoke(new DoDidAcceptDelegate(DoDidAccept), args);
                }
                else if (allowApplicationForms)
                {
                    System.Windows.Forms.Form appForm = GetApplicationForm();
                    if (appForm != null)
                    {
                        appForm.Invoke(new DoDidAcceptDelegate(DoDidAccept), newSocket);
                    }
                }
                else if (allowMultithreadedCallbacks)
                {
                    object[] delPlusArgs = { DidAccept, this, newSocket };
                    eventQueue.Enqueue(delPlusArgs);
                    ProcessEvent();
                }
            }
        }
Example #21
0
 void socket_DidClose(AsyncSocket sender)
 {
     labelDetail.Text = "";
     Log("", "Disconnected", "Disconnected");
 }
        private void DoDidAccept(AsyncSocket newSocket)
        {
            // Threading Notes:
            // This method is called when using a SynchronizingObject or AppForms,
            // so method is executed on the same thread that the delegate is using.
            // Thus, the kClosed flag prevents any callbacks after the delegate calls the close method.

            if ((flags & kClosed) != 0) return;

            try
            {
                if (DidAccept != null)
                {
                    DidAccept(this, newSocket);
                }
            }
            catch { }
        }
Example #23
0
        void socket_DidRead(AsyncSocket sender, byte[] data, long tag)
        {
            String msg = null;

            try
            {
                msg = Encoding.UTF8.GetString(data);
                logWindow.Log = "Received message: " + msg;
                this.Focus();

                // Get json object
                JObject message = JObject.Parse(msg);
                string type = (string)message["Type"];

                if (type != null)
                {
                    // {"Type":"welcome","Server_Version":4,"AuthMethod":0}
                    switch (type)
                    {
                        case "welcome":
                            handleWelcomeMessage((int)message["Server_Version"], (int)message["AuthMethod"]);
                            break;

                        // {"Type":"authenticationresponse","Success":true,"ErrorMessage":null}
                        case "authenticationresponse":
                            // handleAuthenticationResponse((bool)message["Success"], (String)message["ErrorMessage"]);
                            handleAuthenticationResponse((bool)message["Success"], (String)message["ErrorMessage"], (string)message["AutologinKey"]);
                            break;

                        // {"Type":"status","IsPlaying":false,"IsPaused":false,"Title":"","CurrentModule":"Startbildschirm","SelectedItem":""}
                        case "status":
                            handleStatus((bool)message["IsPlaying"], (bool)message["IsPaused"], (string)message["Title"], (string)message["CurrentModule"], (string)message["SelectedItem"]);
                            break;

                        // {"Type":"volume","Volume":37,"IsMuted":false}
                        case "volume":
                            handleVolumeChange((int)message["Volume"], (bool)message["IsMuted"]);
                            break;
                    }
                }
            }
            catch (Exception e)
            {
                Log(null, "Communication Error: " + e.Message, null);
            }

            // Continue listening
            sender.Read(AsyncSocket.CRLFData, -1, 0);
        }
        /// <summary>
        /// Description forthcoming
        /// </summary>
        /// <param name="iar"></param>
        private void socket_DidAccept(IAsyncResult iar)
        {
            lock (lockObj)
            {
                if ((flags & kClosed) > 0) return;

                try
                {
                    Socket socket = (Socket)iar.AsyncState;

                    Socket newSocket = socket.EndAccept(iar);
                    AsyncSocket newAsyncSocket = new AsyncSocket();

                    newAsyncSocket.InheritInvokeOptions(this);
                    newAsyncSocket.PreConfigure(newSocket);

                    OnSocketDidAccept(newAsyncSocket);

                    newAsyncSocket.PostConfigure();

                    // And listen for more connections
                    socket.BeginAccept(new AsyncCallback(socket_DidAccept), socket);
                }
                catch (Exception e)
                {
                    CloseWithException(e);
                }
            }
        }
Example #25
0
 void socket_WillClose(AsyncSocket sender, Exception e)
 {
 }
Example #26
0
        /// <summary>
        /// Connect with manually entered info
        /// </summary>
        public void Connect()
        {
            if (socket != null)
            {
                socket.Close();
                socket = null;
            }

            Connected = false;
            ConnectionFailed = false;
            Authenticated = false;
            AuthenticationFailed = false;

            Log.Info("Setting up WifiRemote connection to {0}:{1}", Address, Port);

            socket = new AsyncSocket();
            socket.DidConnect += new AsyncSocket.SocketDidConnect(socket_DidConnect);
            socket.DidRead += new AsyncSocket.SocketDidRead(socket_DidRead);
            socket.AllowMultithreadedCallbacks = true;
            if (!socket.Connect(Address, 8017))
            {
                Log.Warn("WifiRemoteClient: Could not connect to server, AsyncSocket connect failed");
                ConnectionFailed = true;
            }
        }
        public void StartSocket()
        {
            listenSocket = new AsyncSocket();
            listenSocket.AllowMultithreadedCallbacks = true;
            listenSocket.DidAccept += new AsyncSocket.SocketDidAccept(listenSocket_DidAccept);
            Exception error;
            if (!listenSocket.Accept(ushort.Parse(Preferences.Instance.Value("port")), out error))
            {
                Logger.Instance.eventLog.WriteEntry(String.Format("Error starting server: {0}", error), EventLogEntryType.Information);
                return;
            }

            PublishBonjour();
        }
Example #28
0
        public void Disconnect()
        {
            Connected = false;
            Authenticated = false;

            if (socket != null)
            {
                socket.Close();
                socket = null;
            }
        }
 private void listenSocket_DidAccept(AsyncSocket sender, AsyncSocket newSocket)
 {
     Client client = new Client(newSocket);
     Clients.Instance.AddClient(client);
 }
Example #30
0
        /// <summary>
        /// We have a socket connection
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="address"></param>
        /// <param name="port"></param>
        private void socket_DidConnect(AsyncSocket sender, IPAddress address, ushort port)
        {
            Connected = true;
            ConnectionFailed = false;

            if (autologinKey == null)
            {
                Log.Debug("WifiRemoteClient: Authenticating with server, waiting for welcome message...");
            }
            else
            {
                Log.Debug("WifiRemoteClient: Reconnected to server with autologin key");
            }

            socket.Read(AsyncSocket.CRLFData, -1, 0);
        }