Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

sending and receiving files socket programming

Tags:

c#

sockets

i am developing two application one is server application and other is for handheld device application both communicate using wireless connection.here client is handheld and server is my computer where server application running. when i send files from client to server it send perfectly without any error but when client request for files the server produce error something like "No connection could be made because the target machine actively refused it 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);
    }

this code is used to get file from server.

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);
        }
    }
like image 963
Emaad Ali Avatar asked Jul 28 '10 14:07

Emaad Ali


People also ask

Can sockets send and receive?

Once connected, a TCP socket can only send and receive to/from the remote machine. This means that you'll need one TCP socket for each client in your application. UDP is not connection-based, you can send and receive to/from anyone at any time with the same socket.

Which methods are used for sending and receiving data in TCP socket?

recv(bufsize) − As name implies, this method receives the TCP message from socket. The argument bufsize stands for buffer size and defines the maximum data this method can receive at any one time. socket. send(bytes) − This method is used to send data to the socket which is connected to the remote machine.

Can a socket send and receive at the same time Python?

You can send and receive on the same socket at the same time (via multiple threads). But the send and receive may not actually occur simultaneously, since one operation may block the other from starting until it's done.


1 Answers

You seem to think that you need a second TCP connection in the direction where the file is going. This is not necessary since TCP connection is a full-duplex stream. Also it's never a good design to connect from server back to client, which might be behind a NAT-ing gateway/firewall. This is the problem with FTP (see active vs passive ftp).

Use the same connection the client has already established. You need some sort of protocol on top of base TCP to let the other side know when to expect data and how much to expect. This has been discussed here many times, see for example this SO question.

like image 142
Nikolai Fetissov Avatar answered Sep 21 '22 07:09

Nikolai Fetissov