Allocate a dispatch handle


#include <sys/iofunc.h>
#include <sys/dispatch.h>

dispatch_t *dispatch_create( void );



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


The dispatch_create() function allocates and initializes a dispatch handle. After you've called this function, you need to call one or more of the following functions to attach handlers for the things you want the dispatch layer to deal with:

Then you call dispatch_context_alloc() to allocate the context for dispatch_block() and dispatch_handler().

Note: Once you've called dispatch_context_alloc(), don't call message_attach() or resmgr_attach() specifying a different maximum message size or a different number of message parts for the same dispatch handle.

If you wish, you can do a resmgr_attach() with a NULL path. This has the effect of initializing dispatch to receive messages and creates the channel among other things.

Note: A channel is created only when you first attach something that requires a channel (indicating you will block receiving messages).

If you want to create the channel yourself (e.g. in order to use name_attach()), call dispatch_create_channel() instead of dispatch_create().

This function is part of the dispatch layer of a resource manager. For more information, see Layers in a resource manager in the Bones of a Resource Manager chapter of Writing a Resource Manager.


A handle to a dispatch structure, or NULL if an error occurs.

Note: The dispatch structure, dispatch_t, is an opaque data type; you can't access its contents directly.


Insufficient memory to allocate context.


#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <fcntl.h>
#include <sys/iofunc.h>
#include <sys/dispatch.h>

int my_func( select_context_t *ctp, int fd,
             unsigned flags, void *handle ) {
   int   i, c;

   /* Do some useful stuff with data */
   i = read( fd, &c, 1 );
   fprintf( stderr, "activity on fd %d: read char %c,
                     return code %d\n", fd, c, i ); 

int main( int argc, char **argv ) {
   dispatch_t           *dpp;
   dispatch_context_t   *ctp;
   int                  fd, fd2;

   if( ( dpp = dispatch_create() ) == NULL ) {
     fprintf( stderr, "%s: Unable to allocate \
              dispatch handle.\n",argv[0] );
     return EXIT_FAILURE;
   if( argc <= 2 || (fd = open( argv[1],
                    O_RDWR | O_NONBLOCK )) == -1 ) {
     return EXIT_FAILURE;
   if( argc <= 2 || (fd2 = open( argv[2],
                    O_RDWR | O_NONBLOCK )) == -1 ) {
     return EXIT_FAILURE;

   select_attach( dpp, NULL, fd,
   select_attach( dpp, NULL, fd2,
   ctp = dispatch_context_alloc( dpp );

   for(;;) {
     if( ctp = dispatch_block( ctp ) ) {
       dispatch_handler( ctp );
   return EXIT_SUCCESS;

For more examples using the dispatch interface, see message_attach(), resmgr_attach(), and thread_pool_create().


QNX Neutrino

Cancellation point No
Interrupt handler No
Signal handler No
Thread Yes

See also:

dispatch_block(), dispatch_context_alloc(), dispatch_create_channel(), dispatch_destroy(), dispatch_handler(), dispatch_timeout(), dispatch_unblock() message_attach(), pulse_attach(), resmgr_attach(), select_attach()

Layers in a resource manager in the Bones of a Resource Manager chapter of Writing a Resource Manager

Resource Managers chapter of Getting Started with QNX Neutrino