自学教程：C++ CMSG_SPACE函数代码示例

static int process_response(int wait_for_done, unsigned seq) {    assert(fd >= 0);        do {        size_t bytes;        ssize_t r;        char replybuf[8*1024];        char cred_msg[CMSG_SPACE(sizeof(struct ucred))];        struct msghdr msghdr;        struct cmsghdr *cmsghdr;        struct ucred *ucred;        struct iovec iov;         struct nlmsghdr *p = (struct nlmsghdr *) replybuf;                memset(&iov, 0, sizeof(iov));        iov.iov_base = replybuf;  	iov.iov_len = sizeof(replybuf);        memset(&msghdr, 0, sizeof(msghdr));        msghdr.msg_name = (void*) NULL;        msghdr.msg_namelen = 0;         msghdr.msg_iov = &iov;         msghdr.msg_iovlen = 1;         msghdr.msg_control = cred_msg;         msghdr.msg_controllen = sizeof(cred_msg);  	msghdr.msg_flags = 0;                if ((r = recvmsg(fd, &msghdr, 0)) < 0) {            daemon_log(LOG_ERR, "recvmsg() failed: %s", strerror(errno));            return -1;        }        if (!(cmsghdr = CMSG_FIRSTHDR(&msghdr)) || cmsghdr->cmsg_type != SCM_CREDENTIALS) {            daemon_log(LOG_WARNING, "No sender credentials received, ignoring data.");             return -1;        }        ucred = (struct ucred*) CMSG_DATA(cmsghdr);                if (ucred->uid != 0)            return -1;        bytes = (size_t) r;                for (; bytes > 0; p = NLMSG_NEXT(p, bytes)) {            if (!NLMSG_OK(p, bytes) || bytes < sizeof(struct nlmsghdr) || bytes < p->nlmsg_len) {                daemon_log(LOG_ERR, "Netlink packet too small.");                return -1;            }            if (p->nlmsg_type == NLMSG_DONE && wait_for_done && p->nlmsg_seq == seq && (pid_t) p->nlmsg_pid == getpid())                return 0;            if (p->nlmsg_type == NLMSG_ERROR) {                struct nlmsgerr *e = (struct nlmsgerr *) NLMSG_DATA (p);                if (e->error) {                    daemon_log(LOG_ERR, "Netlink error: %s", strerror(-e->error));                    return -1;                }            }            if (process_nlmsg(p) < 0)                return -1;        }    } while (wait_for_done);    return 0;}

static void routing_packet_read(int fd){    struct in_addr src, dst;    int i, len, ttl = -1;    /*AODV_msg *aodv_msg;*/    struct dev_info *dev;    struct msghdr msgh;    struct cmsghdr *cmsg;    struct iovec iov;    char ctrlbuf[CMSG_SPACE(sizeof(int)) +        CMSG_SPACE(sizeof(struct in_pktinfo))];    struct sockaddr_in src_addr;    iov.iov_base = recv_buf;    iov.iov_len = RECV_BUF_SIZE;    msgh.msg_name = &src_addr;    msgh.msg_namelen = sizeof(src_addr);    msgh.msg_iov = &iov;    msgh.msg_iovlen = 1;    msgh.msg_control = ctrlbuf;    msgh.msg_controllen = sizeof(ctrlbuf);    len = recvmsg(fd, &msgh, 0);    if (len < 0) {        fprintf(stderr, "receive ERROR len=%d!", len);        return;    }    src.s_addr = src_addr.sin_addr.s_addr;    /* Get the ttl and destination address from the control message */    for (cmsg = CMSG_FIRSTHDR(&msgh); cmsg != NULL;            cmsg = CMSG_NXTHDR_FIX(&msgh, cmsg)) {        if (cmsg->cmsg_level == SOL_IP) {            switch (cmsg->cmsg_type) {                case IP_TTL:                    ttl = *(CMSG_DATA(cmsg));                    break;                case IP_PKTINFO:                    dst.s_addr =                        ((struct in_pktinfo *) CMSG_DATA(cmsg))->ipi_addr.s_addr;            }        }    }    if (ttl < 0) {        fprintf(stderr, "No TTL, packet ignored!");        return;    }    /* Ignore messages generated locally */    for (i = 0; i < MAX_NR_INTERFACES; i++)        if (this_host.devs[i].enabled &&                memcmp(&src, &this_host.devs[i].ipaddr,                    sizeof(struct in_addr)) == 0)            return;    /*aodv_msg = (AODV_msg *) recv_buf;*/    /*dev = devfromsock(fd);*/    callback_set.prot_callback(recv_buf, RECV_BUF_SIZE);#if 0     if (!dev) {        DEBUG(LOG_ERR, 0, "Could not get device info!/n");        return;    }#endif}

/* * Class:     sun_nio_ch_sctp_SctpChannelImpl * Method:    receive0 * Signature: (ILsun/nio/ch/sctp/ResultContainer;JIZ)I */JNIEXPORT jint JNICALL Java_sun_nio_ch_sctp_SctpChannelImpl_receive0  (JNIEnv *env, jclass klass, jint fd, jobject resultContainerObj,   jlong address, jint length, jboolean peek) {    SOCKADDR sa;    int sa_len = sizeof(sa);    ssize_t rv = 0;    jlong *addr = jlong_to_ptr(address);    struct iovec iov[1];    struct msghdr msg[1];    char cbuf[CMSG_SPACE(sizeof (struct sctp_sndrcvinfo))];    int flags = peek == JNI_TRUE ? MSG_PEEK : 0;    /* Set up the msghdr structure for receiving */    memset(msg, 0, sizeof (*msg));    msg->msg_name = &sa;    msg->msg_namelen = sa_len;    iov->iov_base = addr;    iov->iov_len = length;    msg->msg_iov = iov;    msg->msg_iovlen = 1;    msg->msg_control = cbuf;    msg->msg_controllen = sizeof(cbuf);    msg->msg_flags = 0;    do {        if ((rv = recvmsg(fd, msg, flags)) < 0) {            if (errno == EWOULDBLOCK) {                return IOS_UNAVAILABLE;            } else if (errno == EINTR) {                return IOS_INTERRUPTED;#ifdef __linux__            } else if (errno == ENOTCONN) {                /* ENOTCONN when EOF reached */                rv = 0;                /* there will be no control data */                msg->msg_controllen = 0;#endif /* __linux__ */            } else {                handleSocketError(env, errno);                return 0;            }        }        if (msg->msg_flags & MSG_NOTIFICATION) {            char *bufp = (char*)addr;            union sctp_notification *snp;            if (!(msg->msg_flags & MSG_EOR) && length < NOTIFICATION_BUFFER_SIZE) {                char buf[NOTIFICATION_BUFFER_SIZE];                int rvSAVE = rv;                memcpy(buf, addr, rv);                iov->iov_base = buf + rv;                iov->iov_len = NOTIFICATION_BUFFER_SIZE - rv;                if ((rv = recvmsg(fd, msg, flags)) < 0) {                    handleSocketError(env, errno);                    return 0;                }                bufp = buf;                rv += rvSAVE;            }            snp = (union sctp_notification *) bufp;            if (handleNotification(env, fd, resultContainerObj, snp, rv,                                   (msg->msg_flags & MSG_EOR),                                   (struct sockaddr*)&sa ) == JNI_TRUE) {                /* We have received a notification that is of interest to                   to the Java API. The appropriate notification will be                   set in the result container. */                return 0;            }            // set iov back to addr, and reset msg_controllen            iov->iov_base = addr;            iov->iov_len = length;            msg->msg_control = cbuf;            msg->msg_controllen = sizeof(cbuf);        }    } while (msg->msg_flags & MSG_NOTIFICATION);    handleMessage(env, resultContainerObj, msg, rv,            (msg->msg_flags & MSG_EOR), (struct sockaddr*)&sa);    return rv;}

int main(int argc, char *argv[]){        int sk1, sk2;        sockaddr_storage_t loop1;        sockaddr_storage_t loop2;        struct iovec iov;        struct msghdr inmessage;	struct msghdr outmessage;	char incmsg[CMSG_SPACE(sizeof(sctp_cmsg_data_t))];	char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];	struct cmsghdr *cmsg;	struct sctp_sndrcvinfo *sinfo;        struct iovec out_iov;        int error;	int pf_class;	uint32_t ppid;	uint32_t stream;	sctp_assoc_t associd1;	struct sctp_assoc_change *sac;	struct sctp_event_subscribe subscribe;	char *big_buffer;	int offset;	struct sctp_send_failed *ssf;	socklen_t len; /* Really becomes 2xlen when set. */	int orig_len; 	struct sctp_status gstatus;        /* Rather than fflush() throughout the code, set stdout to	 * be unbuffered.	 */	setvbuf(stdout, NULL, _IONBF, 0);	/* Set some basic values which depend on the address family. */#if TEST_V6	pf_class = PF_INET6;        loop1.v6.sin6_family = AF_INET6;        loop1.v6.sin6_addr = in6addr_loopback;        loop1.v6.sin6_port = htons(SCTP_TESTPORT_1);        loop2.v6.sin6_family = AF_INET6;        loop2.v6.sin6_addr = in6addr_loopback;        loop2.v6.sin6_port = htons(SCTP_TESTPORT_2);#else	pf_class = PF_INET;        loop1.v4.sin_family = AF_INET;        loop1.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;        loop1.v4.sin_port = htons(SCTP_TESTPORT_1);        loop2.v4.sin_family = AF_INET;        loop2.v4.sin_addr.s_addr = SCTP_IP_LOOPBACK;        loop2.v4.sin_port = htons(SCTP_TESTPORT_2);#endif /* TEST_V6 */        /* Create the two endpoints which will talk to each other.  */        sk1 = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);        sk2 = test_socket(pf_class, SOCK_SEQPACKET, IPPROTO_SCTP);	len = sizeof(int);	error = getsockopt(sk2, SOL_SOCKET, SO_RCVBUF, &orig_len,			   &len);	if (error)		tst_brkm(TBROK, tst_exit, "can't get rcvbuf size: %s",			strerror(errno));	/* Set the MAXSEG to something smallish. */	{		int val = SMALL_MAXSEG;		test_setsockopt(sk1, SCTP_MAXSEG, &val, sizeof(val));	}	memset(&subscribe, 0, sizeof(subscribe));	subscribe.sctp_data_io_event = 1;	subscribe.sctp_association_event = 1;	subscribe.sctp_send_failure_event = 1;	test_setsockopt(sk1, SCTP_EVENTS, &subscribe, sizeof(subscribe));	test_setsockopt(sk2, SCTP_EVENTS, &subscribe, sizeof(subscribe));        /* Bind these sockets to the test ports.  */        test_bind(sk1, &loop1.sa, sizeof(loop1));        test_bind(sk2, &loop2.sa, sizeof(loop2));	/*	 * This code sets the associations RWND very small so we can	 * fill it.  It does this by manipulating the rcvbuf as follows:	 * 1) Reduce the rcvbuf size on the socket	 * 2) create an association so that we advertize rcvbuf/2 as	 *    our initial rwnd	 * 3) raise the rcvbuf value so that we don't drop data wile 	 *    receiving later data	 */	len = SMALL_RCVBUF;	error = setsockopt(sk2, SOL_SOCKET, SO_RCVBUF, &len,			   sizeof(len));	if (error)		tst_brkm(TBROK, tst_exit, "setsockopt(SO_RCVBUF): %s",			 strerror(errno));       /* Mark sk2 as being able to accept new associations.  */	test_listen(sk2, 1);//.........这里部分代码省略.........

static intread_cmsgspecs(struct thread *td, int ncmsghdrs, struct cmsgspec **cmsgspecs,	       payload_size_t *payload_size){	struct cmsgspec *spec, *specs;	payload_size_t actual_payload_size, level_len, nfds_len, type_len;	size_t datasize, size;	int error, i, level, nfds, type;	size = sizeof(specs[0]) * ncmsghdrs;	specs = (struct cmsgspec *)fmaster_malloc(td, size);	if (specs == NULL)		return (ENOMEM);	actual_payload_size = 0;	for (i = 0; i < ncmsghdrs; i++) {		spec = &specs[i];		error = fmaster_read_int(td, &level, &level_len);		if (error != 0)			return (error);		actual_payload_size += level_len;		error = fmaster_read_int(td, &type, &type_len);		if (error != 0)			return (error);		actual_payload_size += type_len;		spec->cmsgspec_level = level;		spec->cmsgspec_type = type;		switch (level) {		case SOL_SOCKET:			switch (type) {			case SCM_CREDS:				datasize = sizeof(struct cmsgcred);				break;			case SCM_RIGHTS:				error = fmaster_read_int(td, &nfds, &nfds_len);				if (error != 0)					return (error);				actual_payload_size += nfds_len;				spec->cmsgspec_nfds = nfds;				datasize = sizeof(int) * nfds;				break;			default:				datasize = 0;				break;			}			break;		default:			datasize = 0;			break;		}		spec->cmsgspec_len = CMSG_LEN(datasize);		spec->cmsgspec_space = CMSG_SPACE(datasize);	}	*cmsgspecs = specs;	*payload_size = actual_payload_size;	return (0);}

voidngx_event_recvmsg(ngx_event_t *ev){    ssize_t            n;    ngx_log_t         *log;    ngx_err_t          err;    ngx_event_t       *rev, *wev;    struct iovec       iov[1];    struct msghdr      msg;    ngx_listening_t   *ls;    ngx_event_conf_t  *ecf;    ngx_connection_t  *c, *lc;    u_char             sa[NGX_SOCKADDRLEN];    static u_char      buffer[65535];#if (NGX_HAVE_MSGHDR_MSG_CONTROL)#if (NGX_HAVE_IP_RECVDSTADDR)    u_char             msg_control[CMSG_SPACE(sizeof(struct in_addr))];#elif (NGX_HAVE_IP_PKTINFO)    u_char             msg_control[CMSG_SPACE(sizeof(struct in_pktinfo))];#endif#if (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)    u_char             msg_control6[CMSG_SPACE(sizeof(struct in6_pktinfo))];#endif#endif    if (ev->timedout) {        if (ngx_enable_accept_events((ngx_cycle_t *) ngx_cycle) != NGX_OK) {            return;        }        ev->timedout = 0;    }    ecf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_event_core_module);    if (!(ngx_event_flags & NGX_USE_KQUEUE_EVENT)) {        ev->available = ecf->multi_accept;    }    lc = ev->data;    ls = lc->listening;    ev->ready = 0;    ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,                   "recvmsg on %V, ready: %d", &ls->addr_text, ev->available);    do {        ngx_memzero(&msg, sizeof(struct msghdr));        iov[0].iov_base = (void *) buffer;        iov[0].iov_len = sizeof(buffer);        msg.msg_name = &sa;        msg.msg_namelen = sizeof(sa);        msg.msg_iov = iov;        msg.msg_iovlen = 1;#if (NGX_HAVE_MSGHDR_MSG_CONTROL)        if (ls->wildcard) {#if (NGX_HAVE_IP_RECVDSTADDR || NGX_HAVE_IP_PKTINFO)            if (ls->sockaddr->sa_family == AF_INET) {                msg.msg_control = &msg_control;                msg.msg_controllen = sizeof(msg_control);            }#endif#if (NGX_HAVE_INET6 && NGX_HAVE_IPV6_RECVPKTINFO)            if (ls->sockaddr->sa_family == AF_INET6) {                msg.msg_control = &msg_control6;                msg.msg_controllen = sizeof(msg_control6);            }#endif        }#endif        n = recvmsg(lc->fd, &msg, 0);        if (n == -1) {            err = ngx_socket_errno;            if (err == NGX_EAGAIN) {                ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, err,                               "recvmsg() not ready");                return;            }            ngx_log_error(NGX_LOG_ALERT, ev->log, err, "recvmsg() failed");            return;        }#if (NGX_STAT_STUB)        (void) ngx_atomic_fetch_add(ngx_stat_accepted, 1);//.........这里部分代码省略.........

  Object* IO::recv_fd(STATE) {#ifdef _WIN32    return Primitives::failure();#else    struct msghdr msg;    struct iovec vec[1];    char buf[1];    struct cmsghdr *cmsg;    char cmsg_buf[cmsg_space];    msg.msg_name = NULL;    msg.msg_namelen = 0;    /* Linux and Solaris doesn't work if msg_iov is NULL. */    buf[0] = '/0';    vec[0].iov_base = buf;    vec[0].iov_len = 1;    msg.msg_iov = vec;    msg.msg_iovlen = 1;    msg.msg_control = (caddr_t)cmsg_buf;    msg.msg_controllen = sizeof(cmsg_buf);    msg.msg_flags = 0;    cmsg = CMSG_FIRSTHDR(&msg);    memset(cmsg_buf, 0, sizeof(cmsg_buf));    cmsg->cmsg_len = CMSG_LEN(sizeof(int));    cmsg->cmsg_level = SOL_SOCKET;    cmsg->cmsg_type = SCM_RIGHTS;    // Workaround for GCC's broken strict-aliasing checks.    int* fd_data = (int *)CMSG_DATA(cmsg);    *fd_data = -1;    int read_fd = descriptor(state);    int code = -1;  retry:    state->vm()->interrupt_with_signal();    state->vm()->thread()->sleep(state, cTrue);    {      UnmanagedPhase unmanaged(state);      code = recvmsg(read_fd, &msg, 0);    }    state->vm()->thread()->sleep(state, cFalse);    state->vm()->clear_waiter();    if(code == -1) {      if(errno == EAGAIN || errno == EINTR) {        if(state->vm()->thread_interrupted_p(state)) return NULL;        ensure_open(state);        goto retry;      }      return Primitives::failure();    }    if(msg.msg_controllen != CMSG_SPACE(sizeof(int))        || cmsg->cmsg_len != CMSG_LEN(sizeof(int))        || cmsg->cmsg_level != SOL_SOCKET        || cmsg->cmsg_type != SCM_RIGHTS) {      return Primitives::failure();    }    // Workaround for GCC's broken strict-aliasing checks.    fd_data = (int *)CMSG_DATA(cmsg);    return Fixnum::from(*fd_data);#endif  }

int J1939SocketRead (int Socket, struct J1939FrameBag *Bags, unsigned int BagsCount, int TimeoutMs){    struct mmsghdr msgs[BagsCount];    struct iovec iovs[BagsCount];    struct sockaddr_can addr[BagsCount];    char ctrlmsgs[BagsCount][            CMSG_SPACE(sizeof(struct timeval))          + CMSG_SPACE(sizeof(__u8)) /* dest addr */          + CMSG_SPACE(sizeof(__u64)) /* dest name */          + CMSG_SPACE(sizeof(__u8)) /* priority */          ];    unsigned int i;    for (i = 0; i < BagsCount; i++)    {        memset(&msgs[i], 0, sizeof(msgs[0]));        memset(&iovs[i], 0, sizeof(iovs[0]));        memset(&addr[i], 0, sizeof(addr[0]));        msgs[i].msg_hdr.msg_name = &addr[i];        msgs[i].msg_hdr.msg_namelen = sizeof(struct sockaddr_can);        iovs[i].iov_base = (void *) &(Bags[i].Frame.data);        iovs[i].iov_len = sizeof(Bags[i].Frame.data);        msgs[i].msg_hdr.msg_iov = &iovs[i];        msgs[i].msg_hdr.msg_iovlen = 1;        msgs[i].msg_hdr.msg_control = &ctrlmsgs[i];        msgs[i].msg_hdr.msg_controllen = sizeof(ctrlmsgs[0]);        msgs[i].msg_hdr.msg_flags = 0;    }    struct timeval tNow, tEnd;    for ( initTimers(&tNow, &tEnd, TimeoutMs); timercmp(&tNow, &tEnd, <=); gettimeofday (&tNow, NULL) )    {        int rcount;        rcount = recvmmsg(Socket, msgs, BagsCount, MSG_DONTWAIT, NULL);        if (rcount >= 0)        {            int i;            for (i = 0; i < rcount; i ++)            {                struct timeval tv;                struct cmsghdr *cmsg;                for (cmsg = CMSG_FIRSTHDR(&msgs[i].msg_hdr);                    cmsg;                    cmsg = CMSG_NXTHDR(&msgs[i].msg_hdr,cmsg))                {                    switch (cmsg->cmsg_level) {                    case SOL_SOCKET:                        if (cmsg->cmsg_type == SO_TIMESTAMP)                        {                            tv = *(struct timeval *)CMSG_DATA(cmsg);                            Bags[i].TimeStamp.seconds = tv.tv_sec;                            Bags[i].TimeStamp.microseconds = tv.tv_usec;                        }                        else if (cmsg->cmsg_type == SO_RXQ_OVFL)                            Bags[i].DroppedMessagesCount = *(__u32 *)CMSG_DATA(cmsg);                        break;                    case SOL_CAN_J1939:                        break;                    }                }                Bags[i].Frame.pgn = addr[i].can_addr.j1939.pgn;                Bags[i].Frame.length = msgs[i].msg_len;                if (msgs[i].msg_hdr.msg_flags & MSG_CONFIRM)                    Bags[i].Flags |= (1 << 0);            }            return rcount;        }        else        {            int errsv = errno;            if (errsv == EAGAIN)            {              usleep (100);              continue;            }            else              return errsv;        }    }    return 0;}

static PyObject *sendmsg_sendmsg(PyObject *self, PyObject *args, PyObject *keywds) {    int fd;    int flags = 0;    Py_ssize_t sendmsg_result, iovec_length;    struct msghdr message_header;    struct iovec iov[1];    PyObject *ancillary = NULL;    PyObject *iterator = NULL;    PyObject *item = NULL;    PyObject *result_object = NULL;    static char *kwlist[] = {"fd", "data", "flags", "ancillary", NULL};    if (!PyArg_ParseTupleAndKeywords(            args, keywds, "it#|iO:sendmsg", kwlist,            &fd,            &iov[0].iov_base,            &iovec_length,            &flags,            &ancillary)) {        return NULL;    }    iov[0].iov_len = iovec_length;    message_header.msg_name = NULL;    message_header.msg_namelen = 0;    message_header.msg_iov = iov;    message_header.msg_iovlen = 1;    message_header.msg_control = NULL;    message_header.msg_controllen = 0;    message_header.msg_flags = 0;    if (ancillary) {        if (!PyList_Check(ancillary)) {            PyErr_Format(PyExc_TypeError,                         "send1msg argument 3 expected list, got %s",                         ancillary->ob_type->tp_name);            goto finished;        }        iterator = PyObject_GetIter(ancillary);        if (iterator == NULL) {            goto finished;        }        size_t all_data_len = 0;        /* First we need to know how big the buffer needs to be in order to           have enough space for all of the messages. */        while ( (item = PyIter_Next(iterator)) ) {            int type, level;            Py_ssize_t data_len;            size_t prev_all_data_len;            char *data;            if (!PyTuple_Check(item)) {                PyErr_Format(PyExc_TypeError,                             "send1msg argument 3 expected list of tuple, "                             "got list containing %s",                             item->ob_type->tp_name);                goto finished;            }            if (!PyArg_ParseTuple(                        item, "iit#:sendmsg ancillary data (level, type, data)",                        &level, &type, &data, &data_len)) {                goto finished;            }            prev_all_data_len = all_data_len;            all_data_len += CMSG_SPACE(data_len);            Py_DECREF(item);            item = NULL;            if (all_data_len < prev_all_data_len) {                PyErr_Format(PyExc_OverflowError,                             "Too much msg_control to fit in a size_t: %zu",                             prev_all_data_len);                goto finished;            }        }        Py_DECREF(iterator);        iterator = NULL;        /* Allocate the buffer for all of the ancillary elements, if we have         * any.  */        if (all_data_len) {            if (all_data_len > SOCKLEN_MAX) {                PyErr_Format(PyExc_OverflowError,                             "Too much msg_control to fit in a socklen_t: %zu",                             all_data_len);//.........这里部分代码省略.........

static int dgram_sctp_write(BIO *b, const char *in, int inl)	{	int ret;	bio_dgram_sctp_data *data = (bio_dgram_sctp_data *)b->ptr;	struct bio_dgram_sctp_sndinfo *sinfo = &(data->sndinfo);	struct bio_dgram_sctp_prinfo *pinfo = &(data->prinfo);	struct bio_dgram_sctp_sndinfo handshake_sinfo;	struct iovec iov[1];	struct msghdr msg;	struct cmsghdr *cmsg;#if defined(SCTP_SNDINFO) && defined(SCTP_PRINFO)	char cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndinfo)) + CMSG_SPACE(sizeof(struct sctp_prinfo))];	struct sctp_sndinfo *sndinfo;	struct sctp_prinfo *prinfo;#else	char cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];	struct sctp_sndrcvinfo *sndrcvinfo;#endif	clear_socket_error();	/* If we're send anything else than application data,	 * disable all user parameters and flags.	 */	if (in[0] != 23) {		memset(&handshake_sinfo, 0x00, sizeof(struct bio_dgram_sctp_sndinfo));#ifdef SCTP_SACK_IMMEDIATELY		handshake_sinfo.snd_flags = SCTP_SACK_IMMEDIATELY;#endif		sinfo = &handshake_sinfo;	}	/* If we have to send a shutdown alert message and the	 * socket is not dry yet, we have to save it and send it	 * as soon as the socket gets dry.	 */	if (data->save_shutdown && !BIO_dgram_sctp_wait_for_dry(b))	{		data->saved_message.bio = b;		data->saved_message.length = inl;		data->saved_message.data = OPENSSL_malloc(inl);		memcpy(data->saved_message.data, in, inl);		return inl;	}	iov[0].iov_base = (char *)in;	iov[0].iov_len = inl;	msg.msg_name = NULL;	msg.msg_namelen = 0;	msg.msg_iov = iov;	msg.msg_iovlen = 1;	msg.msg_control = (caddr_t)cmsgbuf;	msg.msg_controllen = 0;	msg.msg_flags = 0;#if defined(SCTP_SNDINFO) && defined(SCTP_PRINFO)	cmsg = (struct cmsghdr *)cmsgbuf;	cmsg->cmsg_level = IPPROTO_SCTP;	cmsg->cmsg_type = SCTP_SNDINFO;	cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));	sndinfo = (struct sctp_sndinfo *)CMSG_DATA(cmsg);	memset(sndinfo, 0, sizeof(struct sctp_sndinfo));	sndinfo->snd_sid = sinfo->snd_sid;	sndinfo->snd_flags = sinfo->snd_flags;	sndinfo->snd_ppid = sinfo->snd_ppid;	sndinfo->snd_context = sinfo->snd_context;	msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));	cmsg = (struct cmsghdr *)&cmsgbuf[CMSG_SPACE(sizeof(struct sctp_sndinfo))];	cmsg->cmsg_level = IPPROTO_SCTP;	cmsg->cmsg_type = SCTP_PRINFO;	cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));	prinfo = (struct sctp_prinfo *)CMSG_DATA(cmsg);	memset(prinfo, 0, sizeof(struct sctp_prinfo));	prinfo->pr_policy = pinfo->pr_policy;	prinfo->pr_value = pinfo->pr_value;	msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));#else	cmsg = (struct cmsghdr *)cmsgbuf;	cmsg->cmsg_level = IPPROTO_SCTP;	cmsg->cmsg_type = SCTP_SNDRCV;	cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));	sndrcvinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);	memset(sndrcvinfo, 0, sizeof(struct sctp_sndrcvinfo));	sndrcvinfo->sinfo_stream = sinfo->snd_sid;	sndrcvinfo->sinfo_flags = sinfo->snd_flags;#ifdef __FreeBSD__	sndrcvinfo->sinfo_flags |= pinfo->pr_policy;#endif	sndrcvinfo->sinfo_ppid = sinfo->snd_ppid;	sndrcvinfo->sinfo_context = sinfo->snd_context;	sndrcvinfo->sinfo_timetolive = pinfo->pr_value;	msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndrcvinfo));#endif	ret = sendmsg(b->num, &msg, 0);	BIO_clear_retry_flags(b);	if (ret <= 0)		{		if (BIO_dgram_should_retry(ret))//.........这里部分代码省略.........

/** * Send netlink message. * @arg sk		Netlink socket. * @arg msg		Netlink message to be sent. * @arg iov		iovec to be sent. * @arg iovlen		number of struct iovec to be sent. * @see nl_sendmsg() * @return Number of characters sent on success or a negative error code. */int nl_send_iovec(struct nl_sock *sk, struct nl_msg *msg, struct iovec *iov, unsigned iovlen){	struct sockaddr_nl *dst;	struct ucred *creds;	struct msghdr hdr = {		.msg_name = (void *) &sk->s_peer,		.msg_namelen = sizeof(struct sockaddr_nl),		.msg_iov = iov,		.msg_iovlen = iovlen,	};	/* Overwrite destination if specified in the message itself, defaults	 * to the peer address of the socket.	 */	dst = nlmsg_get_dst(msg);	if (dst->nl_family == AF_NETLINK)		hdr.msg_name = dst;	/* Add credentials if present. */	creds = nlmsg_get_creds(msg);	if (creds != NULL) {		char buf[CMSG_SPACE(sizeof(struct ucred))];		struct cmsghdr *cmsg;		hdr.msg_control = buf;		hdr.msg_controllen = sizeof(buf);		cmsg = CMSG_FIRSTHDR(&hdr);		cmsg->cmsg_level = SOL_SOCKET;		cmsg->cmsg_type = SCM_CREDENTIALS;		cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));		memcpy(CMSG_DATA(cmsg), creds, sizeof(struct ucred));	}	return nl_sendmsg(sk, msg, &hdr);}/*** Send netlink message.* @arg sk		Netlink socket.* @arg msg		Netlink message to be sent.* @see nl_sendmsg()* @return Number of characters sent on success or a negative error code.*/int nl_send(struct nl_sock *sk, struct nl_msg *msg){	struct iovec iov = {		.iov_base = (void *) nlmsg_hdr(msg),		.iov_len = nlmsg_hdr(msg)->nlmsg_len,	};	return nl_send_iovec(sk, msg, &iov, 1);}void nl_auto_complete(struct nl_sock *sk, struct nl_msg *msg){	struct nlmsghdr *nlh;	nlh = nlmsg_hdr(msg);	if (nlh->nlmsg_pid == 0)		nlh->nlmsg_pid = sk->s_local.nl_pid;	if (nlh->nlmsg_seq == 0)		nlh->nlmsg_seq = sk->s_seq_next++;	if (msg->nm_protocol == -1)		msg->nm_protocol = sk->s_proto;	nlh->nlmsg_flags |= NLM_F_REQUEST;	if (!(sk->s_flags & NL_NO_AUTO_ACK))		nlh->nlmsg_flags |= NLM_F_ACK;}/** * Send netlink message and check & extend header values as needed. * @arg sk		Netlink socket. * @arg msg		Netlink message to be sent. * * Checks the netlink message /c nlh for completness and extends it * as required before sending it out. Checked fields include pid, * sequence nr, and flags. * * @see nl_send() * @return Number of characters sent or a negative error code. */int nl_send_auto_complete(struct nl_sock *sk, struct nl_msg *msg){	struct nl_cb *cb = sk->s_cb;//.........这里部分代码省略.........

bool Connection::sendOutgoingMessage(std::unique_ptr<MessageEncoder> encoder){    COMPILE_ASSERT(sizeof(MessageInfo) + attachmentMaxAmount * sizeof(size_t) <= messageMaxSize, AttachmentsFitToMessageInline);    Vector<Attachment> attachments = encoder->releaseAttachments();    AttachmentResourceGuard<Vector<Attachment>, Vector<Attachment>::iterator> attachementDisposer(attachments);    if (attachments.size() > (attachmentMaxAmount - 1)) {        ASSERT_NOT_REACHED();        return false;    }    MessageInfo messageInfo(encoder->bufferSize(), attachments.size());    size_t messageSizeWithBodyInline = sizeof(messageInfo) + (attachments.size() * sizeof(AttachmentInfo)) + encoder->bufferSize();    if (messageSizeWithBodyInline > messageMaxSize && encoder->bufferSize()) {        RefPtr<WebKit::SharedMemory> oolMessageBody = WebKit::SharedMemory::create(encoder->bufferSize());        if (!oolMessageBody)            return false;        WebKit::SharedMemory::Handle handle;        if (!oolMessageBody->createHandle(handle, WebKit::SharedMemory::ReadOnly))            return false;        messageInfo.setMessageBodyIsOutOfLine();        memcpy(oolMessageBody->data(), encoder->buffer(), encoder->bufferSize());        attachments.append(handle.releaseToAttachment());    }    struct msghdr message;    memset(&message, 0, sizeof(message));    struct iovec iov[3];    memset(&iov, 0, sizeof(iov));    message.msg_iov = iov;    int iovLength = 1;    iov[0].iov_base = reinterpret_cast<void*>(&messageInfo);    iov[0].iov_len = sizeof(messageInfo);    auto attachmentInfo = std::make_unique<AttachmentInfo[]>(attachments.size());    size_t attachmentFDBufferLength = 0;    if (!attachments.isEmpty()) {        for (size_t i = 0; i < attachments.size(); ++i) {            if (attachments[i].fileDescriptor() != -1)                attachmentFDBufferLength++;        }    }    auto attachmentFDBuffer = std::make_unique<char[]>(CMSG_SPACE(sizeof(int) * attachmentFDBufferLength));    if (!attachments.isEmpty()) {        int* fdPtr = 0;        if (attachmentFDBufferLength) {            message.msg_control = attachmentFDBuffer.get();            message.msg_controllen = CMSG_SPACE(sizeof(int) * attachmentFDBufferLength);            memset(message.msg_control, 0, message.msg_controllen);            struct cmsghdr* cmsg = CMSG_FIRSTHDR(&message);            cmsg->cmsg_level = SOL_SOCKET;            cmsg->cmsg_type = SCM_RIGHTS;            cmsg->cmsg_len = CMSG_LEN(sizeof(int) * attachmentFDBufferLength);            fdPtr = reinterpret_cast<int*>(CMSG_DATA(cmsg));        }        int fdIndex = 0;        for (size_t i = 0; i < attachments.size(); ++i) {            attachmentInfo[i].setType(attachments[i].type());            switch (attachments[i].type()) {            case Attachment::MappedMemoryType:                attachmentInfo[i].setSize(attachments[i].size());                // Fall trhough, set file descriptor or null.            case Attachment::SocketType:                if (attachments[i].fileDescriptor() != -1) {                    ASSERT(fdPtr);                    fdPtr[fdIndex++] = attachments[i].fileDescriptor();                } else                    attachmentInfo[i].setNull();                break;            case Attachment::Uninitialized:            default:                break;            }        }        iov[iovLength].iov_base = attachmentInfo.get();        iov[iovLength].iov_len = sizeof(AttachmentInfo) * attachments.size();        ++iovLength;    }    if (!messageInfo.isMessageBodyIsOutOfLine() && encoder->bufferSize()) {        iov[iovLength].iov_base = reinterpret_cast<void*>(encoder->buffer());        iov[iovLength].iov_len = encoder->bufferSize();        ++iovLength;    }//.........这里部分代码省略.........

/** * Install the seccomp-bpf that generates trace traps for all syscalls * other than those made through _untraced_syscall_entry_point(). */static void install_syscall_filter(void){	void* untraced_syscall_start = get_untraced_syscall_entry_point();	struct sock_filter filter[] = {		/* Allow all system calls from our protected_call		 * callsite */		ALLOW_SYSCALLS_FROM_CALLSITE((uintptr_t)untraced_syscall_start),		/* All the rest are handled in rr */		TRACE_PROCESS,	};	struct sock_fprog prog = {		.len = (unsigned short)(sizeof(filter)/sizeof(filter[0])),		.filter = filter,	};	debug("Initializing syscall buffer: protected_call_start = %p",	      untraced_syscall_start);	if (traced_prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) {		fatal("prctl(NO_NEW_PRIVS) failed, SECCOMP_FILTER is not available: your kernel is too old.  Use `record -n` to disable the filter.");	}	/* Note: the filter is installed only for record. This call	 * will be emulated in the replay */	if (traced_prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER,			 (uintptr_t)&prog, 0, 0)) {		fatal("prctl(SECCOMP) failed, SECCOMP_FILTER is not available: your kernel is too old.  Use `record -n` to disable the filter.");	}	/* anything that happens from this point on gets filtered! */}/** * Return a counter that generates a signal targeted at this task * every time the task is descheduled |nr_descheds| times. */static int open_desched_event_counter(size_t nr_descheds, pid_t tid){	struct perf_event_attr attr;	int fd;	struct f_owner_ex own;	memset(&attr, 0, sizeof(attr));	attr.size = sizeof(attr);	attr.type = PERF_TYPE_SOFTWARE;	attr.config = PERF_COUNT_SW_CONTEXT_SWITCHES;	attr.disabled = 1;	attr.sample_period = nr_descheds;	fd = traced_perf_event_open(&attr, 0/*self*/, -1/*any cpu*/, -1, 0);	if (0 > fd) {		fatal("Failed to perf_event_open(cs, period=%u)", nr_descheds);	}	if (traced_fcntl(fd, F_SETFL, O_ASYNC)) {		fatal("Failed to fcntl(O_ASYNC) the desched counter");	}	own.type = F_OWNER_TID;	own.pid = tid;	if (traced_fcntl(fd, F_SETOWN_EX, &own)) {		fatal("Failed to fcntl(SETOWN_EX) the desched counter to this");	}	if (traced_fcntl(fd, F_SETSIG, SYSCALLBUF_DESCHED_SIGNAL)) {		fatal("Failed to fcntl(SETSIG, %d) the desched counter",		      SYSCALLBUF_DESCHED_SIGNAL);	}	return fd;}static void set_up_buffer(void){	struct sockaddr_un addr;	struct msghdr msg;	struct iovec data;	int msgbuf;	struct cmsghdr* cmsg;	int* msg_fdptr;	int* cmsg_fdptr;	char cmsgbuf[CMSG_SPACE(sizeof(*cmsg_fdptr))];	struct socketcall_args args_vec;	struct rrcall_init_buffers_params args;	pid_t tid = traced_gettid();	assert(!buffer);	/* NB: we want this setup emulated during replay. */	if (buffer_enabled) {		desched_counter_fd = open_desched_event_counter(1, tid);	}	/* Prepare arguments for rrcall.  We do this in the tracee	 * just to avoid some hairy IPC to set up the arguments	 * remotely from the tracer; this isn't strictly	 * necessary. */	prepare_syscallbuf_socket_addr(&addr, tid);	memset(&msg, 0, sizeof(msg));//.........这里部分代码省略.........

static PyObject *sendmsg_recvmsg(PyObject *self, PyObject *args, PyObject *keywds) {    int fd = -1;    int flags = 0;    int maxsize = 8192;    int cmsg_size = 4096;    size_t cmsg_space;    size_t cmsg_overhead;    Py_ssize_t recvmsg_result;    struct msghdr message_header;    struct cmsghdr *control_message;    struct iovec iov[1];    char *cmsgbuf;    PyObject *ancillary;    PyObject *final_result = NULL;    static char *kwlist[] = {"fd", "flags", "maxsize", "cmsg_size", NULL};    if (!PyArg_ParseTupleAndKeywords(args, keywds, "i|iii:recvmsg", kwlist,                                     &fd, &flags, &maxsize, &cmsg_size)) {        return NULL;    }    cmsg_space = CMSG_SPACE(cmsg_size);    /* overflow check */    if (cmsg_space > SOCKLEN_MAX) {        PyErr_Format(PyExc_OverflowError,                     "CMSG_SPACE(cmsg_size) greater than SOCKLEN_MAX: %d",                     cmsg_size);        return NULL;    }    message_header.msg_name = NULL;    message_header.msg_namelen = 0;    iov[0].iov_len = maxsize;    iov[0].iov_base = PyMem_Malloc(maxsize);    if (!iov[0].iov_base) {        PyErr_NoMemory();        return NULL;    }    message_header.msg_iov = iov;    message_header.msg_iovlen = 1;    cmsgbuf = PyMem_Malloc(cmsg_space);    if (!cmsgbuf) {        PyMem_Free(iov[0].iov_base);        PyErr_NoMemory();        return NULL;    }    memset(cmsgbuf, 0, cmsg_space);    message_header.msg_control = cmsgbuf;    /* see above for overflow check */    message_header.msg_controllen = (socklen_t) cmsg_space;    recvmsg_result = recvmsg(fd, &message_header, flags);    if (recvmsg_result < 0) {        PyErr_SetFromErrno(sendmsg_socket_error);        goto finished;    }    ancillary = PyList_New(0);    if (!ancillary) {        goto finished;    }    for (control_message = CMSG_FIRSTHDR(&message_header);         control_message;         control_message = CMSG_NXTHDR(&message_header,                                       control_message)) {        PyObject *entry;        /* Some platforms apparently always fill out the ancillary data           structure with a single bogus value if none is provided; ignore it,           if that is the case. */        if ((!(control_message->cmsg_level)) &&            (!(control_message->cmsg_type))) {            continue;        }        /*         * Figure out how much of the cmsg size is cmsg structure overhead - in         * other words, how much is not part of the application data.  This lets         * us compute the right application data size below.  There should         * really be a CMSG_ macro for this.         */        cmsg_overhead = (char*)CMSG_DATA(control_message) - (char*)control_message;        entry = Py_BuildValue(            "(iis#)",            control_message->cmsg_level,            control_message->cmsg_type,            CMSG_DATA(control_message),            (Py_ssize_t) (control_message->cmsg_len - cmsg_overhead));//.........这里部分代码省略.........

struct command *read_command( int cmd_fd ) {	struct command *cmd = malloc(sizeof(struct command));	if (! cmd) {		fprintf(stderr, "Unable to allocate memory for command!/n");		return NULL;	}	int fd[1] = {-1};	char buffer[CMSG_SPACE(sizeof fd)];	struct iovec v = {		.iov_base = cmd,		.iov_len  = sizeof(*cmd)	};	struct msghdr msg = {		.msg_iov        = &v,		.msg_iovlen     = 1,		.msg_control    = buffer,		.msg_controllen = sizeof(buffer)	};	int done = recvmsg( cmd_fd, &msg, 0 );	if (done == -1) {		fprintf(stderr, "Error reading command.");		free(cmd);		return NULL;	}	struct cmsghdr *cmessage = CMSG_FIRSTHDR(&msg);	if (cmessage) {		memcpy(fd, CMSG_DATA(cmessage), sizeof fd);		/* place FD back in the command message */		cmd->fd = (int) fd[0];	}	return cmd;}int send_command( int cmd_fd, enum command_type type, char *param, int passfd, int exclusive, char *tag ) {	if (type == CMD_ADD && passfd == 1) {		type = CMD_PASSFD;	}	struct command cmd = {		.fd    = -1,		.exclusive = exclusive,		.type  = type,		.param = {0},		.tag = {0}	};	if (param != NULL) {		strncpy(cmd.param, param, TH_COMMAND_PARAM_LENGTH);		cmd.param[TH_COMMAND_PARAM_LENGTH-1] = '/0';	}	if (tag != NULL) {		strncpy(cmd.tag, tag, TH_DEVICE_TAG_LENGTH);		cmd.tag[TH_DEVICE_TAG_LENGTH-1] = '/0';	}	struct iovec v = {		.iov_base = &cmd,		.iov_len = sizeof(cmd)	};	struct msghdr m = {		.msg_iov    = &v,		.msg_iovlen = 1	};	/* add FD */	int dev_fd[1] = { -1 };	char buffer[CMSG_SPACE(sizeof(dev_fd))];	if (passfd) {		int fd = open( param, O_RDONLY );		if (fd < 0) {			perror("open");			return 1;		}		dev_fd[0] = fd ;		m.msg_control = buffer;		m.msg_controllen = sizeof(buffer);		struct cmsghdr *cmessage = CMSG_FIRSTHDR(&m);		cmessage->cmsg_level = SOL_SOCKET;		cmessage->cmsg_type = SCM_RIGHTS;		cmessage->cmsg_len = CMSG_LEN(sizeof(dev_fd));		m.msg_controllen = cmessage->cmsg_len;		memcpy(CMSG_DATA(cmessage), dev_fd, sizeof dev_fd);	}	int done = sendmsg( cmd_fd, &m, 0 );	return (done == -1);}

int sendfromto(int s, void *buf, size_t len, int flags,	       struct sockaddr *from, socklen_t fromlen,	       struct sockaddr *to, socklen_t tolen){	struct msghdr msgh;	struct cmsghdr *cmsg;	struct iovec iov;	char cbuf[256];#ifdef __FreeBSD__	/*	 *	FreeBSD is extra pedantic about the use of IP_SENDSRCADDR,	 *	and sendmsg will fail with EINVAL if IP_SENDSRCADDR is used	 *	with a socket which is bound to something other than	 *	INADDR_ANY	 */	struct sockaddr bound;	socklen_t bound_len = sizeof(bound);	if (getsockname(s, &bound, &bound_len) < 0) {		return -1;	}	switch (bound.sa_family) {	case AF_INET:		if (((struct sockaddr_in *) &bound)->sin_addr.s_addr != INADDR_ANY) {			from = NULL;		}		break;	case AF_INET6:		if (!IN6_IS_ADDR_UNSPECIFIED(&((struct sockaddr_in6 *) &bound)->sin6_addr)) {			from = NULL;		}		break;	}#else#  if !defined(IP_PKTINFO) && !defined(IP_SENDSRCADDR) && !defined(IPV6_PKTINFO)	/*	 *	If the sendmsg() flags aren't defined, fall back to	 *	using sendto().	 */	from = NULL;#  endif#endif	/*	 *	Catch the case where the caller passes invalid arguments.	 */	if (!from || (fromlen == 0) || (from->sa_family == AF_UNSPEC)) {		return sendto(s, buf, len, flags, to, tolen);	}	/* Set up control buffer iov and msgh structures. */	memset(&cbuf, 0, sizeof(cbuf));	memset(&msgh, 0, sizeof(msgh));	memset(&iov, 0, sizeof(iov));	iov.iov_base = buf;	iov.iov_len = len;	msgh.msg_iov = &iov;	msgh.msg_iovlen = 1;	msgh.msg_name = to;	msgh.msg_namelen = tolen;	if (from->sa_family == AF_INET) {#if !defined(IP_PKTINFO) && !defined(IP_SENDSRCADDR)		return sendto(s, buf, len, flags, to, tolen);#else		struct sockaddr_in *s4 = (struct sockaddr_in *) from;#  ifdef IP_PKTINFO		struct in_pktinfo *pkt;		msgh.msg_control = cbuf;		msgh.msg_controllen = CMSG_SPACE(sizeof(*pkt));		cmsg = CMSG_FIRSTHDR(&msgh);		cmsg->cmsg_level = SOL_IP;		cmsg->cmsg_type = IP_PKTINFO;		cmsg->cmsg_len = CMSG_LEN(sizeof(*pkt));		pkt = (struct in_pktinfo *) CMSG_DATA(cmsg);		memset(pkt, 0, sizeof(*pkt));		pkt->ipi_spec_dst = s4->sin_addr;#  endif#  ifdef IP_SENDSRCADDR		struct in_addr *in;		msgh.msg_control = cbuf;		msgh.msg_controllen = CMSG_SPACE(sizeof(*in));		cmsg = CMSG_FIRSTHDR(&msgh);		cmsg->cmsg_level = IPPROTO_IP;		cmsg->cmsg_type = IP_SENDSRCADDR;		cmsg->cmsg_len = CMSG_LEN(sizeof(*in));		in = (struct in_addr *) CMSG_DATA(cmsg);		*in = s4->sin_addr;#  endif//.........这里部分代码省略.........

/* * Receive a file descriptor from a Unix socket. * Contributed by @mkasick * * Returns the file descriptor on success, or -1 if a file * descriptor was not actually included in the message * * On error the function terminates by calling exit(-1) */static int recv_fd(int sockfd) {    // Need to receive data from the message, otherwise don't care about it.    char iovbuf;    struct iovec iov = {        .iov_base = &iovbuf,        .iov_len  = 1,    };    char cmsgbuf[CMSG_SPACE(sizeof(int))];    struct msghdr msg = {        .msg_iov        = &iov,        .msg_iovlen     = 1,        .msg_control    = cmsgbuf,        .msg_controllen = sizeof(cmsgbuf),    };    if (recvmsg(sockfd, &msg, MSG_WAITALL) != 1) {        goto error;    }    // Was a control message actually sent?    switch (msg.msg_controllen) {    case 0:        // No, so the file descriptor was closed and won't be used.        return -1;    case sizeof(cmsgbuf):        // Yes, grab the file descriptor from it.        break;    default:        goto error;    }    struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);    if (cmsg             == NULL                  ||        cmsg->cmsg_len   != CMSG_LEN(sizeof(int)) ||        cmsg->cmsg_level != SOL_SOCKET            ||        cmsg->cmsg_type  != SCM_RIGHTS) {error:        LOGE("unable to read fd");        exit(-1);    }    return *(int *)CMSG_DATA(cmsg);}/* * Send a file descriptor through a Unix socket. * Contributed by @mkasick * * On error the function terminates by calling exit(-1) * * fd may be -1, in which case the dummy data is sent, * but no control message with the FD is sent. */static void send_fd(int sockfd, int fd) {    // Need to send some data in the message, this will do.    struct iovec iov = {        .iov_base = "",        .iov_len  = 1,    };    struct msghdr msg = {        .msg_iov        = &iov,        .msg_iovlen     = 1,    };    char cmsgbuf[CMSG_SPACE(sizeof(int))];    if (fd != -1) {        // Is the file descriptor actually open?        if (fcntl(fd, F_GETFD) == -1) {            if (errno != EBADF) {                goto error;            }            // It's closed, don't send a control message or sendmsg will EBADF.        } else {            // It's open, send the file descriptor in a control message.            msg.msg_control    = cmsgbuf;            msg.msg_controllen = sizeof(cmsgbuf);            struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);            cmsg->cmsg_len   = CMSG_LEN(sizeof(int));            cmsg->cmsg_level = SOL_SOCKET;            cmsg->cmsg_type  = SCM_RIGHTS;            *(int *)CMSG_DATA(cmsg) = fd;        }//.........这里部分代码省略.........

ssize_timsg_read(struct imsgbuf *ibuf){	struct msghdr		 msg;	struct cmsghdr		*cmsg;	union {		struct cmsghdr hdr;		char	buf[CMSG_SPACE(sizeof(int) * 1)];	} cmsgbuf;	struct iovec		 iov;	ssize_t			 n = -1;	int			 fd;	struct imsg_fd		*ifd;	memset(&msg, 0, sizeof(msg));	memset(&cmsgbuf, 0, sizeof(cmsgbuf));	iov.iov_base = ibuf->r.buf + ibuf->r.wpos;	iov.iov_len = sizeof(ibuf->r.buf) - ibuf->r.wpos;	msg.msg_iov = &iov;	msg.msg_iovlen = 1;	msg.msg_control = &cmsgbuf.buf;	msg.msg_controllen = CMSG_SPACE(sizeof(int) * 16);	if ((ifd = calloc(1, sizeof(struct imsg_fd))) == NULL)		return (-1);again:	if (getdtablecount() + imsg_fd_overhead +	    (int)((CMSG_SPACE(sizeof(int))-CMSG_SPACE(0))/sizeof(int))	    >= getdtablesize()) {		errno = EAGAIN;		free(ifd);		return (-1);	}	if ((n = recvmsg(ibuf->fd, &msg, 0)) == -1) {		if (errno == EINTR)			goto again;		goto fail;	}	ibuf->r.wpos += n;	for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;	    cmsg = CMSG_NXTHDR(&msg, cmsg)) {		if (cmsg->cmsg_level == SOL_SOCKET &&		    cmsg->cmsg_type == SCM_RIGHTS) {			int i;			int j;			/*			 * We only accept one file descriptor.  Due to C			 * padding rules, our control buffer might contain			 * more than one fd, and we must close them.			 */			j = ((char *)cmsg + cmsg->cmsg_len -			    (char *)CMSG_DATA(cmsg)) / sizeof(int);			for (i = 0; i < j; i++) {				fd = ((int *)CMSG_DATA(cmsg))[i];				if (ifd != NULL) {					ifd->fd = fd;					TAILQ_INSERT_TAIL(&ibuf->fds, ifd,					    entry);					ifd = NULL;				} else					close(fd);			}		}		/* we do not handle other ctl data level */	}fail:	free(ifd);	return (n);}

//.........这里部分代码省略.........            while(*s && *s != '/') Inc(s);            if(*p && *s) {              p++;              s++;              continue;            }            if(!*p && !*s)              return true;          }          /* failed : try next recursion */          if(ptmp && stmp && !(period && *stmp == '.')) {            while(*stmp && *stmp != '/') Inc(stmp);            if(*stmp) {              p = ptmp;              stmp++;              s = stmp;              continue;            }          }          return false;        }      } else {        return mri_fnmatch_helper(&p, &s, flags);      }    }  }  Object* IO::fnmatch(STATE, String* pattern, String* path, Fixnum* flags) {    return RBOOL(mri_fnmatch(pattern->c_str(state), path->c_str(state), flags->to_native()));  }  /** Socket methods */  static const int cmsg_space = CMSG_SPACE(sizeof(int));  Object* IO::send_io(STATE, IO* io) {#ifdef _WIN32    return Primitives::failure();#else    int fd;    struct msghdr msg;    struct iovec vec[1];    char buf[1];    struct cmsghdr *cmsg;    char cmsg_buf[cmsg_space];    fd = io->descriptor(state);    msg.msg_name = NULL;    msg.msg_namelen = 0;    /* Linux and Solaris doesn't work if msg_iov is NULL. */    buf[0] = '/0';    vec[0].iov_base = buf;    vec[0].iov_len = 1;    msg.msg_iov = vec;    msg.msg_iovlen = 1;    msg.msg_control = (caddr_t)cmsg_buf;    msg.msg_controllen = sizeof(cmsg_buf);    msg.msg_flags = 0;    cmsg = CMSG_FIRSTHDR(&msg);    memset(cmsg_buf, 0, sizeof(cmsg_buf));    cmsg->cmsg_len = CMSG_LEN(sizeof(int));    cmsg->cmsg_level = SOL_SOCKET;

void scm_detach_fds(struct msghdr *msg, struct scm_cookie *scm){	struct cmsghdr __user *cm		= (__force struct cmsghdr __user*)msg->msg_control;	int fdmax = 0;	int fdnum = scm->fp->count;	struct file **fp = scm->fp->fp;	int __user *cmfptr;	int err = 0, i;	if (MSG_CMSG_COMPAT & msg->msg_flags) {		scm_detach_fds_compat(msg, scm);		return;	}	if (msg->msg_controllen > sizeof(struct cmsghdr))		fdmax = ((msg->msg_controllen - sizeof(struct cmsghdr))			 / sizeof(int));	if (fdnum < fdmax)		fdmax = fdnum;	for (i=0, cmfptr=(__force int __user *)CMSG_DATA(cm); i<fdmax;	     i++, cmfptr++)	{		struct socket *sock;		int new_fd;		err = security_file_receive(fp[i]);		if (err)			break;		err = get_unused_fd_flags(MSG_CMSG_CLOEXEC & msg->msg_flags					  ? O_CLOEXEC : 0);		if (err < 0)			break;		new_fd = err;		err = put_user(new_fd, cmfptr);		if (err) {			put_unused_fd(new_fd);			break;		}		/* Bump the usage count and install the file. */		sock = sock_from_file(fp[i], &err);		if (sock)			sock_update_netprioidx(sock->sk, current);		fd_install(new_fd, get_file(fp[i]));	}	if (i > 0)	{		int cmlen = CMSG_LEN(i*sizeof(int));		err = put_user(SOL_SOCKET, &cm->cmsg_level);		if (!err)			err = put_user(SCM_RIGHTS, &cm->cmsg_type);		if (!err)			err = put_user(cmlen, &cm->cmsg_len);		if (!err) {			cmlen = CMSG_SPACE(i*sizeof(int));			msg->msg_control += cmlen;			msg->msg_controllen -= cmlen;		}	}	if (i < fdnum || (fdnum && fdmax <= 0))		msg->msg_flags |= MSG_CTRUNC;	/*	 * All of the files that fit in the message have had their	 * usage counts incremented, so we just free the list.	 */	__scm_destroy(scm);}

uint8_t negotiate(struct np_map *npm, uint8_t no_maps, const struct in6_addr *saddr, const struct in6_addr *daddr, int iif, int sock_fd){//    uint8_t all_hosts_addr[] = {0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,1};    struct sockaddr_in6 addr;    struct nd_neighbor_advert *na;    struct iovec iov;    struct cmsghdr *cmsg;    char chdr[CMSG_SPACE(sizeof(struct in6_pktinfo))];    struct in6_pktinfo *pkt_info;    struct msghdr mhdr;    int i,j = 0;	float cur_best_prio = -1;//	struct np_finalise npf;	struct np_fin_nd_opt npf;	char *proc_cat_s = malloc(MAX_PROC_STR_SIZE + 1);    unsigned char buff[MSG_SIZE];    int len = 0;    int err;	struct ifreq ifr;	uint8_t *ucp;	unsigned int slla_len;    memset((void *)&addr, 0, sizeof(addr));    addr.sin6_family = AF_INET6;    addr.sin6_port = htons(IPPROTO_ICMPV6);    memcpy(&addr.sin6_addr, saddr, sizeof(struct in6_addr));    memset(&buff, 0, sizeof(buff));    na = (struct nd_neighbor_advert *) buff;    na->nd_na_type = ND_NEIGHBOR_ADVERT;    na->nd_na_code  = 0;    na->nd_na_cksum = 0;    na->nd_na_target = *daddr;    len = sizeof(struct nd_neighbor_advert);	/*	* Add the Source LL Address ICMPv6 Option	*/	ifr.ifr_addr.sa_family = AF_INET6;	strncpy(ifr.ifr_name, conf.interface, IF_NAMESIZE-1);	ioctl(sock_fd, SIOCGIFHWADDR, &ifr);	printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x/n",			(unsigned char)ifr.ifr_hwaddr.sa_data[0],			(unsigned char)ifr.ifr_hwaddr.sa_data[1],			(unsigned char)ifr.ifr_hwaddr.sa_data[2],			(unsigned char)ifr.ifr_hwaddr.sa_data[3],			(unsigned char)ifr.ifr_hwaddr.sa_data[4],			(unsigned char)ifr.ifr_hwaddr.sa_data[5]);	ucp = (uint8_t *) (buff + len);	*ucp++  = ND_OPT_SOURCE_LINKADDR;	*ucp++  = 1; /* XXX : HACK : This will only work for MAC */	len += 2 * sizeof(uint8_t);	slla_len = 6; /* XXX : HACK : This will only work for MAC */	memcpy(buff + len, &ifr.ifr_hwaddr.sa_data, slla_len);	len+= slla_len;	/*	* Add NP++ Finalisation Option	*/	npf.type = 63;	npf.length = 1;	for(i = 0; i < NP_FIN_PAD_SIZE; i++)	{		npf.pad[i] = 0;	}	/*	* Perform comparison of mapping tables to determine best mapping to use	*/	for(i = 0; i < no_maps; i++)	{		for(j = 0; j < no_my_maps; j++)		{			// Check mapping exists in both lists			if(my_npm[j].mapping == npm[i].mapping)			{				float av_prio = 0;				av_prio = (float)(((float)my_npm[j].prio + (float)npm[i].prio) / 2);				if(av_prio > cur_best_prio)				{					cur_best_prio = av_prio;					npf.mapping = my_npm[j].mapping;				}			}		}	}	printf("New Mapping ID == %d/n", npf.mapping);//.........这里部分代码省略.........

/* * If sendStdio is non-zero, the current process's stdio file descriptors * will be sent and inherited by the spawned process. */static int send_request(int fd, int sendStdio, int argc, const char **argv){#ifndef HAVE_ANDROID_OS    // not supported on simulator targets    //ALOGE("zygote_* not supported on simulator targets");    return -1;#else /* HAVE_ANDROID_OS */    uint32_t pid;    int i;    struct iovec ivs[2];    struct msghdr msg;    char argc_buffer[12];    const char *newline_string = "/n";    struct cmsghdr *cmsg;    char msgbuf[CMSG_SPACE(sizeof(int) * 3)];    int *cmsg_payload;    ssize_t ret;    memset(&msg, 0, sizeof(msg));    memset(&ivs, 0, sizeof(ivs));    // First line is arg count     snprintf(argc_buffer, sizeof(argc_buffer), "%d/n", argc);    ivs[0].iov_base = argc_buffer;    ivs[0].iov_len = strlen(argc_buffer);    msg.msg_iov = ivs;    msg.msg_iovlen = 1;    if (sendStdio != 0) {        // Pass the file descriptors with the first write        msg.msg_control = msgbuf;        msg.msg_controllen = sizeof msgbuf;        cmsg = CMSG_FIRSTHDR(&msg);        cmsg->cmsg_len = CMSG_LEN(3 * sizeof(int));        cmsg->cmsg_level = SOL_SOCKET;        cmsg->cmsg_type = SCM_RIGHTS;        cmsg_payload = (int *)CMSG_DATA(cmsg);        cmsg_payload[0] = STDIN_FILENO;        cmsg_payload[1] = STDOUT_FILENO;        cmsg_payload[2] = STDERR_FILENO;    }    do {        ret = sendmsg(fd, &msg, MSG_NOSIGNAL);    } while (ret < 0 && errno == EINTR);    if (ret < 0) {        return -1;    }    // Only send the fd's once    msg.msg_control = NULL;    msg.msg_controllen = 0;    // replace any newlines with spaces and send the args    for (i = 0; i < argc; i++) {        char *tofree = NULL;        const char *toprint;        toprint = argv[i];        if (strchr(toprint, '/n') != NULL) {            tofree = strdup(toprint);            toprint = tofree;            replace_nl(tofree);        }        ivs[0].iov_base = (char *)toprint;        ivs[0].iov_len = strlen(toprint);        ivs[1].iov_base = (char *)newline_string;        ivs[1].iov_len = 1;        msg.msg_iovlen = 2;        do {            ret = sendmsg(fd, &msg, MSG_NOSIGNAL);        } while (ret < 0 && errno == EINTR);        if (tofree != NULL) {            free(tofree);        }        if (ret < 0) {            return -1;        }    }    // Read the pid, as a 4-byte network-order integer    ivs[0].iov_base = &pid;    ivs[0].iov_len = sizeof(pid);//.........这里部分代码省略.........

static int afalg_start_cipher_sk(afalg_ctx *actx, const unsigned char *in,                                 size_t inl, const unsigned char *iv,                                 unsigned int enc){    struct msghdr msg = { 0 };    struct cmsghdr *cmsg;    struct iovec iov;    ssize_t sbytes;# ifdef ALG_ZERO_COPY    int ret;# endif    char cbuf[CMSG_SPACE(ALG_IV_LEN(ALG_AES_IV_LEN)) + CMSG_SPACE(ALG_OP_LEN)];    memset(cbuf, 0, sizeof(cbuf));    msg.msg_control = cbuf;    msg.msg_controllen = sizeof(cbuf);    /*     * cipher direction (i.e. encrypt or decrypt) and iv are sent to the     * kernel as part of sendmsg()'s ancillary data     */    cmsg = CMSG_FIRSTHDR(&msg);    afalg_set_op_sk(cmsg, enc);    cmsg = CMSG_NXTHDR(&msg, cmsg);    afalg_set_iv_sk(cmsg, iv, ALG_AES_IV_LEN);    /* iov that describes input data */    iov.iov_base = (unsigned char *)in;    iov.iov_len = inl;    msg.msg_flags = MSG_MORE;# ifdef ALG_ZERO_COPY    /*     * ZERO_COPY mode     * Works best when buffer is 4k aligned     * OPENS: out of place processing (i.e. out != in)     */    /* Input data is not sent as part of call to sendmsg() */    msg.msg_iovlen = 0;    msg.msg_iov = NULL;    /* Sendmsg() sends iv and cipher direction to the kernel */    sbytes = sendmsg(actx->sfd, &msg, 0);    if (sbytes < 0) {        ALG_PERR("%s: sendmsg failed for zero copy cipher operation : ",                 __func__);        return 0;    }    /*     * vmsplice and splice are used to pin the user space input buffer for     * kernel space processing avoiding copys from user to kernel space     */    ret = vmsplice(actx->zc_pipe[1], &iov, 1, SPLICE_F_GIFT);    if (ret < 0) {        ALG_PERR("%s: vmsplice failed : ", __func__);        return 0;    }    ret = splice(actx->zc_pipe[0], NULL, actx->sfd, NULL, inl, 0);    if (ret < 0) {        ALG_PERR("%s: splice failed : ", __func__);        return 0;    }# else    msg.msg_iovlen = 1;    msg.msg_iov = &iov;    /* Sendmsg() sends iv, cipher direction and input data to the kernel */    sbytes = sendmsg(actx->sfd, &msg, 0);    if (sbytes < 0) {        ALG_PERR("%s: sendmsg failed for cipher operation : ", __func__);        return 0;    }    if (sbytes != (ssize_t) inl) {        ALG_WARN("Cipher operation send bytes %zd != inlen %zd/n", sbytes,                inl);        return 0;    }# endif    return 1;}

void linux_event_loop<handler>::run(){    int ready_cnt;    int buf_size;    struct epoll_event evlist[MAX_EVENTS];    char buffer[MAX_BUFFER];     struct msghdr msg;    struct iovec iov;    char ctrl[CMSG_SPACE(sizeof(struct timeval))];    struct cmsghdr *cmsg = (struct cmsghdr *) & ctrl;        struct timeval kernel_time;         iov.iov_base = buffer;    iov.iov_len = MAX_BUFFER;    msg.msg_name = NULL;    msg.msg_namelen = 0;    msg.msg_iov = &iov;    msg.msg_iovlen = 1;    msg.msg_control = (char *)ctrl;    msg.msg_controllen = sizeof(ctrl);       struct timeval tcp_time;     _is_running =  true;    while( _is_running )    {        ready_cnt = epoll_wait( _fd_epoll, evlist, MAX_EVENTS, -1 );        if( ready_cnt < 0 )         {            char m[1000];            perror(m);            std::cerr  << "Error in epoll_wait " << m <<  std::endl;            continue;        }        if( ready_cnt == 0 )            continue;        for( int i = 0; i < ready_cnt; ++i)        {            if (evlist[i].events & (EPOLLHUP | EPOLLERR | EPOLLRDHUP))            {                std::string what_exactly;                if( evlist[i].events & EPOLLHUP ) what_exactly = "EPOLLHUP";                else if ( evlist[i].events & EPOLLERR ) what_exactly = "EPOLLERR";                else if ( evlist[i].events & EPOLLRDHUP ) what_exactly = "EPOLLRDHUP";	                std::cerr << "Error " << what_exactly << " on fd =" << evlist[i].data.fd << std::endl;                disable(evlist[i].data.fd);                remove(evlist[i].data.fd);                _handler->on_disconnect(evlist[i].data.fd);                continue;            }            con_type type = _cons[ evlist[i].data.fd ].type;            if(type == UDP)            {                if(evlist[i].events & EPOLLIN)                 {                    iov.iov_len = MAX_BUFFER;                    while( (buf_size = recvmsg(evlist[i].data.fd, &msg, MSG_DONTWAIT)) > 0 )                     {                        if(cmsg->cmsg_level != SOL_SOCKET ||                              cmsg->cmsg_type != SCM_TIMESTAMP ||                             cmsg->cmsg_len != CMSG_LEN(sizeof(kernel_time)))                        {                            std::cerr << "cannot obtain kernel timestamp ignoring UDP packet" << std::endl;                        }                         else                         {                            _handler->on_udp_packet(evlist[i].data.fd, buffer, buf_size,                                 from_timeval(*(struct timeval *)CMSG_DATA(cmsg)));                        }                        iov.iov_len = MAX_BUFFER;                    }	                    }            }            else if(type == TCP)             {                if(evlist[i].events & EPOLLIN)                 {                    while( ( buf_size = recv(evlist[i].data.fd, buffer, MAX_BUFFER, MSG_DONTWAIT)) > 0)                     {                        gettimeofday((struct timeval *)&tcp_time, NULL);                        _handler->on_tcp_packet(evlist[i].data.fd, buffer, buf_size, from_timeval(tcp_time));                    }                }            }            else if(type == TIMER)             {                if(evlist[i].events & EPOLLIN)                 {                    if ( (buf_size = read(evlist[i].data.fd, buffer, MAX_BUFFER)) > 0)                     {                        gettimeofday((struct timeval *)&tcp_time, NULL);                        _handler->on_timer(evlist[i].data.fd, buffer, buf_size, from_timeval(tcp_time));                    }//.........这里部分代码省略.........

intmain(int argc, char *argv[]){        int error;	socklen_t len;	int sk,lstn_sk,clnt_sk,acpt_sk,pf_class,sk1;	struct msghdr outmessage;        struct msghdr inmessage;        char *message = "hello, world!/n";        struct iovec iov;        struct iovec iov_rcv;        struct sctp_sndrcvinfo *sinfo;        int msg_count;        char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];        struct cmsghdr *cmsg;        struct iovec out_iov;        char * buffer_snd;        char * buffer_rcv;	char incmsg[CMSG_SPACE(sizeof(sctp_cmsg_data_t))];	struct sockaddr *laddrs, *paddrs;        struct sockaddr_in conn_addr,lstn_addr,acpt_addr;	struct sockaddr_in *addr;	/* Rather than fflush() throughout the code, set stdout to         * be unbuffered.         */        setvbuf(stdout, NULL, _IONBF, 0);        setvbuf(stderr, NULL, _IONBF, 0);        pf_class = PF_INET;        sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);	/*Creating a regular socket*/	clnt_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);	/*Creating a listen socket*/        lstn_sk = test_socket(pf_class, SOCK_STREAM, IPPROTO_SCTP);	conn_addr.sin_family = AF_INET;        conn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK;        conn_addr.sin_port = htons(SCTP_TESTPORT_1);	lstn_addr.sin_family = AF_INET;        lstn_addr.sin_addr.s_addr = SCTP_IP_LOOPBACK;        lstn_addr.sin_port = htons(SCTP_TESTPORT_1);	/*Binding the listen socket*/	test_bind(lstn_sk, (struct sockaddr *) &lstn_addr, sizeof(lstn_addr));	/*Listening many sockets as we are calling too many connect here*/	test_listen(lstn_sk, 1);	len = sizeof(struct sockaddr_in);	test_connect(clnt_sk, (struct sockaddr *) &conn_addr, len);	acpt_sk = test_accept(lstn_sk, (struct sockaddr *) &acpt_addr, &len);	memset(&inmessage, 0, sizeof(inmessage));        buffer_rcv = malloc(REALLY_BIG);        iov_rcv.iov_base = buffer_rcv;        iov_rcv.iov_len = REALLY_BIG;        inmessage.msg_iov = &iov_rcv;        inmessage.msg_iovlen = 1;        inmessage.msg_control = incmsg;        inmessage.msg_controllen = sizeof(incmsg);        msg_count = strlen(message) + 1;	memset(&outmessage, 0, sizeof(outmessage));        buffer_snd = malloc(REALLY_BIG);        outmessage.msg_name = &lstn_addr;        outmessage.msg_namelen = sizeof(lstn_addr);        outmessage.msg_iov = &out_iov;        outmessage.msg_iovlen = 1;        outmessage.msg_control = outcmsg;        outmessage.msg_controllen = sizeof(outcmsg);        outmessage.msg_flags = 0;        cmsg = CMSG_FIRSTHDR(&outmessage);        cmsg->cmsg_level = IPPROTO_SCTP;        cmsg->cmsg_type = SCTP_SNDRCV;        cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));        outmessage.msg_controllen = cmsg->cmsg_len;        sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);        memset(sinfo, 0x00, sizeof(struct sctp_sndrcvinfo));        iov.iov_base = buffer_snd;	iov.iov_len = REALLY_BIG;        outmessage.msg_iov->iov_base = message;        outmessage.msg_iov->iov_len = msg_count;	test_sendmsg(clnt_sk, &outmessage, MSG_NOSIGNAL, msg_count);	test_recvmsg(acpt_sk, &inmessage, MSG_NOSIGNAL);//.........这里部分代码省略.........

static int ndisc_send_unspec(int oif, const struct in6_addr *dest,			     uint8_t *hdr, int hdrlen, struct iovec *optv,			     size_t optvlen){	struct {		struct ip6_hdr ip;		struct icmp6_hdr icmp;		uint8_t data[1500];	} frame;	struct msghdr msgh;	struct cmsghdr *cmsg;	struct in6_pktinfo *pinfo;	struct sockaddr_in6 dst;	char cbuf[CMSG_SPACE(sizeof(*pinfo))];	struct iovec iov;	uint8_t *data = (uint8_t *)(&frame.icmp);	int type, fd, ret, remlen, datalen = 0, written = 0, v = 1;	if (hdr == NULL || hdrlen < 0 ||	    (size_t)hdrlen < sizeof(struct icmp6_hdr) ||	    (size_t)hdrlen > (sizeof(frame) - sizeof(struct ip6_hdr)))		return -EINVAL;	if ((fd = socket(AF_INET6, SOCK_RAW, IPPROTO_RAW)) < 0)		return -1;	if (setsockopt(fd, IPPROTO_IPV6, IP_HDRINCL, &v, sizeof(v)) < 0) {		dbg("cannot set IP_HDRINCL: %s/n", strerror(errno));		close(fd);		return -errno;	}	memset(&frame, 0, sizeof(frame));	memset(&dst, 0, sizeof(dst));	dst.sin6_addr = *dest;	/* Copy ICMPv6 header and update various length values */	memcpy(data, hdr, hdrlen);	data += hdrlen;	datalen += hdrlen;	remlen = sizeof(frame) - sizeof(struct ip6_hdr) - hdrlen;	/* Prepare for csum: write trailing options by linearizing iov */	if ((iov_linearize(data, remlen, optv, optvlen, &written) != 0) ||	    (written & 0x1)) /* Ensure length is even for csum() */		return -1;	datalen += written;	/* Fill in the IPv6 header */	frame.ip.ip6_vfc = 0x60;	frame.ip.ip6_plen = htons(datalen);	frame.ip.ip6_nxt = IPPROTO_ICMPV6;	frame.ip.ip6_hlim = 255;	frame.ip.ip6_dst = *dest;	/* all other fields are already set to zero */	frame.icmp.icmp6_cksum = in6_cksum(&in6addr_any, dest, &frame.icmp,					   datalen, IPPROTO_ICMPV6);	iov.iov_base = &frame;	iov.iov_len = sizeof(frame.ip) + datalen;	dst.sin6_family = AF_INET6;	msgh.msg_name = &dst;	msgh.msg_namelen = sizeof(dst);	msgh.msg_iov = &iov;	msgh.msg_iovlen = 1;	msgh.msg_flags = 0;	memset(cbuf, 0, CMSG_SPACE(sizeof(*pinfo)));	cmsg = (struct cmsghdr *)cbuf;	pinfo = (struct in6_pktinfo *)CMSG_DATA(cmsg);	pinfo->ipi6_ifindex = oif;	cmsg->cmsg_len = CMSG_LEN(sizeof(*pinfo));	cmsg->cmsg_level = IPPROTO_IPV6;	cmsg->cmsg_type = IPV6_PKTINFO;	msgh.msg_control = cmsg;	msgh.msg_controllen = cmsg->cmsg_len;	ret = sendmsg(fd, &msgh, 0);	if (ret < 0)		dbg("sendmsg: %s/n", strerror(errno));	close(fd);	type = hdr[0];	if (type == ND_NEIGHBOR_SOLICIT) {		statistics_inc(&mipl_stat, MIPL_STATISTICS_OUT_NS_UNSPEC);	} else if (type == ND_ROUTER_SOLICIT) {		statistics_inc(&mipl_stat, MIPL_STATISTICS_OUT_RS_UNSPEC);	}	return ret;}

bool LogListener::onDataAvailable(SocketClient *cli) {    static bool name_set;    if (!name_set) {        prctl(PR_SET_NAME, "logd.writer");        name_set = true;    }    char buffer[sizeof_log_id_t + sizeof(uint16_t) + sizeof(log_time)        + LOGGER_ENTRY_MAX_PAYLOAD];    struct iovec iov = { buffer, sizeof(buffer) };    memset(buffer, 0, sizeof(buffer));    char control[CMSG_SPACE(sizeof(struct ucred))];    struct msghdr hdr = {        NULL,        0,        &iov,        1,        control,        sizeof(control),        0,    };    int socket = cli->getSocket();    ssize_t n = recvmsg(socket, &hdr, 0);    if (n <= (ssize_t)(sizeof(android_log_header_t))) {        return false;    }    struct ucred *cred = NULL;    struct cmsghdr *cmsg = CMSG_FIRSTHDR(&hdr);    while (cmsg != NULL) {        if (cmsg->cmsg_level == SOL_SOCKET                && cmsg->cmsg_type  == SCM_CREDENTIALS) {            cred = (struct ucred *)CMSG_DATA(cmsg);            break;        }        cmsg = CMSG_NXTHDR(&hdr, cmsg);    }    if (cred == NULL) {        return false;    }    if (cred->uid == AID_LOGD) {        // ignore log messages we send to ourself.        // Such log messages are often generated by libraries we depend on        // which use standard Android logging.        return false;    }    android_log_header_t *header = reinterpret_cast<android_log_header_t *>(buffer);    if (/* header->id < LOG_ID_MIN || */ header->id >= LOG_ID_MAX) {        return false;    }    char *msg = ((char *)buffer) + sizeof(android_log_header_t);    n -= sizeof(android_log_header_t);    // NB: hdr.msg_flags & MSG_TRUNC is not tested, silently passing a    // truncated message to the logs.    if (logbuf->log((log_id_t)header->id, header->realtime,            cred->uid, cred->pid, header->tid, msg,            ((size_t) n <= USHRT_MAX) ? (unsigned short) n : USHRT_MAX) >= 0) {        reader->notifyNewLog();    }    return true;}