How is such binary compatibility ordinarily achieved?  Compression
programs come to mind---a bzip2 file is usable under any platform that
has the bzip2 utility.

I doesn't seem too elegant for my program to have a million #if
directives for every platform, and makes dealing with new platforms
ugly.

So my initial thought is to use the following scheme: commit to always
using one endianness, say big-endian for this example.  Then my code
will look something like the following:

my_function(input_data) {
        if (architecture_is_not_big-endian()) {
                covert_data_to_big-endian(input_data);
        }
        // do whatever needs to be done with input_data

struct CpioHdr {
    uchar magic[2];
    uchar size[4];
    ...

#define getshort(a) (a[0] << 8 | a[1])
#define getlong(a) (a{0] << 24 | a[1] << 16 | a[2] << 8 | a[3])

        http://www.eskimo.com/~scs/C-faq/top.html

dave

[1] If you don't have ntohl, something like this should work (with the
    usual disclaimer that I haven't compiled or tested it):
--------
#if BIG_ENDIAN
        /*ntohl is just the identity function.  A smart compiler may be
            able to recognize and inline (=>completely eliminate) it.
        */
        unsigned long ntohl(unsigned long x){return x;}
#elif LITTLE_ENDIAN
        /*Assumes 32-bit long, 8-bit byte*/
        unsigned long ntohl(unsigned long x)
        {
                /*I've seen bit and byte reversals done this way in a
                    bunch of places.  Not sure who to give credit for
                    the original idea to.
                */
                /*The unwanted bits here just slide off the end...*/
                x=(x>>16)|(x<<16);
                /*...but we have to mask them here*/
                x=((x>>8) & 0x00ff00ff) | ((x<<8) & 0xff00ff00))

                return x;
        }
#else   /*weird-endian*/
        /*Assumes 32-bit long, 8-bit byte
          Also requires (implicit in sizes assumed) that there are no trap
            representations for unsigned long.
        */
        unsigned long ntohl(unsigned long src)
        {
                /*If we're on a weird-endian system, we end up having
                    to pack the bytes by hand instead of playing games
                    with the values to shift them around.
                  Note that this version will work anywhere that the size
                    assumptions are valid, no matter what the endianness.
                  Depending on the processor, this may even be faster
                    than the little-endian version.  In the highly
                    unlikely event it's where your program is spending
                    most of its time, you might want to check the
                    generated assembly to see which to use.
                */
                unsigned long dest;
                unsigned char *ptr=(unsigned char *)&dest;

                ptr[3]=src&0xff;    src<<=8;
                ptr[2]=src&0xff;    src<<=8;
                ptr[1]=src&0xff;    src<<=8;
                ptr[0]=src&0xff;

In many cases, the best approach is to turn everything into text
(use printf() on integers) rather than using a binary file.

My suggestion is to never represent multi-byte integers as big-endian
or little-endian.  Too boring.

Example:

        A Student Data Record consists of a Student Data Header Record
        followed by one Student Record per student.

        A Student Data Header Record contains the number of Student
        Records to follow (24-bit unsigned integer):

        Byte 0:  Most significant 8 bits of the number of Student Records
        Byte 1:  Least significant 8 bits of the number of Student Records
        Byte 2:  Middle significant 8 bits of the number of Student Records
        Byte 3:  The letter 'S', in ASCII
        Byte 4:  The letter 'D', in ASCII
        Byte 5:  The letter 'R', in ASCII

        A Student Record contains the following data:

        Byte 0:  Day of birth (1-31)
        Byte 1:  Month of birth (1-12)
                 A year is a 12-bit unsigned integer (runs out in the
                 year 4095), represented as follows:
        Byte 2:  Least significant 3 bits of the Year of birth
        Byte 3:  Most signifcant 3 bits of the Year of birth
        Byte 4:  Middle significant 6 bits of the Year of birth
        Bytes 5-24:  First 20 characters of student's last name.
                     If there are less than 20 characters, pad with spaces.
                     If there are more than 20 characters, tough, chop it.
        ...

        buffer[0] = (number_of_students >> 16) & 0xff;
        buffer[1] = number_of_students & 0xff;
        buffer[2] = (number_of_students >> 8) & 0xff;

number_of_students needs at least 24 bits, so an appropriate C type is
long.  This might even work on a machine with 11 bit chars if somehow
in the process of outputting the most significant 3 bits end up getting
discarded.  We *DON'T CARE* what the endianness of the host machine is.
The code still works.  

Going the other way:

        number_of_students = (buffer[0] & 0xff) << 16 |
                                (buffer[1] & 0xff) |
                                (buffer[2] & 0xff) << 8 ;

(Note that the number of students is specified as a non-big-endian
non-little-endian value).