Home
QNX Software Development Platform
QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for target boards running the QNX OS 8.0.
Utilities & Libraries
C Library Reference
A
acl_valid()
Validate an access control list (ACL)

QNX Momentics IDE User's Guide
This User's Guide describes version 8.0 of the Integrated Development Environment (IDE) that's part of the QNX Tool Suite.
QNX Software Development Platform
QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for target boards running the QNX OS 8.0.
- Quickstart Guide
- System Architecture
  The System Architecture guide accompanies the QNX OS and is intended for both application developers and end-users.
- OS Components & Operations
- Graphics
- Programming
- System Security Guide
  The QNX System Security Guide is intended for both system integrators who are responsible for the security of a QNX OS system and developers who want to create a QNX OS resource manager free from vulnerabilities.
- Utilities & Libraries
  - C Library Reference
    - What's in a Function Description?
    - Manifests
    - Character Sets
    - A
      - abort()
        Raise the SIGABRT signal to terminate program execution
      - abs()
        Return the absolute value of an integer
      - access()
        Check to see if a file or directory can be accessed
      - acl_add_perm()
        Add a permission to an access control list (ACL) permissions set
      - acl_calc_mask()
        Calculate the group class mask for an access control list (ACL)
      - acl_clear_perms()
        Clear all permissions from an ACL permissions set
      - acl_copy_entry()
        Copy the contents of one ACL entry into another
      - acl_copy_ext()
        Copy an ACL from system space to user space
      - acl_copy_int()
        Copy an ACL from user space to system space
      - acl_create_entry()
        Create an entry in an access control list
      - acl_delete_entry()
        Delete an entry from an access control list (ACL)
      - acl_delete_perm()
        Delete a permission from an ACL permissions set
      - acl_dup()
        Duplicate an access control list (ACL) in a working storage area
      - acl_free()
        Free the working storage area allocated for an access control list (ACL) data object
      - acl_from_text()
        Create an access control list (ACL) from text
      - acl_get_entry()
        Get an entry in an access control list (ACL)
      - acl_get_fd()
        Get the access control list associated with a file descriptor
      - acl_get_file()
        Get the ACL for a given path
      - acl_get_perm_np()
        Test whether a given permission is present in an ACL permissions set
      - acl_get_permset()
        Get a permissions set from an ACL entry
      - acl_get_qualifier()
        Get the qualifier from an ACL entry
      - acl_get_tag_type()
        Get the type of tag from an ACL entry
      - acl_init()
        Allocate and initialize an access control list (ACL) working storage area
      - acl_set_fd()
        Set the access ACL for the object associated with a file descriptor
      - acl_set_file()
        Set the access control list for a path
      - acl_set_permset()
        Set the permissions set in an ACL entry
      - acl_set_qualifier()
        Set the qualifier for an ACL entry
      - acl_set_tag_type()
        Set the tag type of an ACL entry
      - acl_size()
        Determine the size of the external form of an ACL
      - acl_to_text()
        Convert an access control list (ACL) into text
      - acl_valid()
        Validate an access control list (ACL)
      - acos(), acosf(), acosl()
        Compute the arccosine of an angle
      - acosh(), acoshf(), acoshl()
        Compute the inverse hyperbolic cosine
      - aio_cancel()
        Cancel an asynchronous I/O operation
      - aio_error()
        Get the error status for an asynchronous I/O operation
      - aio_fsync()
        Asynchronously synchronize a file
      - aio_read(), aio_read64()
        Asynchronously read from a file
      - aio_return()
        Get the return status for an asynchronous I/O operation
      - aio_suspend()
        Wait for asynchronous I/O operations to be completed
      - aio_write(), aio_write64()
        Asynchronously write to a file
      - aiocb, aiocb64
        Asynchronous I/O control block
      - alarm()
        Schedule an alarm
      - alignas, __alignas_is_defined
        Specify the alignment of an object
      - aligned_alloc()
        Allocate aligned memory
      - alignof(), __alignof_is_defined
        Get the alignment of a type
      - alloca()
        Allocate automatic space from the stack
      - alphasort()
        Compare two directory entries
      - _amblksiz
        The arena size for heap allocations
      - _argc
        The number of arguments passed to main()
      - _argv
        A pointer to the vector of arguments passed to main()
      - asctime(), asctime_r()
        Convert time information to a string
      - asin(), asinf(), asinl()
        Compute the arcsine of an angle
      - asinh(), asinhf(), asinhl()
        Compute the inverse hyperbolic sine
      - asprintf()
        Write formatted output into an allocated string
      - assert()
        Display a diagnostic message and optionally terminate the program
      - at_quick_exit()
        Register functions to be called during program termination via quick_exit()
      - atan(), atanf(), atanl()
        Compute the arctangent of an angle
      - atan2(), atan2f(), atan2l()
        Compute the arctangent, determining the quadrant
      - atanh(), atanhf(), atanhl()
        Compute an inverse hyperbolic tangent
      - atexit()
        Register functions to be called during normal program termination
      - atof()
        Convert a string into a double
      - atoi()
        Convert a string into an integer
      - atol(), atoll()
        Convert a string into a long integer
      - ATOMIC_*_LOCK_FREE
        Macros that indicate whether an atomic type is lock-free (C11)
      - atomic_*
        Data types for atomic operations (C11)
      - atomic_add()
        Safely add to a variable (QNX OS)
      - atomic_add_value()
        Safely add to a variable, returning the previous value (QNX OS)
      - atomic_clr()
        Safely clear bits in a variable (QNX OS)
      - atomic_clr_value()
        Safely clear bits in a variable, returning the previous value (QNX OS)
      - atomic_compare_exchange_strong(), atomic_compare_exchange_strong_explicit(), atomic_compare_exchange_weak(), atomic_compare_exchange_weak_explicit()
        Compare and potentially exchange the value of an atomic object (C11)
      - atomic_exchange(), atomic_exchange_explicit()
        Atomically change the value of an atomic object (C11)
      - atomic_fetch_add(), atomic_fetch_add_explicit()
        Atomically add to the value of an atomic object (C11)
      - atomic_fetch_and(), atomic_fetch_and_explicit()
        Atomically AND a value into an atomic object (C11)
      - atomic_fetch_or(), atomic_fetch_or_explicit()
        Atomically OR a value into an atomic object (C11)
      - atomic_fetch_sub(), atomic_fetch_sub_explicit()
        Atomically subtract the value of an atomic object (C11)
      - atomic_fetch_xor(), atomic_fetch_xor_explicit()
        Atomically XOR a value into an atomic object (C11)
      - atomic_flag_clear(), atomic_flag_clear_explicit()
        Atomically clear a flag (C11)
      - atomic_flag_test_and_set(), atomic_flag_test_and_set_explicit()
        Atomically set a flag (C11)
      - atomic_init()
        Initialize an atomic object (C11)
      - atomic_is_lock_free()
        Determine whether atomic operations on an object are lock-free (C11)
      - atomic_load(), atomic_load_explicit()
        Atomically read the value of an atomic object (C11)
      - atomic_set()
        Safely set bits in a variable (QNX OS)
      - atomic_set_value()
        Safely set bits in a variable, returning the previous value (QNX OS)
      - atomic_signal_fence()
        Fence between a thread and a signal handler executed in the same thread (C11)
      - atomic_store(), atomic_store_explicit()
        Atomically set the value of an atomic object (C11)
      - atomic_sub()
        Safely subtract from a variable (QNX OS)
      - atomic_sub_value()
        Safely subtract from a variable, returning the previous value (QNX OS)
      - atomic_thread_fence()
        Generic memory order-dependent fence synchronization primitive (C11)
      - atomic_toggle()
        Safely toggle bits in a variable (QNX OS)
      - atomic_toggle_value()
        Safely toggle bits in a variable, returning the previous value (QNX OS)
      - _auxv
        A pointer to a vector of auxiliary arguments to main()
    - B
    - C
    - D
    - E
    - F
    - G
    - H
    - I
    - J
    - K
    - L
    - M
    - N
    - O
    - P
    - Q
    - R
    - S
    - T
    - U
    - V
    - W
    - X
    - Y
    - Z
    - Full Safety Information
    - Glossary
  - Devctl and Ioctl Commands
  - JSON Library Reference
  - PAM Reference
  - QNX Helpers Developer's Guide
    These libraries provide QNX helpers, including helpers that assist with logging, string conversion, and number and type sizes.
  - SPI Framework Technote
  - Utilities Reference
  - WPA Control Interface Reference
    This document provides a reference for the Wi-Fi Protected Access (WPA) control interface, which provides a C API for the WPA/IEEE 802.11i protocols in Wi-Fi client stations. Application developers who want to control WPA operations and get associated status and event data should read this reference.
- Migrating to QNX OS 8.0
QNX Software in the Cloud
QNX Toolkit for Visual Studio Code
This User's Guide describes the QNX^® Toolkit for Visual Studio Code. The guide introduces you to the QNX Toolkit by explaining the QNX development environment and how to build, run, and debug your QNX^® Operating System (OS) applications and systems.
Typographical Conventions, Support, and Licensing
This section describes the typographical conventions used throughout the documentation, explains how to obtain technical support, and provides some information about licensing.

acl_valid()

QNX SDP8.0C Library ReferenceAPIDeveloper

Validate an access control list (ACL)

Synopsis:

#include <sys/acl.h>

int acl_valid( acl_t acl );

Arguments:

acl: A pointer to the ACL that you want to check.

Library:

libc

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

Description:

The acl_valid() function checks an access control list to make sure it's valid:

The ACL must have one each of the ACL_USER_OBJ, ACL_GROUP_OBJ, and ACL_OTHER entries.
If the ACL has any ACL_USER (named user) or ACL_GROUP (named group) entries, there must be one ACL_MASK entry.
There must not be more than one entry for the same named user or group.

Returns:

0, or -1 if an error occurred (errno is set).

Errors:

EINVAL: The ACL is missing some of the required entries or there are entries that aren't unique.
ENOTSUP: The ACL type isn't ACL_TYPE_ACCESS or ACL_TYPE_DEFAULT.

Classification:

This function is based on the withdrawn POSIX draft P1003.1e.


Safety:
Cancellation point	No
Signal handler	No
Thread	Yes

Page updated: August 09, 2024