For these kinds of "strong typedefs" I use something like:template<class T,class Name>
struct PrimitiveWrap
{
explicit PrimitiveWrap(T v) : value(v) {}
operator const T&() const { return value; }
operator T&() { return value; }
private:
T value;
};

struct LittleEndian_Tag {};
typedef PrimitiveWrap<int, LittleEndian_Tag> LittleEndian;

Your options are going to be pretty limited in C's comparatively weak type system. The closest thing I can think of would be to have something like this:

struct LittleEndian
{
int Value;
};

struct BigEndian
{
int Value;
};

typedef struct LittleEndian NativeEndian; // or BigEndian depending on platform

The syntactic overhead will be a bit annoying, as you'll have to access the value member all over the place, but... eh. The compiler should eliminate all the cost anyways, so it's strictly a matter of doing extra typing.

The other alternative that comes to mind is some macro magic:

#define MAKE_LITTLE_ENDIAN(x) (x)
#define MAKE_BIG_ENDIAN(x) ENDIAN_SWAP(x)
#define N(x) MAKE_LITTLE_ENDIAN(x)

/* And of course swap the above macros on big-endian platforms */

void NetworkTransmit(int native)
{
int little = MAKE_LITTLE_ENDIAN(native);
/* Do stuff */
}

int main()
{
int autoendian = N(42);

printf("Number: %d\n", autoendian);
NetworkTransmit(autoendian);
}

Just out of curiosity, why don't you have both computers communicate in the normal networking way? htons(), htonl(), ntohs(), ntohl() (though you'll have to write your own 64 bit function if you need 64-bit ints).

And about the floating point stuff... you should pick the hardware you'll support, and then write to support that hardware. If you don't do that and you want to support everything under the sun (including non-IEEE 754 formats, though that's not legal C then), you have to send data as text (or some other intermediary format) and then convert it on both ends. 99% of computers (that's a made up stat, but I wouldn't be surprised if it's close) use little-endian IEEE 754 floats, so it's not like you'll be missing a big market there if you say only little-endian IEEE 754 floats are supported. Also, read this: http://en.wikipedia...._and_endianness

But of course, since C is going to use IEEE 754, you could also send a special float at the beginning that will inform the server of the computer's endianness. Something like -3.0f should be enough. OR you could just make your own htonf(), htond(), ntohf(), ntohd() (host to network float, host to network double, etc) and use them. But if you're seriously going to be this pedantic about things, you should also be pedantic about the size of bytes on a system (CHAR_BIT does not have to be 8), and the number of bytes in int, short, long, etc.

One option is to use a fixed point format for sending "float" data on the network.