TCP Sockets and .Net Micro Framework

Question

I'm new to sockets and just can't seem to get my app working. What I want to do is send a log file from the Netduino+2 back to my laptop. The approach I took was to prepend the file size to the byte array before sending. However, I never seem to receive exactly what I send. I realize this is a very common problem with folks who are new to sockets and I've searched high and low to find tips on how to avoid this problem. Maybe this is something unique to micro framework, but I kind of doubt it.

Here is my code. I've got a client app that runs on the N+2 and a console app running on my laptop. The data file I'm retrieving is attached below. This sort of works, but is not delivering the file consistently. Any help you can give me would be appreciated.

Client app running on N+2. When you press the onboard button, it sends the file.

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
using System.IO;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.Netduino;

namespace SocketClient
    {

    public class Program
        {
        static string strDeviceIP = "";
        static string strDeviceSubnet = "";
        static string strDeviceGateway = "";
        static string strDevicePort = "";
        static string strControllerIP = "";

        public static OutputPort opLED = new OutputPort(Pins.GPIO_PIN_D13, false);
        InputPort button = new InputPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled);

        public static void Main()
            {
            strDeviceIP = "192.168.2.102";
            strDeviceSubnet = "255.255.255.0";
            strDeviceGateway = "192.168.2.2";
            strControllerIP = "192.168.2.222";
            strDevicePort = "9999";
            InterruptPort btn = new InterruptPort(Pins.ONBOARD_SW1, false, 
                              Port.ResistorMode.Disabled, Port.InterruptMode.InterruptEdgeLow);
            btn.OnInterrupt += new NativeEventHandler(ButtonPress);

            while (true)
                {

                }
            }

        public static void ButtonPress(uint data1, uint data2, DateTime time)
            {
            opLED.Write(true);

            Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
                    ProtocolType.Tcp);
            IPAddress hostAddress = IPAddress.Parse(strControllerIP);
            IPEndPoint endpoint = new IPEndPoint(hostAddress, Int32.Parse(strDevicePort));

            string fileName = "runlog2.txt";

            // read the file into a byte array
            byte[] data = File.ReadAllBytes(@"SD\" + fileName);
            byte[] sizeinfo = new byte[4];
            byte[] senddata = new byte[4 + data.Length];

            // check to make sure it's not too big
            if (data.Length > 850 * 1024)
                {
                Debug.Print("File too large");
                }

            // convert data.length into a byte array
            sizeinfo[0] = (byte)data.Length;
            sizeinfo[1] = (byte)(data.Length >> 8);
            sizeinfo[2] = (byte)(data.Length >> 16);
            sizeinfo[3] = (byte)(data.Length >> 24);

            // prepend the size into the senddata array
            sizeinfo.CopyTo(senddata, 0);

            // copy read data into the senddata array
            data.CopyTo(senddata, 4);

            // send the data
            socket.Connect(endpoint);
            socket.Send(senddata);
            socket.Close();
            opLED.Write(false);
            }
        }
    }

Here is my server side console app.

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Collections;
using System.Threading;





namespace SocketConsole
    {
    class Program
        {
        static void Main(string[] args)
            {
            Thread thread1 = new Thread(new ThreadStart(Listener));
            thread1.Start();



            while (true)
                {
                }
            }

       public static void Listener()
            {
            try
                {
                Socket sktMain = new Socket(AddressFamily.InterNetwork, SocketType.Stream, 
                                      ProtocolType.Tcp);
                sktMain.Bind(new IPEndPoint(IPAddress.Parse("192.168.2.222"), 9999));
                sktMain.Listen(10);
                var message = new ArrayList();

                while (true)
                    {
                    // create the client socket
                    using (var client = sktMain.Accept())
                        {
                        //If connected,
                        if (SocketConnected(client, 100))
                            {
                            while (SocketConnected(client, 100))
                                {
                                byte[] sizeinfo = new byte[4];

                                //read the size of the message into sizeinfo
                                int totalread = 0, currentread = 0;
                                currentread = totalread = client.Receive(sizeinfo, 4, 
                                SocketFlags.None);

                                while (totalread < sizeinfo.Length && currentread > 0)
                                    {
                                    currentread = client.Receive(sizeinfo, totalread,
                                 sizeinfo.Length - totalread, SocketFlags.None);
                                    totalread += currentread;
                                    }

                                int messagesize = 0;
                                messagesize |= sizeinfo[0];
                                messagesize |= (((int)sizeinfo[1]) << 8);
                                messagesize |= (((int)sizeinfo[2]) << 16);
                                messagesize |= (((int)sizeinfo[3]) << 24);

                                byte[] data = new byte[messagesize];
                                totalread = 0;
                                currentread = totalread = client.Receive(data, 0, data.Length -
                               totalread, SocketFlags.None);
                                var received = Encoding.UTF8.GetChars(data);

                                int diff = data.Length - totalread;

                                while (totalread < messagesize && currentread > 0)
                                    {
                                    currentread = client.Receive(data, 0, data.Length - totalread,
                                    SocketFlags.None);
                                    totalread += currentread;
                                    for (var i = 0; i < received.Length; i++)
                                        message.Add(received[i]);
                                    }
                                string fName = "runlog.txt";
                                if (File.Exists(fName)) File.Delete(fName);

                                BinaryWriter bWrite = new BinaryWriter(File.Open(fName, 
                             FileMode.Create));
                                bWrite.Write(data);
                                bWrite.Close();
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                Console.WriteLine(ex.Message);
                }
            }

           // socket polling
           static bool SocketConnected(Socket s, int ms)
               {
               return !(s.Poll(ms, SelectMode.SelectRead) & (s.Available == 0));
               }

        }
    }

If I look at the byte array data, after receiving all the data, every byte above 255 has a value of 0. It's as if it stops reading at 255. If I debug.print in the while loop filling "data", I get the following output:

client accepting data
 client.Receive sizeinfo: currentread = 4, totalread = 4
 total message size = 3296
 client.Receive data: currentread = 252, totalread = 252
 client.Receive data: currentread = 256 totalread = 508
 client.Receive data: currentread = 256 totalread = 764
 client.Receive data: currentread = 256 totalread = 1020
 client.Receive data: currentread = 256 totalread = 1276
 client.Receive data: currentread = 256 totalread = 1532
 client.Receive data: currentread = 256 totalread = 1788
 client.Receive data: currentread = 256 totalread = 2044
 client.Receive data: currentread = 256 totalread = 2300
 client.Receive data: currentread = 256 totalread = 2556
 client.Receive data: currentread = 256 totalread = 2812
 client.Receive data: currentread = 256 totalread = 3068
 client.Receive data: currentread = 228 totalread = 3296
 client.Receive data final: currentread = 228 totalread = 3296

So it is accepting 256 bytes each time, but they are all zero. Obviously, I don't understand what's going on:(

Answer 1

In the second while loop, and while calling the Receive method, you are using it this way:

currentread = client.Receive(data, 0, data.Length - totalread, SocketFlags.None);

The second parameter here denotes : "The location in buffer to store the received data."

This means that all your read data is actually overwriting all old data.

You should replace it with the following code:

currentread = client.Receive(data, totalread, data.Length - totalread, SocketFlags.None);

Because the totalread varaible in your code always holds the total read bytes which also can be used to point to the new location for the new received data.