使用unix domain socket传递file descriptor的例子

刚抄完，先贴上来吧。慢慢再分析。

#include <apue.h>

#include <errno.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/uio.h>

#include <sys/socket.h>

#define CL_OPEN "open"

#define CS_OPEN "/tmp/opend"

#define BUFFSIZE 8192

int csopen(char *, int);

int

main(int argc, char* argv[])

{

int n, fd;

char buf[BUFFSIZE], line[MAXLINE];

/* read filename to cat from stdin */

while (fgets(line, MAXLINE, stdin) != NULL)

{

if (line[strlen(line) - 1] == '/n')

line[strlen(line) - 1] = 0;

/* open the file */

if ((fd = csopen(line, O_RDONLY)) < 0)

continue;

/* and cat to stdout */

while ((n = read(fd, buf, BUFFSIZE)) > 0)

if (write(STDOUT_FILENO, buf, n) != n)

err_sys("write error");

if (n < 0)

err_sys("read error");

close(fd);

}

}

#define CONTROLLEN CMSG_LEN(sizeof(int))

static struct cmsghdr *cmptr = NULL;

int

recv_fd1(int fd, ssize_t (*userfunc)(int, const void *, size_t))

{

int newfd, nr, status;

char *ptr;

char buf[MAXLINE];

struct iovec iov[1];

struct msghdr msg;

status = -1;

for (;;)

{

iov[0].iov_base = buf;

iov[0].iov_len = sizeof(buf);

msg.msg_iov = iov;

msg.msg_iovlen = 1;

msg.msg_name = NULL;

msg.msg_namelen = 0;

if (cmptr == NULL && (cmptr = malloc(CONTROLLEN)) == NULL)

return -1;

msg.msg_control = cmptr;

msg.msg_controllen = CONTROLLEN;

if ((nr = recvmsg(fd, &msg, 0)) < 0)

{

err_sys("recvmsg error");

}

else if (nr == 0)

{

err_ret("connection closed by server");

return -1;

}

for (ptr = buf; ptr < &buf[nr]; )

{

if (*ptr++ == 0)

{

if (ptr != &buf[nr-1])

err_dump("message format error");

status = *ptr & 0xFF; /* prevent sign extension */

if (status == 0)

{

if (msg.msg_controllen != CONTROLLEN)

err_dump("status = 0 but no fd");

newfd = *(int *)CMSG_DATA(cmptr);

}

else

{

newfd = -status;

}

nr -= 2;

}

}

if (nr > 0 && (*userfunc)(STDERR_FILENO, buf, nr) != nr)

return -1;

if (status >= 0)

return newfd;

}

}

int

csopen(char *name, int oflag)

{

int len;

char buf[10];

struct iovec iov[3];

static int csfd = -1;

if (csfd < 0)

{/* open connection to conn server */

if ((csfd = cli_conn(CS_OPEN)) < 0)

err_sys("cli_conn error");

}

sprintf(buf, " %d", oflag);

iov[0].iov_base = CL_OPEN " ";

iov[0].iov_len = strlen(CL_OPEN) + 1;

iov[1].iov_base = name;

iov[1].iov_len = strlen(name);

iov[2].iov_base = buf;

iov[2].iov_len = strlen(buf) + 1; /* null always sent */

len = iov[0].iov_len + iov[1].iov_len + iov[2].iov_len ;

if (writev(csfd, &iov[0], 3) != len)

err_sys("writev error");

/* read back descriptor; returned errors handled by write() */

return(recv_fd1(csfd, write));

}

#include "apue.h"

#include <errno.h>

#include <syslog.h>

#include <sys/time.h>

#include <sys/select.h>

#include <sys/socket.h>

#define CS_OPEN "/tmp/opend"

#define CL_OPEN "open"

#define MAXARGC 50

#define WHITE " /t/n"

#define NALLOC 10

int debug;

char errmsg[MAXLINE];

int oflag;

char *pathname;

int log_to_stderr = 1;

typedef struct

{

int fd;

uid_t uid;

}Client;

Client *client = NULL;

int client_size;

int cli_args(int, char **);

int client_add(int, uid_t);

void client_del(int);

void loop(void);

void request(char *, int, int, uid_t);

static void

client_alloc(void) /* alloc more entries in the client[] array */

{

int i;

if (client == NULL)

client = malloc(NALLOC * sizeof(Client));

else

client = realloc(client, (client_size+NALLOC)*sizeof(Client));

if (client == NULL)

err_sys("can't alloc for client array");

/* initialize the new entries */

for (i = client_size; i < client_size + NALLOC; i++)

{

client[i].fd = -1;

}

client_size += NALLOC;

}

/*

* Called by loop() when connection request from a new client arrives

*/

int

client_add(int fd, uid_t uid)

{

int i;

if (client == NULL)

client_alloc();

again:

for (i = 0; i < client_size; i++)

{

if (client[i].fd == -1) /* find an available entry */

{

client[i].fd = fd;

client[i].uid = uid;

return i;

}

}

/* client arry full, realloc for more */

client_alloc();

goto again;

}

/* called by loop() when we're done with a client */

void

client_del(int fd)

{

int i;

for (i = 0; i < client_size; i++)

{

if (client[i].fd == fd)

{

client[i].fd = -1;

return;

}

}

// log_quit("can't find client entry for fd %d", fd);

}

int

main(int argc, char* argv[])

{

int c;

log_open("open.serv", LOG_PID, LOG_USER);

opterr = 0; /* don't want getopt() write to stderr */

while ((c = getopt(argc, argv, "d")) != EOF)

{

switch (c)

{

case 'd': /* debug */

debug = log_to_stderr = 1;

break;

case '?':

err_quit("unrecongnized option: -%c", optopt);

}

}

// if (debug == 0)

// daemonize("opend");

loop();

return 0;

}

#define CONTROLLEN CMSG_LEN(sizeof(int))

static struct cmsghdr *cmptr = NULL;

int

send_fd1(int fd, int fd_to_send)

{

struct iovec iov[1];

struct msghdr msg;

char buf[2];

iov[0].iov_base = buf;

iov[0].iov_len = 2;

msg.msg_iov = iov;

msg.msg_iovlen = 1;

msg.msg_name = NULL;

msg.msg_namelen = 0;

if (fd_to_send < 0)

{

msg.msg_control = NULL;

msg.msg_controllen = 0;

buf[1] = -fd_to_send;

if (buf[1] == 0)

buf[1] = 1; /* -256 */

}

else

{

if (cmptr == NULL && (cmptr = malloc(CONTROLLEN)) == NULL)

return -1;

cmptr->cmsg_level = SOL_SOCKET;

cmptr->cmsg_type = SCM_RIGHTS;

cmptr->cmsg_len = CONTROLLEN;

msg.msg_control = cmptr;

msg.msg_controllen = CONTROLLEN;

*(int*)CMSG_DATA(cmptr) = fd_to_send;

buf[1] = 0;

}

buf[0] = 0;

if (sendmsg(fd, &msg, 0) != 2)

return -1;

return 0;

}

void

request(char *buf, int nread, int clifd, uid_t uid)

{

int newfd;

if (buf[nread-1] != 0)

{

sprintf(errmsg,

"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)

{

sprintf(errmsg, "can't open %s: %s/n",

pathname, strerror(errno));

send_err(clifd, -1, errmsg);

log_msg(errmsg);

return;

}

/* send the descriptor */

if (send_fd1(clifd, newfd) < 0)

log_sys("send_fd error");

log_msg("sent fd %d over fd %d for %s", newfd, clifd, pathname);

close(newfd);

}

void

loop(void)

{

int i, n, maxfd, maxi, listenfd, clifd, nread;

char buf[MAXLINE];

uid_t uid;

fd_set rset, allset;

FD_ZERO(&allset);

/* obtain fd to listen for client requests on */

if ((listenfd = serv_listen(CS_OPEN)) < 0)

log_sys("serv_listen error");

FD_SET(listenfd, &allset);

maxfd = listenfd;

maxi = -1;

for ( ; ; )

{

rset = allset; /* rset gets modified each time around */

if ((n = select(maxfd + 1, &rset, NULL, NULL, NULL)) < 0)

log_sys("select error");

if (FD_ISSET(listenfd, &rset))

{

/* accept new client request */

if ((clifd = serv_accept(listenfd, &uid)) < 0)

log_sys("serv_acept error: %d", clifd);

i = client_add(clifd, uid);

FD_SET(clifd, &allset);

if (clifd > maxfd)

maxfd = clifd; /* max fd for select() */

if (i > maxi)

maxi = i; /* max index in client[] array */

log_msg("new connection: uid %d, fd %d", uid, clifd);

continue;

}

for (i = 0; i <= maxi; i++) /* go through client[] array */

{

if ((clifd = client[i].fd) < 0) /* empty entry */

continue;

if (FD_ISSET(clifd, &rset))

{

/* read argument buffer from client */

if ((nread = read(clifd, buf, MAXLINE)) < 0)

{

log_sys("read error on fd %d", clifd);

}

else if (nread == 0)

{

log_msg("closed: uid %d, fd %d",

client[i].uid, clifd);

client_del(clifd);

FD_CLR(clifd, &allset);

close(clifd);

}

else

{ /* process client's request */

request(buf, nread, clifd, client[i].uid);

}

}

}

}

}

int

buf_args(char *buf, int (*optfunc)(int, char **))

{

char *ptr, *argv[MAXARGC];

int argc;

if (strtok(buf, WHITE) == NULL)

return -1;

argv[argc = 0] = buf;

while ((ptr = strtok(NULL, WHITE)) != NULL)

{

if (++argc >= MAXARGC-1)

return -1;

argv[argc] = ptr;

}

argv[++argc] = NULL;

return (*optfunc)(argc, argv);

}

int

cli_args(int argc, char* argv[])

{

if (argc != 3 || strcmp(argv[0], CL_OPEN) != 0)

{

strcpy(errmsg, "usage: <pathname> <oflag>/n");

return -1;

}

pathname = argv[1];

oflag = atoi(argv[2]);

return 0;

}