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_copy_entry()
Copy the contents of one ACL entry into another

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
  - QNX Cryptography Library
    The QNX Cryptography Library (qcrypto) is a flexible cryptography framework that allows you to choose which cryptography provider responds to requests on a per-process basis.
  - QNX devcrypto Service
  - 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 Software in the Cloud enables developers to use the QNX OS in the Amazon cloud environment.
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.
QNX Hypervisor User's Guide
This User's Guide explains the QNX hypervisor architecture and provides instructions for installing and running a QNX Hypervisor system, changing system components and configuration, and using hypervisor features such as virtual devices (vdevs).
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_copy_entry()

QNX SDP8.0C Library ReferenceAPIDeveloper

Copy the contents of one ACL entry into another

Synopsis:

#include <sys/acl.h>

int acl_copy_entry( acl_entry_t dest_d,
                    acl_entry_t src_d );

Arguments:

dest_d: The descriptor for the destination entry.
src_d: The descriptor for the entry that you want to copy.

Library:

libc

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

Description:

The acl_copy_entry() function copies the contents of the ACL entry referred to by src_d into the entry referred to by dest_d.

Returns:

Classification:

QNX OS

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


Safety:
Cancellation point	No
Signal handler	No
Thread	Yes

Page updated: August 11, 2025