C++ send_fd函数代码示例

int tcp_conn_send(struct tcp_connection *c)
{
	long response[2];
	int n;

	/* inform TCP main about this new connection */
	if (c->state==S_CONN_CONNECTING) {
		response[0]=(long)c;
		response[1]=ASYNC_CONNECT;
		n=send_fd(unix_tcp_sock, response, sizeof(response), c->s);
		if (n<=0) {
			LM_ERR("Failed to send the socket to main for async connection\n");
			goto error;
		}
		close(c->s);
	} else {
		response[0]=(long)c;
		response[1]=CONN_NEW;
		n=send_fd(unix_tcp_sock, response, sizeof(response), c->s);
		if (n<=0){
			LM_ERR("failed send_fd: %s (%d)\n", strerror(errno), errno);
			goto error;
		}
	}

	return 0;
error:
	_tcpconn_rm(c);
	tcp_connections_no--;
	return -1;
}

int main(int argc, char *argv[])
{
    while (1) {
        pid_t child;

        child = fork();
        if (child == -1)
            exit(EXIT_FAILURE);

        if (child == 0) {
            int fd[2];
            int i;

            if (socketpair(PF_UNIX, SOCK_SEQPACKET, 0, fd) == -1)
                goto out_error;

            for (i = 0; i < 100; ++i) {
                if (send_fd(fd[0], fd[0]) == -1)
                    goto out_error;

                if (send_fd(fd[1], fd[1]) == -1)
                    goto out_error;
            }

            close(fd[0]);
            close(fd[1]);
            goto out;

out_error:
            fprintf(stderr, "error: %s\n", strerror(errno));
out:
            exit(EXIT_SUCCESS);
        }

        while (1) {
            pid_t kid;
            int status;

            kid = wait(&status);
            if (kid == -1) {
                if (errno == ECHILD)
                    break;
                if (errno == EINTR)
                    continue;

                exit(EXIT_FAILURE);
            }

            if (WIFEXITED(status)) {
                if (WEXITSTATUS(status))
                    exit(WEXITSTATUS(status));
                break;
            }
        }
    }

    return EXIT_SUCCESS;
}

int kdbus_test_fd_passing(struct kdbus_test_env *env)
{
	struct kdbus_conn *conn_src, *conn_dst;
	const char *str = "stackenblocken";
	const struct kdbus_item *item;
	struct kdbus_msg *msg;
	unsigned int i;
	int fds[2];
	int ret;

	/* create two connections */
	conn_src = kdbus_hello(env->buspath, 0, NULL, 0);
	conn_dst = kdbus_hello(env->buspath, 0, NULL, 0);
	ASSERT_RETURN(conn_src && conn_dst);

	/*
	 * Try to ass the handle of a connection as message payload.
	 * This must fail.
	 */
	ret = send_fd(conn_src, conn_dst->id, conn_src->fd);
	ASSERT_RETURN(ret == -ELOOP);

	ret = send_fd(conn_src, conn_dst->id, conn_dst->fd);
	ASSERT_RETURN(ret == -ELOOP);

	ret = pipe(fds);
	ASSERT_RETURN(ret == 0);

	i = write(fds[1], str, strlen(str));
	ASSERT_RETURN(i == strlen(str));

	ret = send_fd(conn_src, conn_dst->id, fds[0]);
	ASSERT_RETURN(ret == 0);

	ret = kdbus_msg_recv(conn_dst, &msg);
	ASSERT_RETURN(ret == 0);

	KDBUS_ITEM_FOREACH(item, msg, items) {
		if (item->type == KDBUS_ITEM_FDS) {
			char tmp[14];
			int nfds = (item->size - KDBUS_ITEM_HEADER_SIZE) /
					sizeof(int);

			ASSERT_RETURN(nfds == 1);

			i = read(item->fds[0], tmp, sizeof(tmp));
			ASSERT_RETURN(i == sizeof(tmp));
			ASSERT_RETURN(memcmp(tmp, str, sizeof(tmp)) == 0);

			close(item->fds[0]);
			break;
		}
	}

	return TEST_OK;
}

/*
 * sends stdin and stdout over the socket
 * in that order, returns 0 on success
 */
static int socket_send_sdtio( int fd ) {
    if ( send_fd ( fd, STDIN_FILENO ) < 0  ) {
        LOGE ( "sending STDIN failed\n" );
        return -1;
    }

    if ( send_fd ( fd, STDOUT_FILENO ) < 0 ) {
        LOGE ( "sending STDOUT failed\n" );
        return -1;
    }
    return 0;
}

void
handle_request(char *buf, int nread, int fd)
{
	int		newfd;

	if (buf[nread-1] != 0) {
		snprintf(errmsg, MAXLINE-1,
		  "request not null terminated: %*.*s\n", nread, nread, buf);
		send_err(fd, -1, errmsg);
		return;
	}
	if (buf_args(buf, cli_args) < 0) {	/* 将客户进程请求分解成标准argv型的参数表，调用cli_args处理客户进程的参数*/
		send_err(fd, -1, errmsg);
		return;
	}
	if ((newfd = open(pathname, oflag)) < 0) { // 打开相应文件
		snprintf(errmsg, MAXLINE-1, "can't open %s: %s\n", pathname,
		  strerror(errno));
		send_err(fd, -1, errmsg);
		return;
	}
	if (send_fd(fd, newfd) < 0)		/* 经由fd管道将描述符回送给客户进程*/
		err_sys("send_fd error");
	close(newfd);		/* we're done with descriptor */
}

int
do_snapshot(int parent_fd)
{
	int fds[2];
	struct command_response resp;
	long child;
	int r;

	r = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
	if (r < 0)
		VG_(tool_panic)((Char *)"error creating socket pair");
	child = my_fork();
	if (child < 0)
		VG_(tool_panic)((Char *)"forking snapshot");
	if (child == 0) {
		VG_(close)(fds[1]);
		VG_(close)(parent_fd);
		return fds[0];
	}
	VG_(close)(fds[0]);
	resp.res = 0;
	safeish_write(parent_fd, &resp, sizeof(resp));
	send_fd(parent_fd, fds[1]);
	VG_(close)(fds[1]);
	return parent_fd;
}

void on_set(int sfd){
	int client_sfd = _accept(sfd);
	int index = get_service_index(sfd);
	printf("Client requested for service %s\n", services[index].name);
	// if (services[index].started == 0){
	// 	int pid = fork();
	// 	if (pid == 0){
	// 		char *cap = (char *)malloc(sizeof(char)*10);
	// 		sprintf(cap, "%d", services[index].capacity);
	// 		if (index == 0){
	// 			execl(services[index].name, services[index].name, services[index].name, cap,"server", services[index+1].name,(char*)0);

	// 		}
	// 		else if (index == MAX_SERVICES -1){
	// 			execl(services[index].name, services[index].name, services[index].name, cap,services[index-1].name, "server",(char*)0);

	// 		}
	// 		else{
	// 			execl(services[index].name, services[index].name, services[index].name, cap,services[index-1].name, services[index+1].name,(char*)0);

	// 		}
	// 	}
	// 	else{
	// 		services[index].unsfd = _accept(services[index].usfd);
	// 		services[index].started = 1;
	// 	}
		
	// }
	send_fd(services[index].usfd, client_sfd); // sending the accepted client sfd to the service.
	// printf("Sent the fd\n");
}

int conjuration_service_ipc_server(conjuration_diy_tmp *tmp,int socket) {
	int fd;
	int err = 0;
	int flags;
	mode_t mode;
	ucred creds;
	
	get_local_socket_credentials(socket,&creds);
	
	if(read(socket,&flags,sizeof(flags)) != sizeof(flags) && !err) {
		err = errno;
	}
	if(read(socket,&mode,sizeof(mode)) != sizeof(mode) && !err) {
		err = errno;
	}
	
	fd = conjuration_diy(flags,mode,creds.uid,creds.gid,tmp);
	if(fd < 0) {
		err = errno;
	}
	
	if(send_fd(socket,fd) < 0 && !err) {
		err = errno;
	}
	if(write(socket,&err,sizeof(err)) != sizeof(err) && !err) {
		err = errno;
	}
	if(fd > 0) {
		close(fd);
	}
	return err;
}

int main(){
    int pipefd[2];
	int fd_to_pass=0;

	//创建父子进程之间的管道,文件描述符pipefd[0]和pipefd[1]都是UNIX域套接字
	int ret=socketpair(PF_UNIX,SOCK_STREAM,0,pipefd);
	assert(ret!=-1);

	pid_t pid=fork();
	assert(pid>=0);

	if(pid==0){
		close(pipefd[0]);
		fd_to_pass=open("select.c",O_RDONLY);
		send_fd(pipefd[1],fd_to_pass);
		close(fd_to_pass);
		exit(EXIT_SUCCESS);
	}

	else{
		sleep(3);
		close(pipefd[1]);
		fd_to_pass=recv_fd(pipefd[0]);
		char buf[1024];
		memset(buf,0,1024);
		read(fd_to_pass,buf,1024);
		printf("I got fd %d and data %s\n",fd_to_pass,buf);
		close(fd_to_pass);
	}
}

void request(char *buf, int nread, int fd)
{
	int newfd;

	if (buf[nread-1] != 0)
	{
		sprintf(errmsg, "request not null terminated:%*.*s\n", nread, nread, buf);
		send_err(fd, -1, errmsg);
		return;
	}

	if (buf_args(buf, cli_args) < 0) {
		send_err(fd, -1, errmsg);
		return;
	}

	if ( (newfd = open(pathname, oflag)) < 0)
	{
		sprintf(errmsg, "can't open %s: %s\n", pathname, strerror(errno));
		send_err(fd, -1, errmsg);
		return;
	}
	
	if (send_fd(fd, newfd) < 0)
		err_sys("send_fd error", errno);
	close(newfd);	
}

void handle_request(char *buf, int nread, int fd)
{
	int	newfd;

	if (buf[nread - 1] != 0) {
		/*
		 * "%*.*s", m, n, "string"
		 * total field width is m
		 * precision is n.
		 * this manner can limit print max(m, n) chars up to 
		 * max(n, m)
		 */
		snprintf(errmsg, MAXLINE - 1,
				"request not null terminated: %*.*s\n",
				nread, nread, buf);
		send_err(fd, -1, errmsg);
		return;
	}
	if (buf_args(buf, cli_args) < 0) { /* parse args & set options */
		send_err(fd, -1, errmsg);
		return;
	}
	if ((newfd = open(pathname, oflag)) < 0) {
		snprintf(errmsg, MAXLINE - 1, "can't open %s: %s\n", pathname,
				strerror(errno));
		send_err(fd, -1, errmsg);
		return;
	}
	if (send_fd(fd, newfd) < 0) /* send the descriptor */
		err_sys("send_fd error");
	close(newfd); /* we're done with descriptor */
}

int main()
{
    int socket_fd, client_fd;
    struct sockaddr_un server_address;

    if ((socket_fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
        perror("socket()");
        return -1;
    }

    memset(&server_address, 0, sizeof(server_address));
    server_address.sun_family = AF_UNIX;
    strcpy(server_address.sun_path, "#hax");
    server_address.sun_path[0] = 0;             // make it abstract

    if (bind(socket_fd, (struct sockaddr*)&server_address, sizeof(server_address)) < 0) {
        perror("bind()");
        return -1;
    }

    if (listen(socket_fd, 1) != 0) {
        perror("listen()");
        return -1;
    }

    if ((client_fd = accept(socket_fd, 0, 0)) == -1) {
        perror("accept()");
        return -1;
    }

    int dir_fd = open("/", O_RDONLY);
    send_fd(client_fd, dir_fd);

    return 0;
}

int main(int argc,char* argv[])
{
	if(argc != 2)
	{
		printf("error args\n");
		return -1;
	}
	int fds[2];
	int ret=socketpair(AF_LOCAL,SOCK_STREAM,0,fds);
	if(-1==ret)
	{
		perror("socketpair");
		return -1;
	}	
	if(!fork())
	{
		close(fds[1]);
		int fd;
		recv_fd(fds[0],&fd);
		printf("i am child,fd is %d\n",fd);
		char buf[10]={0};
		read(fd,buf,sizeof(buf));
		printf("the buf is %s\n",buf);
		return 0;
	}else{
		close(fds[0]);
		int fd=open(argv[1],O_RDWR);
		printf("i am parent,fd is %d\n",fd);
		send_fd(fds[1],fd);  //把fd这个描述符 写到fds[1]写描述符中
		wait(NULL);
		return 0;
	}

}

void handle_request(char *buf, int nread, int clifd, uid_t uid)
{
	int	newfd;

	if (buf[nread - 1] != 0) {
		snprintf(errmsg, MAXLINE - 1,
				"request from uid %d not null terminated: %*.*s\n",
				uid, nread, nread, buf);
		send_err(clifd, -1, errmsg);
		return;
	}
	log_msg("request: %s, from uid %d", buf, uid);
	/* parse the arguments, set options */
	if (buf_args(buf, cli_args) < 0) {
		send_err(clifd, -1, errmsg);
		log_msg(errmsg);
		return;
	}

	if ((newfd = open(pathname, oflag)) < 0) {
		snprintf(errmsg, MAXLINE - 1, "can't open %s: %s\n",
				pathname, strerror(errno));
		send_err(clifd, -1, errmsg);
		log_msg(errmsg);
		return;
	}

	/* send the desrciptor */
	if (send_fd(clifd, newfd) < 0)
		log_sys("send_fd error");
	log_msg("send fd %d over fd %d for %s", newfd, clifd, pathname);
	close(newfd);	/* we're done with desrciptor */
}

void
handle_request(char *buf, int nread, int fd)
{
	int		newfd;

	if (buf[nread-1] != 0) {
		snprintf(errmsg, MAXLINE-1,
		  "request not null terminated: %*.*s\n", nread, nread, buf);
		send_err(fd, -1, errmsg);
		return;
	}
	if (buf_args(buf, cli_args) < 0) {	/* parse args & set options */
		send_err(fd, -1, errmsg);
		return;
	}
	if ((newfd = open(pathname, oflag)) < 0) {
		snprintf(errmsg, MAXLINE-1, "can't open %s: %s\n", pathname,
		  strerror(errno));
		send_err(fd, -1, errmsg);
		return;
	}
	if (send_fd(fd, newfd) < 0)		/* send the descriptor */
		err_sys("send_fd error");
	close(newfd);		/* we're done with descriptor */
}