CODEWITHSUNDEEP
c#hexasciipacket
R3DLINE
R3DLINE

Reputation: 95

Encoding/Decoding hex packet

I want to send this hex packet:

00 38 60 dc 00 00 04 33  30 3c 00 00 00 20 63 62 
39 62 33 61 36 37 34 64  31 36 66 32 31 39 30 64 
30 34 30 63 30 39 32 66  34 66 38 38 32 62 00 06 
35 2e 31 33 2e 31 00 00  02 3c

so i build the string:

string packet = "003860dc0000" + textbox1.text+ "00000020" + textbox2.text+ "0006" + textbox3.text;

then "convert" it to ascii:

conn_str = HexString2Ascii(packet);

then i send the packet... but i have this:

00 38 60 **c3 9c** 00 00 04 33  30 3c 00 00 00 20 63 
62 39 62 33 61 36 37 34 64  31 36 66 32 31 39 30 
64 30 34 30 63 30 39 32 66  34 66 38 38 32 62 00 
06 35 2e 31 33 2e 31 00 00  02 3c **0a**

why?? Thank you! P.S. the function is:

private string HexString2Ascii(string hexString)
{
     byte[] tmp;
     int j = 0;
     int lenght;
     lenght=hexString.Length-2;
     tmp = new byte[(hexString.Length)/2];
     for (int i = 0; i <= lenght; i += 2)
     {
         tmp[j] =(byte)Convert.ToChar(Int32.Parse(hexString.Substring(i, 2), System.Globalization.NumberStyles.HexNumber));
         j++;
     }
     return Encoding.GetEncoding(1252).GetString(tmp);
}

EDIT: if i convert directly in byte, the hex packet in coded as string:

00000000  30 30 33 38 36 30 64 63  30 30 30 30 30 34 33 33 003860dc 00000433
00000010  33 30 33 43 30 30 30 30  30 30 32 30 33 34 33 32 303C0000 00203432
00000020  36 33 36 33 33 35 33 39  33 32 33 34 36 36 33 39 63633539 32346639
00000030  36 33 33 39 33 31 33 39  33 30 33 36 33 33 36 35 63393139 30363365
00000040  33 35 36 33 36 35 36 35  36 35 33 31 33 39 33 38 35636565 65313938
00000050  36 33 33 31 36 34 33 34  36 33 33 30 30 30 30 36 63316434 63300006
00000060  33 35 32 65 33 31 33 33  32 65 33 31 30 30 30 30 352e3133 2e310000
00000070  30 32 33 43                                      023C

Upvotes: 1

Views: 4880

Answers (1)

Michael Edenfield
Michael Edenfield

Reputation: 28338

You cannot convert raw binary data to string data and expect things to just work. They are not the same. This is especially true when you mix up your character encodings.

C# characters are not ASCII characters. They are Unicode characters, represented by Unicode code points. When you then turn around and write those characters out, you need to specify what kind of data to write out. When you read your byte array into a string, using Encoding.GetEncoding(1252), you are getting the characters corresponding to code page 1252, in which 0xdc is a Ü.

But when your string is being converted back into bytes to send over the network, it is being written out as UTF-8. In UTF-8, UTF-00DC cannot be encoded as a single byte, since that byte value is used to indicate the start of a multi-byte sequence. Instead, it's encoded as the multi-byte sequence 0xc3 0x9c. As far as C# is concerned, those two values are the same character. (I don't know where that extra 0x0a is coming from, but my guess is an errant line feed from one of your text boxes and/or some other part of your process).

Its not clear what exactly you're trying to do, but I suspect you are converting way too many times for it to work out correctly. If you know the byte sequence you want to send, why not just encode that as a byte[] directly? For example, use a MemoryStream and write the constant bytes you need into it.

To get the values out of your text boxes, your original code to "convert" the string of hex digits into a string of ASCII characters had the right idea. You just need to stop at the point where you have a byte array, since ultimately the byte array is what you want.

public byte[] GetBytesFrom(string hex)
{
    var length = hex.Length / 2;
    var result = new byte[length];
    for (var i = 0; i < length; i++)
    {          
      result[i] = byte.Parse(hex.Substring(i, 2), NumberStyles.HexNumber);
    }

    return result;
}

// Variable portions of packet structure.
var byte[] segment2 = GetBytesFrom(textbox1.Text);
var byte[] segment4 = GetBytesFrom(textbox2.Text);
var byte[] segment6 = GetBytesFrom(textbox3.Text);

MemoryStream output = new MemoryStream();
output.Write(new[] { 0x00, 0x38, 0x60, 0xdc, 0x00, 0x00 }, 0, 6);
output.Write(segment2, 0, segment2.Length);
output.Write(new[] { 0x00, 0x00, 0x00, 0x20 }, 0, 4);
output.Write(segment4, 0, segment4.Length);
output.Write(new[] { 0x00, 0x06 }, 0, 2);
output.Write(segment6, 0, segment6.Length);

From here, you could use MemoryStream.CopyTo() to copy it to another stream, or MemoryStream.Read() to read the entire packet into a new byte array, or MemoryStream.GetBuffer() to get the underlying buffer (though that last one is rarely what you want -- it includes unused padding bytes)

Upvotes: 2

Related Questions