Beispiel #1
0
      /// <summary>
      /// Saves the given Server information into a bookmark file in the
      /// currently configured bookmark directory.
      /// </summary>
      /// <param name="server">The Server object to save.</param>
      /// <returns>Status result code.</returns>
      public static Status AddBookmark(Server server)
      {
         if (server == null)
            return Status.GetFailure("Internal error (null server object provided)");

         string fullPath = null;
         try
         {
            s_log.InfoFormat("Saving bookmark for server '{0}'", server.ServerName);

            string filename = server.ServerName + s_bookmarkExtension;
            fullPath = Path.Combine(GetBookmarkDirectory(), filename);
            if (File.Exists(fullPath))
            {
               s_log.WarnFormat("Bookmark already exists: {0}", fullPath);
               return Status.GetFailure("A bookmark with that name already exists.");
            }
            CustomSerialize(server, fullPath);
            return Status.Success;
         }
         catch (Exception e)
         {
            s_log.ErrorFormat("Error saving bookmark: {0}", e.Message);
            try { File.Delete(fullPath); }
            catch { }
            return Status.GetFailure(String.Format("Error while saving bookmark: {0}", e.Message));
         }
      }
      public Status Connect(Server server)
      {
         if (server == null)
            return Status.Failure;

         // If connected to another server, disconnect first.
         if (m_server != null)
            m_server.Disconnect();

         // If we're connecting to a new server, set up the delegates.
         // This is typically only the same server during the "auto-reconnect" cycle.
         if (m_server != server)
         {
            m_server = server;

            // Set up the event delegates for this Server connection.
            m_server.ProgressUpdated += HandleProgressUpdated;
            m_server.Connected += HandleConnected;
            m_server.Disconnected += HandleDisconnected;
            m_server.ChatReceived += HandleChatReceived;
            m_server.UserListUpdate += HandleUserListUpdate;
            m_server.PmReceived += HandlePmReceived;
            m_server.UserInfoReceived += HandleUserInfoReceived;
         }

         // Initiate server connection.
         if (m_server.Connect() == Status.Failure)
         {
            string message = String.Format("Connecting to {0} failed.", m_server.Address);
            s_log.ErrorFormat(message);
            LocalChatMessage(message);
            m_server = null;
            return Status.Failure;
         }

         // Print a message indicating successful connection.
         LocalChatMessage(String.Format("Connected to '{0}'", m_server.ServerName));

         // Send initial transactions.
         Login login = new Login(m_server.LoginName,
                                 m_server.Password,
                                 m_server.Nick,
                                 m_server.Icon);
         if (m_server.SendTransaction(login) == Status.Failure)
         {
            string message = String.Format("Sending login to server failed.");
            s_log.ErrorFormat(message);
            LocalChatMessage(message);
            m_server = null;
            return Status.Failure;
         }

         // Store initial user settings.
         m_localUser = new User();
         m_localUser.Username = m_server.Nick;
         m_localUser.IconId = m_server.Icon;

         return Status.Success;
      }
Beispiel #3
0
      internal Status Connect(Server target)
      {
         if (target == null)
            return Status.Failure;
         m_server = target;

         try
         {
            // Parse address information from the server target.
            IPAddress ipAddress;
            AddressFamily targetFamily;
            int targetPort;
            if (ParseAddress(target.Address, out ipAddress, out targetFamily, out targetPort) == Status.Failure)
               return Status.Failure;

            // If the socket is already connected, disconnect it.
            if (m_socket != null && m_socket.Connected == true)
               m_socket.Disconnect(true);

            // If the socket has not been created or will be changing address families, create a new socket.
            if (m_socket == null || m_socket.AddressFamily != targetFamily)
            {
               // Release the system resources before we create a new socket.
               if (m_socket != null)
                  m_socket.Close();
               m_socket = new Socket(targetFamily, SocketType.Stream, ProtocolType.Tcp);
            }

            m_socket.Connect(ipAddress, targetPort);
            s_log.InfoFormat("Connected to '{0}' at '{1}' on port {2}", target.ServerName, target.Address, targetPort);

            return Status.Success;
         }
         catch (Exception e)
         {
            s_log.ErrorFormat("Exception opening socket for {0}: {1}", target.ServerName, e.Message);
            m_server = null;
            return Status.Failure;
         }
      }
Beispiel #4
0
      private Status InitiateConnectDelegate(Server server)
      {
         if (server == null)
            return Status.Failure;

         // Update the Chat window state.
         m_chatWindow.SetConnecting(server.ServerName);

         // Connect to the server.
         Status result = m_controller.Connect(server);

         // Hide the progress bar when finished.

         // Reset the window title if connecting failed.
         if (result != Status.Success)
         {
            m_chatWindow.SetConnectFailed();
         }

         return result;
      }
Beispiel #5
0
 internal void InitiateConnect(Server server)
 {
    m_backgroundActions.Add(() => InitiateConnectDelegate(server));
 }
      private Server MakeServerFromControls()
      {
         try
         {
            Server server = new Server();

            server.ServerName = m_serverName.Text;
            server.Address = m_addressText.Text;
            server.Nick = m_nickText.Text;
            server.Icon = 31337;
            server.LoginName = m_usernameText.Text;
            server.Password = m_passwordText.Password;

            return server;
         }
         catch (Exception e)
         {
            s_log.ErrorFormat("Exception setting values from window: {0}", e.Message);
            return null;
         }
      }
 private void ConnectButton_Click(object sender, RoutedEventArgs e)
 {
    // Persist the settings and close the window.
    this.ConfiguredServer = MakeServerFromControls();
    this.Close();
 }
 private void CancelButton_Click(object sender, RoutedEventArgs e)
 {
    this.ConfiguredServer = null;
    this.Close();
 }
      // Even though the FileUtils class can be accessed directly, the View
      // should generally use the Controller class for every operation.

      public Status AddBookmark(Server server)
      {
         return FileUtils.AddBookmark(server);
      }
Beispiel #10
0
 private static Server CustomDeserialize(string fullPath)
 {
    Server server = new Server();
    using (StreamReader sr = new StreamReader(fullPath))
    {
       //TODO: allow the lines in any order
       server.ServerName =      CopyAfterEquals(sr.ReadLine());
       server.Address =         CopyAfterEquals(sr.ReadLine());
       server.LoginName =       CopyAfterEquals(sr.ReadLine());
       server.Password = Decode(CopyAfterEquals(sr.ReadLine()));
       server.Nick =            CopyAfterEquals(sr.ReadLine());
       server.Icon =  int.Parse(CopyAfterEquals(sr.ReadLine()));
    }
    return server;
 }
Beispiel #11
0
      /// <summary>
      /// Uses [Serializable] attribute to serialize via BinaryFormatter.
      /// </summary>
      //private static void BinarySerialize(Server server, string fullPath)
      //{
      //   using (FileStream fs = new FileStream(fullPath, FileMode.Create))
      //   {
      //      BinaryFormatter serializer = new BinaryFormatter();
      //      serializer.Serialize(fs, server);
      //   }
      //}

      /// <summary>
      /// Uses [Serializable] attribute to deserialize via BinaryFormatter.
      /// </summary>
      //private static Server BinaryDeserialize(string fullPath)
      //{
      //   using (FileStream fs = new FileStream(fullPath, FileMode.Open))
      //   {
      //      BinaryFormatter serializer = new BinaryFormatter();
      //      return (Server)serializer.Deserialize(fs);
      //   }
      //}

      //private static void XmlSerialize(Server server, string fullPath)
      //{
      //   using (FileStream fs = new FileStream(fullPath, FileMode.Create))
      //   {
      //      SoapFormatter serializer = new SoapFormatter();
      //      serializer.Serialize(fs, server);
      //   }
      //}

      //private static Server XmlDeserialize(string fullPath)
      //{
      //   using (FileStream fs = new FileStream(fullPath, FileMode.Open))
      //   {
      //      SoapFormatter serializer = new SoapFormatter();
      //      return (Server)serializer.Deserialize(fs);
      //   }
      //}

      private static void CustomSerialize(Server server, string fullPath)
      {
         using (StreamWriter sw = new StreamWriter(fullPath, false))
         {
            //TODO: write generically via reflection
            sw.WriteLine(String.Format("ServerName={0}",        server.ServerName));
            sw.WriteLine(String.Format("Address={0}",           server.Address));
            sw.WriteLine(String.Format("LoginName={0}",         server.LoginName));
            sw.WriteLine(String.Format("Password={0}",   Encode(server.Password)));
            sw.WriteLine(String.Format("Nick={0}",              server.Nick));
            sw.WriteLine(String.Format("Icon={0}",              server.Icon));
         }
      }
Beispiel #12
0
      private Status ConnectToServer(Server server)
      {
         if (server == null)
            return Status.NoResult;

         m_screen.WriteLine("Connecting to: {0}", server.ToString());

         Status result = m_controller.Connect(server);

         if (result == Status.Failure)
            m_screen.WriteLine("Failed to connect");

         return result;
      }
Beispiel #13
0
      private Server ParseServerArguments(string[] args)
      {
         Server server = new Server();

         for (int i = 0; i < 5; i++)
         {
            if (args.Length < i + 1)
               break;

            switch (i)
            {
               case 0:
                  server.Address = args[i];
                  break;
               case 1:
                  server.Nick = args[i];
                  break;
               case 2:
                  server.LoginName = args[i];
                  break;
               case 3:
                  server.Password = args[i];
                  break;
               case 4:
                  int.TryParse(args[i], out server.Icon);
                  break;
            }
         }

         return server;
      }
Beispiel #14
0
      private Status ParseBookmark(string text, out Server bookmark)
      {
         bookmark = null;
         string[] args = text.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

         // There must be at least two parameters.
         if (args.Length < 2)
            return Status.GetFailure("A bookmark name and server address are required to create a bookmark.");

         // The first token is the new bookmark name (server name), then normal server parameters.
         string bookmarkName = args[0];

         // Copy the server parameters to a new array so we can re-use the parsing method.
         string[] serverArgs = new string[args.Length - 1];
         for (int i = 1; i < args.Length; i++)
         {
            serverArgs[i - 1] = args[i];
         }

         // Parse the parameters, and set the bookmark name as the server name.
         bookmark = ParseServerArguments(serverArgs);
         bookmark.ServerName = bookmarkName;
         return Status.Success;
      }