Verify a client's read access to a resource


#include <sys/iofunc.h>

int iofunc_read_verify( resmgr_context_t* ctp,
                        io_read_t* msg,
                        iofunc_ocb_t* ocb,
                        int* nonblock );


A pointer to a resmgr_context_t structure that the resource-manager library uses to pass context information between functions.
A pointer to the io_read_t structure that contains the message that the resource manager received; see below.
A pointer to the iofunc_ocb_t structure for the Open Control Block that was created when the client opened the resource.
NULL, or a pointer to a location where the function can store a value that indicates whether or not the device is nonblocking:
  • O_NONBLOCK — the client doesn't want to be blocked.
  • Zero — the client wants to be blocked.



Use the -l c option to qcc to link against this library. This library is usually included automatically.


The iofunc_read_verify() helper function checks that the client that sent the _IO_READ or _IO_READ64 message actually has read access to the resource, and, if nonblock isn't NULL, sets nonblock to O_NONBLOCK or 0).

The read permission check is done against ocb->ioflag.

Note that the io_read_t message has an override flag called msg->i.xtype. This flag allows the client to override the default blocking behavior for the resource on a per-request basis. This override flag is checked, and returned in the optional nonblock.

Note that if you're reading from a directory entry, you must return struct dirent structures in the read callout for your resource manager.

You'll also need to indicate how many bytes were read. You can do this with the macro:

_IO_SET_READ_NBYTES( resmgr_context_t *ctp,
                     int nbytes )

io_read_t structure

The io_read_t structure holds the _IO_READ or _IO_READ64 message received by the resource manager:

struct _io_read {
    uint16_t            type;
    uint16_t            combine_len;
    uint32_t            nbytes;
    uint32_t            xtype;
    uint32_t            zero;

struct _io_read64 {
    uint16_t            type;
    uint16_t            combine_len;
    uint32_t            nbytes;
    uint32_t            xtype;
    uint32_t            nbytes_hi;

typedef union {
    struct _io_read     i;
    struct _io_read     i64;
    /* unsigned char    data[nbytes];    */
    /* nbytes is returned with MsgReply  */
} io_read_t;

The I/O message structures are unions of an input message (coming to the resource manager) and an output or reply message (going back to the client). In this case, there's only an input message, i or i64, that contains the following members:

_IO_READ or _IO_READ64. The client library uses the _IO_READ64 form only when the length is greater than 4 GB.
If the message is a combine message, _IO_COMBINE_FLAG is set in this member. For more information, see Combine Messages chapter of Writing a Resource Manager.
The number of bytes that the client wants to read. For an _IO_READ64 message, the high 32 bits of the length are in nbytes_hi.
Extended type information. This information includes a type and optionally some flags. To isolate the type from the flags, AND the xtype member with _IO_XTYPE_MASK:
if ((msg->i.xtype & _IO_XTYPE_MASK) == ...)

The relevant types include the following:


The xtype member may also include the following flags:

  • _IO_XFLAG_DIR_EXTRA_HINT — this flag is valid only when reading from a directory. The filesystem should normally return extra directory information when it's easy to get. If this flag is set, it is a hint to the filesystem to try harder (possibly causing media lookups) to return the extra information. The most common use would be to return _DTYPE_LSTAT information.
  • _IO_XFLAG_DIR_STAT_FORM_UNSET, _IO_XFLAG_DIR_STAT_FORM_T32_2001, _IO_XFLAG_DIR_STAT_FORM_T32_2008, or _IO_XFLAG_DIR_STAT_FORM_T64_2008 — (QNX Neutrino 7.0 or later) these flags specify the type of stat structure to return when reading from a directory.

For more information, see Handling other read/write details in the Handling Read and Write Messages chapter of Writing a Resource Manager.

(_IO_READ64 only) The high 32 bits of the length.
Note: You can use the _IO_READ_GET_NBYTES() macro (defined in <sys/iofunc.h>) to determine the number of bytes. You pass it a pointer to the message:
num_bytes = _IO_READ_GET_NBYTES(msg);

The commented-out declaration for data indicates that nbytes bytes of data immediately follow the io_read_t structure.


The client has read access to this resource.
The client doesn't have read access to this resource.


QNX Neutrino

Cancellation point No
Interrupt handler No
Signal handler Yes
Thread Yes