lib/socket_wrapper/socket_wrapper.h

ソースコードを見る。

関数
int	swrap_socket (int family, int type, int protocol)
int	swrap_accept (int s, struct sockaddr *addr, socklen_t *addrlen)
int	swrap_connect (int s, const struct sockaddr *serv_addr, socklen_t addrlen)
int	swrap_bind (int s, const struct sockaddr *myaddr, socklen_t addrlen)
int	swrap_listen (int s, int backlog)
int	swrap_getpeername (int s, struct sockaddr *name, socklen_t *addrlen)
int	swrap_getsockname (int s, struct sockaddr *name, socklen_t *addrlen)
int	swrap_getsockopt (int s, int level, int optname, void *optval, socklen_t *optlen)
int	swrap_setsockopt (int s, int level, int optname, const void *optval, socklen_t optlen)
ssize_t	swrap_recvfrom (int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
ssize_t	swrap_sendto (int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
int	swrap_ioctl (int s, int req, void *ptr)
ssize_t	swrap_recv (int s, void *buf, size_t len, int flags)
ssize_t	swrap_send (int s, const void *buf, size_t len, int flags)
int	swrap_close (int)

---

関数

int swrap_socket	(	int	family,
		int	type,
		int	protocol
	)

socket_wrapper.c の 1056 行で定義されています。

参照先 errno・socket_info::family・socket_info::fd・fd・socket_info::protocol・socket_wrapper_dir()・sockets・socket_info::type.

{
        struct socket_info *si;
        int fd;

        if (!socket_wrapper_dir()) {
                return real_socket(family, type, protocol);
        }

        switch (family) {
        case AF_INET:
                break;
        case AF_UNIX:
                return real_socket(family, type, protocol);
        default:
                errno = EAFNOSUPPORT;
                return -1;
        }

        switch (type) {
        case SOCK_STREAM:
                break;
        case SOCK_DGRAM:
                break;
        default:
                errno = EPROTONOSUPPORT;
                return -1;
        }

        switch (protocol) {
        case 0:
                break;
        default:
                errno = EPROTONOSUPPORT;
                return -1;
        }

        fd = real_socket(AF_UNIX, type, 0);

        if (fd == -1) return -1;

        si = (struct socket_info *)calloc(1, sizeof(struct socket_info));

        si->family = family;
        si->type = type;
        si->protocol = protocol;
        si->fd = fd;

        SWRAP_DLIST_ADD(sockets, si);

        return si->fd;
}

int swrap_accept	(	int	s,
		struct sockaddr *	addr,
		socklen_t *	addrlen
	)

socket_wrapper.c の 1109 行で定義されています。

参照先 socket_info::family・fd・find_socket_info()・socket_info::protocol・sockaddr_convert_from_un()・sockaddr_dup()・sockets・SWRAP_ACCEPT_ACK・SWRAP_ACCEPT_RECV・SWRAP_ACCEPT_SEND・swrap_dump_packet()・socket_info::type.

{
        struct socket_info *parent_si, *child_si;
        int fd;
        struct sockaddr_un un_addr;
        socklen_t un_addrlen = sizeof(un_addr);
        struct sockaddr_un un_my_addr;
        socklen_t un_my_addrlen = sizeof(un_my_addr);
        struct sockaddr my_addr;
        socklen_t my_addrlen = sizeof(my_addr);
        int ret;

        parent_si = find_socket_info(s);
        if (!parent_si) {
                return real_accept(s, addr, addrlen);
        }

        memset(&un_addr, 0, sizeof(un_addr));
        memset(&un_my_addr, 0, sizeof(un_my_addr));
        memset(&my_addr, 0, sizeof(my_addr));

        ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
        if (ret == -1) return ret;

        fd = ret;

        ret = sockaddr_convert_from_un(parent_si, &un_addr, un_addrlen,
                                       parent_si->family, addr, addrlen);
        if (ret == -1) {
                close(fd);
                return ret;
        }

        child_si = (struct socket_info *)malloc(sizeof(struct socket_info));
        memset(child_si, 0, sizeof(*child_si));

        child_si->fd = fd;
        child_si->family = parent_si->family;
        child_si->type = parent_si->type;
        child_si->protocol = parent_si->protocol;
        child_si->bound = 1;
        child_si->is_server = 1;

        ret = real_getsockname(fd, (struct sockaddr *)&un_my_addr, &un_my_addrlen);
        if (ret == -1) {
                free(child_si);
                close(fd);
                return ret;
        }

        ret = sockaddr_convert_from_un(child_si, &un_my_addr, un_my_addrlen,
                                       child_si->family, &my_addr, &my_addrlen);
        if (ret == -1) {
                free(child_si);
                close(fd);
                return ret;
        }

        child_si->myname_len = my_addrlen;
        child_si->myname = sockaddr_dup(&my_addr, my_addrlen);

        child_si->peername_len = *addrlen;
        child_si->peername = sockaddr_dup(addr, *addrlen);

        SWRAP_DLIST_ADD(sockets, child_si);

        swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_SEND, NULL, 0);
        swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_RECV, NULL, 0);
        swrap_dump_packet(child_si, addr, SWRAP_ACCEPT_ACK, NULL, 0);

        return fd;
}

int swrap_connect	(	int	s,
		const struct sockaddr *	serv_addr,
		socklen_t	addrlen
	)

socket_wrapper.c の 1255 行で定義されています。

参照先 socket_info::bound・errno・find_socket_info()・socket_info::peername・socket_info::peername_len・sockaddr_convert_to_un()・sockaddr_dup()・swrap_auto_bind()・SWRAP_CONNECT_ACK・SWRAP_CONNECT_RECV・SWRAP_CONNECT_SEND・SWRAP_CONNECT_UNREACH・swrap_dump_packet().

{
        int ret;
        struct sockaddr_un un_addr;
        struct socket_info *si = find_socket_info(s);

        if (!si) {
                return real_connect(s, serv_addr, addrlen);
        }

        if (si->bound == 0) {
                ret = swrap_auto_bind(si);
                if (ret == -1) return -1;
        }

        ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr, 0, NULL);
        if (ret == -1) return -1;

        swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_SEND, NULL, 0);

        ret = real_connect(s, (struct sockaddr *)&un_addr, 
                           sizeof(struct sockaddr_un));

        /* to give better errors */
        if (ret == -1 && errno == ENOENT) {
                errno = EHOSTUNREACH;
        }

        if (ret == 0) {
                si->peername_len = addrlen;
                si->peername = sockaddr_dup(serv_addr, addrlen);

                swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_RECV, NULL, 0);
                swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_ACK, NULL, 0);
        } else {
                swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_UNREACH, NULL, 0);
        }

        return ret;
}

int swrap_bind	(	int	s,
		const struct sockaddr *	myaddr,
		socklen_t	addrlen
	)

socket_wrapper.c の 1296 行で定義されています。

参照先 socket_info::bcast・socket_info::bound・find_socket_info()・socket_info::myname・socket_info::myname_len・sockaddr_convert_to_un()・sockaddr_dup().

{
        int ret;
        struct sockaddr_un un_addr;
        struct socket_info *si = find_socket_info(s);

        if (!si) {
                return real_bind(s, myaddr, addrlen);
        }

        si->myname_len = addrlen;
        si->myname = sockaddr_dup(myaddr, addrlen);

        ret = sockaddr_convert_to_un(si, (const struct sockaddr *)myaddr, addrlen, &un_addr, 1, &si->bcast);
        if (ret == -1) return -1;

        unlink(un_addr.sun_path);

        ret = real_bind(s, (struct sockaddr *)&un_addr,
                        sizeof(struct sockaddr_un));

        if (ret == 0) {
                si->bound = 1;
        }

        return ret;
}

int swrap_listen	(	int	s,
		int	backlog
	)

socket_wrapper.c の 1324 行で定義されています。

参照先 find_socket_info().

{
        int ret;
        struct socket_info *si = find_socket_info(s);

        if (!si) {
                return real_listen(s, backlog);
        }

        ret = real_listen(s, backlog);

        return ret;
}

int swrap_getpeername	(	int	s,
		struct sockaddr *	name,
		socklen_t *	addrlen
	)

socket_wrapper.c の 1338 行で定義されています。

参照先 errno・find_socket_info()・name・socket_info::peername・socket_info::peername_len.

{
        struct socket_info *si = find_socket_info(s);

        if (!si) {
                return real_getpeername(s, name, addrlen);
        }

        if (!si->peername)
        {
                errno = ENOTCONN;
                return -1;
        }

        memcpy(name, si->peername, si->peername_len);
        *addrlen = si->peername_len;

        return 0;
}

int swrap_getsockname	(	int	s,
		struct sockaddr *	name,
		socklen_t *	addrlen
	)

socket_wrapper.c の 1358 行で定義されています。

参照先 find_socket_info()・socket_info::myname・socket_info::myname_len・name.

{
        struct socket_info *si = find_socket_info(s);

        if (!si) {
                return real_getsockname(s, name, addrlen);
        }

        memcpy(name, si->myname, si->myname_len);
        *addrlen = si->myname_len;

        return 0;
}

int swrap_getsockopt	(	int	s,
		int	level,
		int	optname,
		void *	optval,
		socklen_t *	optlen
	)

socket_wrapper.c の 1372 行で定義されています。

参照先 errno・find_socket_info().

{
        struct socket_info *si = find_socket_info(s);

        if (!si) {
                return real_getsockopt(s, level, optname, optval, optlen);
        }

        if (level == SOL_SOCKET) {
                return real_getsockopt(s, level, optname, optval, optlen);
        } 

        errno = ENOPROTOOPT;
        return -1;
}

int swrap_setsockopt	(	int	s,
		int	level,
		int	optname,
		const void *	optval,
		socklen_t	optlen
	)

socket_wrapper.c の 1388 行で定義されています。

参照先 errno・socket_info::family・find_socket_info().

{
        struct socket_info *si = find_socket_info(s);

        if (!si) {
                return real_setsockopt(s, level, optname, optval, optlen);
        }

        if (level == SOL_SOCKET) {
                return real_setsockopt(s, level, optname, optval, optlen);
        }

        switch (si->family) {
        case AF_INET:
                return 0;
        default:
                errno = ENOPROTOOPT;
                return -1;
        }
}

ssize_t swrap_recvfrom	(	int	s,
		void *	buf,
		size_t	len,
		int	flags,
		struct sockaddr *	from,
		socklen_t *	fromlen
	)

socket_wrapper.c の 1409 行で定義されています。

参照先 socket_info::family・find_socket_info()・from・sockaddr_convert_from_un()・swrap_dump_packet()・SWRAP_RECVFROM.

{
        struct sockaddr_un un_addr;
        socklen_t un_addrlen = sizeof(un_addr);
        int ret;
        struct socket_info *si = find_socket_info(s);

        if (!si) {
                return real_recvfrom(s, buf, len, flags, from, fromlen);
        }

        /* irix 6.4 forgets to null terminate the sun_path string :-( */
        memset(&un_addr, 0, sizeof(un_addr));
        ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
        if (ret == -1) 
                return ret;

        if (sockaddr_convert_from_un(si, &un_addr, un_addrlen,
                                     si->family, from, fromlen) == -1) {
                return -1;
        }

        swrap_dump_packet(si, from, SWRAP_RECVFROM, buf, ret);

        return ret;
}

ssize_t swrap_sendto	(	int	s,
		const void *	buf,
		size_t	len,
		int	flags,
		const struct sockaddr *	to,
		socklen_t	tolen
	)

socket_wrapper.c の 1437 行で定義されています。

参照先 socket_info::bcast・socket_info::bound・errno・find_socket_info()・snprintf()・sockaddr_convert_to_un()・socket_wrapper_dir()・swrap_auto_bind()・swrap_dump_packet()・SWRAP_SENDTO・SWRAP_SENDTO_UNREACH・to・type.

{
        struct sockaddr_un un_addr;
        int ret;
        struct socket_info *si = find_socket_info(s);
        int bcast = 0;

        if (!si) {
                return real_sendto(s, buf, len, flags, to, tolen);
        }

        if (si->bound == 0) {
                ret = swrap_auto_bind(si);
                if (ret == -1) return -1;
        }

        ret = sockaddr_convert_to_un(si, to, tolen, &un_addr, 0, &bcast);
        if (ret == -1) return -1;

        if (bcast) {
                struct stat st;
                unsigned int iface;
                unsigned int prt = ntohs(((const struct sockaddr_in *)to)->sin_port);
                char type;

                type = SOCKET_TYPE_CHAR_UDP;

                for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
                        snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT, 
                                 socket_wrapper_dir(), type, iface, prt);
                        if (stat(un_addr.sun_path, &st) != 0) continue;

                        /* ignore the any errors in broadcast sends */
                        real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
                }

                swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);

                return len;
        }

        ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));

        /* to give better errors */
        if (ret == -1 && errno == ENOENT) {
                errno = EHOSTUNREACH;
        }

        if (ret == -1) {
                swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
                swrap_dump_packet(si, to, SWRAP_SENDTO_UNREACH, buf, len);
        } else {
                swrap_dump_packet(si, to, SWRAP_SENDTO, buf, ret);
        }

        return ret;
}

int swrap_ioctl	(	int	s,
		int	req,
		void *	ptr
	)

socket_wrapper.c の 1495 行で定義されています。

参照先 errno・find_socket_info()・swrap_dump_packet()・SWRAP_PENDING_RST.

{
        int ret;
        struct socket_info *si = find_socket_info(s);
        int value;

        if (!si) {
                return real_ioctl(s, r, p);
        }

        ret = real_ioctl(s, r, p);

        switch (r) {
        case FIONREAD:
                value = *((int *)p);
                if (ret == -1 && errno != EAGAIN && errno != ENOBUFS) {
                        swrap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
                } else if (value == 0) { /* END OF FILE */
                        swrap_dump_packet(si, NULL, SWRAP_PENDING_RST, NULL, 0);
                }
                break;
        }

        return ret;
}

ssize_t swrap_recv	(	int	s,
		void *	buf,
		size_t	len,
		int	flags
	)

socket_wrapper.c の 1521 行で定義されています。

参照先 errno・find_socket_info()・swrap_dump_packet()・SWRAP_RECV・SWRAP_RECV_RST.

{
        int ret;
        struct socket_info *si = find_socket_info(s);

        if (!si) {
                return real_recv(s, buf, len, flags);
        }

        ret = real_recv(s, buf, len, flags);
        if (ret == -1 && errno != EAGAIN && errno != ENOBUFS) {
                swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
        } else if (ret == 0) { /* END OF FILE */
                swrap_dump_packet(si, NULL, SWRAP_RECV_RST, NULL, 0);
        } else {
                swrap_dump_packet(si, NULL, SWRAP_RECV, buf, ret);
        }

        return ret;
}

ssize_t swrap_send	(	int	s,
		const void *	buf,
		size_t	len,
		int	flags
	)

socket_wrapper.c の 1543 行で定義されています。

参照先 find_socket_info()・swrap_dump_packet()・SWRAP_SEND・SWRAP_SEND_RST.

{
        int ret;
        struct socket_info *si = find_socket_info(s);

        if (!si) {
                return real_send(s, buf, len, flags);
        }

        ret = real_send(s, buf, len, flags);

        if (ret == -1) {
                swrap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
                swrap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0);
        } else {
                swrap_dump_packet(si, NULL, SWRAP_SEND, buf, ret);
        }

        return ret;
}

int swrap_close

(

int

)

socket_wrapper.c の 1564 行で定義されています。

参照先 find_socket_info()・socket_info::myname・socket_info::path・socket_info::peername・sockets・SWRAP_CLOSE_ACK・SWRAP_CLOSE_RECV・SWRAP_CLOSE_SEND・swrap_dump_packet()・socket_info::tmp_path.

{
        struct socket_info *si = find_socket_info(fd);
        int ret;

        if (!si) {
                return real_close(fd);
        }

        SWRAP_DLIST_REMOVE(sockets, si);

        if (si->myname && si->peername) {
                swrap_dump_packet(si, NULL, SWRAP_CLOSE_SEND, NULL, 0);
        }

        ret = real_close(fd);

        if (si->myname && si->peername) {
                swrap_dump_packet(si, NULL, SWRAP_CLOSE_RECV, NULL, 0);
                swrap_dump_packet(si, NULL, SWRAP_CLOSE_ACK, NULL, 0);
        }

        if (si->path) free(si->path);
        if (si->myname) free(si->myname);
        if (si->peername) free(si->peername);
        if (si->tmp_path) {
                unlink(si->tmp_path);
                free(si->tmp_path);
        }
        free(si);

        return ret;
}

---