Provided by:
manpages-es_1.55-10_all 
NONMBRE
CMSG_ALIGN, CMSG_SPACE, CMSG_NXTHDR, CMSG_FIRSTHDR - Acceso a datos
auxiliares.
SINOPSIS
#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 {
socklen_t cmsg_len; /* cantidad de bytes de datos,
incluyendo la cabecera */
int cmsg_level; /* protocolo originario */
int cmsg_type; /* tipo especifico del protocolo */
/* seguido de
unsigned char cmsg_data[]; */
};
DESCRIPCI'ON
Estas macros se usan para crear y acceder a mensajes de control
(tambien llamados datos auxiliares) que no son parte del contenido util
de un conector. Esta informacion de control puede incluir la interfaz
en la que se ha recibido el paquete, diferentes campos de cabecera
usados raramente, una descripcion de error ampliada, un conjunto de
descriptores de fichero o credenciales de Unix. Por ejemplo, los
mensajes de control se pueden usar para enviar campos de cabecera
adicionales tales como opciones IP. Los datos auxiliares se envian
llamando a sendmsg(2) y se reciben llamando a recvmsg(2). Vea sus
paginas de manual para mas informacion.
Los datos auxiliares son una secuencia de estructuras struct cmsghdr
con datos anadidos. Solo se deberia acceder a esta secuencia usando las
macros descritas en esta pagina de manual y nunca directamente. Vea
las paginas de manual especificas del protocolo para conocer los tipos
de mensajes de control disponibles. El tamano maximo permitido del
buffer auxiliar por conector se puede configura con la sysctl
net.core.optmem_max. Vea socket(7).
CMSG_FIRSTHDR devuelve un puntero a la primera cmsghdr en el buffer de
datos auxiliares asociado con la msghdr pasada.
CMSG_NXTHDR devuelve la siguiente cmsghdr valida despues de la cmsghdr
pasada. Devuelve NULL cuando no queda suficiente espacio en el buffer.
when there isn't enough space left in the buffer.
CMSG_ALIGN, dada una longitud, la devuelve incluyendo la alineacion
necesaria. Esta es una expresion constante.
CMSG_SPACE devuelve la cantidad de bytes que ocupa un elemento auxiliar
cuyo contenido util es de la longitud de datos pasada. Esta es una
expresion constante.
CMSG_DATA devuelve un puntero a la porcion de datos de una cmsghdr.
CMSG_LEN devuelve el valor a almacenar en el miembro cmsg_len de la
estructura cmsghdr teniendo en cuenta cualquier alineacion necesaria.
Toma como argumento la longitud de los datos. Esta es una expresion
constante.
Para crear datos auxiliares, inicialice primero el miembro
msg_controllen de la estructura msghdr con el tamano del buffer de
mensajes de control. Use CMSG_FIRSTHDR sobre msghdr para obtener el
primer mensaje de control y CMSG_NEXTHDR para obtener los siguientes.
En cada mensaje de control, inicialice cmsg_len (con CMSG_LEN), los
otros campos cabecera de cmsghdr y la parte de datos usando CMSG_DATA.
Finalmente, deberia asignar al campo msg_controllen de msghdr la suma
de los CMSG_SPACE de las longitudes de todos los mensajes de control
del buffer. Para mas informacion sobre msghdr, vea recvmsg(2).
Cuando el buffer de mensajes de control es demasiado pequeno para
almacenar todos los mensajes, se activa la bandera MSG_CTRUNC en el
miembro msg_flags de msghdr.
EJEMPLO
Este codigo busca la opcion IP_TTL en un buffer auxiliar recibido:
struct msghdr msgh;
struct cmsghdr *cmsg;
int *ttlptr;
int received_ttl;
/* Recibir los datos auxiliares en msgh */
for (cmsg = CMSG_FIRSTHDR(&msgh);
cmsg != NULL;
cmsg = CMSG_NXTHDR(&msgh,cmsg) {
if (cmsg->cmsg_level == SOL_IP
&& cmsg->cmsg_type == IP_TTL) {
ttlptr = (int *) CMSG_DATA(cmsg);
received_ttl = *ttlptr;
break;
}
}
if (cmsg == NULL) {
/* Error: IP_TTL no habilitada o buffer pequeno o
* error de E/S.
*/
}
El siguiente codigo pasa un vector de descriptores de ficheros mediante
un conector Unix usando SCM_RIGHTS:
struct msghdr msg = {0};
struct cmsghdr *cmsg;
int myfds[NUM_FD]; /* Los descriptores de fichero a pasar. */
char buf[CMSG_SPACE(sizeof myfds)]; /* buffer de datos auxiliares */
int *fdptr;
msg.msg_control = buf;
msg.msg_controllen = sizeof buf;
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(sizeof(int) * NUM_FD);
/* Inicializar el contenido util: */
fdptr = (int *)CMSG_DATA(cmsg);
memcpy(fdptr, myfds, NUM_FD * sizeof(int));
/* Sumar la longitud de todos los mensajes de control en el buffer: */
msg.msg_controllen = cmsg->cmsg_len;
OBSERVACIONES
Para transportabilidad, solo se deberia acceder a los datos auxiliares
usando las macros descritas aqui. CMSG_ALIGN es una extension de Linux
y no deberia usarse en programas transportables.
En Linux, CMSG_LEN, CMSG_DATA y CMSG_ALIGN son expresiones constantes
(suponiendo que su argumento sea contante). Esto se podria usar para
declarar el tamano de variables globales pero, sin embargo, podria no
ser transportable.
CONFORME A
El modelo de datos auxiliares sigue el borrador POSIX.1003.1g, 4.4BSD-
Lite, la API avanzada de IPv6 descrita en RFC2292 y the Single Unix
specification v2. CMSG_ALIGN es una extension de Linux.
V'EASE TAMBI'EN
sendmsg(2), recvmsg(2)
RFC 2292
Pagina man de Linux 2 octubre 1998 CMSG(3)