6

Suppose there is already written, unchangeable host program, that receives such C++ struct by socket:

#pragma pack(push, 2)
struct Data {
  double x;
  double y;
  double z;
  long frameNumber;
};
#pragma pack(pop)

platform: C++ / 32-bit Windows Application compiled in Visual Studio 2008

How to send such data from Java Socket? I have attemted to fill ByteBuffer with putDouble(), and putLong(), also putInt() assuming long as 32-bit, but i cannot produce valid values.

I have also generated and sended data randomly, and structure-level bytes assignment looks fine(I can randomize only one value, for example X), but I cannot produce exact value (propably different double representation?), but only random stuff by sending Math.random() * Double.MAX_VALUE;

Can I use Google Protocol Buffers on only one side (client producing data) to solve this problem?

remember, I cannot change the server (receiving) side

I know that I can move sending data to C++ and use JNI, but I'm searching for simpler solution.

I see at least 2 possible problems here:

  • double representation at byte-level (like 01234567 and 76543210 on other side)
  • bits representation in one byte (like 00000001 and 1000000 on other side)

What those things look in Java in C++?

In several hours I will provide exact sample data for "byte-hacking" (exact Java value before send and value of received double in C++)

About server bad-design answering

I know that such implemented and unchangeable server is bad software, but the environment in this problem is to inject some data to small old application at "hobbistic-level"

Java representation

Maybe this would help some bits-level C++ expert:

Long.toBinaryString( Double.doubleToRawLongBits( (double) 0 ) );
// 000000000000000000000000000000000000000000000000000000000000000

Long.toBinaryString( Double.doubleToRawLongBits( 1 ) );
// 011111111110000000000000000000000000000000000000000000000000000

Long.toBinaryString( Double.doubleToRawLongBits( 1.1 ) );
// 011111111110001100110011001100110011001100110011001100110011010

Long.toBinaryString( Double.doubleToRawLongBits( 1024 ) );
// 100000010010000000000000000000000000000000000000000000000000000

Long.toBinaryString( Double.doubleToRawLongBits( 1024.1024 ) );
// 100000010010000000000000110100011011011100010111010110001110001

Long.toBinaryString( Double.doubleToRawLongBits( Double.MAX_VALUE ) );
// 111111111101111111111111111111111111111111111111111111111111111
Improve this question
4
  • no worries about the unchangeable server. This is very common to happen and it's often not worth the effort to try and fix. In hobby programming, you can always change everything whenever you want. Professionally, however, all the rules change. Commented May 13, 2013 at 8:50
  • @killer_PL, how about to use JNI to convert Java types to VC++ types? Commented May 13, 2013 at 9:00
  • @megabyte1024, nice idea, I will go for it in worst case, but now I will still wait for some simpler solution Commented May 13, 2013 at 9:15
  • This shows that java uses IEEE 754 floating point representation (which is defined in the java standard) Now show us the same things from c++ Commented May 14, 2013 at 2:43

3 Answers 3

Reset to default
3

Suppose there is already written, unchangeable host program, that receives such C++ struct by socket

Then you already have a major problem which some unknown person has kindly left you as a legacy. You now have to produce Java code to conform to a specific C++ compiler's conception of the wire format of a specific struct, which depends on:

  • the hardware
  • the compiler vendor
  • the compiler version
  • the compilation options
  • the surrounding #pragmas
  • ...

I strongly suggest to you that you take the opportunity to fix the whole megillah and define a proper wire format for the transaction.

Once you've done that you can emulate it easily enough with the facilities of DataOutputStream, or if the problem is even worse and endian-ness is involved, NIO plus ByteBuffer.

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

it's entirely possible they have the source for the program, but have a number of clients out in the wild and cannot easily change the format. If all their clients are x86 32-bit windows clients, it may not be that big of a deal -- until now. I'm not saying this is good, but I can see how it can happen and how you can get stuck with it.
@xaxxon I didn't say anything about changing the format. I spoke of defining the format, in terms other than a struct definition, which is dependent on all the things I said above, and no doubt some more I forgot.
I see. Well, that makes sense. Basically document what you find as you're doing this investigation so others don't have to do the same.
You said: "specific C++ compiler's conception of the wire format". It's not a wire format, it's an in-memory layout. Just for the record.
@xaxxon You are sending it over the wire. Ergo it's a wire format. The fact that it is also an in-memory format is the problem here.
|
3

I figured it out. Int value is sent fine (propably, can't check this 100% sure in host program), the problem is with doubles endian. You need to convert doubles before send:

public static double changeEndian( double x ) {
      ByteBuffer cv = ByteBuffer.allocate( 8 ).putDouble( x );
      cv.order( ByteOrder.LITTLE_ENDIAN );
      cv.rewind();
      return cv.getDouble();
}

And use ByteBufer with putDouble()/putInt().

Improve this answer

2 Comments

This REALLY seems wrong. floats and doubles that conform to IEEE 754 don't have a byte order that varies between platforms. steve.hollasch.net/cgindex/coding/ieeefloat.html and en.wikipedia.org/wiki/Double_precision_floating-point_format doesn't mention anything about byte orders. Also, while it's not conclusive proof, the C api has htonl and htons, but no htonf or htond. Java uses IEEE 754 floating point numbers people.uncw.edu/tompkinsj/133/Numbers/Reals.htm. It's harder to find, but I believe x86 hardware only supports IEEE 754 floating point natively
Hrmm.. I guess the IEEE 754 format doesn't specify the endianness, which leaves it open to interpretation. Learned something today.
1

You'll need to verify the encoding used for double (usually an IEEE standard, but it doesn't have to be) as well as long (big vs little endian) on the platform with the server. You'll also need to identify any padding involved as well.

Then you'll need to manually construct the binary values appropriate to send if they aren't java native encodings. This can be non-trivial, especially for the floating point values, if you are on a pretty messed up server platform.

Also, track down the person who decided to use an implicit binary protocol for the server you can't change and use rubber-hose cryptanalysis on them:

http://en.wikipedia.org/wiki/Rubber-hose_cryptanalysis

There's no easy way to do it, without knowing all the details about the server's platform.

Java has a standard representation for floats and ints across all platforms, but c++ does not define those things. It is platform/architecture specific for c++.

Improve this answer

2 Comments

Updated platform information. Padding is propably fine (0), because I can change randomly selected values, I only cannot represent exact double value as I want.
I don't have the systems to dive in to this. It sounds like you know basically what to do and I don't think you'll run into floating point format issues based on running windows. Make sure NOT to try to force a "network byte order" your floats. On sane platforms (windows actually counts as sane in this case), those are all the same order. If you get a better answer than this, I'll delete this answer.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.