#include <sys/socket.h>

   struct cmsghdr *CMSG_FIRSTHDR(struct msghdr *msgh);
   struct cmsghdr *CMSG_NXTHDR(struct msghdr *msgh, struct cmsghdr *cmsg);
   size_t CMSG_ALIGN(size_t length);
   size_t CMSG_SPACE(size_t length);
   size_t CMSG_LEN(size_t length);
   unsigned char *CMSG_DATA(struct cmsghdr *cmsg);

   struct cmsghdr {
       size_t cmsg_len;    /* Data byte count, including header
                              (type is socklen_t in POSIX) */
       int    cmsg_level;  /* Originating protocol */
       int    cmsg_type;   /* Protocol-specific type */
   /* followed by
      unsigned char cmsg_data[]; */


   These macros are used to  create  and  access  control  messages  (also
   called ancillary data) that are not a part of the socket payload.  This
   control information may include the interface the packet  was  received
   on, various rarely used header fields, an extended error description, a
   set of file descriptors or UNIX  credentials.   For  instance,  control
   messages  can  be  used  to  send  additional  header fields such as IP
   options.  Ancillary data is sent by calling sendmsg(2) and received  by
   calling recvmsg(2).  See their manual pages for more information.

   Ancillary data is a sequence of struct cmsghdr structures with appended
   data.  This sequence should be accessed using only the macros described
   in  this manual page and never directly.  See the specific protocol man
   pages for the available control message types.  The  maximum  ancillary
   buffer    size    allowed    per    socket    can    be    set    using
   /proc/sys/net/core/optmem_max; see socket(7).

   CMSG_FIRSTHDR() returns a pointer to the first cmsghdr in the ancillary
   data buffer associated with the passed msghdr.

   CMSG_NXTHDR()  returns the next valid cmsghdr after the passed cmsghdr.
   It returns NULL when there isn't enough space left in the buffer.

   CMSG_ALIGN(),  given  a  length,  returns  it  including  the  required
   alignment.  This is a constant expression.

   CMSG_SPACE()  returns  the  number  of  bytes an ancillary element with
   payload of the  passed  data  length  occupies.   This  is  a  constant

   CMSG_DATA() returns a pointer to the data portion of a cmsghdr.

   CMSG_LEN()  returns  the  value  to store in the cmsg_len member of the
   cmsghdr structure, taking into account  any  necessary  alignment.   It
   takes the data length as an argument.  This is a constant expression.

   To create ancillary data, first initialize the msg_controllen member of
   the msghdr  with  the  length  of  the  control  message  buffer.   Use
   CMSG_FIRSTHDR()  on  the  msghdr  to  get the first control message and
   CMSG_NXTHDR() to get all subsequent ones.   In  each  control  message,
   initialize cmsg_len (with CMSG_LEN()), the other cmsghdr header fields,
   and the data portion using CMSG_DATA().   Finally,  the  msg_controllen
   field of the msghdr should be set to the sum of the CMSG_SPACE() of the
   length of all control messages in the buffer.  For more information  on
   the msghdr, see recvmsg(2).

   When the control message buffer is too short to store all messages, the
   MSG_CTRUNC flag is set in the msg_flags member of the msghdr.


   This ancillary data model conforms to the POSIX.1g draft,  4.4BSD-Lite,
   the IPv6 advanced API described in RFC 2292 and SUSv2.  CMSG_ALIGN() is
   a Linux extension.


   For portability, ancillary data  should  be  accessed  using  only  the
   macros  described  here.   CMSG_ALIGN() is a Linux extension and should
   not be used in portable programs.

   In  Linux,  CMSG_LEN(),  CMSG_DATA(),  and  CMSG_ALIGN()  are  constant
   expressions  (assuming  their argument is constant); this could be used
   to declare the size of global variables.  This  may  not  be  portable,


   This code looks for the IP_TTL option in a received ancillary buffer:

       struct msghdr msgh;
       struct cmsghdr *cmsg;
       int *ttlptr;
       int received_ttl;

       /* Receive auxiliary data in msgh */

       for (cmsg = CMSG_FIRSTHDR(&msgh); cmsg != NULL;
               cmsg = CMSG_NXTHDR(&msgh, cmsg)) {
           if (cmsg->cmsg_level == IPPROTO_IP
                   && cmsg->cmsg_type == IP_TTL) {
               ttlptr = (int *) CMSG_DATA(cmsg);
               received_ttl = *ttlptr;

       if (cmsg == NULL) {
           /* Error: IP_TTL not enabled or small buffer or I/O error */

   The  code  below passes an array of file descriptors over a UNIX domain
   socket using SCM_RIGHTS:

       struct msghdr msg = { 0 };
       struct cmsghdr *cmsg;
       int myfds[NUM_FD];  /* Contains the file descriptors to pass */
       int *fdptr;
       union {         /* Ancillary data buffer, wrapped in a union
                          in order to ensure it is suitably aligned */
           char buf[CMSG_SPACE(sizeof(myfds))];
           struct cmsghdr align;
       } u;

       msg.msg_control = u.buf;
       msg.msg_controllen = sizeof(u.buf);
       cmsg = CMSG_FIRSTHDR(&msg);
       cmsg->cmsg_level = SOL_SOCKET;
       cmsg->cmsg_type = SCM_RIGHTS;
       cmsg->cmsg_len = CMSG_LEN(sizeof(int) * NUM_FD);
       fdptr = (int *) CMSG_DATA(cmsg);    /* Initialize the payload */
       memcpy(fdptr, myfds, NUM_FD * sizeof(int));


   recvmsg(2), sendmsg(2)

   RFC 2292


   This page is part of release 4.09 of the Linux  man-pages  project.   A
   description  of  the project, information about reporting bugs, and the
   latest    version    of    this    page,    can     be     found     at


Personal Opportunity - Free software gives you access to billions of dollars of software at no cost. Use this software for your business, personal use or to develop a profitable skill. Access to source code provides access to a level of capabilities/information that companies protect though copyrights. Open source is a core component of the Internet and it is available to you. Leverage the billions of dollars in resources and capabilities to build a career, establish a business or change the world. The potential is endless for those who understand the opportunity.

Business Opportunity - Goldman Sachs, IBM and countless large corporations are leveraging open source to reduce costs, develop products and increase their bottom lines. Learn what these companies know about open source and how open source can give you the advantage.

Free Software

Free Software provides computer programs and capabilities at no cost but more importantly, it provides the freedom to run, edit, contribute to, and share the software. The importance of free software is a matter of access, not price. Software at no cost is a benefit but ownership rights to the software and source code is far more significant.

Free Office Software - The Libre Office suite provides top desktop productivity tools for free. This includes, a word processor, spreadsheet, presentation engine, drawing and flowcharting, database and math applications. Libre Office is available for Linux or Windows.

Free Books

The Free Books Library is a collection of thousands of the most popular public domain books in an online readable format. The collection includes great classical literature and more recent works where the U.S. copyright has expired. These books are yours to read and use without restrictions.

Source Code - Want to change a program or know how it works? Open Source provides the source code for its programs so that anyone can use, modify or learn how to write those programs themselves. Visit the GNU source code repositories to download the source.


Study at Harvard, Stanford or MIT - Open edX provides free online courses from Harvard, MIT, Columbia, UC Berkeley and other top Universities. Hundreds of courses for almost all major subjects and course levels. Open edx also offers some paid courses and selected certifications.

Linux Manual Pages - A man or manual page is a form of software documentation found on Linux/Unix operating systems. Topics covered include computer programs (including library and system calls), formal standards and conventions, and even abstract concepts.