编辑
我知道了问题所在,但是现在我又遇到了另一个问题。我想从另一台PC远程控制1台PC,该部分可以工作,但是您必须向前端口进行端口移植。是否可以像TeamViewer一样进行连接?因此,我绕过防火墙并且不必端口转发吗?如果是,怎么办?如果有人可以帮助我,那就太好了:)

  • 布拉姆

  • 原始帖子

    我编写了一个代码,以便您可以从另一台计算机控制一台计算机。唯一的问题是它不适用于您自己网络之外的计算机(也许我连接了错误的IP?我尝试了该家伙的IPv4和WhatIsMyIP的IP)。我该如何在我的网络之外进行这项工作?

    这是服务器类(我删除了很多代码,因为它没有意义)
        public partial class Form1 : Form
        {
            [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
            public static extern void mouse_event(long dwFlags, long dx, long dy, long cButtons, long dwExtraInfo);
    
            private const int MOUSE_LEFTDOWN = 0x02;
            private const int MOUSE_LEFTUP = 0x04;
            private const int MOUSE_RIGTDOWN = 0x08;
            private const int MOUSE_RIGHTUP = 0x10;
    
            private TcpListener listener;
            private Socket mainSocket;
            private int port;
            private Stream s;
            private Thread eventWatcher;
            private int imageDelay;
            string connString;
            string connToString;
            string db;
            MySqlCommand command;
            MySqlCommand command2;
            MySqlCommand command3;
            MySqlCommand command4;
    
            MySqlConnection connection = null;
    
            public Form1()
            {
                InitializeComponent();
                port = 1338;
                imageDelay = 1000;
            }
            public Form1(int p)
            {
                port = p;
                imageDelay = 1000;
                InitializeComponent();
            }
    
            private void Form1_Load(object sender, EventArgs e)
            {
                MessageBox.Show(getIP());
                startConnection();
    
                command = connection.CreateCommand();
                command2 = connection.CreateCommand();
                command3 = connection.CreateCommand();
                command4 = connection.CreateCommand();
                MessageBox.Show(connString);
                MessageBox.Show(db);
    
                this.Hide();
                port = 1338;
                while (true)
                {
                    try
                    {
                        startListening();
                    }
                    catch (Exception)
                    {
                    }
                }
            }
    
            public void startListening()
            {
                try
                {
                    listener = new TcpListener(port);
                    listener.Start();
                    mainSocket = listener.AcceptSocket();
                    s = new NetworkStream(mainSocket);
                    eventWatcher = new Thread(new ThreadStart(waitForKeys));
                    eventWatcher.Start();
                    while (true)
                    {
                        Bitmap screeny = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, PixelFormat.Format32bppArgb);
                        Graphics theShot = Graphics.FromImage(screeny);
                        theShot.ScaleTransform(.25F, .25F);
                        theShot.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, 0, 0, Screen.PrimaryScreen.Bounds.Size, CopyPixelOperation.SourceCopy);
                        BinaryFormatter bFormat = new BinaryFormatter();
                        bFormat.Serialize(s, screeny);
                        Thread.Sleep(imageDelay);
                        theShot.Dispose();
                        screeny.Dispose();
                    }
                }
                catch (Exception)
                {
                    if (mainSocket.IsBound)
                        mainSocket.Close();
                    if (listener != null)
                        listener.Stop();
                }
            }
    
            private static void trigger(IAsyncResult i) { }
    

    和客户端代码(再次,删除了很多):
        public class StateObject
        {
            public Socket workSocket = null;
            public const int BufferSize = 256;
            public byte[] buffer = new byte[BufferSize];
            public StringBuilder sb = new StringBuilder();
        }
    
        public partial class Form2 : Form
        {
            private static string response;
    
            private Stream stream;
            private StreamWriter eventSender;
            private Thread theThread;
            private TcpClient client;
            private Form1 mForm;
            private int resolutionX;
            private int resolutionY;
            //private int sendDelay = 250;
            //private Thread delayThread;
            public bool sendKeysAndMouse = false;
    
            private static ManualResetEvent sendDone = new ManualResetEvent(false);
            private static ManualResetEvent receiveDone = new ManualResetEvent(false);
    
            public Form2()
            {
                InitializeComponent();
            }
            public Form2(TcpClient s, Form1 callingForm)
            {
                client = s;
                mForm = callingForm;
                InitializeComponent();
                theThread = new Thread(new ThreadStart(startRead));
                theThread.Start();
            }
    
            private void Form2_FormClosed(object sender, FormClosedEventArgs e)
            {
                if (theThread.IsAlive)
                    theThread.Abort();
                mForm.form2Closed();
            }
            private void startRead()
            {
                try
                {
                    stream = client.GetStream();
                    eventSender = new StreamWriter(stream);
                    while (true)
                    {
                        BinaryFormatter bFormat = new BinaryFormatter();
                        Bitmap inImage = bFormat.Deserialize(stream) as Bitmap;
                        resolutionX = inImage.Width;
                        resolutionY = inImage.Height;
                        theImage.Image = (Image)inImage;
                    }
                }
                catch (Exception) { }
                /*try
                {
                    Image theDesktop;
                    stream = client.GetStream();
                    theDesktop.Save(stream,new ImageFormat(
                    while (true)
                    {
                        while (stream.Read(buffer, 0, 1024) > 0)
                            theDesktop.Read(buffer, 0, 1024);
                        if(theDesktop != null) {
                            theDesktop.
                            theImage.Image = temp;
                    }
                }
                catch (Exception gay) { }*/
            }
    
            private void Form2_ResizeEnd(object sender, EventArgs e)
            {
    
            }
    
            private void Form2_Load(object sender, EventArgs e)
            {
    
            }
    
    
            private void Form2_MouseMove(object sender, MouseEventArgs e)
            {
            }
    
    
            private void theImage_MouseClick(object sender, MouseEventArgs e)
            {
                if (!sendKeysAndMouse)
                    return;
                eventSender.Write("LCLICK\n");
                eventSender.Flush();
            }
    
            private void theImage_MouseDown(object sender, MouseEventArgs e)
            {
                if (!sendKeysAndMouse)
                    return;
                eventSender.Write("LDOWN\n");
                eventSender.Flush();
            }
    
            private void theImage_MouseUp(object sender, MouseEventArgs e)
            {
                if (!sendKeysAndMouse)
                    return;
                eventSender.Write("LUP\n");
                eventSender.Flush();
            }
    
            private void Receive(Socket client)
            {
                try
                {
                    StateObject state = new StateObject();
                    state.workSocket = client;
    
                    client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
            }
    
            private void Send(Socket client, String data)
            {
                byte[] byteData = Encoding.ASCII.GetBytes(data);
    
                client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client);
            }
    
            private void ReceiveCallback(IAsyncResult ar)
            {
                try
                {
                    StateObject state = (StateObject)ar.AsyncState;
                    Socket client = state.workSocket;
    
                    int bytesRead = client.EndReceive(ar);
    
                    if (bytesRead > 0)
                    {
                        state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
    
                        client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
                    }
                    else
                    {
                        if (state.sb.Length > 1)
                        {
                            response = state.sb.ToString();
                        }
                        receiveDone.Set();
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
            }
    
            private void SendCallback(IAsyncResult ar)
            {
                try
                {
                    Socket client = (Socket)ar.AsyncState;
    
                    int bytesSent = client.EndSend(ar);
                    Console.WriteLine("Sent {0} bytes to server.", bytesSent);
    
                    sendDone.Set();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
            }
        }
    }
    

    我希望有人可以帮助我,或者向我解释我做错了什么以及如何使它起作用。

    最佳答案

    Team Viewer进行此操作的方式是在交互中使用第三台计算机。 Team Viewer在Internet上有一个公共(public)服务器,您和您要连接的人都可以与之交谈,而它所做的只是充当将传入消息从一端传递到另一端的桥梁。现在,两端都具有出站连接,并且不需要端口转发。

    要对您的系统执行相同的操作,您需要在Internet上设置,托管(付费)并维护一个公用服务器,程序的所有用户都将与该公用服务器通信并充当通信的桥梁。

    步骤如下:

  • Computer1打开与Server1的出站连接并保持打开状态,现在他们可以在不进行端口托管的情况下来回通信。
  • Computer2打开与Server1的出站连接并保持打开状态,现在他们可以在不进行端口转发的情况下来回通信。
  • Computer1向Server1发送一条消息,内容为“将以下内容转发给Computer2”
  • Server1使用Computer2启动的步骤2中的打开连接来转发消息。
  • 当Computer2要回复时,它向Server1发送一条消息,内容为“将以下内容转发给Computer1”
  • Server1使用Computer1发起的步骤1中的打开连接来转发消息。
  • 关于c# - C#-无需端口转发即可远程控制PC(例如TeamViewer),我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/25792683/

    10-13 01:22