iofunc_write_verify()

Verify a client's write access to a resource

Synopsis:

#include <sys/iofunc.h>

int iofunc_write_verify( resmgr_context_t* ctp,
                         io_write_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_write_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:

• Nonzero — the client doesn't want to be blocked (i.e. O_NONBLOCK was set).
• Zero — the client wants to be blocked.

Library:

libc

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

Description:

The iofunc_write_verify() function checks that the client that sent the write message actually has write access to the resource, and, optionally (if nonblock isn't NULL), sets nonblock to O_NONBLOCK or 0.

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

Note that the io_write_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.

In write callout for your resource manager, you'll need to indicate how many bytes were written. You can do this with the macro:

_IO_SET_WRITE_NBYTES( resmgr_context_t *ctp,
                      int nbytes )

io_write_t structure

The io_write_t structure holds the _IO_WRITE message received by the resource manager:

struct _io_write {
    uint16_t                    type;
    uint16_t                    combine_len;
    int32_t                     nbytes;
    uint32_t                    xtype;
    uint32_t                    zero;
/*  unsigned char               data[nbytes];   */
};


typedef union {
    struct _io_write            i;
/*  nbytes is returned with MsgReply */
} io_write_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_write that contains the following members:

type

_IO_WRITE.

combine_len

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.

nbytes

The number of bytes that the client wants to write.

xtype

Extended type information; one of:

• _IO_XTYPE_NONE
• _IO_XTYPE_READCOND
• _IO_XTYPE_MQUEUE
• _IO_XTYPE_TCPIP
• _IO_XTYPE_TCPIP_MSG
• _IO_XTYPE_OFFSET
• _IO_XTYPE_REGISTRY
• _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_NONBLOCK
• _IO_XFLAG_BLOCK

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

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

Returns:

EOK

The client has write access to this resource.

EBADF

The client doesn't have write access to this resource.

Classification:

QNX Neutrino

See also:

iofunc_read_verify()

Writing a Resource Manager

Resource Managers chapter of Getting Started with QNX Neutrino