senden und empfangen von Dateien, socket-Programmierung

ich entwickle zwei Anwendung ist eine server-Anwendung und andere für handheld-Gerät
Anwendung beide kommunizieren über eine drahtlose Verbindung.hier ist client-handheld und server
mein computer, auf dem die server-Anwendung läuft. wenn ich das senden von Dateien vom client zum server zu schicken
perfekt ohne Fehler, aber wenn die client-Anforderung für Dateien, die die server erzeugen Fehler
so etwas wie
"Es konnte keine Verbindung hergestellt werden, da der Zielcomputer aktiv verweigert 192.168.1.5:9050"

server-side-code:

    private bool SendData(string StrIP)
    {

        try
        {
            string strmyFile = Directory.GetCurrentDirectory() + "\\" + "XML" + @"\Login.xml";
            char[] delimiter = splitter.ToCharArray();
            split = strmyFile.Split(delimiter);
            int limit = split.Length;
            fName = split[limit - 1].ToString();

            byte[] fileName = Encoding.UTF8.GetBytes(fName); //file name
            byte[] fileData = File.ReadAllBytes(strmyFile); //file
            using (FileStream stream = File.OpenRead(strmyFile))
            {
                fileData = new byte[stream.Length];
                stream.Read(fileData, 0, fileData.Length);
            }

            byte[] fileNameLen = BitConverter.GetBytes(fileName.Length); //lenght of file name
            clientData = new byte[4 + fileName.Length + fileData.Length];

            fileNameLen.CopyTo(clientData, 0);
            fileName.CopyTo(clientData, 4);
            fileData.CopyTo(clientData, 4 + fileName.Length);

            System.Net.IPAddress ipAdd = System.Net.IPAddress.Parse(StrIP);

            try
            {
                Socket clientSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPEndPoint ipEnd = new IPEndPoint(ipAdd, 9050);
                clientSock.Connect(ipEnd); //target machine's ip address and the port number
                clientSock.Send(clientData);
                clientSock.Close();
                ind = 1;

                //Socket Sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                //IPEndPoint ipEnd = new IPEndPoint(ipAdd, 9050);
                //Sock.Bind(ipEnd);//target machine's ip address and the port number
                //Sock.Listen(100);

                //Socket clientSock = Sock.Accept();

                //clientSock.Send(clientData);
                //clientSock.Close();
                //ind = 1;
            }
            catch (Exception ex)
            {

                req = false;
                return false;

            }
            req = true;
        }
        catch (Exception ex)
        {

        }
        return true;
    }


    public class StateObject
    {
        //Client socket.
        public Socket workSocket = null;

        public const int BufferSize = 1024 * 5000;
        //Receive buffer.
        public byte[] buffer = new byte[BufferSize];
    }

    public static ManualResetEvent allDone = new ManualResetEvent(false);

    public void StartListening()
    {


        byte[] bytes = new Byte[1024 * 5000];
        IPEndPoint ipEnd = new IPEndPoint(IPAddress.Any, 9050);
        Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        try
        {
            listener.Bind(ipEnd);
            listener.Listen(100);

            while (true)
            {
                allDone.Reset();
               //string ip = listener.RemoteEndPoint.ToString();
                listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                allDone.WaitOne();

            }
        }
        catch (Exception ex)
        {

        }

    }


    public void AcceptCallback(IAsyncResult ar)
    {

        allDone.Set();


        Socket listener = (Socket)ar.AsyncState;
        Socket handler = listener.EndAccept(ar);

        StateObject state = new StateObject();
        state.workSocket = handler;
        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
        new AsyncCallback(ReadCallback), state);

        flag = 0;

    }

    private bool req = false;
    public void ReadCallback(IAsyncResult ar)
    {
        try
        {

            int fileNameLen = 1;
            String content = String.Empty;
            StateObject state = (StateObject)ar.AsyncState;
            Socket handler = state.workSocket;
            string[] str = new string[2];
            str = handler.RemoteEndPoint.ToString().Split(':');
            string path = Directory.GetCurrentDirectory() + "\\TEST\\" + str[0].ToString();
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
            if (req == false)
            {
                Sender snddata = new Sender();
                snddata.sendme(str[0].ToString());
                SendData(str[0].ToString());
            }

            int bytesRead = handler.EndReceive(ar);

            if (bytesRead > 0)
            {
                    if (flag == 0)
                    {
                        fileNameLen = BitConverter.ToInt32(state.buffer, 0);
                        string fileName = Encoding.UTF8.GetString(state.buffer, 4, fileNameLen);
                        receivedPath = Directory.GetCurrentDirectory() + "\\TEST\\" + str[0].ToString() + @"\" + fileName;
                        flag++;
                    }
                    if (flag >= 1)
                    {
                        BinaryWriter writer = new BinaryWriter(File.Open(receivedPath, FileMode.Append));
                        if (flag == 1)
                        {
                            writer.Write(state.buffer, 4 + fileNameLen, bytesRead - (4 + fileNameLen));
                            flag++;
                        }
                        else
                            writer.Write(state.buffer, 0, bytesRead);
                        writer.Close();
                        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                        new AsyncCallback(ReadCallback), state);
                    }
            }
            else
            {

                Invoke(new MyDelegate(LabelWriter));
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);

        }
    }
public class Sender
{
    public void sendme(string strIP)
    {
        try
        {
           //MessageBox.Show("That program can transfer small file. I've test up to 850kb file");
            IPEndPoint ipEnd = new IPEndPoint(IPAddress.Any, 9050);
            Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
            sock.Bind(ipEnd);
            sock.Listen(100);

            while (true)
            {
                //clientSock is the socket object of client, so we can use it now to transfer data to client
                Socket clientSock = sock.Accept();


                string fileName =  "Login.xml";//"Your File Name";
                string filePath = Directory.GetCurrentDirectory() + "\\" + "XML" + @"\" ;//Your File Path;
                byte[] fileNameByte = Encoding.ASCII.GetBytes(fileName);

                byte[] fileData = File.ReadAllBytes(filePath + fileName);
                byte[] clientData = new byte[4 + fileNameByte.Length + fileData.Length];
                byte[] fileNameLen = BitConverter.GetBytes(fileNameByte.Length);

                fileNameLen.CopyTo(clientData, 0);
                fileNameByte.CopyTo(clientData, 4);
                fileData.CopyTo(clientData, 4 + fileNameByte.Length);


                clientSock.Send(clientData);
               //MessageBox.Show("File:{0} has been sent." + fileName);
            }
            //sock.Shutdown(SocketShutdown.Both);
            //sock.Close();


           //Console.ReadLine();
            //sendme();
        }
        catch (Exception ex)
        {
            MessageBox.Show("File Receiving fail." + ex.Message);
        }
    }
}

client-side-code:

public class StateObject
    {
        //Client socket.
        public Socket workSocket = null;

        public const int BufferSize = 1024;
        //Receive buffer.
        public byte[] buffer = new byte[BufferSize];
    }

    public static ManualResetEvent allDone = new ManualResetEvent(false);

    public void StartListening()
    {
        byte[] bytes = new Byte[1024];
        IPAddress address = IPAddress.Parse(ServerIP);
        IPEndPoint ipEnd = new IPEndPoint(address, 9050);
        Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        try
        {
            listener.Bind(ipEnd);
            listener.Listen(100);

            while (true)
            {
                allDone.Reset();
                //string ip = listener.RemoteEndPoint.ToString();
                listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                allDone.WaitOne();

            }
        }
        catch (Exception ex)
        {
            throw ex;
        }


    }


    public void AcceptCallback(IAsyncResult ar)
    {

        allDone.Set();


        Socket listener = (Socket)ar.AsyncState;
        Socket handler = listener.EndAccept(ar);


        StateObject state = new StateObject();
        state.workSocket = handler;
        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
        new AsyncCallback(ReadCallback), state);
        flag = 0;
    }

    public void ReadCallback(IAsyncResult ar)
    {

        try
        {

            int fileNameLen = 1;
            String content = String.Empty;
            StateObject state = (StateObject)ar.AsyncState;
            Socket handler = state.workSocket;
            //string[] str = new string[2];
            //str = handler.RemoteEndPoint.ToString().Split(':');
            string path = mypath + "@Login.XML";
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }

            int bytesRead = handler.EndReceive(ar);

            if (bytesRead > 0)
            {

                if (flag == 0)
                {
                    fileNameLen = BitConverter.ToInt32(state.buffer, 0);
                    string fileName = Encoding.UTF8.GetString(state.buffer, 4, fileNameLen);
                    receivedPath = mypath + "@Login.XML";
                    flag++;
                }
                if (flag >= 1)
                {
                    BinaryWriter writer = new BinaryWriter(File.Open(receivedPath, FileMode.Append));
                    if (flag == 1)
                    {
                        writer.Write(state.buffer, 4 + fileNameLen, bytesRead - (4 + fileNameLen));
                        flag++;
                    }
                    else
                        writer.Write(state.buffer, 0, bytesRead);
                    writer.Close();
                    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                    new AsyncCallback(ReadCallback), state);
                }

            }
            else
            {

                Invoke(new MyDelegate(LabelWriter));
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);

        }
    }
    public void LabelWriter()
    {
       MessageBox.Show("Data has been received");
       Programs p = new Programs();
       p.GetFile(serverIP);
    }

dieser code wird verwendet, um die Datei vom server abrufen".

private void GetLoginTemp()
    {
        Socket clientSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        try
        {
            char[] delimiter = splitter.ToCharArray();
            byte[] fileName = Encoding.UTF8.GetBytes("empty"); //file name
            byte[] fileData;
            fileData = Encoding.UTF8.GetBytes("empty");
            //byte[] fileData = reads.ReadToEnd().to; //file
            byte[] fileNameLen = BitConverter.GetBytes(fileName.Length); //lenght of file name
            clientData = new byte[4 + fileName.Length + fileData.Length];

            fileNameLen.CopyTo(clientData, 0);
            fileName.CopyTo(clientData, 4);
            fileData.CopyTo(clientData, 4 + fileName.Length);
            System.Net.IPAddress ipAdd = System.Net.IPAddress.Parse(serverIP);

            IPEndPoint ipEnd = new IPEndPoint(ipAdd, 9050);
            clientSock.Connect(ipEnd); //target machine's ip address and the port number
            clientSock.Send(clientData);

            byte[] clientData1 = new byte[1024 * 5000];
            string receivedPath = mypath + @"\XML" + @"\Login.xml";

            int receivedBytesLen = clientSock.Receive(clientData1);

            int fileNameLen1 = BitConverter.ToInt32(clientData1, 0);
            string fileName1 = Encoding.ASCII.GetString(clientData1, 4, fileNameLen1);

            BinaryWriter bWrite = new BinaryWriter(File.Open(receivedPath + fileName, FileMode.Append)); ;
            bWrite.Write(clientData, 4 + fileNameLen1, receivedBytesLen - 4 - fileNameLen1);
            //clientSock.Shutdown(SocketShutdown.Send);

            clientSock.Close();
        }
        catch (Exception ex)
        {
            clientSock.Close();
            MessageBox.Show(ex.Message);
        }
    }