I have a C program that is called by an assembler program.  The
assembler program passes an address of a piece of storage to the C
program.

The storage contains a variety of fields.  I want to be able to access
one of those fields in the C program.  It is a fullword binary field.

I know I need a struct.   My problem is getting addressablity to the
struct.

Program snippets follow:
********************************************************************
<snip>
typedef struct jrbdsub_type{
  char jrbdsub_subcode[4];
  char jrbdsub_filler[44];
  int jrbdsub_suberrno;

When I compile the C program I receive:

CBC3076 Character constant 'SUB ' has more than one character. No more
than rightmost 4 characters are used.
CBC3068 Operation between types "unsigned char*" and "int" is not
allowed.

I know that subptr contains a good pointer to the storage (because an
assembler program I call later can use it successfully).

1) am I loading the st_ptr correctly in order to get addressability to
jrbdsub?
2) How can I get rid of the compile errors.
3) How many other ways am I screwing this up?

But in this case I doubt that it will work at all if you want to pass
your program an address belonging to a different program unless you
are working on a system where each process can access the memory of
all other processes (and it's getting quite off-topic for c.l.c. since
standard C does not know about the mere existence of more than one
process). Under normal modern OSes each process has its own memory
space and an address passed to it from another process will mean
nothing to the program...

And even if this works because your system allows it, the layout of the
structure may look quite different from what you expect. The compiler
can insert as many padding bytes between the elements of the structure
as it thinks necessary or prudent (and a different compiler is allowed
to have different opinions). This would be one of the cases where you
wouldn't use a structure directly but do the unpacking manually byte
by byte and the push the extracted data into a structure.

And here you will need strncmp() because 'st_ptr->jrbdsub_subcode'
can't hold the string "SUB ", this string requires 5 chars (a string
must always end in a '\0' character. So you must restrict the
comparison to the first four bytes anyway, strcmp() will only stop
when it finds a '\0' in one of the strings and thus would compare
past the end of what's stored in 'st_ptr->jrbdsub_subcode'.

2. You can't compare arrays with the == operator. For strings, use the
strcmp() function.

3. Get a good book on C and read it through before trying to write any
code.

    To compare two arbitrary four-byte arrays (not necessarily
"strings"), use the memcmp() function:

        if (memcmp(st_ptr->jrbdsub_subcode, "SUB ", 4) == 0)
            ...

(The literal "SUB " actually creates a properly-terminated
string, a five-byte array containing 'S','U','B',' ','\0'.
But the final '\0' won't confuse memcmp(), because it's been
told to inspect only the first four characters of each array.)

7.21.4.4  The strncmp function

Synopsis

[#1]
        #include <string.h>
        int strncmp(const char *s1, const char *s2, size_t n);

Description

[#2]   The   strncmp  function  compares  not  more  than  n
characters (characters that follow a null character are  not <--
compared)  from  the  array  pointed  to  by s1 to the array
pointed to by s2.

Returns

[#3] The strncmp function returns an integer  greater  than,
equal  to,  or  less  than zero, accordingly as the possibly
null-terminated array pointed to  by  s1  is  greater  than,
equal  to,  or  less than the possibly null-terminated array
pointed to by s2.

    1)  The O.P.'s data is a four-character array, and he's
        trying to find out whether those four characters
        are 'S','U','B',' '.

    2)  The four-character array lacks a terminating '\0'
        and hence is not a string, so strcmp() is out.

    3)  If the array actually contains 'S','U','B',' '
        either memcmp() or strncmp() against the first
        four bytes of the five-byte string "SUB " will
        detect the match.

    4)  If the array actually contains something else,
        either memcmp() or strncmp() will detect the
        mismatch.

    5)  But (4) only holds because 'S','U','B',' ' has
        no embedded zero bytes.

    6)  In the more general case where the key value could
        contain embedded zeroes, memcmp() would always
        deliver the correct answer but strncmp() could be
        fooled.  For example, if the test value were
        'A',0,'B',1 (note the un-quoted digits) and the
        array held 'A',0,'X',42 strncmp() would report a
        match because it would inspect only the first
        two characters.

    7)  Since the O.P. is unfamiliar with C's world-view
        I didn't want him to get the notion that strncmp()
        was the preferred way to compare arbitrary chunks
        of memory.  strncmp() can handle non-strings, yes,
        but it still has string-ish behavior.

    8)  Therefore I recommended memcmp().

You can write the test as:

strncmp (buf, "the literal", sizeof buf);

This has certain value for the problem. You can't run off the end of
buf, because of sizeof, and you can't run off the end of the literal
since strncmp() will terminate when it hits the '\0' character.
Naturally though, it requires buf to be an actual array in that scope,
not a character pointer. As a struct member, that's not a problem IN
THIS CASE.

For the general problem of two character buffers that aren't necessarily
strings, the size of each buffer will have to be calculated first, as
there is no other way to do memcmp() safely. As in:

if (sizeof buf1 != sizeof buf2)
{
   /* obviously can't match report failure */