Caution: This version of this document is no longer maintained. For the latest documentation, see http://www.qnx.com/developers/docs.

iofunc_read_verify()

Verify a client's read access to a resource

Synopsis:

#include <sys/iofunc.h>

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

Arguments:

ctp
A pointer to a resmgr_context_t structure that the resource-manager library uses to pass context information between functions.
msg
A pointer to the io_read_t structure that contains the message that the resource manager received; see below.
ocb
A pointer to the iofunc_ocb_t structure for the Open Control Block that was created when the client opened the resource.
nonblock
NULL, or a pointer to a location where the function can store a value that indicates whether or not the device is nonblocking:

Library:

libc

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

Description:

The iofunc_read_verify() helper function checks that the client that sent the _IO_READ 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 message received by the resource manager:

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

typedef union {
    struct _io_read             i;
/*  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.

The i member is a structure of type _io_read that contains the following members:

type
_IO_READ.
combine_len
If the message is a combine message, _IO_COMBINE_FLAG is set in this member. For more information, see "Combine messages" in the Writing a Resource Manager chapter of the Programmer's Guide.
nbytes
The number of bytes that the client wants to read.
xtype
Extended type information; one of:

For more information, see "Handling other read/write details" in the Writing a Resource Manager chapter of the Programmer's Guide.

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

Returns:

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

Classification:

QNX Neutrino

Safety:
Cancellation point No
Interrupt handler No
Signal handler Yes
Thread Yes

See also:

dirent, iofunc_open(), iofunc_write_verify()

Writing a Resource Manager chapter of the Neutrino Programmer's Guide

Resource Managers chapter of Getting Started with QNX Neutrino