Expand tabs [ci skip]

[Misc #18891]

19 files changed, 1410 insertions, 1410 deletions

diff --git a/ext/socket/addrinfo.h b/ext/socket/addrinfo.h
index f0b977d79c..eb9eb8ae0e 100644
--- a/ext/socket/addrinfo.h
+++ b/ext/socket/addrinfo.h
@@ -129,14 +129,14 @@
 
 #ifndef HAVE_TYPE_STRUCT_ADDRINFO
 struct addrinfo {
-	int	ai_flags;	/* AI_PASSIVE, AI_CANONNAME */
-	int	ai_family;	/* PF_xxx */
-	int	ai_socktype;	/* SOCK_xxx */
-	int	ai_protocol;	/* 0 or IPPROTO_xxx for IPv4 and IPv6 */
-	size_t	ai_addrlen;	/* length of ai_addr */
-	char	*ai_canonname;	/* canonical name for hostname */
-	struct sockaddr *ai_addr;	/* binary address */
-	struct addrinfo *ai_next;	/* next structure in linked list */
+        int	ai_flags;	/* AI_PASSIVE, AI_CANONNAME */
+        int	ai_family;	/* PF_xxx */
+        int	ai_socktype;	/* SOCK_xxx */
+        int	ai_protocol;	/* 0 or IPPROTO_xxx for IPv4 and IPv6 */
+        size_t	ai_addrlen;	/* length of ai_addr */
+        char	*ai_canonname;	/* canonical name for hostname */
+        struct sockaddr *ai_addr;	/* binary address */
+        struct addrinfo *ai_next;	/* next structure in linked list */
 };
 #endif
 
@@ -158,18 +158,18 @@ struct addrinfo {
 #endif
 
 extern int getaddrinfo __P((
-	const char *hostname, const char *servname,
-	const struct addrinfo *hints,
-	struct addrinfo **res));
+        const char *hostname, const char *servname,
+        const struct addrinfo *hints,
+        struct addrinfo **res));
 
 extern int getnameinfo __P((
-	const struct sockaddr *sa,
-	socklen_t salen,
-	char *host,
-	socklen_t hostlen,
-	char *serv,
-	socklen_t servlen,
-	int flags));
+        const struct sockaddr *sa,
+        socklen_t salen,
+        char *host,
+        socklen_t hostlen,
+        char *serv,
+        socklen_t servlen,
+        int flags));
 
 extern void freehostent __P((struct hostent *));
 extern void freeaddrinfo __P((struct addrinfo *));
diff --git a/ext/socket/ancdata.c b/ext/socket/ancdata.c
index aa62cab0ec..071e3323bb 100644
--- a/ext/socket/ancdata.c
+++ b/ext/socket/ancdata.c
@@ -333,11 +333,11 @@ ancillary_timestamp(VALUE self)
     if (level == SOL_SOCKET && type == SCM_BINTIME &&
         RSTRING_LEN(data) == sizeof(struct bintime)) {
         struct bintime bt;
-	VALUE d, timev;
+        VALUE d, timev;
         memcpy((char*)&bt, RSTRING_PTR(data), sizeof(bt));
-	d = ULL2NUM(0x100000000ULL);
-	d = mul(d,d);
-	timev = add(TIMET2NUM(bt.sec), quo(ULL2NUM(bt.frac), d));
+        d = ULL2NUM(0x100000000ULL);
+        d = mul(d,d);
+        timev = add(TIMET2NUM(bt.sec), quo(ULL2NUM(bt.frac), d));
         result = rb_time_num_new(timev, Qnil);
     }
 # endif
@@ -697,7 +697,7 @@ anc_inspect_passcred_credentials(int level, int type, VALUE data, VALUE ret)
         struct ucred cred;
         memcpy(&cred, RSTRING_PTR(data), sizeof(struct ucred));
         rb_str_catf(ret, " pid=%u uid=%u gid=%u", cred.pid, cred.uid, cred.gid);
-	rb_str_cat2(ret, " (ucred)");
+        rb_str_cat2(ret, " (ucred)");
         return 1;
     }
     else {
@@ -712,7 +712,7 @@ static int
 anc_inspect_socket_creds(int level, int type, VALUE data, VALUE ret)
 {
     if (level != SOL_SOCKET && type != SCM_CREDS)
-	return 0;
+        return 0;
 
     /*
      * FreeBSD has struct cmsgcred and struct sockcred.
@@ -727,46 +727,46 @@ anc_inspect_socket_creds(int level, int type, VALUE data, VALUE ret)
 
 #if defined(HAVE_TYPE_STRUCT_CMSGCRED) /* FreeBSD */
     if (RSTRING_LEN(data) == sizeof(struct cmsgcred)) {
-	struct cmsgcred cred;
+        struct cmsgcred cred;
         memcpy(&cred, RSTRING_PTR(data), sizeof(struct cmsgcred));
         rb_str_catf(ret, " pid=%u", cred.cmcred_pid);
         rb_str_catf(ret, " uid=%u", cred.cmcred_uid);
         rb_str_catf(ret, " euid=%u", cred.cmcred_euid);
         rb_str_catf(ret, " gid=%u", cred.cmcred_gid);
-	if (cred.cmcred_ngroups) {
-	    int i;
-	    const char *sep = " groups=";
-	    for (i = 0; i < cred.cmcred_ngroups; i++) {
-		rb_str_catf(ret, "%s%u", sep, cred.cmcred_groups[i]);
-		sep = ",";
-	    }
-	}
-	rb_str_cat2(ret, " (cmsgcred)");
+        if (cred.cmcred_ngroups) {
+            int i;
+            const char *sep = " groups=";
+            for (i = 0; i < cred.cmcred_ngroups; i++) {
+                rb_str_catf(ret, "%s%u", sep, cred.cmcred_groups[i]);
+                sep = ",";
+            }
+        }
+        rb_str_cat2(ret, " (cmsgcred)");
         return 1;
     }
 #endif
 #if defined(HAVE_TYPE_STRUCT_SOCKCRED) /* FreeBSD, NetBSD */
     if ((size_t)RSTRING_LEN(data) >= SOCKCREDSIZE(0)) {
-	struct sockcred cred0, *cred;
+        struct sockcred cred0, *cred;
         memcpy(&cred0, RSTRING_PTR(data), SOCKCREDSIZE(0));
-	if ((size_t)RSTRING_LEN(data) == SOCKCREDSIZE(cred0.sc_ngroups)) {
-	    cred = (struct sockcred *)ALLOCA_N(char, SOCKCREDSIZE(cred0.sc_ngroups));
-	    memcpy(cred, RSTRING_PTR(data), SOCKCREDSIZE(cred0.sc_ngroups));
-	    rb_str_catf(ret, " uid=%u", cred->sc_uid);
-	    rb_str_catf(ret, " euid=%u", cred->sc_euid);
-	    rb_str_catf(ret, " gid=%u", cred->sc_gid);
-	    rb_str_catf(ret, " egid=%u", cred->sc_egid);
-	    if (cred0.sc_ngroups) {
-		int i;
-		const char *sep = " groups=";
-		for (i = 0; i < cred0.sc_ngroups; i++) {
-		    rb_str_catf(ret, "%s%u", sep, cred->sc_groups[i]);
-		    sep = ",";
-		}
-	    }
-	    rb_str_cat2(ret, " (sockcred)");
-	    return 1;
-	}
+        if ((size_t)RSTRING_LEN(data) == SOCKCREDSIZE(cred0.sc_ngroups)) {
+            cred = (struct sockcred *)ALLOCA_N(char, SOCKCREDSIZE(cred0.sc_ngroups));
+            memcpy(cred, RSTRING_PTR(data), SOCKCREDSIZE(cred0.sc_ngroups));
+            rb_str_catf(ret, " uid=%u", cred->sc_uid);
+            rb_str_catf(ret, " euid=%u", cred->sc_euid);
+            rb_str_catf(ret, " gid=%u", cred->sc_gid);
+            rb_str_catf(ret, " egid=%u", cred->sc_egid);
+            if (cred0.sc_ngroups) {
+                int i;
+                const char *sep = " groups=";
+                for (i = 0; i < cred0.sc_ngroups; i++) {
+                    rb_str_catf(ret, "%s%u", sep, cred->sc_groups[i]);
+                    sep = ",";
+                }
+            }
+            rb_str_cat2(ret, " (sockcred)");
+            return 1;
+        }
     }
 #endif
     return 0;
@@ -906,37 +906,37 @@ inspect_bintime_as_abstime(int level, int optname, VALUE data, VALUE ret)
     if (RSTRING_LEN(data) == sizeof(struct bintime)) {
         struct bintime bt;
         struct tm tm;
-	uint64_t frac_h, frac_l;
-	uint64_t scale_h, scale_l;
-	uint64_t tmp1, tmp2;
-	uint64_t res_h, res_l;
+        uint64_t frac_h, frac_l;
+        uint64_t scale_h, scale_l;
+        uint64_t tmp1, tmp2;
+        uint64_t res_h, res_l;
         char buf[32];
         memcpy((char*)&bt, RSTRING_PTR(data), sizeof(bt));
         LOCALTIME(bt.sec, tm);
         strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm);
 
-	/* res_h = frac * 10**19 / 2**64 */
+        /* res_h = frac * 10**19 / 2**64 */
 
-	frac_h = bt.frac >> 32;
-	frac_l = bt.frac & 0xffffffff;
+        frac_h = bt.frac >> 32;
+        frac_l = bt.frac & 0xffffffff;
 
-	scale_h = 0x8ac72304; /* 0x8ac7230489e80000 == 10**19 */
-	scale_l = 0x89e80000;
+        scale_h = 0x8ac72304; /* 0x8ac7230489e80000 == 10**19 */
+        scale_l = 0x89e80000;
 
-	res_h = frac_h * scale_h;
-	res_l = frac_l * scale_l;
+        res_h = frac_h * scale_h;
+        res_l = frac_l * scale_l;
 
-	tmp1 = frac_h * scale_l;
-	res_h += tmp1 >> 32;
-	tmp2 = res_l;
-	res_l += tmp1 & 0xffffffff;
-	if (res_l < tmp2) res_h++;
+        tmp1 = frac_h * scale_l;
+        res_h += tmp1 >> 32;
+        tmp2 = res_l;
+        res_l += tmp1 & 0xffffffff;
+        if (res_l < tmp2) res_h++;
 
-	tmp1 = frac_l * scale_h;
-	res_h += tmp1 >> 32;
-	tmp2 = res_l;
-	res_l += tmp1 & 0xffffffff;
-	if (res_l < tmp2) res_h++;
+        tmp1 = frac_l * scale_h;
+        res_h += tmp1 >> 32;
+        tmp2 = res_l;
+        res_l += tmp1 & 0xffffffff;
+        if (res_l < tmp2) res_h++;
 
         rb_str_catf(ret, " %s.%019"PRIu64, buf, res_h);
         return 1;
@@ -1136,8 +1136,8 @@ rb_sendmsg(int fd, const struct msghdr *msg, int flags)
 
 static VALUE
 bsock_sendmsg_internal(VALUE sock, VALUE data, VALUE vflags,
-		       VALUE dest_sockaddr, VALUE controls, VALUE ex,
-		       int nonblock)
+                       VALUE dest_sockaddr, VALUE controls, VALUE ex,
+                       int nonblock)
 {
     rb_io_t *fptr;
     struct msghdr mh;
@@ -1160,15 +1160,15 @@ bsock_sendmsg_internal(VALUE sock, VALUE data, VALUE vflags,
     tmp = rb_str_tmp_frozen_acquire(data);
 
     if (!RB_TYPE_P(controls, T_ARRAY)) {
-	controls = rb_ary_new();
+        controls = rb_ary_new();
     }
     controls_num = RARRAY_LENINT(controls);
 
     if (controls_num) {
 #if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL)
-	int i;
-	size_t last_pad = 0;
-	const VALUE *controls_ptr = RARRAY_CONST_PTR(controls);
+        int i;
+        size_t last_pad = 0;
+        const VALUE *controls_ptr = RARRAY_CONST_PTR(controls);
 #if defined(__NetBSD__)
         int last_level = 0;
         int last_type = 0;
@@ -1215,9 +1215,9 @@ bsock_sendmsg_internal(VALUE sock, VALUE data, VALUE vflags,
             last_level = cmh.cmsg_level;
             last_type = cmh.cmsg_type;
 #endif
-	    last_pad = cspace - cmh.cmsg_len;
+            last_pad = cspace - cmh.cmsg_len;
         }
-	if (last_pad) {
+        if (last_pad) {
             /*
              * This code removes the last padding from msg_controllen.
              *
@@ -1242,10 +1242,10 @@ bsock_sendmsg_internal(VALUE sock, VALUE data, VALUE vflags,
             if (last_level == SOL_SOCKET && last_type == SCM_RIGHTS)
                 rb_str_set_len(controls_str, RSTRING_LEN(controls_str)-last_pad);
 #endif
-	}
-	RB_GC_GUARD(controls);
+        }
+        RB_GC_GUARD(controls);
 #else
-	rb_raise(rb_eNotImpError, "control message for sendmsg is unimplemented");
+        rb_raise(rb_eNotImpError, "control message for sendmsg is unimplemented");
 #endif
     }
 
@@ -1256,7 +1256,7 @@ bsock_sendmsg_internal(VALUE sock, VALUE data, VALUE vflags,
 #endif
 
     if (!NIL_P(dest_sockaddr))
-	SockAddrStringValue(dest_sockaddr);
+        SockAddrStringValue(dest_sockaddr);
 
     rb_io_check_closed(fptr);
 
@@ -1284,20 +1284,20 @@ bsock_sendmsg_internal(VALUE sock, VALUE data, VALUE vflags,
     ss = rb_sendmsg(fptr->fd, &mh, flags);
 
     if (ss == -1) {
-	int e;
+        int e;
         if (!nonblock && rb_io_maybe_wait_writable(errno, fptr->self, Qnil)) {
             rb_io_check_closed(fptr);
             goto retry;
         }
-	e = errno;
-	if (nonblock && (e == EWOULDBLOCK || e == EAGAIN)) {
-	    if (ex == Qfalse) {
-		return sym_wait_writable;
-	    }
-	    rb_readwrite_syserr_fail(RB_IO_WAIT_WRITABLE, e,
-				     "sendmsg(2) would block");
-	}
-	rb_syserr_fail(e, "sendmsg(2)");
+        e = errno;
+        if (nonblock && (e == EWOULDBLOCK || e == EAGAIN)) {
+            if (ex == Qfalse) {
+                return sym_wait_writable;
+            }
+            rb_readwrite_syserr_fail(RB_IO_WAIT_WRITABLE, e,
+                                     "sendmsg(2) would block");
+        }
+        rb_syserr_fail(e, "sendmsg(2)");
     }
 #if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL)
     RB_GC_GUARD(controls_str);
@@ -1311,20 +1311,20 @@ bsock_sendmsg_internal(VALUE sock, VALUE data, VALUE vflags,
 #if defined(HAVE_SENDMSG)
 VALUE
 rsock_bsock_sendmsg(VALUE sock, VALUE data, VALUE flags, VALUE dest_sockaddr,
-		    VALUE controls)
+                    VALUE controls)
 {
     return bsock_sendmsg_internal(sock, data, flags, dest_sockaddr, controls,
-				  Qtrue, 0);
+                                  Qtrue, 0);
 }
 #endif
 
 #if defined(HAVE_SENDMSG)
 VALUE
 rsock_bsock_sendmsg_nonblock(VALUE sock, VALUE data, VALUE flags,
-			     VALUE dest_sockaddr, VALUE controls, VALUE ex)
+                             VALUE dest_sockaddr, VALUE controls, VALUE ex)
 {
     return bsock_sendmsg_internal(sock, data, flags, dest_sockaddr,
-				  controls, ex, 1);
+                                  controls, ex, 1);
 }
 #endif
 
@@ -1422,12 +1422,12 @@ make_io_for_unix_rights(VALUE ctl, struct cmsghdr *cmh, char *msg_end)
 {
     if (cmh->cmsg_level == SOL_SOCKET && cmh->cmsg_type == SCM_RIGHTS) {
         int *fdp, *end;
-	VALUE ary = rb_ary_new();
-	rb_ivar_set(ctl, rb_intern("unix_rights"), ary);
+        VALUE ary = rb_ary_new();
+        rb_ivar_set(ctl, rb_intern("unix_rights"), ary);
         fdp = (int *)CMSG_DATA(cmh);
         end = (int *)((char *)cmh + cmh->cmsg_len);
         while ((char *)fdp + sizeof(int) <= (char *)end &&
-	       (char *)fdp + sizeof(int) <= msg_end) {
+               (char *)fdp + sizeof(int) <= msg_end) {
             int fd = *fdp;
             struct stat stbuf;
             VALUE io;
@@ -1443,15 +1443,15 @@ make_io_for_unix_rights(VALUE ctl, struct cmsghdr *cmh, char *msg_end)
             rb_ary_push(ary, io);
             fdp++;
         }
-	OBJ_FREEZE(ary);
+        OBJ_FREEZE(ary);
     }
 }
 #endif
 
 static VALUE
 bsock_recvmsg_internal(VALUE sock,
-		VALUE vmaxdatlen, VALUE vflags, VALUE vmaxctllen,
-		VALUE scm_rights, VALUE ex, int nonblock)
+                VALUE vmaxdatlen, VALUE vflags, VALUE vmaxctllen,
+                VALUE scm_rights, VALUE ex, int nonblock)
 {
     rb_io_t *fptr;
     int grow_buffer;
@@ -1505,28 +1505,28 @@ bsock_recvmsg_internal(VALUE sock,
 
 #if !defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL)
     if (grow_buffer) {
-	int socktype;
-	socklen_t optlen = (socklen_t)sizeof(socktype);
+        int socktype;
+        socklen_t optlen = (socklen_t)sizeof(socktype);
         if (getsockopt(fptr->fd, SOL_SOCKET, SO_TYPE, (void*)&socktype, &optlen) == -1) {
-	    rb_sys_fail("getsockopt(SO_TYPE)");
-	}
-	if (socktype == SOCK_STREAM)
-	    grow_buffer = 0;
+            rb_sys_fail("getsockopt(SO_TYPE)");
+        }
+        if (socktype == SOCK_STREAM)
+            grow_buffer = 0;
     }
 #endif
 
   retry:
     if (NIL_P(dat_str))
-	dat_str = rb_str_tmp_new(maxdatlen);
+        dat_str = rb_str_tmp_new(maxdatlen);
     else
-	rb_str_resize(dat_str, maxdatlen);
+        rb_str_resize(dat_str, maxdatlen);
     datbuf = RSTRING_PTR(dat_str);
 
 #if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL)
     if (NIL_P(ctl_str))
-	ctl_str = rb_str_tmp_new(maxctllen);
+        ctl_str = rb_str_tmp_new(maxctllen);
     else
-	rb_str_resize(ctl_str, maxctllen);
+        rb_str_resize(ctl_str, maxctllen);
     ctlbuf = RSTRING_PTR(ctl_str);
 #endif
 
@@ -1556,20 +1556,20 @@ bsock_recvmsg_internal(VALUE sock,
     ss = rb_recvmsg(fptr->fd, &mh, flags);
 
     if (ss == -1) {
-	int e;
+        int e;
         if (!nonblock && rb_io_maybe_wait_readable(errno, fptr->self, Qnil)) {
             rb_io_check_closed(fptr);
             goto retry;
         }
-	e = errno;
-	if (nonblock && (e == EWOULDBLOCK || e == EAGAIN)) {
+        e = errno;
+        if (nonblock && (e == EWOULDBLOCK || e == EAGAIN)) {
             if (ex == Qfalse) {
                 return sym_wait_readable;
             }
-	    rb_readwrite_syserr_fail(RB_IO_WAIT_READABLE, e, "recvmsg(2) would block");
+            rb_readwrite_syserr_fail(RB_IO_WAIT_READABLE, e, "recvmsg(2) would block");
         }
 #if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL)
-	if (!gc_done && (e == EMFILE || e == EMSGSIZE)) {
+        if (!gc_done && (e == EMFILE || e == EMSGSIZE)) {
           /*
            * When SCM_RIGHTS hit the file descriptors limit:
            * - Linux 2.6.18 causes success with MSG_CTRUNC
@@ -1579,24 +1579,24 @@ bsock_recvmsg_internal(VALUE sock,
           gc_and_retry:
             rb_gc();
             gc_done = 1;
-	    goto retry;
+            goto retry;
         }
 #else
-	if (NIL_P(vmaxdatlen) && grow_buffer && e == EMSGSIZE)
-	    ss = (ssize_t)iov.iov_len;
-	else
+        if (NIL_P(vmaxdatlen) && grow_buffer && e == EMSGSIZE)
+            ss = (ssize_t)iov.iov_len;
+        else
 #endif
-	rb_syserr_fail(e, "recvmsg(2)");
+        rb_syserr_fail(e, "recvmsg(2)");
     }
 
     if (grow_buffer) {
-	int grown = 0;
-	if (NIL_P(vmaxdatlen) && ss != -1 && ss == (ssize_t)iov.iov_len) {
+        int grown = 0;
+        if (NIL_P(vmaxdatlen) && ss != -1 && ss == (ssize_t)iov.iov_len) {
             if (SIZE_MAX/2 < maxdatlen)
                 rb_raise(rb_eArgError, "max data length too big");
-	    maxdatlen *= 2;
-	    grown = 1;
-	}
+            maxdatlen *= 2;
+            grown = 1;
+        }
 #if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL)
         if (NIL_P(vmaxctllen) && (mh.msg_flags & MSG_CTRUNC)) {
 #define BIG_ENOUGH_SPACE 65536
@@ -1605,9 +1605,9 @@ bsock_recvmsg_internal(VALUE sock,
                 /* there are big space bug truncated.
                  * file descriptors limit? */
                 if (!gc_done) {
-		    rsock_discard_cmsg_resource(&mh, (flags & MSG_PEEK) != 0);
+                    rsock_discard_cmsg_resource(&mh, (flags & MSG_PEEK) != 0);
                     goto gc_and_retry;
-		}
+                }
             }
             else {
                 if (SIZE_MAX/2 < maxctllen)
@@ -1616,13 +1616,13 @@ bsock_recvmsg_internal(VALUE sock,
                 grown = 1;
             }
 #undef BIG_ENOUGH_SPACE
-	}
+        }
 #endif
-	if (grown) {
+        if (grown) {
             rsock_discard_cmsg_resource(&mh, (flags & MSG_PEEK) != 0);
-	    goto retry;
-	}
-	else {
+            goto retry;
+        }
+        else {
             grow_buffer = 0;
             if (flags != orig_flags) {
                 rsock_discard_cmsg_resource(&mh, (flags & MSG_PEEK) != 0);
@@ -1636,31 +1636,31 @@ bsock_recvmsg_internal(VALUE sock,
         dat_str = rb_str_new(datbuf, ss);
     else {
         rb_str_resize(dat_str, ss);
-	rb_obj_reveal(dat_str, rb_cString);
+        rb_obj_reveal(dat_str, rb_cString);
     }
 
     ret = rb_ary_new3(3, dat_str,
                          rsock_io_socket_addrinfo(sock, mh.msg_name, mh.msg_namelen),
 #if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL)
-			 INT2NUM(mh.msg_flags)
+                         INT2NUM(mh.msg_flags)
 #else
-			 Qnil
+                         Qnil
 #endif
-			 );
+                         );
 
 #if defined(HAVE_STRUCT_MSGHDR_MSG_CONTROL)
     family = rsock_getfamily(fptr);
     if (mh.msg_controllen) {
-	char *msg_end = (char *)mh.msg_control + mh.msg_controllen;
+        char *msg_end = (char *)mh.msg_control + mh.msg_controllen;
         for (cmh = CMSG_FIRSTHDR(&mh); cmh != NULL; cmh = CMSG_NXTHDR(&mh, cmh)) {
             VALUE ctl;
-	    char *ctl_end;
+            char *ctl_end;
             size_t clen;
             if (cmh->cmsg_len == 0) {
                 rb_raise(rb_eTypeError, "invalid control message (cmsg_len == 0)");
             }
             ctl_end = (char*)cmh + cmh->cmsg_len;
-	    clen = (ctl_end <= msg_end ? ctl_end : msg_end) - (char*)CMSG_DATA(cmh);
+            clen = (ctl_end <= msg_end ? ctl_end : msg_end) - (char*)CMSG_DATA(cmh);
             ctl = ancdata_new(family, cmh->cmsg_level, cmh->cmsg_type, rb_str_new((char*)CMSG_DATA(cmh), clen));
             if (request_scm_rights)
                 make_io_for_unix_rights(ctl, cmh, msg_end);
@@ -1679,7 +1679,7 @@ bsock_recvmsg_internal(VALUE sock,
 #if defined(HAVE_RECVMSG)
 VALUE
 rsock_bsock_recvmsg(VALUE sock, VALUE dlen, VALUE flags, VALUE clen,
-		    VALUE scm_rights)
+                    VALUE scm_rights)
 {
     VALUE ex = Qtrue;
     return bsock_recvmsg_internal(sock, dlen, flags, clen, scm_rights, ex, 0);
@@ -1689,7 +1689,7 @@ rsock_bsock_recvmsg(VALUE sock, VALUE dlen, VALUE flags, VALUE clen,
 #if defined(HAVE_RECVMSG)
 VALUE
 rsock_bsock_recvmsg_nonblock(VALUE sock, VALUE dlen, VALUE flags, VALUE clen,
-			     VALUE scm_rights, VALUE ex)
+                             VALUE scm_rights, VALUE ex)
 {
     return bsock_recvmsg_internal(sock, dlen, flags, clen, scm_rights, ex, 1);
 }
diff --git a/ext/socket/basicsocket.c b/ext/socket/basicsocket.c
index 44fb7a4eb7..93196c924d 100644
--- a/ext/socket/basicsocket.c
+++ b/ext/socket/basicsocket.c
@@ -94,16 +94,16 @@ bsock_shutdown(int argc, VALUE *argv, VALUE sock)
 
     rb_scan_args(argc, argv, "01", &howto);
     if (howto == Qnil)
-	how = SHUT_RDWR;
+        how = SHUT_RDWR;
     else {
-	how = rsock_shutdown_how_arg(howto);
+        how = rsock_shutdown_how_arg(howto);
         if (how != SHUT_WR && how != SHUT_RD && how != SHUT_RDWR) {
-	    rb_raise(rb_eArgError, "`how' should be either :SHUT_RD, :SHUT_WR, :SHUT_RDWR");
-	}
+            rb_raise(rb_eArgError, "`how' should be either :SHUT_RD, :SHUT_WR, :SHUT_RDWR");
+        }
     }
     GetOpenFile(sock, fptr);
     if (shutdown(fptr->fd, how) == -1)
-	rb_sys_fail("shutdown(2)");
+        rb_sys_fail("shutdown(2)");
 
     return INT2FIX(0);
 }
@@ -126,7 +126,7 @@ bsock_close_read(VALUE sock)
     GetOpenFile(sock, fptr);
     shutdown(fptr->fd, 0);
     if (!(fptr->mode & FMODE_WRITABLE)) {
-	return rb_io_close(sock);
+        return rb_io_close(sock);
     }
     fptr->mode &= ~FMODE_READABLE;
 
@@ -155,7 +155,7 @@ bsock_close_write(VALUE sock)
 
     GetOpenFile(sock, fptr);
     if (!(fptr->mode & FMODE_READABLE)) {
-	return rb_io_close(sock);
+        return rb_io_close(sock);
     }
     shutdown(fptr->fd, 1);
     fptr->mode &= ~FMODE_WRITABLE;
@@ -246,21 +246,21 @@ bsock_setsockopt(int argc, VALUE *argv, VALUE sock)
 
     switch (TYPE(val)) {
       case T_FIXNUM:
-	i = FIX2INT(val);
-	goto numval;
+        i = FIX2INT(val);
+        goto numval;
       case T_FALSE:
-	i = 0;
-	goto numval;
+        i = 0;
+        goto numval;
       case T_TRUE:
-	i = 1;
+        i = 1;
       numval:
-	v = (char*)&i; vlen = (int)sizeof(i);
-	break;
+        v = (char*)&i; vlen = (int)sizeof(i);
+        break;
       default:
-	StringValue(val);
-	v = RSTRING_PTR(val);
-	vlen = RSTRING_SOCKLEN(val);
-	break;
+        StringValue(val);
+        v = RSTRING_PTR(val);
+        vlen = RSTRING_SOCKLEN(val);
+        break;
     }
 
     rb_io_check_closed(fptr);
@@ -357,7 +357,7 @@ bsock_getsockopt(VALUE sock, VALUE lev, VALUE optname)
     rb_io_check_closed(fptr);
 
     if (getsockopt(fptr->fd, level, option, buf, &len) < 0)
-	rsock_sys_fail_path("getsockopt(2)", fptr->pathv);
+        rsock_sys_fail_path("getsockopt(2)", fptr->pathv);
 
     return rsock_sockopt_new(family, level, option, rb_str_new(buf, len));
 }
@@ -385,7 +385,7 @@ bsock_getsockname(VALUE sock)
 
     GetOpenFile(sock, fptr);
     if (getsockname(fptr->fd, &buf.addr, &len) < 0)
-	rb_sys_fail("getsockname(2)");
+        rb_sys_fail("getsockname(2)");
     if (len0 < len) len = len0;
     return rb_str_new((char*)&buf, len);
 }
@@ -416,7 +416,7 @@ bsock_getpeername(VALUE sock)
 
     GetOpenFile(sock, fptr);
     if (getpeername(fptr->fd, &buf.addr, &len) < 0)
-	rb_sys_fail("getpeername(2)");
+        rb_sys_fail("getpeername(2)");
     if (len0 < len) len = len0;
     return rb_str_new((char*)&buf, len);
 }
@@ -453,7 +453,7 @@ bsock_getpeereid(VALUE self)
     gid_t egid;
     GetOpenFile(self, fptr);
     if (getpeereid(fptr->fd, &euid, &egid) == -1)
-	rb_sys_fail("getpeereid(3)");
+        rb_sys_fail("getpeereid(3)");
     return rb_assoc_new(UIDT2NUM(euid), GIDT2NUM(egid));
 #elif defined(SO_PEERCRED) /* GNU/Linux */
     rb_io_t *fptr;
@@ -461,7 +461,7 @@ bsock_getpeereid(VALUE self)
     socklen_t len = sizeof(cred);
     GetOpenFile(self, fptr);
     if (getsockopt(fptr->fd, SOL_SOCKET, SO_PEERCRED, &cred, &len) == -1)
-	rb_sys_fail("getsockopt(SO_PEERCRED)");
+        rb_sys_fail("getsockopt(SO_PEERCRED)");
     return rb_assoc_new(UIDT2NUM(cred.uid), GIDT2NUM(cred.gid));
 #elif defined(HAVE_GETPEERUCRED) /* Solaris */
     rb_io_t *fptr;
@@ -469,7 +469,7 @@ bsock_getpeereid(VALUE self)
     VALUE ret;
     GetOpenFile(self, fptr);
     if (getpeerucred(fptr->fd, &uc) == -1)
-	rb_sys_fail("getpeerucred(3C)");
+        rb_sys_fail("getpeerucred(3C)");
     ret = rb_assoc_new(UIDT2NUM(ucred_geteuid(uc)), GIDT2NUM(ucred_getegid(uc)));
     ucred_free(uc);
     return ret;
@@ -506,7 +506,7 @@ bsock_local_address(VALUE sock)
 
     GetOpenFile(sock, fptr);
     if (getsockname(fptr->fd, &buf.addr, &len) < 0)
-	rb_sys_fail("getsockname(2)");
+        rb_sys_fail("getsockname(2)");
     if (len0 < len) len = len0;
     return rsock_fd_socket_addrinfo(fptr->fd, &buf.addr, len);
 }
@@ -540,7 +540,7 @@ bsock_remote_address(VALUE sock)
 
     GetOpenFile(sock, fptr);
     if (getpeername(fptr->fd, &buf.addr, &len) < 0)
-	rb_sys_fail("getpeername(2)");
+        rb_sys_fail("getpeername(2)");
     if (len0 < len) len = len0;
     return rsock_fd_socket_addrinfo(fptr->fd, &buf.addr, len);
 }
@@ -656,10 +656,10 @@ bsock_do_not_reverse_lookup_set(VALUE sock, VALUE state)
 
     GetOpenFile(sock, fptr);
     if (RTEST(state)) {
-	fptr->mode |= FMODE_NOREVLOOKUP;
+        fptr->mode |= FMODE_NOREVLOOKUP;
     }
     else {
-	fptr->mode &= ~FMODE_NOREVLOOKUP;
+        fptr->mode &= ~FMODE_NOREVLOOKUP;
     }
     return sock;
 }
@@ -747,9 +747,9 @@ rsock_init_basicsocket(void)
     rb_undef_method(rb_cBasicSocket, "initialize");
 
     rb_define_singleton_method(rb_cBasicSocket, "do_not_reverse_lookup",
-			       bsock_do_not_rev_lookup, 0);
+                               bsock_do_not_rev_lookup, 0);
     rb_define_singleton_method(rb_cBasicSocket, "do_not_reverse_lookup=",
-			       bsock_do_not_rev_lookup_set, 1);
+                               bsock_do_not_rev_lookup_set, 1);
     rb_define_singleton_method(rb_cBasicSocket, "for_fd", bsock_s_for_fd, 1);
 
     rb_define_method(rb_cBasicSocket, "close_read", bsock_close_read, 0);
@@ -770,23 +770,23 @@ rsock_init_basicsocket(void)
 
     /* for ext/socket/lib/socket.rb use only: */
     rb_define_private_method(rb_cBasicSocket,
-			     "__recv_nonblock", bsock_recv_nonblock, 4);
+                             "__recv_nonblock", bsock_recv_nonblock, 4);
 
 #if MSG_DONTWAIT_RELIABLE
     rb_define_private_method(rb_cBasicSocket,
-			     "__read_nonblock", rsock_read_nonblock, 3);
+                             "__read_nonblock", rsock_read_nonblock, 3);
     rb_define_private_method(rb_cBasicSocket,
-			     "__write_nonblock", rsock_write_nonblock, 2);
+                             "__write_nonblock", rsock_write_nonblock, 2);
 #endif
 
     /* in ancdata.c */
     rb_define_private_method(rb_cBasicSocket, "__sendmsg",
-			     rsock_bsock_sendmsg, 4);
+                             rsock_bsock_sendmsg, 4);
     rb_define_private_method(rb_cBasicSocket, "__sendmsg_nonblock",
-			     rsock_bsock_sendmsg_nonblock, 5);
+                             rsock_bsock_sendmsg_nonblock, 5);
     rb_define_private_method(rb_cBasicSocket, "__recvmsg",
-			     rsock_bsock_recvmsg, 4);
+                             rsock_bsock_recvmsg, 4);
     rb_define_private_method(rb_cBasicSocket, "__recvmsg_nonblock",
-			    rsock_bsock_recvmsg_nonblock, 5);
+                            rsock_bsock_recvmsg_nonblock, 5);
 
 }
diff --git a/ext/socket/constants.c b/ext/socket/constants.c
index 1bbb53b173..1213f2ae17 100644
--- a/ext/socket/constants.c
+++ b/ext/socket/constants.c
@@ -26,14 +26,14 @@ constant_arg(VALUE arg, int (*str_to_int)(const char*, long, int*), const char *
         goto str;
     }
     else if (!NIL_P(tmp = rb_check_string_type(arg))) {
-	arg = tmp;
+        arg = tmp;
       str:
         ptr = RSTRING_PTR(arg);
         if (str_to_int(ptr, RSTRING_LEN(arg), &ret) == -1)
-	    rb_raise(rb_eSocket, "%s: %s", errmsg, ptr);
+            rb_raise(rb_eSocket, "%s: %s", errmsg, ptr);
     }
     else {
-	ret = NUM2INT(arg);
+        ret = NUM2INT(arg);
     }
     return ret;
 }
diff --git a/ext/socket/getaddrinfo.c b/ext/socket/getaddrinfo.c
index ce6dc40478..95a2feb3be 100644
--- a/ext/socket/getaddrinfo.c
+++ b/ext/socket/getaddrinfo.c
@@ -98,42 +98,42 @@ static struct in6_addr faith_prefix = IN6ADDR_ANY_INIT;
 
 static const char in_addrany[] = { 0, 0, 0, 0 };
 static const char in6_addrany[] = {
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
 static const char in_loopback[] = { 127, 0, 0, 1 };
 static const char in6_loopback[] = {
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
 };
 
 struct sockinet {
-	u_char	si_len;
-	u_char	si_family;
-	u_short	si_port;
+        u_char	si_len;
+        u_char	si_family;
+        u_short	si_port;
 };
 
 static const struct afd {
-	int a_af;
-	int a_addrlen;
-	int a_socklen;
-	int a_off;
-	const char *a_addrany;
-	const char *a_loopback;
+        int a_af;
+        int a_addrlen;
+        int a_socklen;
+        int a_off;
+        const char *a_addrany;
+        const char *a_loopback;
 } afdl [] = {
 #ifdef INET6
 #define N_INET6 0
-	{PF_INET6, sizeof(struct in6_addr),
-	 sizeof(struct sockaddr_in6),
-	 offsetof(struct sockaddr_in6, sin6_addr),
-	 in6_addrany, in6_loopback},
+        {PF_INET6, sizeof(struct in6_addr),
+         sizeof(struct sockaddr_in6),
+         offsetof(struct sockaddr_in6, sin6_addr),
+         in6_addrany, in6_loopback},
 #define N_INET  1
 #else
 #define N_INET  0
 #endif
-	{PF_INET, sizeof(struct in_addr),
-	 sizeof(struct sockaddr_in),
-	 offsetof(struct sockaddr_in, sin_addr),
-	 in_addrany, in_loopback},
-	{0, 0, 0, 0, NULL, NULL},
+        {PF_INET, sizeof(struct in_addr),
+         sizeof(struct sockaddr_in),
+         offsetof(struct sockaddr_in, sin_addr),
+         in_addrany, in_loopback},
+        {0, 0, 0, 0, NULL, NULL},
 };
 
 #ifdef INET6
@@ -143,58 +143,58 @@ static const struct afd {
 #endif
 
 static int get_name __P((const char *, const struct afd *,
-			  struct addrinfo **, char *, struct addrinfo *,
-			  int));
+                          struct addrinfo **, char *, struct addrinfo *,
+                          int));
 static int get_addr __P((const char *, int, struct addrinfo **,
-			struct addrinfo *, int));
+                        struct addrinfo *, int));
 static int str_isnumber __P((const char *));
 
 #ifndef HAVE_GAI_STRERROR
 static const char *const ai_errlist[] = {
-	"success.",
-	"address family for hostname not supported.",	/* EAI_ADDRFAMILY */
-	"temporary failure in name resolution.",	/* EAI_AGAIN      */
-	"invalid value for ai_flags.",		       	/* EAI_BADFLAGS   */
-	"non-recoverable failure in name resolution.", 	/* EAI_FAIL       */
-	"ai_family not supported.",			/* EAI_FAMILY     */
-	"memory allocation failure.", 			/* EAI_MEMORY     */
-	"no address associated with hostname.", 	/* EAI_NODATA     */
-	"hostname nor servname provided, or not known.",/* EAI_NONAME     */
-	"servname not supported for ai_socktype.",	/* EAI_SERVICE    */
-	"ai_socktype not supported.", 			/* EAI_SOCKTYPE   */
-	"system error returned in errno.", 		/* EAI_SYSTEM     */
-	"invalid value for hints.",			/* EAI_BADHINTS	  */
-	"resolved protocol is unknown.",		/* EAI_PROTOCOL   */
-	"unknown error.", 				/* EAI_MAX        */
+        "success.",
+        "address family for hostname not supported.",	/* EAI_ADDRFAMILY */
+        "temporary failure in name resolution.",	/* EAI_AGAIN      */
+        "invalid value for ai_flags.",		       	/* EAI_BADFLAGS   */
+        "non-recoverable failure in name resolution.", 	/* EAI_FAIL       */
+        "ai_family not supported.",			/* EAI_FAMILY     */
+        "memory allocation failure.", 			/* EAI_MEMORY     */
+        "no address associated with hostname.", 	/* EAI_NODATA     */
+        "hostname nor servname provided, or not known.",/* EAI_NONAME     */
+        "servname not supported for ai_socktype.",	/* EAI_SERVICE    */
+        "ai_socktype not supported.", 			/* EAI_SOCKTYPE   */
+        "system error returned in errno.", 		/* EAI_SYSTEM     */
+        "invalid value for hints.",			/* EAI_BADHINTS	  */
+        "resolved protocol is unknown.",		/* EAI_PROTOCOL   */
+        "unknown error.", 				/* EAI_MAX        */
 };
 #endif
 
 #define GET_CANONNAME(ai, str) \
 if (pai->ai_flags & AI_CANONNAME) {\
-	if (((ai)->ai_canonname = (char *)malloc(strlen(str) + 1)) != NULL) {\
-		strcpy((ai)->ai_canonname, (str));\
-	} else {\
-		error = EAI_MEMORY;\
-		goto free;\
-	}\
+        if (((ai)->ai_canonname = (char *)malloc(strlen(str) + 1)) != NULL) {\
+                strcpy((ai)->ai_canonname, (str));\
+        } else {\
+                error = EAI_MEMORY;\
+                goto free;\
+        }\
 }
 
 #define GET_AI(ai, afd, addr, port) {\
-	char *p;\
-	if (((ai) = (struct addrinfo *)malloc(sizeof(struct addrinfo) +\
-					      ((afd)->a_socklen)))\
-	    == NULL) {\
-		error = EAI_MEMORY;\
-		goto free;\
-	}\
-	memcpy((ai), pai, sizeof(struct addrinfo));\
-	(ai)->ai_addr = (struct sockaddr *)((ai) + 1);\
-	(ai)->ai_family = (afd)->a_af;\
-	(ai)->ai_addrlen = (afd)->a_socklen;\
-	INIT_SOCKADDR((ai)->ai_addr, (afd)->a_af, (afd)->a_socklen);\
-	((struct sockinet *)(ai)->ai_addr)->si_port = (port);\
-	p = (char *)((ai)->ai_addr);\
-	memcpy(p + (afd)->a_off, (addr), (afd)->a_addrlen);\
+        char *p;\
+        if (((ai) = (struct addrinfo *)malloc(sizeof(struct addrinfo) +\
+                                              ((afd)->a_socklen)))\
+            == NULL) {\
+                error = EAI_MEMORY;\
+                goto free;\
+        }\
+        memcpy((ai), pai, sizeof(struct addrinfo));\
+        (ai)->ai_addr = (struct sockaddr *)((ai) + 1);\
+        (ai)->ai_family = (afd)->a_af;\
+        (ai)->ai_addrlen = (afd)->a_socklen;\
+        INIT_SOCKADDR((ai)->ai_addr, (afd)->a_af, (afd)->a_socklen);\
+        ((struct sockinet *)(ai)->ai_addr)->si_port = (port);\
+        p = (char *)((ai)->ai_addr);\
+        memcpy(p + (afd)->a_off, (addr), (afd)->a_addrlen);\
 }
 
 #define ERR(err) { error = (err); goto bad; }
@@ -206,36 +206,36 @@ const
 char *
 gai_strerror(int ecode)
 {
-	if (ecode < 0 || ecode > EAI_MAX)
-		ecode = EAI_MAX;
-	return (char *)ai_errlist[ecode];
+        if (ecode < 0 || ecode > EAI_MAX)
+                ecode = EAI_MAX;
+        return (char *)ai_errlist[ecode];
 }
 #endif
 
 void
 freeaddrinfo(struct addrinfo *ai)
 {
-	struct addrinfo *next;
-
-	do {
-		next = ai->ai_next;
-		if (ai->ai_canonname)
-			free(ai->ai_canonname);
-		/* no need to free(ai->ai_addr) */
-		free(ai);
-	} while ((ai = next) != NULL);
+        struct addrinfo *next;
+
+        do {
+                next = ai->ai_next;
+                if (ai->ai_canonname)
+                        free(ai->ai_canonname);
+                /* no need to free(ai->ai_addr) */
+                free(ai);
+        } while ((ai = next) != NULL);
 }
 
 static int
 str_isnumber(const char *p)
 {
-	char *q = (char *)p;
-	while (*q) {
-		if (! isdigit(*q))
-			return NO;
-		q++;
-	}
-	return YES;
+        char *q = (char *)p;
+        while (*q) {
+                if (! isdigit(*q))
+                        return NO;
+                q++;
+        }
+        return YES;
 }
 
 #ifndef HAVE_INET_PTON
@@ -243,435 +243,435 @@ str_isnumber(const char *p)
 static int
 inet_pton(int af, const char *hostname, void *pton)
 {
-	struct in_addr in;
+        struct in_addr in;
 
 #ifdef HAVE_INET_ATON
-	if (!inet_aton(hostname, &in))
-	    return 0;
+        if (!inet_aton(hostname, &in))
+            return 0;
 #else
-	int d1, d2, d3, d4;
-	char ch;
-
-	if (sscanf(hostname, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
-	    0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
-	    0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
-	    in.s_addr = htonl(
-		((long) d1 << 24) | ((long) d2 << 16) |
-		((long) d3 << 8) | ((long) d4 << 0));
-	}
-	else {
-	    return 0;
-	}
-#endif
-	memcpy(pton, &in, sizeof(in));
-	return 1;
+        int d1, d2, d3, d4;
+        char ch;
+
+        if (sscanf(hostname, "%d.%d.%d.%d%c", &d1, &d2, &d3, &d4, &ch) == 4 &&
+            0 <= d1 && d1 <= 255 && 0 <= d2 && d2 <= 255 &&
+            0 <= d3 && d3 <= 255 && 0 <= d4 && d4 <= 255) {
+            in.s_addr = htonl(
+                ((long) d1 << 24) | ((long) d2 << 16) |
+                ((long) d3 << 8) | ((long) d4 << 0));
+        }
+        else {
+            return 0;
+        }
+#endif
+        memcpy(pton, &in, sizeof(in));
+        return 1;
 }
 #endif
 
 int
 getaddrinfo(const char *hostname, const char *servname, const struct addrinfo *hints, struct addrinfo **res)
 {
-	struct addrinfo sentinel;
-	struct addrinfo *top = NULL;
-	struct addrinfo *cur;
-	int i, error = 0;
-	char pton[PTON_MAX];
-	struct addrinfo ai;
-	struct addrinfo *pai;
-	u_short port;
+        struct addrinfo sentinel;
+        struct addrinfo *top = NULL;
+        struct addrinfo *cur;
+        int i, error = 0;
+        char pton[PTON_MAX];
+        struct addrinfo ai;
+        struct addrinfo *pai;
+        u_short port;
 
 #ifdef FAITH
-	static int firsttime = 1;
-
-	if (firsttime) {
-		/* translator hack */
-		{
-			char *q = getenv("GAI");
-			if (q && inet_pton(AF_INET6, q, &faith_prefix) == 1)
-				translate = YES;
-		}
-		firsttime = 0;
-	}
-#endif
-
-	/* initialize file static vars */
-	sentinel.ai_next = NULL;
-	cur = &sentinel;
-	pai = &ai;
-	pai->ai_flags = 0;
-	pai->ai_family = PF_UNSPEC;
-	pai->ai_socktype = ANY;
-	pai->ai_protocol = ANY;
-	pai->ai_addrlen = 0;
-	pai->ai_canonname = NULL;
-	pai->ai_addr = NULL;
-	pai->ai_next = NULL;
-	port = ANY;
-
-	if (hostname == NULL && servname == NULL)
-		return EAI_NONAME;
-	if (hints) {
-		/* error check for hints */
-		if (hints->ai_addrlen || hints->ai_canonname ||
-		    hints->ai_addr || hints->ai_next)
-			ERR(EAI_BADHINTS); /* xxx */
-		if (hints->ai_flags & ~AI_MASK)
-			ERR(EAI_BADFLAGS);
-		switch (hints->ai_family) {
-		case PF_UNSPEC:
-		case PF_INET:
+        static int firsttime = 1;
+
+        if (firsttime) {
+                /* translator hack */
+                {
+                        char *q = getenv("GAI");
+                        if (q && inet_pton(AF_INET6, q, &faith_prefix) == 1)
+                                translate = YES;
+                }
+                firsttime = 0;
+        }
+#endif
+
+        /* initialize file static vars */
+        sentinel.ai_next = NULL;
+        cur = &sentinel;
+        pai = &ai;
+        pai->ai_flags = 0;
+        pai->ai_family = PF_UNSPEC;
+        pai->ai_socktype = ANY;
+        pai->ai_protocol = ANY;
+        pai->ai_addrlen = 0;
+        pai->ai_canonname = NULL;
+        pai->ai_addr = NULL;
+        pai->ai_next = NULL;
+        port = ANY;
+
+        if (hostname == NULL && servname == NULL)
+                return EAI_NONAME;
+        if (hints) {
+                /* error check for hints */
+                if (hints->ai_addrlen || hints->ai_canonname ||
+                    hints->ai_addr || hints->ai_next)
+                        ERR(EAI_BADHINTS); /* xxx */
+                if (hints->ai_flags & ~AI_MASK)
+                        ERR(EAI_BADFLAGS);
+                switch (hints->ai_family) {
+                case PF_UNSPEC:
+                case PF_INET:
 #ifdef INET6
-		case PF_INET6:
-#endif
-			break;
-		default:
-			ERR(EAI_FAMILY);
-		}
-		memcpy(pai, hints, sizeof(*pai));
-		switch (pai->ai_socktype) {
-		case ANY:
-			switch (pai->ai_protocol) {
-			case ANY:
-				break;
-			case IPPROTO_UDP:
-				pai->ai_socktype = SOCK_DGRAM;
-				break;
-			case IPPROTO_TCP:
-				pai->ai_socktype = SOCK_STREAM;
-				break;
-			default:
+                case PF_INET6:
+#endif
+                        break;
+                default:
+                        ERR(EAI_FAMILY);
+                }
+                memcpy(pai, hints, sizeof(*pai));
+                switch (pai->ai_socktype) {
+                case ANY:
+                        switch (pai->ai_protocol) {
+                        case ANY:
+                                break;
+                        case IPPROTO_UDP:
+                                pai->ai_socktype = SOCK_DGRAM;
+                                break;
+                        case IPPROTO_TCP:
+                                pai->ai_socktype = SOCK_STREAM;
+                                break;
+                        default:
 #if defined(SOCK_RAW)
-				pai->ai_socktype = SOCK_RAW;
+                                pai->ai_socktype = SOCK_RAW;
 #endif
-				break;
-			}
-			break;
+                                break;
+                        }
+                        break;
 #if defined(SOCK_RAW)
-		case SOCK_RAW:
-			break;
-#endif
-		case SOCK_DGRAM:
-			if (pai->ai_protocol != IPPROTO_UDP &&
-			    pai->ai_protocol != ANY)
-				ERR(EAI_BADHINTS);	/*xxx*/
-			pai->ai_protocol = IPPROTO_UDP;
-			break;
-		case SOCK_STREAM:
-			if (pai->ai_protocol != IPPROTO_TCP &&
-			    pai->ai_protocol != ANY)
-				ERR(EAI_BADHINTS);	/*xxx*/
-			pai->ai_protocol = IPPROTO_TCP;
-			break;
-		default:
-			ERR(EAI_SOCKTYPE);
-			break;
-		}
-	}
-
-	/*
-	 * service port
-	 */
-	if (servname) {
-		if (str_isnumber(servname)) {
-			if (pai->ai_socktype == ANY) {
-				/* caller accept *ANY* socktype */
-				pai->ai_socktype = SOCK_DGRAM;
-				pai->ai_protocol = IPPROTO_UDP;
-			}
-			port = htons((unsigned short)atoi(servname));
+                case SOCK_RAW:
+                        break;
+#endif
+                case SOCK_DGRAM:
+                        if (pai->ai_protocol != IPPROTO_UDP &&
+                            pai->ai_protocol != ANY)
+                                ERR(EAI_BADHINTS);	/*xxx*/
+                        pai->ai_protocol = IPPROTO_UDP;
+                        break;
+                case SOCK_STREAM:
+                        if (pai->ai_protocol != IPPROTO_TCP &&
+                            pai->ai_protocol != ANY)
+                                ERR(EAI_BADHINTS);	/*xxx*/
+                        pai->ai_protocol = IPPROTO_TCP;
+                        break;
+                default:
+                        ERR(EAI_SOCKTYPE);
+                        break;
+                }
+        }
+
+        /*
+         * service port
+         */
+        if (servname) {
+                if (str_isnumber(servname)) {
+                        if (pai->ai_socktype == ANY) {
+                                /* caller accept *ANY* socktype */
+                                pai->ai_socktype = SOCK_DGRAM;
+                                pai->ai_protocol = IPPROTO_UDP;
+                        }
+                        port = htons((unsigned short)atoi(servname));
                 } else if (pai->ai_flags & AI_NUMERICSERV) {
                         ERR(EAI_NONAME);
-		} else {
-			struct servent *sp;
-			const char *proto;
-
-			proto = NULL;
-			switch (pai->ai_socktype) {
-			case ANY:
-				proto = NULL;
-				break;
-			case SOCK_DGRAM:
-				proto = "udp";
-				break;
-			case SOCK_STREAM:
-				proto = "tcp";
-				break;
-			default:
-				fprintf(stderr, "panic!\n");
-				break;
-			}
-			if ((sp = getservbyname((char*)servname, proto)) == NULL)
-				ERR(EAI_SERVICE);
-			port = sp->s_port;
-			if (pai->ai_socktype == ANY)
-				if (strcmp(sp->s_proto, "udp") == 0) {
-					pai->ai_socktype = SOCK_DGRAM;
-					pai->ai_protocol = IPPROTO_UDP;
-				} else if (strcmp(sp->s_proto, "tcp") == 0) {
-					pai->ai_socktype = SOCK_STREAM;
-					pai->ai_protocol = IPPROTO_TCP;
-				} else
-					ERR(EAI_PROTOCOL);	/*xxx*/
-		}
-	}
-
-	/*
-	 * hostname == NULL.
-	 * passive socket -> anyaddr (0.0.0.0 or ::)
-	 * non-passive socket -> localhost (127.0.0.1 or ::1)
-	 */
-	if (hostname == NULL) {
-		const struct afd *afd;
-		int s;
-
-		for (afd = &afdl[0]; afd->a_af; afd++) {
-			if (!(pai->ai_family == PF_UNSPEC
-			   || pai->ai_family == afd->a_af)) {
-				continue;
-			}
-
-			/*
-			 * filter out AFs that are not supported by the kernel
-			 * XXX errno?
-			 */
-			s = socket(afd->a_af, SOCK_DGRAM, 0);
-			if (s < 0)
-				continue;
-
-			close(s);
-
-			if (pai->ai_flags & AI_PASSIVE) {
-				GET_AI(cur->ai_next, afd, afd->a_addrany, port);
-				/* xxx meaningless?
-				 * GET_CANONNAME(cur->ai_next, "anyaddr");
-				 */
-			} else {
-				GET_AI(cur->ai_next, afd, afd->a_loopback,
-					port);
-				/* xxx meaningless?
-				 * GET_CANONNAME(cur->ai_next, "localhost");
-				 */
-			}
-			cur = cur->ai_next;
-		}
-		top = sentinel.ai_next;
-		if (top)
-			goto good;
-		else
-			ERR(EAI_FAMILY);
-	}
-
-	/* hostname as numeric name */
-	for (i = 0; afdl[i].a_af; i++) {
-		if (inet_pton(afdl[i].a_af, hostname, pton)) {
-			u_long v4a;
+                } else {
+                        struct servent *sp;
+                        const char *proto;
+
+                        proto = NULL;
+                        switch (pai->ai_socktype) {
+                        case ANY:
+                                proto = NULL;
+                                break;
+                        case SOCK_DGRAM:
+                                proto = "udp";
+                                break;
+                        case SOCK_STREAM:
+                                proto = "tcp";
+                                break;
+                        default:
+                                fprintf(stderr, "panic!\n");
+                                break;
+                        }
+                        if ((sp = getservbyname((char*)servname, proto)) == NULL)
+                                ERR(EAI_SERVICE);
+                        port = sp->s_port;
+                        if (pai->ai_socktype == ANY)
+                                if (strcmp(sp->s_proto, "udp") == 0) {
+                                        pai->ai_socktype = SOCK_DGRAM;
+                                        pai->ai_protocol = IPPROTO_UDP;
+                                } else if (strcmp(sp->s_proto, "tcp") == 0) {
+                                        pai->ai_socktype = SOCK_STREAM;
+                                        pai->ai_protocol = IPPROTO_TCP;
+                                } else
+                                        ERR(EAI_PROTOCOL);	/*xxx*/
+                }
+        }
+
+        /*
+         * hostname == NULL.
+         * passive socket -> anyaddr (0.0.0.0 or ::)
+         * non-passive socket -> localhost (127.0.0.1 or ::1)
+         */
+        if (hostname == NULL) {
+                const struct afd *afd;
+                int s;
+
+                for (afd = &afdl[0]; afd->a_af; afd++) {
+                        if (!(pai->ai_family == PF_UNSPEC
+                           || pai->ai_family == afd->a_af)) {
+                                continue;
+                        }
+
+                        /*
+                         * filter out AFs that are not supported by the kernel
+                         * XXX errno?
+                         */
+                        s = socket(afd->a_af, SOCK_DGRAM, 0);
+                        if (s < 0)
+                                continue;
+
+                        close(s);
+
+                        if (pai->ai_flags & AI_PASSIVE) {
+                                GET_AI(cur->ai_next, afd, afd->a_addrany, port);
+                                /* xxx meaningless?
+                                 * GET_CANONNAME(cur->ai_next, "anyaddr");
+                                 */
+                        } else {
+                                GET_AI(cur->ai_next, afd, afd->a_loopback,
+                                        port);
+                                /* xxx meaningless?
+                                 * GET_CANONNAME(cur->ai_next, "localhost");
+                                 */
+                        }
+                        cur = cur->ai_next;
+                }
+                top = sentinel.ai_next;
+                if (top)
+                        goto good;
+                else
+                        ERR(EAI_FAMILY);
+        }
+
+        /* hostname as numeric name */
+        for (i = 0; afdl[i].a_af; i++) {
+                if (inet_pton(afdl[i].a_af, hostname, pton)) {
+                        u_long v4a;
 #ifdef INET6
-			u_char pfx;
-#endif
-
-			switch (afdl[i].a_af) {
-			case AF_INET:
-				v4a = ((struct in_addr *)pton)->s_addr;
-				if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
-					pai->ai_flags &= ~AI_CANONNAME;
-				v4a >>= IN_CLASSA_NSHIFT;
-				if (v4a == 0 || v4a == IN_LOOPBACKNET)
-					pai->ai_flags &= ~AI_CANONNAME;
-				break;
+                        u_char pfx;
+#endif
+
+                        switch (afdl[i].a_af) {
+                        case AF_INET:
+                                v4a = ((struct in_addr *)pton)->s_addr;
+                                if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
+                                        pai->ai_flags &= ~AI_CANONNAME;
+                                v4a >>= IN_CLASSA_NSHIFT;
+                                if (v4a == 0 || v4a == IN_LOOPBACKNET)
+                                        pai->ai_flags &= ~AI_CANONNAME;
+                                break;
 #ifdef INET6
-			case AF_INET6:
-				pfx = ((struct in6_addr *)pton)->s6_addr[0];
-				if (pfx == 0 || pfx == 0xfe || pfx == 0xff)
-					pai->ai_flags &= ~AI_CANONNAME;
-				break;
-#endif
-			}
-
-			if (pai->ai_family == afdl[i].a_af ||
-			    pai->ai_family == PF_UNSPEC) {
-				if (! (pai->ai_flags & AI_CANONNAME)) {
-					GET_AI(top, &afdl[i], pton, port);
-					goto good;
-				}
-				/*
-				 * if AI_CANONNAME and if reverse lookup
-				 * fail, return ai anyway to pacify
-				 * calling application.
-				 *
-				 * XXX getaddrinfo() is a name->address
-				 * translation function, and it looks strange
-				 * that we do addr->name translation here.
-				 */
-				get_name(pton, &afdl[i], &top, pton, pai, port);
-				goto good;
-			} else
-				ERR(EAI_FAMILY);	/*xxx*/
-		}
-	}
-
-	if (pai->ai_flags & AI_NUMERICHOST)
-		ERR(EAI_NONAME);
-
-	/* hostname as alphabetical name */
-	error = get_addr(hostname, pai->ai_family, &top, pai, port);
-	if (error == 0) {
-		if (top) {
+                        case AF_INET6:
+                                pfx = ((struct in6_addr *)pton)->s6_addr[0];
+                                if (pfx == 0 || pfx == 0xfe || pfx == 0xff)
+                                        pai->ai_flags &= ~AI_CANONNAME;
+                                break;
+#endif
+                        }
+
+                        if (pai->ai_family == afdl[i].a_af ||
+                            pai->ai_family == PF_UNSPEC) {
+                                if (! (pai->ai_flags & AI_CANONNAME)) {
+                                        GET_AI(top, &afdl[i], pton, port);
+                                        goto good;
+                                }
+                                /*
+                                 * if AI_CANONNAME and if reverse lookup
+                                 * fail, return ai anyway to pacify
+                                 * calling application.
+                                 *
+                                 * XXX getaddrinfo() is a name->address
+                                 * translation function, and it looks strange
+                                 * that we do addr->name translation here.
+                                 */
+                                get_name(pton, &afdl[i], &top, pton, pai, port);
+                                goto good;
+                        } else
+                                ERR(EAI_FAMILY);	/*xxx*/
+                }
+        }
+
+        if (pai->ai_flags & AI_NUMERICHOST)
+                ERR(EAI_NONAME);
+
+        /* hostname as alphabetical name */
+        error = get_addr(hostname, pai->ai_family, &top, pai, port);
+        if (error == 0) {
+                if (top) {
  good:
-			*res = top;
-			return SUCCESS;
-		} else
-			error = EAI_FAIL;
-	}
+                        *res = top;
+                        return SUCCESS;
+                } else
+                        error = EAI_FAIL;
+        }
  free:
-	if (top)
-		freeaddrinfo(top);
+        if (top)
+                freeaddrinfo(top);
  bad:
-	*res = NULL;
-	return error;
+        *res = NULL;
+        return error;
 }
 
 static int
 get_name(const char *addr, const struct afd *afd, struct addrinfo **res, char *numaddr, struct addrinfo *pai, int port0)
 {
-	u_short port = port0 & 0xffff;
-	struct hostent *hp;
-	struct addrinfo *cur;
-	int error = 0;
+        u_short port = port0 & 0xffff;
+        struct hostent *hp;
+        struct addrinfo *cur;
+        int error = 0;
 #ifdef INET6
-	int h_error;
+        int h_error;
 #endif
 
 #ifdef INET6
-	hp = getipnodebyaddr(addr, afd->a_addrlen, afd->a_af, &h_error);
+        hp = getipnodebyaddr(addr, afd->a_addrlen, afd->a_af, &h_error);
 #else
-	hp = gethostbyaddr((char*)addr, afd->a_addrlen, AF_INET);
+        hp = gethostbyaddr((char*)addr, afd->a_addrlen, AF_INET);
 #endif
-	if (hp && hp->h_name && hp->h_name[0] && hp->h_addr_list[0]) {
-		GET_AI(cur, afd, hp->h_addr_list[0], port);
-		GET_CANONNAME(cur, hp->h_name);
-	} else
-		GET_AI(cur, afd, numaddr, port);
+        if (hp && hp->h_name && hp->h_name[0] && hp->h_addr_list[0]) {
+                GET_AI(cur, afd, hp->h_addr_list[0], port);
+                GET_CANONNAME(cur, hp->h_name);
+        } else
+                GET_AI(cur, afd, numaddr, port);
 
 #ifdef INET6
-	if (hp)
-		freehostent(hp);
+        if (hp)
+                freehostent(hp);
 #endif
-	*res = cur;
-	return SUCCESS;
+        *res = cur;
+        return SUCCESS;
  free:
-	if (cur)
-		freeaddrinfo(cur);
+        if (cur)
+                freeaddrinfo(cur);
 #ifdef INET6
-	if (hp)
-		freehostent(hp);
+        if (hp)
+                freehostent(hp);
 #endif
  /* bad: */
-	*res = NULL;
-	return error;
+        *res = NULL;
+        return error;
 }
 
 static int
 get_addr(const char *hostname, int af, struct addrinfo **res, struct addrinfo *pai, int port0)
 {
-	u_short port = port0 & 0xffff;
-	struct addrinfo sentinel;
-	struct hostent *hp;
-	struct addrinfo *top, *cur;
-	const struct afd *afd;
-	int i, error = 0, h_error;
-	char *ap;
-
-	top = NULL;
-	sentinel.ai_next = NULL;
-	cur = &sentinel;
+        u_short port = port0 & 0xffff;
+        struct addrinfo sentinel;
+        struct hostent *hp;
+        struct addrinfo *top, *cur;
+        const struct afd *afd;
+        int i, error = 0, h_error;
+        char *ap;
+
+        top = NULL;
+        sentinel.ai_next = NULL;
+        cur = &sentinel;
 #ifdef INET6
-	if (af == AF_UNSPEC) {
-		hp = getipnodebyname(hostname, AF_INET6,
-				AI_ADDRCONFIG|AI_ALL|AI_V4MAPPED, &h_error);
-	} else
-		hp = getipnodebyname(hostname, af, AI_ADDRCONFIG, &h_error);
+        if (af == AF_UNSPEC) {
+                hp = getipnodebyname(hostname, AF_INET6,
+                                AI_ADDRCONFIG|AI_ALL|AI_V4MAPPED, &h_error);
+        } else
+                hp = getipnodebyname(hostname, af, AI_ADDRCONFIG, &h_error);
 #else
-	if (strlen(hostname) >= NI_MAXHOST) ERR(EAI_NODATA);
-	hp = gethostbyname((char*)hostname);
-	h_error = h_errno;
-#endif
-	if (hp == NULL) {
-		switch (h_error) {
-		case HOST_NOT_FOUND:
-		case NO_DATA:
-			error = EAI_NODATA;
-			break;
-		case TRY_AGAIN:
-			error = EAI_AGAIN;
-			break;
-		case NO_RECOVERY:
-		default:
-			error = EAI_FAIL;
-			break;
-		}
-		goto bad;
-	}
-
-	if ((hp->h_name == NULL) || (hp->h_name[0] == 0) ||
-	    (hp->h_addr_list[0] == NULL))
-		ERR(EAI_FAIL);
-
-	for (i = 0; (ap = hp->h_addr_list[i]) != NULL; i++) {
-		switch (af) {
+        if (strlen(hostname) >= NI_MAXHOST) ERR(EAI_NODATA);
+        hp = gethostbyname((char*)hostname);
+        h_error = h_errno;
+#endif
+        if (hp == NULL) {
+                switch (h_error) {
+                case HOST_NOT_FOUND:
+                case NO_DATA:
+                        error = EAI_NODATA;
+                        break;
+                case TRY_AGAIN:
+                        error = EAI_AGAIN;
+                        break;
+                case NO_RECOVERY:
+                default:
+                        error = EAI_FAIL;
+                        break;
+                }
+                goto bad;
+        }
+
+        if ((hp->h_name == NULL) || (hp->h_name[0] == 0) ||
+            (hp->h_addr_list[0] == NULL))
+                ERR(EAI_FAIL);
+
+        for (i = 0; (ap = hp->h_addr_list[i]) != NULL; i++) {
+                switch (af) {
 #ifdef INET6
-		case AF_INET6:
-			afd = &afdl[N_INET6];
-			break;
+                case AF_INET6:
+                        afd = &afdl[N_INET6];
+                        break;
 #endif
 #ifndef INET6
-		default:	/* AF_UNSPEC */
+                default:	/* AF_UNSPEC */
 #endif
-		case AF_INET:
-			afd = &afdl[N_INET];
-			break;
+                case AF_INET:
+                        afd = &afdl[N_INET];
+                        break;
 #ifdef INET6
-		default:	/* AF_UNSPEC */
-			if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ap)) {
-				ap += sizeof(struct in6_addr) -
-					sizeof(struct in_addr);
-				afd = &afdl[N_INET];
-			} else
-				afd = &afdl[N_INET6];
-			break;
-#endif
-		}
+                default:	/* AF_UNSPEC */
+                        if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ap)) {
+                                ap += sizeof(struct in6_addr) -
+                                        sizeof(struct in_addr);
+                                afd = &afdl[N_INET];
+                        } else
+                                afd = &afdl[N_INET6];
+                        break;
+#endif
+                }
 #ifdef FAITH
-		if (translate && afd->a_af == AF_INET) {
-			struct in6_addr *in6;
-
-			GET_AI(cur->ai_next, &afdl[N_INET6], ap, port);
-			in6 = &((struct sockaddr_in6 *)cur->ai_next->ai_addr)->sin6_addr;
-			memcpy(&in6->s6_addr, &faith_prefix,
-			       sizeof(struct in6_addr) - sizeof(struct in_addr));
-			memcpy(&in6->s6_addr + sizeof(struct in_addr), ap,
-			       sizeof(struct in_addr));
-		} else
+                if (translate && afd->a_af == AF_INET) {
+                        struct in6_addr *in6;
+
+                        GET_AI(cur->ai_next, &afdl[N_INET6], ap, port);
+                        in6 = &((struct sockaddr_in6 *)cur->ai_next->ai_addr)->sin6_addr;
+                        memcpy(&in6->s6_addr, &faith_prefix,
+                               sizeof(struct in6_addr) - sizeof(struct in_addr));
+                        memcpy(&in6->s6_addr + sizeof(struct in_addr), ap,
+                               sizeof(struct in_addr));
+                } else
 #endif /* FAITH */
-		GET_AI(cur->ai_next, afd, ap, port);
-		if (cur == &sentinel) {
-			top = cur->ai_next;
-			GET_CANONNAME(top, hp->h_name);
-		}
-		cur = cur->ai_next;
-	}
+                GET_AI(cur->ai_next, afd, ap, port);
+                if (cur == &sentinel) {
+                        top = cur->ai_next;
+                        GET_CANONNAME(top, hp->h_name);
+                }
+                cur = cur->ai_next;
+        }
 #ifdef INET6
-	freehostent(hp);
+        freehostent(hp);
 #endif
-	*res = top;
-	return SUCCESS;
+        *res = top;
+        return SUCCESS;
  free:
-	if (top)
-		freeaddrinfo(top);
+        if (top)
+                freeaddrinfo(top);
 #ifdef INET6
-	if (hp)
-		freehostent(hp);
+        if (hp)
+                freehostent(hp);
 #endif
  bad:
-	*res = NULL;
-	return error;
+        *res = NULL;
+        return error;
 }
diff --git a/ext/socket/getnameinfo.c b/ext/socket/getnameinfo.c
index 94a5eb9439..ae5284fab6 100644
--- a/ext/socket/getnameinfo.c
+++ b/ext/socket/getnameinfo.c
@@ -84,30 +84,30 @@ typedef int socklen_t;
 #define NO  0
 
 struct sockinet {
-	u_char	si_len;
-	u_char	si_family;
-	u_short	si_port;
+        u_char	si_len;
+        u_char	si_family;
+        u_short	si_port;
 };
 
 static struct afd {
-	int a_af;
-	int a_addrlen;
-	int a_socklen;
-	int a_off;
+        int a_af;
+        int a_addrlen;
+        int a_socklen;
+        int a_off;
 } afdl [] = {
 #ifdef INET6
 #define N_INET6 0
-	{PF_INET6, sizeof(struct in6_addr),
-	 sizeof(struct sockaddr_in6),
-	 offsetof(struct sockaddr_in6, sin6_addr)},
+        {PF_INET6, sizeof(struct in6_addr),
+         sizeof(struct sockaddr_in6),
+         offsetof(struct sockaddr_in6, sin6_addr)},
 #define N_INET  1
 #else
 #define N_INET  0
 #endif
-	{PF_INET, sizeof(struct in_addr),
-	 sizeof(struct sockaddr_in),
-	 offsetof(struct sockaddr_in, sin_addr)},
-	{0, 0, 0, 0},
+        {PF_INET, sizeof(struct in_addr),
+         sizeof(struct sockaddr_in),
+         offsetof(struct sockaddr_in, sin_addr)},
+        {0, 0, 0, 0},
 };
 
 #define ENI_NOSOCKET 	0
@@ -121,123 +121,123 @@ static struct afd {
 int
 getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags)
 {
-	struct afd *afd;
-	struct hostent *hp;
-	u_short port;
-	int family, len, i;
-	char *addr, *p;
-	u_long v4a;
+        struct afd *afd;
+        struct hostent *hp;
+        u_short port;
+        int family, len, i;
+        char *addr, *p;
+        u_long v4a;
 #ifdef INET6
-	u_char pfx;
+        u_char pfx;
 #endif
-	int h_error;
-	char numserv[512];
-	char numaddr[512];
+        int h_error;
+        char numserv[512];
+        char numaddr[512];
 
-	if (sa == NULL)
-		return ENI_NOSOCKET;
+        if (sa == NULL)
+                return ENI_NOSOCKET;
 
-	if (!VALIDATE_SOCKLEN(sa, salen)) return ENI_SALEN;
+        if (!VALIDATE_SOCKLEN(sa, salen)) return ENI_SALEN;
         len = salen;
 
-	family = sa->sa_family;
-	for (i = 0; afdl[i].a_af; i++)
-		if (afdl[i].a_af == family) {
-			afd = &afdl[i];
-			goto found;
-		}
-	return ENI_FAMILY;
+        family = sa->sa_family;
+        for (i = 0; afdl[i].a_af; i++)
+                if (afdl[i].a_af == family) {
+                        afd = &afdl[i];
+                        goto found;
+                }
+        return ENI_FAMILY;
 
  found:
-	if (len != afd->a_socklen) return ENI_SALEN;
-
-	port = ((struct sockinet *)sa)->si_port; /* network byte order */
-	addr = (char *)sa + afd->a_off;
-
-	if (serv == NULL || servlen == 0) {
-		/* what we should do? */
-	} else if (flags & NI_NUMERICSERV) {
-		snprintf(numserv, sizeof(numserv), "%d", ntohs(port));
-		if (strlen(numserv) + 1 > servlen)
-			return ENI_MEMORY;
-		strcpy(serv, numserv);
-	} else {
+        if (len != afd->a_socklen) return ENI_SALEN;
+
+        port = ((struct sockinet *)sa)->si_port; /* network byte order */
+        addr = (char *)sa + afd->a_off;
+
+        if (serv == NULL || servlen == 0) {
+                /* what we should do? */
+        } else if (flags & NI_NUMERICSERV) {
+                snprintf(numserv, sizeof(numserv), "%d", ntohs(port));
+                if (strlen(numserv) + 1 > servlen)
+                        return ENI_MEMORY;
+                strcpy(serv, numserv);
+        } else {
 #if defined(HAVE_GETSERVBYPORT)
-		struct servent *sp = getservbyport(port, (flags & NI_DGRAM) ? "udp" : "tcp");
-		if (sp) {
-			if (strlen(sp->s_name) + 1 > servlen)
-				return ENI_MEMORY;
-			strcpy(serv, sp->s_name);
-		} else
-			return ENI_NOSERVNAME;
+                struct servent *sp = getservbyport(port, (flags & NI_DGRAM) ? "udp" : "tcp");
+                if (sp) {
+                        if (strlen(sp->s_name) + 1 > servlen)
+                                return ENI_MEMORY;
+                        strcpy(serv, sp->s_name);
+                } else
+                        return ENI_NOSERVNAME;
 #else
-		return ENI_NOSERVNAME;
-#endif
-	}
-
-	switch (sa->sa_family) {
-	case AF_INET:
-		v4a = ntohl(((struct sockaddr_in *)sa)->sin_addr.s_addr);
-		if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
-			flags |= NI_NUMERICHOST;
-		v4a >>= IN_CLASSA_NSHIFT;
-		if (v4a == 0)
-			flags |= NI_NUMERICHOST;
-		break;
+                return ENI_NOSERVNAME;
+#endif
+        }
+
+        switch (sa->sa_family) {
+        case AF_INET:
+                v4a = ntohl(((struct sockaddr_in *)sa)->sin_addr.s_addr);
+                if (IN_MULTICAST(v4a) || IN_EXPERIMENTAL(v4a))
+                        flags |= NI_NUMERICHOST;
+                v4a >>= IN_CLASSA_NSHIFT;
+                if (v4a == 0)
+                        flags |= NI_NUMERICHOST;
+                break;
 #ifdef INET6
-	case AF_INET6:
+        case AF_INET6:
 #ifdef HAVE_ADDR8
-		pfx = ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr8[0];
+                pfx = ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr8[0];
 #else
-		pfx = ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr[0];
-#endif
-		if (pfx == 0 || pfx == 0xfe || pfx == 0xff)
-			flags |= NI_NUMERICHOST;
-		break;
-#endif
-	}
-	if (host == NULL || hostlen == 0) {
-		/* what should we do? */
-	} else if (flags & NI_NUMERICHOST) {
-		if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
-		    == NULL)
-			return ENI_SYSTEM;
-		if (strlen(numaddr) > hostlen)
-			return ENI_MEMORY;
-		strcpy(host, numaddr);
-	} else {
+                pfx = ((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr[0];
+#endif
+                if (pfx == 0 || pfx == 0xfe || pfx == 0xff)
+                        flags |= NI_NUMERICHOST;
+                break;
+#endif
+        }
+        if (host == NULL || hostlen == 0) {
+                /* what should we do? */
+        } else if (flags & NI_NUMERICHOST) {
+                if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
+                    == NULL)
+                        return ENI_SYSTEM;
+                if (strlen(numaddr) > hostlen)
+                        return ENI_MEMORY;
+                strcpy(host, numaddr);
+        } else {
 #ifdef INET6
-		hp = getipnodebyaddr(addr, afd->a_addrlen, afd->a_af, &h_error);
+                hp = getipnodebyaddr(addr, afd->a_addrlen, afd->a_af, &h_error);
 #else
-		hp = gethostbyaddr(addr, afd->a_addrlen, afd->a_af);
-		h_error = h_errno;
+                hp = gethostbyaddr(addr, afd->a_addrlen, afd->a_af);
+                h_error = h_errno;
 #endif
 
-		if (hp) {
-			if (flags & NI_NOFQDN) {
-				p = strchr(hp->h_name, '.');
-				if (p) *p = '\0';
-			}
-			if (strlen(hp->h_name) + 1 > hostlen) {
+                if (hp) {
+                        if (flags & NI_NOFQDN) {
+                                p = strchr(hp->h_name, '.');
+                                if (p) *p = '\0';
+                        }
+                        if (strlen(hp->h_name) + 1 > hostlen) {
 #ifdef INET6
-				freehostent(hp);
+                                freehostent(hp);
 #endif
-				return ENI_MEMORY;
-			}
-			strcpy(host, hp->h_name);
+                                return ENI_MEMORY;
+                        }
+                        strcpy(host, hp->h_name);
 #ifdef INET6
-			freehostent(hp);
-#endif
-		} else {
-			if (flags & NI_NAMEREQD)
-				return ENI_NOHOSTNAME;
-			if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
-			    == NULL)
-				return ENI_NOHOSTNAME;
-			if (strlen(numaddr) > hostlen)
-				return ENI_MEMORY;
-			strcpy(host, numaddr);
-		}
-	}
-	return SUCCESS;
+                        freehostent(hp);
+#endif
+                } else {
+                        if (flags & NI_NAMEREQD)
+                                return ENI_NOHOSTNAME;
+                        if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr))
+                            == NULL)
+                                return ENI_NOHOSTNAME;
+                        if (strlen(numaddr) > hostlen)
+                                return ENI_MEMORY;
+                        strcpy(host, numaddr);
+                }
+        }
+        return SUCCESS;
 }
diff --git a/ext/socket/ifaddr.c b/ext/socket/ifaddr.c
index 1da259bd6f..ab163dcc8f 100644
--- a/ext/socket/ifaddr.c
+++ b/ext/socket/ifaddr.c
@@ -104,7 +104,7 @@ rsock_getifaddrs(void)
         rb_sys_fail("getifaddrs");
 
     if (!ifaddrs) {
-	return rb_ary_new();
+        return rb_ary_new();
     }
 
     numifaddrs = 0;
@@ -128,9 +128,9 @@ rsock_getifaddrs(void)
     result = rb_ary_new2(numifaddrs);
     rb_ary_push(result, addr);
     for (i = 1; i < numifaddrs; i++) {
-	addr = TypedData_Wrap_Struct(rb_cSockIfaddr, &ifaddr_type, &root->ary[i]);
-	root->refcount++;
-	rb_ary_push(result, addr);
+        addr = TypedData_Wrap_Struct(rb_cSockIfaddr, &ifaddr_type, &root->ary[i]);
+        root->refcount++;
+        rb_ary_push(result, addr);
     }
 
     return result;
diff --git a/ext/socket/init.c b/ext/socket/init.c
index 359696e626..0cff3d6794 100644
--- a/ext/socket/init.c
+++ b/ext/socket/init.c
@@ -41,7 +41,7 @@ rsock_raise_socket_error(const char *reason, int error)
 #ifdef EAI_SYSTEM
     int e;
     if (error == EAI_SYSTEM && (e = errno) != 0)
-	rb_syserr_fail(e, reason);
+        rb_syserr_fail(e, reason);
 #endif
 #ifdef _WIN32
     rb_encoding *enc = rb_default_internal_encoding();
@@ -71,7 +71,7 @@ rsock_init_sock(VALUE sock, int fd)
     fp->mode = FMODE_READWRITE|FMODE_DUPLEX;
     rb_io_ascii8bit_binmode(sock);
     if (rsock_do_not_reverse_lookup) {
-	fp->mode |= FMODE_NOREVLOOKUP;
+        fp->mode |= FMODE_NOREVLOOKUP;
     }
     rb_io_synchronized(fp);
 
@@ -85,7 +85,7 @@ rsock_sendto_blocking(void *data)
     VALUE mesg = arg->mesg;
     ssize_t ret;
     do_write_retry(sendto(arg->fd, RSTRING_PTR(mesg), RSTRING_LEN(mesg),
-			  arg->flags, arg->to, arg->tolen));
+                          arg->flags, arg->to, arg->tolen));
     return (VALUE)ret;
 }
 
@@ -96,7 +96,7 @@ rsock_send_blocking(void *data)
     VALUE mesg = arg->mesg;
     ssize_t ret;
     do_write_retry(send(arg->fd, RSTRING_PTR(mesg), RSTRING_LEN(mesg),
-			arg->flags));
+                        arg->flags));
     return (VALUE)ret;
 }
 
@@ -132,9 +132,9 @@ rsock_strbuf(VALUE str, long buflen)
     StringValue(str);
     len = RSTRING_LEN(str);
     if (len >= buflen) {
-	rb_str_modify(str);
+        rb_str_modify(str);
     } else {
-	rb_str_modify_expand(str, buflen - len);
+        rb_str_modify_expand(str, buflen - len);
     }
     return str;
 }
@@ -197,32 +197,32 @@ rsock_s_recvfrom(VALUE socket, int argc, VALUE *argv, enum sock_recv_type from)
     rb_str_set_len(str, slen);
     switch (from) {
       case RECV_RECV:
-	return str;
+        return str;
       case RECV_IP:
 #if 0
-	if (arg.alen != sizeof(struct sockaddr_in)) {
-	    rb_raise(rb_eTypeError, "sockaddr size differs - should not happen");
-	}
+        if (arg.alen != sizeof(struct sockaddr_in)) {
+            rb_raise(rb_eTypeError, "sockaddr size differs - should not happen");
+        }
 #endif
-	if (arg.alen && arg.alen != sizeof(arg.buf)) /* OSX doesn't return a from result for connection-oriented sockets */
-	    return rb_assoc_new(str, rsock_ipaddr(&arg.buf.addr, arg.alen, fptr->mode & FMODE_NOREVLOOKUP));
-	else
-	    return rb_assoc_new(str, Qnil);
+        if (arg.alen && arg.alen != sizeof(arg.buf)) /* OSX doesn't return a from result for connection-oriented sockets */
+            return rb_assoc_new(str, rsock_ipaddr(&arg.buf.addr, arg.alen, fptr->mode & FMODE_NOREVLOOKUP));
+        else
+            return rb_assoc_new(str, Qnil);
 
 #ifdef HAVE_SYS_UN_H
       case RECV_UNIX:
         return rb_assoc_new(str, rsock_unixaddr(&arg.buf.un, arg.alen));
 #endif
       case RECV_SOCKET:
-	return rb_assoc_new(str, rsock_io_socket_addrinfo(socket, &arg.buf.addr, arg.alen));
+        return rb_assoc_new(str, rsock_io_socket_addrinfo(socket, &arg.buf.addr, arg.alen));
       default:
-	rb_bug("rsock_s_recvfrom called with bad value");
+        rb_bug("rsock_s_recvfrom called with bad value");
     }
 }
 
 VALUE
 rsock_s_recvfrom_nonblock(VALUE sock, VALUE len, VALUE flg, VALUE str,
-			  VALUE ex, enum sock_recv_type from)
+                          VALUE ex, enum sock_recv_type from)
 {
     rb_io_t *fptr;
     union_sockaddr buf;
@@ -245,14 +245,14 @@ rsock_s_recvfrom_nonblock(VALUE sock, VALUE len, VALUE flg, VALUE str,
 
     GetOpenFile(sock, fptr);
     if (rb_io_read_pending(fptr)) {
-	rb_raise(rb_eIOError, "recvfrom for buffered IO");
+        rb_raise(rb_eIOError, "recvfrom for buffered IO");
     }
     fd = fptr->fd;
 
     rb_io_check_closed(fptr);
 
     if (!MSG_DONTWAIT_RELIABLE)
-	rb_io_set_nonblock(fptr);
+        rb_io_set_nonblock(fptr);
 
     len0 = alen;
     slen = recvfrom(fd, RSTRING_PTR(str), buflen, flags, &buf.addr, &alen);
@@ -260,20 +260,20 @@ rsock_s_recvfrom_nonblock(VALUE sock, VALUE len, VALUE flg, VALUE str,
         alen = len0;
 
     if (slen < 0) {
-	int e = errno;
-	switch (e) {
-	  case EAGAIN:
+        int e = errno;
+        switch (e) {
+          case EAGAIN:
 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
-	  case EWOULDBLOCK:
+          case EWOULDBLOCK:
 #endif
             if (ex == Qfalse)
-		return sym_wait_readable;
+                return sym_wait_readable;
             rb_readwrite_syserr_fail(RB_IO_WAIT_READABLE, e, "recvfrom(2) would block");
-	}
-	rb_syserr_fail(e, "recvfrom(2)");
+        }
+        rb_syserr_fail(e, "recvfrom(2)");
     }
     if (slen != RSTRING_LEN(str)) {
-	rb_str_set_len(str, slen);
+        rb_str_set_len(str, slen);
     }
     switch (from) {
       case RECV_RECV:
@@ -324,31 +324,31 @@ rsock_read_nonblock(VALUE sock, VALUE length, VALUE buf, VALUE ex)
     GetOpenFile(sock, fptr);
 
     if (len == 0) {
-	rb_str_set_len(str, 0);
-	return str;
+        rb_str_set_len(str, 0);
+        return str;
     }
 
     ptr = RSTRING_PTR(str);
     n = read_buffered_data(ptr, len, fptr);
     if (n <= 0) {
-	n = (long)recv(fptr->fd, ptr, len, MSG_DONTWAIT);
-	if (n < 0) {
-	    int e = errno;
-	    if ((e == EWOULDBLOCK || e == EAGAIN)) {
-		if (ex == Qfalse) return sym_wait_readable;
-		rb_readwrite_syserr_fail(RB_IO_WAIT_READABLE,
-					 e, "read would block");
-	    }
-	    rb_syserr_fail_path(e, fptr->pathv);
-	}
+        n = (long)recv(fptr->fd, ptr, len, MSG_DONTWAIT);
+        if (n < 0) {
+            int e = errno;
+            if ((e == EWOULDBLOCK || e == EAGAIN)) {
+                if (ex == Qfalse) return sym_wait_readable;
+                rb_readwrite_syserr_fail(RB_IO_WAIT_READABLE,
+                                         e, "read would block");
+            }
+            rb_syserr_fail_path(e, fptr->pathv);
+        }
     }
     if (n != RSTRING_LEN(str)) {
-	rb_str_modify(str);
-	rb_str_set_len(str, n);
+        rb_str_modify(str);
+        rb_str_set_len(str, n);
     }
     if (n == 0) {
-	if (ex == Qfalse) return Qnil;
-	rb_eof_error();
+        if (ex == Qfalse) return Qnil;
+        rb_eof_error();
     }
 
     return str;
@@ -362,7 +362,7 @@ rsock_write_nonblock(VALUE sock, VALUE str, VALUE ex)
     long n;
 
     if (!RB_TYPE_P(str, T_STRING))
-	str = rb_obj_as_string(str);
+        str = rb_obj_as_string(str);
 
     sock = rb_io_get_write_io(sock);
     GetOpenFile(sock, fptr);
@@ -374,7 +374,7 @@ rsock_write_nonblock(VALUE sock, VALUE str, VALUE ex)
      * are not userspace-buffered in Ruby by default.
      */
     if (fptr->wbuf.len > 0) {
-	rb_io_flush(sock);
+        rb_io_flush(sock);
     }
 
 #ifdef __APPLE__
@@ -382,19 +382,19 @@ rsock_write_nonblock(VALUE sock, VALUE str, VALUE ex)
 #endif
     n = (long)send(fptr->fd, RSTRING_PTR(str), RSTRING_LEN(str), MSG_DONTWAIT);
     if (n < 0) {
-	int e = errno;
+        int e = errno;
 
 #ifdef __APPLE__
-	if (e == EPROTOTYPE) {
-	    goto again;
-	}
-#endif
-	if (e == EWOULDBLOCK || e == EAGAIN) {
-	    if (ex == Qfalse) return sym_wait_writable;
-	    rb_readwrite_syserr_fail(RB_IO_WAIT_WRITABLE, e,
-				    "write would block");
-	}
-	rb_syserr_fail_path(e, fptr->pathv);
+        if (e == EPROTOTYPE) {
+            goto again;
+        }
+#endif
+        if (e == EWOULDBLOCK || e == EAGAIN) {
+            if (ex == Qfalse) return sym_wait_writable;
+            rb_readwrite_syserr_fail(RB_IO_WAIT_WRITABLE, e,
+                                    "write would block");
+        }
+        rb_syserr_fail_path(e, fptr->pathv);
     }
 
     return LONG2FIX(n);
@@ -497,11 +497,11 @@ wait_connectable(int fd, struct timeval *timeout)
        * interrupted connect()
        */
 
-	/* when the connection timed out, no errno is set and revents is 0. */
-	if (timeout && revents == 0) {
-	    errno = ETIMEDOUT;
-	    return -1;
-	}
+        /* when the connection timed out, no errno is set and revents is 0. */
+        if (timeout && revents == 0) {
+            errno = ETIMEDOUT;
+            return -1;
+        }
       case EINTR:
 #ifdef ERESTART
       case ERESTART:
@@ -516,7 +516,7 @@ wait_connectable(int fd, struct timeval *timeout)
 #ifdef EISCONN
       case EISCONN:
 #endif
-	return 0; /* success */
+        return 0; /* success */
       default:
         /* likely (but not limited to): ECONNREFUSED, ETIMEDOUT, EHOSTUNREACH */
         errno = sockerr;
@@ -634,27 +634,27 @@ cloexec_accept(int socket, struct sockaddr *address, socklen_t *address_len)
 
 VALUE
 rsock_s_accept_nonblock(VALUE klass, VALUE ex, rb_io_t *fptr,
-			struct sockaddr *sockaddr, socklen_t *len)
+                        struct sockaddr *sockaddr, socklen_t *len)
 {
     int fd2;
 
     rb_io_set_nonblock(fptr);
     fd2 = cloexec_accept(fptr->fd, (struct sockaddr*)sockaddr, len);
     if (fd2 < 0) {
-	int e = errno;
-	switch (e) {
-	  case EAGAIN:
+        int e = errno;
+        switch (e) {
+          case EAGAIN:
 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
-	  case EWOULDBLOCK:
+          case EWOULDBLOCK:
 #endif
-	  case ECONNABORTED:
+          case ECONNABORTED:
 #if defined EPROTO
-	  case EPROTO:
+          case EPROTO:
 #endif
             if (ex == Qfalse)
-		return sym_wait_readable;
+                return sym_wait_readable;
             rb_readwrite_syserr_fail(RB_IO_WAIT_READABLE, e, "accept(2) would block");
-	}
+        }
         rb_syserr_fail(e, "accept(2)");
     }
     rb_update_max_fd(fd2);
@@ -730,11 +730,11 @@ rsock_getfamily(rb_io_t *fptr)
     if (cached) {
         switch (cached) {
 #ifdef AF_UNIX
-	    case FMODE_UNIX: return AF_UNIX;
+            case FMODE_UNIX: return AF_UNIX;
 #endif
-	    case FMODE_INET: return AF_INET;
-	    case FMODE_INET6: return AF_INET6;
-	}
+            case FMODE_INET: return AF_INET;
+            case FMODE_INET6: return AF_INET6;
+        }
     }
 
     ss.addr.sa_family = AF_UNSPEC;
diff --git a/ext/socket/ipsocket.c b/ext/socket/ipsocket.c
index b5cdc60080..0c13620258 100644
--- a/ext/socket/ipsocket.c
+++ b/ext/socket/ipsocket.c
@@ -14,8 +14,8 @@ struct inetsock_arg
 {
     VALUE sock;
     struct {
-	VALUE host, serv;
-	struct rb_addrinfo *res;
+        VALUE host, serv;
+        struct rb_addrinfo *res;
     } remote, local;
     int type;
     int fd;
@@ -28,15 +28,15 @@ inetsock_cleanup(VALUE v)
 {
     struct inetsock_arg *arg = (void *)v;
     if (arg->remote.res) {
-	rb_freeaddrinfo(arg->remote.res);
-	arg->remote.res = 0;
+        rb_freeaddrinfo(arg->remote.res);
+        arg->remote.res = 0;
     }
     if (arg->local.res) {
-	rb_freeaddrinfo(arg->local.res);
-	arg->local.res = 0;
+        rb_freeaddrinfo(arg->local.res);
+        arg->local.res = 0;
     }
     if (arg->fd >= 0) {
-	close(arg->fd);
+        close(arg->fd);
     }
     return Qnil;
 }
@@ -61,8 +61,8 @@ init_inetsock_internal(VALUE v)
     }
 
     arg->remote.res = rsock_addrinfo(arg->remote.host, arg->remote.serv,
-				     family, SOCK_STREAM,
-				     (type == INET_SERVER) ? AI_PASSIVE : 0);
+                                     family, SOCK_STREAM,
+                                     (type == INET_SERVER) ? AI_PASSIVE : 0);
 
 
     /*
@@ -70,15 +70,15 @@ init_inetsock_internal(VALUE v)
      */
 
     if (type != INET_SERVER && (!NIL_P(arg->local.host) || !NIL_P(arg->local.serv))) {
-	arg->local.res = rsock_addrinfo(arg->local.host, arg->local.serv,
-					family, SOCK_STREAM, 0);
+        arg->local.res = rsock_addrinfo(arg->local.host, arg->local.serv,
+                                        family, SOCK_STREAM, 0);
     }
 
     arg->fd = fd = -1;
     for (res = arg->remote.res->ai; res; res = res->ai_next) {
 #if !defined(INET6) && defined(AF_INET6)
-	if (res->ai_family == AF_INET6)
-	    continue;
+        if (res->ai_family == AF_INET6)
+            continue;
 #endif
         lres = NULL;
         if (arg->local.res) {
@@ -94,73 +94,73 @@ init_inetsock_internal(VALUE v)
                 lres = arg->local.res->ai;
             }
         }
-	status = rsock_socket(res->ai_family,res->ai_socktype,res->ai_protocol);
-	syscall = "socket(2)";
-	fd = status;
-	if (fd < 0) {
-	    error = errno;
-	    continue;
-	}
-	arg->fd = fd;
-	if (type == INET_SERVER) {
+        status = rsock_socket(res->ai_family,res->ai_socktype,res->ai_protocol);
+        syscall = "socket(2)";
+        fd = status;
+        if (fd < 0) {
+            error = errno;
+            continue;
+        }
+        arg->fd = fd;
+        if (type == INET_SERVER) {
 #if !defined(_WIN32) && !defined(__CYGWIN__)
-	    status = 1;
-	    setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
-		       (char*)&status, (socklen_t)sizeof(status));
+            status = 1;
+            setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
+                       (char*)&status, (socklen_t)sizeof(status));
 #endif
-	    status = bind(fd, res->ai_addr, res->ai_addrlen);
-	    syscall = "bind(2)";
-	}
-	else {
-	    if (lres) {
+            status = bind(fd, res->ai_addr, res->ai_addrlen);
+            syscall = "bind(2)";
+        }
+        else {
+            if (lres) {
 #if !defined(_WIN32) && !defined(__CYGWIN__)
                 status = 1;
                 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
                            (char*)&status, (socklen_t)sizeof(status));
 #endif
-		status = bind(fd, lres->ai_addr, lres->ai_addrlen);
-		local = status;
-		syscall = "bind(2)";
-	    }
-
-	    if (status >= 0) {
-		status = rsock_connect(fd, res->ai_addr, res->ai_addrlen,
-				       (type == INET_SOCKS), tv);
-		syscall = "connect(2)";
-	    }
-	}
-
-	if (status < 0) {
-	    error = errno;
-	    close(fd);
-	    arg->fd = fd = -1;
-	    continue;
-	} else
-	    break;
+                status = bind(fd, lres->ai_addr, lres->ai_addrlen);
+                local = status;
+                syscall = "bind(2)";
+            }
+
+            if (status >= 0) {
+                status = rsock_connect(fd, res->ai_addr, res->ai_addrlen,
+                                       (type == INET_SOCKS), tv);
+                syscall = "connect(2)";
+            }
+        }
+
+        if (status < 0) {
+            error = errno;
+            close(fd);
+            arg->fd = fd = -1;
+            continue;
+        } else
+            break;
     }
     if (status < 0) {
-	VALUE host, port;
-
-	if (local < 0) {
-	    host = arg->local.host;
-	    port = arg->local.serv;
-	} else {
-	    host = arg->remote.host;
-	    port = arg->remote.serv;
-	}
+        VALUE host, port;
+
+        if (local < 0) {
+            host = arg->local.host;
+            port = arg->local.serv;
+        } else {
+            host = arg->remote.host;
+            port = arg->remote.serv;
+        }
 
-	rsock_syserr_fail_host_port(error, syscall, host, port);
+        rsock_syserr_fail_host_port(error, syscall, host, port);
     }
 
     arg->fd = -1;
 
     if (type == INET_SERVER) {
-	status = listen(fd, SOMAXCONN);
-	if (status < 0) {
-	    error = errno;
-	    close(fd);
-	    rb_syserr_fail(error, "listen(2)");
-	}
+        status = listen(fd, SOMAXCONN);
+        if (status < 0) {
+            error = errno;
+            close(fd);
+            rb_syserr_fail(error, "listen(2)");
+        }
     }
 
     /* create new instance */
@@ -169,8 +169,8 @@ init_inetsock_internal(VALUE v)
 
 VALUE
 rsock_init_inetsock(VALUE sock, VALUE remote_host, VALUE remote_serv,
-	            VALUE local_host, VALUE local_serv, int type,
-		    VALUE resolv_timeout, VALUE connect_timeout)
+                    VALUE local_host, VALUE local_serv, int type,
+                    VALUE resolv_timeout, VALUE connect_timeout)
 {
     struct inetsock_arg arg;
     arg.sock = sock;
@@ -185,7 +185,7 @@ rsock_init_inetsock(VALUE sock, VALUE remote_host, VALUE remote_serv,
     arg.resolv_timeout = resolv_timeout;
     arg.connect_timeout = connect_timeout;
     return rb_ensure(init_inetsock_internal, (VALUE)&arg,
-		     inetsock_cleanup, (VALUE)&arg);
+                     inetsock_cleanup, (VALUE)&arg);
 }
 
 static ID id_numeric, id_hostname;
@@ -201,11 +201,11 @@ rsock_revlookup_flag(VALUE revlookup, int *norevlookup)
       case Qfalse: return_norevlookup(1);
       case Qnil: break;
       default:
-	Check_Type(revlookup, T_SYMBOL);
-	id = SYM2ID(revlookup);
-	if (id == id_numeric) return_norevlookup(1);
-	if (id == id_hostname) return_norevlookup(0);
-	rb_raise(rb_eArgError, "invalid reverse_lookup flag: :%s", rb_id2name(id));
+        Check_Type(revlookup, T_SYMBOL);
+        id = SYM2ID(revlookup);
+        if (id == id_numeric) return_norevlookup(1);
+        if (id == id_hostname) return_norevlookup(0);
+        rb_raise(rb_eArgError, "invalid reverse_lookup flag: :%s", rb_id2name(id));
     }
     return 0;
 #undef return_norevlookup
@@ -226,24 +226,24 @@ ip_inspect(VALUE sock)
     socklen_t len = (socklen_t)sizeof addr;
     ID id;
     if (fptr && fptr->fd >= 0 &&
-	getsockname(fptr->fd, &addr.addr, &len) >= 0 &&
-	(id = rsock_intern_family(addr.addr.sa_family)) != 0) {
-	VALUE family = rb_id2str(id);
-	char hbuf[1024], pbuf[1024];
-	long slen = RSTRING_LEN(str);
-	const char last = (slen > 1 && RSTRING_PTR(str)[slen - 1] == '>') ?
-	    (--slen, '>') : 0;
-	str = rb_str_subseq(str, 0, slen);
-	rb_str_cat_cstr(str, ", ");
-	rb_str_append(str, family);
-	if (!rb_getnameinfo(&addr.addr, len, hbuf, sizeof(hbuf),
-			    pbuf, sizeof(pbuf), NI_NUMERICHOST | NI_NUMERICSERV)) {
-	    rb_str_cat_cstr(str, ", ");
-	    rb_str_cat_cstr(str, hbuf);
-	    rb_str_cat_cstr(str, ", ");
-	    rb_str_cat_cstr(str, pbuf);
-	}
-	if (last) rb_str_cat(str, &last, 1);
+        getsockname(fptr->fd, &addr.addr, &len) >= 0 &&
+        (id = rsock_intern_family(addr.addr.sa_family)) != 0) {
+        VALUE family = rb_id2str(id);
+        char hbuf[1024], pbuf[1024];
+        long slen = RSTRING_LEN(str);
+        const char last = (slen > 1 && RSTRING_PTR(str)[slen - 1] == '>') ?
+            (--slen, '>') : 0;
+        str = rb_str_subseq(str, 0, slen);
+        rb_str_cat_cstr(str, ", ");
+        rb_str_append(str, family);
+        if (!rb_getnameinfo(&addr.addr, len, hbuf, sizeof(hbuf),
+                            pbuf, sizeof(pbuf), NI_NUMERICHOST | NI_NUMERICSERV)) {
+            rb_str_cat_cstr(str, ", ");
+            rb_str_cat_cstr(str, hbuf);
+            rb_str_cat_cstr(str, ", ");
+            rb_str_cat_cstr(str, pbuf);
+        }
+        if (last) rb_str_cat(str, &last, 1);
     }
     return str;
 }
@@ -282,9 +282,9 @@ ip_addr(int argc, VALUE *argv, VALUE sock)
     GetOpenFile(sock, fptr);
 
     if (argc < 1 || !rsock_revlookup_flag(argv[0], &norevlookup))
-	norevlookup = fptr->mode & FMODE_NOREVLOOKUP;
+        norevlookup = fptr->mode & FMODE_NOREVLOOKUP;
     if (getsockname(fptr->fd, &addr.addr, &len) < 0)
-	rb_sys_fail("getsockname(2)");
+        rb_sys_fail("getsockname(2)");
     return rsock_ipaddr(&addr.addr, len, norevlookup);
 }
 
@@ -323,9 +323,9 @@ ip_peeraddr(int argc, VALUE *argv, VALUE sock)
     GetOpenFile(sock, fptr);
 
     if (argc < 1 || !rsock_revlookup_flag(argv[0], &norevlookup))
-	norevlookup = fptr->mode & FMODE_NOREVLOOKUP;
+        norevlookup = fptr->mode & FMODE_NOREVLOOKUP;
     if (getpeername(fptr->fd, &addr.addr, &len) < 0)
-	rb_sys_fail("getpeername(2)");
+        rb_sys_fail("getpeername(2)");
     return rsock_ipaddr(&addr.addr, len, norevlookup);
 }
 
diff --git a/ext/socket/option.c b/ext/socket/option.c
index 4b33b3f1d3..2dbe6379c4 100644
--- a/ext/socket/option.c
+++ b/ext/socket/option.c
@@ -31,7 +31,7 @@ VALUE rb_cSockOpt;
     ((len) == (size) ? \
      (void)0 : \
      rb_raise(rb_eTypeError, "size differ.  expected as "#size"=%d but %ld", \
-	      (int)size, (long)(len)))
+              (int)size, (long)(len)))
 
 static VALUE
 sockopt_pack_byte(VALUE value)
@@ -309,7 +309,7 @@ sockopt_bool(VALUE self)
     StringValue(data);
     len = RSTRING_LEN(data);
     if (len == 1) {
-	return *RSTRING_PTR(data) == 0 ? Qfalse : Qtrue;
+        return *RSTRING_PTR(data) == 0 ? Qfalse : Qtrue;
     }
     check_size(len, sizeof(int));
     memcpy((char*)&i, RSTRING_PTR(data), len);
@@ -420,7 +420,7 @@ sockopt_ipv4_multicast_loop(VALUE self)
 
 #if defined(IPPROTO_IP) && defined(IP_MULTICAST_LOOP)
     if (family == AF_INET && level == IPPROTO_IP && optname == IP_MULTICAST_LOOP) {
-	return XCAT(sockopt_,TYPE_IP_MULTICAST_LOOP)(self);
+        return XCAT(sockopt_,TYPE_IP_MULTICAST_LOOP)(self);
     }
 #endif
     rb_raise(rb_eTypeError, "ipv4_multicast_loop socket option expected");
@@ -471,7 +471,7 @@ sockopt_ipv4_multicast_ttl(VALUE self)
 
 #if defined(IPPROTO_IP) && defined(IP_MULTICAST_TTL)
     if (family == AF_INET && level == IPPROTO_IP && optname == IP_MULTICAST_TTL) {
-	return XCAT(sockopt_,TYPE_IP_MULTICAST_TTL)(self);
+        return XCAT(sockopt_,TYPE_IP_MULTICAST_TTL)(self);
     }
 #endif
     rb_raise(rb_eTypeError, "ipv4_multicast_ttl socket option expected");
@@ -657,8 +657,8 @@ inet_ntop(int af, const void *addr, char *numaddr, size_t numaddr_len)
 #else
     unsigned long x = ntohl(*(unsigned long*)addr);
     snprintf(numaddr, numaddr_len, "%d.%d.%d.%d",
-	     (int) (x>>24) & 0xff, (int) (x>>16) & 0xff,
-	     (int) (x>> 8) & 0xff, (int) (x>> 0) & 0xff);
+             (int) (x>>24) & 0xff, (int) (x>>16) & 0xff,
+             (int) (x>> 8) & 0xff, (int) (x>> 0) & 0xff);
 #endif
     return numaddr;
 }
@@ -1059,16 +1059,16 @@ inspect_tcp_info(int level, int optname, VALUE data, VALUE ret)
         rb_str_catf(ret, " fackets=%u", s.tcpi_fackets);
 #endif
 #ifdef HAVE_STRUCT_TCP_INFO_TCPI_LAST_DATA_SENT
-	inspect_tcpi_last_data_sent(ret, s.tcpi_last_data_sent);
+        inspect_tcpi_last_data_sent(ret, s.tcpi_last_data_sent);
 #endif
 #ifdef HAVE_STRUCT_TCP_INFO_TCPI_LAST_ACK_SENT
-	inspect_tcpi_last_ack_sent(ret, s.tcpi_last_ack_sent);
+        inspect_tcpi_last_ack_sent(ret, s.tcpi_last_ack_sent);
 #endif
 #ifdef HAVE_STRUCT_TCP_INFO_TCPI_LAST_DATA_RECV
-	inspect_tcpi_last_data_recv(ret, s.tcpi_last_data_recv);
+        inspect_tcpi_last_data_recv(ret, s.tcpi_last_data_recv);
 #endif
 #ifdef HAVE_STRUCT_TCP_INFO_TCPI_LAST_ACK_RECV
-	inspect_tcpi_last_ack_recv(ret, s.tcpi_last_ack_recv);
+        inspect_tcpi_last_ack_recv(ret, s.tcpi_last_ack_recv);
 #endif
 #ifdef HAVE_STRUCT_TCP_INFO_TCPI_PMTU
         rb_str_catf(ret, " pmtu=%u", s.tcpi_pmtu);
@@ -1077,10 +1077,10 @@ inspect_tcp_info(int level, int optname, VALUE data, VALUE ret)
         rb_str_catf(ret, " rcv_ssthresh=%u", s.tcpi_rcv_ssthresh);
 #endif
 #ifdef HAVE_STRUCT_TCP_INFO_TCPI_RTT
-	inspect_tcpi_rtt(ret, s.tcpi_rtt);
+        inspect_tcpi_rtt(ret, s.tcpi_rtt);
 #endif
 #ifdef HAVE_STRUCT_TCP_INFO_TCPI_RTTVAR
-	inspect_tcpi_rttvar(ret, s.tcpi_rttvar);
+        inspect_tcpi_rttvar(ret, s.tcpi_rttvar);
 #endif
 #ifdef HAVE_STRUCT_TCP_INFO_TCPI_SND_SSTHRESH
         rb_str_catf(ret, " snd_ssthresh=%u", s.tcpi_snd_ssthresh);
@@ -1150,7 +1150,7 @@ inspect_peercred(int level, int optname, VALUE data, VALUE ret)
         RUBY_SOCK_PEERCRED cred;
         memcpy(&cred, RSTRING_PTR(data), sizeof(RUBY_SOCK_PEERCRED));
         rb_str_catf(ret, " pid=%u euid=%u egid=%u",
-		    (unsigned)cred.pid, (unsigned)cred.uid, (unsigned)cred.gid);
+                    (unsigned)cred.pid, (unsigned)cred.uid, (unsigned)cred.gid);
         rb_str_cat2(ret, " (ucred)");
         return 1;
     }
@@ -1171,14 +1171,14 @@ inspect_local_peercred(int level, int optname, VALUE data, VALUE ret)
             return 0;
         rb_str_catf(ret, " version=%u", cred.cr_version);
         rb_str_catf(ret, " euid=%u", cred.cr_uid);
-	if (cred.cr_ngroups) {
-	    int i;
-	    const char *sep = " groups=";
-	    for (i = 0; i < cred.cr_ngroups; i++) {
-		rb_str_catf(ret, "%s%u", sep, cred.cr_groups[i]);
-		sep = ",";
-	    }
-	}
+        if (cred.cr_ngroups) {
+            int i;
+            const char *sep = " groups=";
+            for (i = 0; i < cred.cr_ngroups; i++) {
+                rb_str_catf(ret, "%s%u", sep, cred.cr_groups[i]);
+                sep = ",";
+            }
+        }
         rb_str_cat2(ret, " (xucred)");
         return 1;
     }
@@ -1216,42 +1216,42 @@ sockopt_inspect(VALUE self)
 
     family_id = rsock_intern_family_noprefix(family);
     if (family_id)
-	rb_str_catf(ret, " %s", rb_id2name(family_id));
+        rb_str_catf(ret, " %s", rb_id2name(family_id));
     else
         rb_str_catf(ret, " family:%d", family);
 
     if (level == SOL_SOCKET) {
         rb_str_cat2(ret, " SOCKET");
 
-	optname_id = rsock_intern_so_optname(optname);
-	if (optname_id)
-	    rb_str_catf(ret, " %s", rb_id2name(optname_id));
-	else
-	    rb_str_catf(ret, " optname:%d", optname);
+        optname_id = rsock_intern_so_optname(optname);
+        if (optname_id)
+            rb_str_catf(ret, " %s", rb_id2name(optname_id));
+        else
+            rb_str_catf(ret, " optname:%d", optname);
     }
 #ifdef HAVE_SYS_UN_H
     else if (family == AF_UNIX) {
-	rb_str_catf(ret, " level:%d", level);
+        rb_str_catf(ret, " level:%d", level);
 
-	optname_id = rsock_intern_local_optname(optname);
-	if (optname_id)
-	    rb_str_catf(ret, " %s", rb_id2name(optname_id));
-	else
-	    rb_str_catf(ret, " optname:%d", optname);
+        optname_id = rsock_intern_local_optname(optname);
+        if (optname_id)
+            rb_str_catf(ret, " %s", rb_id2name(optname_id));
+        else
+            rb_str_catf(ret, " optname:%d", optname);
     }
 #endif
     else if (IS_IP_FAMILY(family)) {
-	level_id = rsock_intern_iplevel(level);
-	if (level_id)
-	    rb_str_catf(ret, " %s", rb_id2name(level_id));
-	else
-	    rb_str_catf(ret, " level:%d", level);
-
-	v = optname_to_sym(level, optname);
-	if (SYMBOL_P(v))
-	    rb_str_catf(ret, " %"PRIsVALUE, rb_sym2str(v));
-	else
-	    rb_str_catf(ret, " optname:%d", optname);
+        level_id = rsock_intern_iplevel(level);
+        if (level_id)
+            rb_str_catf(ret, " %s", rb_id2name(level_id));
+        else
+            rb_str_catf(ret, " level:%d", level);
+
+        v = optname_to_sym(level, optname);
+        if (SYMBOL_P(v))
+            rb_str_catf(ret, " %"PRIsVALUE, rb_sym2str(v));
+        else
+            rb_str_catf(ret, " optname:%d", optname);
     }
     else {
         rb_str_catf(ret, " level:%d", level);
diff --git a/ext/socket/raddrinfo.c b/ext/socket/raddrinfo.c
index 8772572d2e..b914aa6520 100644
--- a/ext/socket/raddrinfo.c
+++ b/ext/socket/raddrinfo.c
@@ -24,28 +24,28 @@ static const int lookup_order_table[] = {
 
 static int
 ruby_getaddrinfo(const char *nodename, const char *servname,
-		 const struct addrinfo *hints, struct addrinfo **res)
+                 const struct addrinfo *hints, struct addrinfo **res)
 {
     struct addrinfo tmp_hints;
     int i, af, error;
 
     if (hints->ai_family != PF_UNSPEC) {
-	return getaddrinfo(nodename, servname, hints, res);
+        return getaddrinfo(nodename, servname, hints, res);
     }
 
     for (i = 0; i < LOOKUP_ORDERS; i++) {
-	af = lookup_order_table[i];
-	MEMCPY(&tmp_hints, hints, struct addrinfo, 1);
-	tmp_hints.ai_family = af;
-	error = getaddrinfo(nodename, servname, &tmp_hints, res);
-	if (error) {
-	    if (tmp_hints.ai_family == PF_UNSPEC) {
-		break;
-	    }
-	}
-	else {
-	    break;
-	}
+        af = lookup_order_table[i];
+        MEMCPY(&tmp_hints, hints, struct addrinfo, 1);
+        tmp_hints.ai_family = af;
+        error = getaddrinfo(nodename, servname, &tmp_hints, res);
+        if (error) {
+            if (tmp_hints.ai_family == PF_UNSPEC) {
+                break;
+            }
+        }
+        else {
+            break;
+        }
     }
 
     return error;
@@ -56,17 +56,17 @@ ruby_getaddrinfo(const char *nodename, const char *servname,
 #if defined(_AIX)
 static int
 ruby_getaddrinfo__aix(const char *nodename, const char *servname,
-		      const struct addrinfo *hints, struct addrinfo **res)
+                      const struct addrinfo *hints, struct addrinfo **res)
 {
     int error = getaddrinfo(nodename, servname, hints, res);
     struct addrinfo *r;
     if (error)
-	return error;
+        return error;
     for (r = *res; r != NULL; r = r->ai_next) {
-	if (r->ai_addr->sa_family == 0)
-	    r->ai_addr->sa_family = r->ai_family;
-	if (r->ai_addr->sa_len == 0)
-	    r->ai_addr->sa_len = r->ai_addrlen;
+        if (r->ai_addr->sa_family == 0)
+            r->ai_addr->sa_family = r->ai_family;
+        if (r->ai_addr->sa_len == 0)
+            r->ai_addr->sa_len = r->ai_addrlen;
     }
     return 0;
 }
@@ -74,21 +74,21 @@ ruby_getaddrinfo__aix(const char *nodename, const char *servname,
 #define getaddrinfo(node,serv,hints,res) ruby_getaddrinfo__aix((node),(serv),(hints),(res))
 static int
 ruby_getnameinfo__aix(const struct sockaddr *sa, size_t salen,
-		      char *host, size_t hostlen,
-		      char *serv, size_t servlen, int flags)
+                      char *host, size_t hostlen,
+                      char *serv, size_t servlen, int flags)
 {
     struct sockaddr_in6 *sa6;
     u_int32_t *a6;
 
     if (sa->sa_family == AF_INET6) {
-	sa6 = (struct sockaddr_in6 *)sa;
-	a6 = sa6->sin6_addr.u6_addr.u6_addr32;
+        sa6 = (struct sockaddr_in6 *)sa;
+        a6 = sa6->sin6_addr.u6_addr.u6_addr32;
 
-	if (a6[0] == 0 && a6[1] == 0 && a6[2] == 0 && a6[3] == 0) {
-	    strncpy(host, "::", hostlen);
-	    snprintf(serv, servlen, "%d", sa6->sin6_port);
-	    return 0;
-	}
+        if (a6[0] == 0 && a6[1] == 0 && a6[2] == 0 && a6[3] == 0) {
+            strncpy(host, "::", hostlen);
+            snprintf(serv, servlen, "%d", sa6->sin6_port);
+            return 0;
+        }
     }
     return getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
 }
@@ -102,7 +102,7 @@ static int str_is_number(const char *);
 #if defined(__APPLE__)
 static int
 ruby_getaddrinfo__darwin(const char *nodename, const char *servname,
-			 const struct addrinfo *hints, struct addrinfo **res)
+                         const struct addrinfo *hints, struct addrinfo **res)
 {
     /* fix [ruby-core:29427] */
     const char *tmp_servname;
@@ -112,12 +112,12 @@ ruby_getaddrinfo__darwin(const char *nodename, const char *servname,
     tmp_servname = servname;
     MEMCPY(&tmp_hints, hints, struct addrinfo, 1);
     if (nodename && servname) {
-	if (str_is_number(tmp_servname) && atoi(servname) == 0) {
-	    tmp_servname = NULL;
+        if (str_is_number(tmp_servname) && atoi(servname) == 0) {
+            tmp_servname = NULL;
 #ifdef AI_NUMERICSERV
-	    if (tmp_hints.ai_flags) tmp_hints.ai_flags &= ~AI_NUMERICSERV;
+            if (tmp_hints.ai_flags) tmp_hints.ai_flags &= ~AI_NUMERICSERV;
 #endif
-	}
+        }
     }
 
     error = getaddrinfo(nodename, tmp_servname, &tmp_hints, res);
@@ -193,7 +193,7 @@ nogvl_getaddrinfo(void *arg)
      * it cause getaddrinfo to return EAI_SYSTEM/ENOENT. [ruby-list:49420]
      */
     if (ret == EAI_SYSTEM && errno == ENOENT)
-	ret = EAI_NONAME;
+        ret = EAI_NONAME;
 #endif
     return (void *)(VALUE)ret;
 }
@@ -212,15 +212,15 @@ numeric_getaddrinfo(const char *node, const char *service,
     int port;
 
     if (node && parse_numeric_port(service, &port)) {
-	static const struct {
-	    int socktype;
-	    int protocol;
-	} list[] = {
-	    { SOCK_STREAM, IPPROTO_TCP },
-	    { SOCK_DGRAM, IPPROTO_UDP },
-	    { SOCK_RAW, 0 }
-	};
-	struct addrinfo *ai = NULL;
+        static const struct {
+            int socktype;
+            int protocol;
+        } list[] = {
+            { SOCK_STREAM, IPPROTO_TCP },
+            { SOCK_DGRAM, IPPROTO_UDP },
+            { SOCK_RAW, 0 }
+        };
+        struct addrinfo *ai = NULL;
         int hint_family = hints ? hints->ai_family : PF_UNSPEC;
         int hint_socktype = hints ? hints->ai_socktype : 0;
         int hint_protocol = hints ? hints->ai_protocol : 0;
@@ -319,9 +319,9 @@ nogvl_getnameinfo(void *arg)
 {
     struct getnameinfo_arg *ptr = arg;
     return (void *)(VALUE)getnameinfo(ptr->sa, ptr->salen,
-				      ptr->host, (socklen_t)ptr->hostlen,
-				      ptr->serv, (socklen_t)ptr->servlen,
-				      ptr->flags);
+                                      ptr->host, (socklen_t)ptr->hostlen,
+                                      ptr->serv, (socklen_t)ptr->servlen,
+                                      ptr->flags);
 }
 #endif
 
@@ -587,7 +587,7 @@ rsock_fd_family(int fd)
 
     if (fd < 0 || getsockname(fd, &sa, &sa_len) != 0 ||
         (size_t)sa_len < offsetof(struct sockaddr, sa_family) + sizeof(sa.sa_family)) {
-	return AF_UNSPEC;
+        return AF_UNSPEC;
     }
     return sa.sa_family;
 }
@@ -677,19 +677,19 @@ rsock_unix_sockaddr_len(VALUE path)
 {
 #ifdef __linux__
     if (RSTRING_LEN(path) == 0) {
-	/* autobind; see unix(7) for details. */
-	return (socklen_t) sizeof(sa_family_t);
+        /* autobind; see unix(7) for details. */
+        return (socklen_t) sizeof(sa_family_t);
     }
     else if (RSTRING_PTR(path)[0] == '\0') {
-	/* abstract namespace; see unix(7) for details. */
+        /* abstract namespace; see unix(7) for details. */
         if (SOCKLEN_MAX - offsetof(struct sockaddr_un, sun_path) < (size_t)RSTRING_LEN(path))
             rb_raise(rb_eArgError, "Linux abstract socket too long");
-	return (socklen_t) offsetof(struct sockaddr_un, sun_path) +
-	    RSTRING_SOCKLEN(path);
+        return (socklen_t) offsetof(struct sockaddr_un, sun_path) +
+            RSTRING_SOCKLEN(path);
     }
     else {
 #endif
-	return (socklen_t) sizeof(struct sockaddr_un);
+        return (socklen_t) sizeof(struct sockaddr_un);
 #ifdef __linux__
     }
 #endif
@@ -727,7 +727,7 @@ make_hostent_internal(VALUE v)
     rb_ary_push(ary, rb_str_new2(hostp));
 
     if (addr->ai_canonname && strlen(addr->ai_canonname) < NI_MAXHOST &&
-	(h = gethostbyname(addr->ai_canonname))) {
+        (h = gethostbyname(addr->ai_canonname))) {
         names = rb_ary_new();
         if (h->h_aliases != NULL) {
             for (pch = h->h_aliases; *pch; pch++) {
@@ -875,19 +875,19 @@ call_getaddrinfo(VALUE node, VALUE service,
     hints.ai_family = NIL_P(family) ? PF_UNSPEC : rsock_family_arg(family);
 
     if (!NIL_P(socktype)) {
-	hints.ai_socktype = rsock_socktype_arg(socktype);
+        hints.ai_socktype = rsock_socktype_arg(socktype);
     }
     if (!NIL_P(protocol)) {
-	hints.ai_protocol = NUM2INT(protocol);
+        hints.ai_protocol = NUM2INT(protocol);
     }
     if (!NIL_P(flags)) {
-	hints.ai_flags = NUM2INT(flags);
+        hints.ai_flags = NUM2INT(flags);
     }
 
     res = rsock_getaddrinfo(node, service, &hints, socktype_hack);
 
     if (res == NULL)
-	rb_raise(rb_eSocket, "host not found");
+        rb_raise(rb_eSocket, "host not found");
     return res;
 }
 
@@ -1037,7 +1037,7 @@ init_unix_addrinfo(rb_addrinfo_t *rai, VALUE path, int socktype)
 
     len = rsock_unix_sockaddr_len(path);
     init_addrinfo(rai, (struct sockaddr *)&un, len,
-		  PF_UNIX, socktype, 0, Qnil, Qnil);
+                  PF_UNIX, socktype, 0, Qnil, Qnil);
 }
 
 static long
@@ -1119,7 +1119,7 @@ addrinfo_initialize(int argc, VALUE *argv, VALUE self)
         int af;
         StringValue(afamily);
         if (rsock_family_to_int(RSTRING_PTR(afamily), RSTRING_LEN(afamily), &af) == -1)
-	    rb_raise(rb_eSocket, "unknown address family: %s", StringValueCStr(afamily));
+            rb_raise(rb_eSocket, "unknown address family: %s", StringValueCStr(afamily));
         switch (af) {
           case AF_INET: /* ["AF_INET", 46102, "localhost.localdomain", "127.0.0.1"] */
 #ifdef INET6
@@ -1209,45 +1209,45 @@ rsock_inspect_sockaddr(struct sockaddr *sockaddr_arg, socklen_t socklen, VALUE r
     else {
         switch (sockaddr->addr.sa_family) {
           case AF_UNSPEC:
-	  {
-	    rb_str_cat2(ret, "UNSPEC");
+          {
+            rb_str_cat2(ret, "UNSPEC");
             break;
-	  }
+          }
 
           case AF_INET:
           {
             struct sockaddr_in *addr;
             int port;
-	    addr = &sockaddr->in;
-	    if ((socklen_t)(((char*)&addr->sin_addr)-(char*)addr+0+1) <= socklen)
-		rb_str_catf(ret, "%d", ((unsigned char*)&addr->sin_addr)[0]);
-	    else
-		rb_str_cat2(ret, "?");
-	    if ((socklen_t)(((char*)&addr->sin_addr)-(char*)addr+1+1) <= socklen)
-		rb_str_catf(ret, ".%d", ((unsigned char*)&addr->sin_addr)[1]);
-	    else
-		rb_str_cat2(ret, ".?");
-	    if ((socklen_t)(((char*)&addr->sin_addr)-(char*)addr+2+1) <= socklen)
-		rb_str_catf(ret, ".%d", ((unsigned char*)&addr->sin_addr)[2]);
-	    else
-		rb_str_cat2(ret, ".?");
-	    if ((socklen_t)(((char*)&addr->sin_addr)-(char*)addr+3+1) <= socklen)
-		rb_str_catf(ret, ".%d", ((unsigned char*)&addr->sin_addr)[3]);
-	    else
-		rb_str_cat2(ret, ".?");
-
-	    if ((socklen_t)(((char*)&addr->sin_port)-(char*)addr+(int)sizeof(addr->sin_port)) < socklen) {
-		port = ntohs(addr->sin_port);
-		if (port)
-		    rb_str_catf(ret, ":%d", port);
-	    }
-	    else {
-		rb_str_cat2(ret, ":?");
-	    }
-	    if ((socklen_t)sizeof(struct sockaddr_in) != socklen)
-		rb_str_catf(ret, " (%d bytes for %d bytes sockaddr_in)",
-		  (int)socklen,
-		  (int)sizeof(struct sockaddr_in));
+            addr = &sockaddr->in;
+            if ((socklen_t)(((char*)&addr->sin_addr)-(char*)addr+0+1) <= socklen)
+                rb_str_catf(ret, "%d", ((unsigned char*)&addr->sin_addr)[0]);
+            else
+                rb_str_cat2(ret, "?");
+            if ((socklen_t)(((char*)&addr->sin_addr)-(char*)addr+1+1) <= socklen)
+                rb_str_catf(ret, ".%d", ((unsigned char*)&addr->sin_addr)[1]);
+            else
+                rb_str_cat2(ret, ".?");
+            if ((socklen_t)(((char*)&addr->sin_addr)-(char*)addr+2+1) <= socklen)
+                rb_str_catf(ret, ".%d", ((unsigned char*)&addr->sin_addr)[2]);
+            else
+                rb_str_cat2(ret, ".?");
+            if ((socklen_t)(((char*)&addr->sin_addr)-(char*)addr+3+1) <= socklen)
+                rb_str_catf(ret, ".%d", ((unsigned char*)&addr->sin_addr)[3]);
+            else
+                rb_str_cat2(ret, ".?");
+
+            if ((socklen_t)(((char*)&addr->sin_port)-(char*)addr+(int)sizeof(addr->sin_port)) < socklen) {
+                port = ntohs(addr->sin_port);
+                if (port)
+                    rb_str_catf(ret, ":%d", port);
+            }
+            else {
+                rb_str_cat2(ret, ":?");
+            }
+            if ((socklen_t)sizeof(struct sockaddr_in) != socklen)
+                rb_str_catf(ret, " (%d bytes for %d bytes sockaddr_in)",
+                  (int)socklen,
+                  (int)sizeof(struct sockaddr_in));
             break;
           }
 
@@ -1398,20 +1398,20 @@ rsock_inspect_sockaddr(struct sockaddr *sockaddr_arg, socklen_t socklen, VALUE r
 #endif
 
 #if defined(AF_LINK) && defined(HAVE_TYPE_STRUCT_SOCKADDR_DL)
-	  /* AF_LINK is defined in 4.4BSD derivations since Net2.
-	     link_ntoa is also defined at Net2.
+          /* AF_LINK is defined in 4.4BSD derivations since Net2.
+             link_ntoa is also defined at Net2.
              However Debian GNU/kFreeBSD defines AF_LINK but
              don't have link_ntoa.  */
           case AF_LINK:
-	  {
-	    /*
-	     * Simple implementation using link_ntoa():
-	     * This doesn't work on Debian GNU/kFreeBSD 6.0.7 (squeeze).
+          {
+            /*
+             * Simple implementation using link_ntoa():
+             * This doesn't work on Debian GNU/kFreeBSD 6.0.7 (squeeze).
              * Also, the format is bit different.
-	     *
-	     * rb_str_catf(ret, "LINK %s", link_ntoa(&sockaddr->dl));
-	     * break;
-	     */
+             *
+             * rb_str_catf(ret, "LINK %s", link_ntoa(&sockaddr->dl));
+             * break;
+             */
             struct sockaddr_dl *addr = &sockaddr->dl;
             char *np = NULL, *ap = NULL, *endp;
             int nlen = 0, alen = 0;
@@ -1438,14 +1438,14 @@ rsock_inspect_sockaddr(struct sockaddr *sockaddr_arg, socklen_t socklen, VALUE r
                     alen = (int)(endp - ap);
             }
 
-	    CATSEP;
+            CATSEP;
             if (np)
                 rb_str_catf(ret, "%.*s", nlen, np);
             else
                 rb_str_cat2(ret, "?");
 
             if (ap && 0 < alen) {
-		CATSEP;
+                CATSEP;
                 for (i = 0; i < alen; i++)
                     rb_str_catf(ret, "%s%02x", i == 0 ? "" : ":", (unsigned char)ap[i]);
             }
@@ -1456,10 +1456,10 @@ rsock_inspect_sockaddr(struct sockaddr *sockaddr_arg, socklen_t socklen, VALUE r
                 /* longer length is possible behavior because struct sockaddr_dl has "minimum work area, can be larger" as the last field.
                  * cf. Net2:/usr/src/sys/net/if_dl.h. */
                 socklen < (socklen_t)(offsetof(struct sockaddr_dl, sdl_data) + addr->sdl_nlen + addr->sdl_alen + addr->sdl_slen)) {
-		CATSEP;
+                CATSEP;
                 rb_str_catf(ret, "(%d bytes for %d bytes sockaddr_dl)",
                     (int)socklen, (int)sizeof(struct sockaddr_dl));
-	    }
+            }
 
             rb_str_cat2(ret, "]");
 #undef CATSEP
@@ -2009,7 +2009,7 @@ addrinfo_ip_unpack(VALUE self)
     VALUE ret, portstr;
 
     if (!IS_IP_FAMILY(family))
-	rb_raise(rb_eSocket, "need IPv4 or IPv6 address");
+        rb_raise(rb_eSocket, "need IPv4 or IPv6 address");
 
     vflags = INT2NUM(NI_NUMERICHOST|NI_NUMERICSERV);
     ret = addrinfo_getnameinfo(1, &vflags, self);
@@ -2036,7 +2036,7 @@ addrinfo_ip_address(VALUE self)
     VALUE ret;
 
     if (!IS_IP_FAMILY(family))
-	rb_raise(rb_eSocket, "need IPv4 or IPv6 address");
+        rb_raise(rb_eSocket, "need IPv4 or IPv6 address");
 
     vflags = INT2NUM(NI_NUMERICHOST|NI_NUMERICSERV);
     ret = addrinfo_getnameinfo(1, &vflags, self);
@@ -2062,9 +2062,9 @@ addrinfo_ip_port(VALUE self)
     if (!IS_IP_FAMILY(family)) {
       bad_family:
 #ifdef AF_INET6
-	rb_raise(rb_eSocket, "need IPv4 or IPv6 address");
+        rb_raise(rb_eSocket, "need IPv4 or IPv6 address");
 #else
-	rb_raise(rb_eSocket, "need IPv4 address");
+        rb_raise(rb_eSocket, "need IPv4 address");
 #endif
     }
 
@@ -2084,7 +2084,7 @@ addrinfo_ip_port(VALUE self)
 #endif
 
       default:
-	goto bad_family;
+        goto bad_family;
     }
 
     return INT2NUM(port);
@@ -2362,7 +2362,7 @@ addrinfo_unix_path(VALUE self)
     long n;
 
     if (family != AF_UNIX)
-	rb_raise(rb_eSocket, "need AF_UNIX address");
+        rb_raise(rb_eSocket, "need AF_UNIX address");
 
     addr = &rai->addr.un;
 
@@ -2429,10 +2429,10 @@ addrinfo_s_getaddrinfo(int argc, VALUE *argv, VALUE self)
     VALUE node, service, family, socktype, protocol, flags, opts, timeout;
 
     rb_scan_args(argc, argv, "24:", &node, &service, &family, &socktype,
-		 &protocol, &flags, &opts);
+                 &protocol, &flags, &opts);
     rb_get_kwargs(opts, &id_timeout, 0, 1, &timeout);
     if (timeout == Qundef) {
-	timeout = Qnil;
+        timeout = Qnil;
     }
 
     return addrinfo_list_new(node, service, family, socktype, protocol, flags, timeout);
diff --git a/ext/socket/rubysocket.h b/ext/socket/rubysocket.h
index c0d40addca..9ec893ee8c 100644
--- a/ext/socket/rubysocket.h
+++ b/ext/socket/rubysocket.h
@@ -368,23 +368,23 @@ enum sock_recv_type {
 };
 
 VALUE rsock_s_recvfrom_nonblock(VALUE sock, VALUE len, VALUE flg, VALUE str,
-			        VALUE ex, enum sock_recv_type from);
+                                VALUE ex, enum sock_recv_type from);
 VALUE rsock_s_recvfrom(VALUE sock, int argc, VALUE *argv, enum sock_recv_type from);
 
 int rsock_connect(int fd, const struct sockaddr *sockaddr, int len, int socks, struct timeval *timeout);
 
 VALUE rsock_s_accept(VALUE klass, VALUE io, struct sockaddr *sockaddr, socklen_t *len);
 VALUE rsock_s_accept_nonblock(VALUE klass, VALUE ex, rb_io_t *fptr,
-			      struct sockaddr *sockaddr, socklen_t *len);
+                              struct sockaddr *sockaddr, socklen_t *len);
 VALUE rsock_sock_listen(VALUE sock, VALUE log);
 
 VALUE rsock_sockopt_new(int family, int level, int optname, VALUE data);
 
 #if defined(HAVE_SENDMSG)
 VALUE rsock_bsock_sendmsg(VALUE sock, VALUE data, VALUE flags,
-			  VALUE dest_sockaddr, VALUE controls);
+                          VALUE dest_sockaddr, VALUE controls);
 VALUE rsock_bsock_sendmsg_nonblock(VALUE sock, VALUE data, VALUE flags,
-			     VALUE dest_sockaddr, VALUE controls, VALUE ex);
+                             VALUE dest_sockaddr, VALUE controls, VALUE ex);
 #else
 #define rsock_bsock_sendmsg rb_f_notimplement
 #define rsock_bsock_sendmsg_nonblock rb_f_notimplement
@@ -392,9 +392,9 @@ VALUE rsock_bsock_sendmsg_nonblock(VALUE sock, VALUE data, VALUE flags,
 
 #if defined(HAVE_RECVMSG)
 VALUE rsock_bsock_recvmsg(VALUE sock, VALUE dlen, VALUE clen, VALUE flags,
-			  VALUE scm_rights);
+                          VALUE scm_rights);
 VALUE rsock_bsock_recvmsg_nonblock(VALUE sock, VALUE dlen, VALUE clen,
-				   VALUE flags, VALUE scm_rights, VALUE ex);
+                                   VALUE flags, VALUE scm_rights, VALUE ex);
 ssize_t rsock_recvmsg(int socket, struct msghdr *message, int flags);
 #else
 #define rsock_bsock_recvmsg rb_f_notimplement
diff --git a/ext/socket/socket.c b/ext/socket/socket.c
index 4ba1c6cd61..b1965deb9e 100644
--- a/ext/socket/socket.c
+++ b/ext/socket/socket.c
@@ -26,7 +26,7 @@ rsock_syserr_fail_host_port(int err, const char *mesg, VALUE host, VALUE port)
     VALUE message;
 
     message = rb_sprintf("%s for %+"PRIsVALUE" port % "PRIsVALUE"",
-			 mesg, host, port);
+                         mesg, host, port);
 
     rb_syserr_fail_str(err, message);
 }
@@ -43,11 +43,11 @@ rsock_syserr_fail_path(int err, const char *mesg, VALUE path)
     VALUE message;
 
     if (RB_TYPE_P(path, T_STRING)) {
-	message = rb_sprintf("%s for % "PRIsVALUE"", mesg, path);
-	rb_syserr_fail_str(err, message);
+        message = rb_sprintf("%s for % "PRIsVALUE"", mesg, path);
+        rb_syserr_fail_str(err, message);
     }
     else {
-	rb_syserr_fail(err, mesg);
+        rb_syserr_fail(err, mesg);
     }
 }
 
@@ -96,12 +96,12 @@ rsock_syserr_fail_raddrinfo_or_sockaddr(int err, const char *mesg, VALUE addr, V
     if (NIL_P(rai)) {
         StringValue(addr);
 
-	rsock_syserr_fail_sockaddr(err, mesg,
+        rsock_syserr_fail_sockaddr(err, mesg,
             (struct sockaddr *)RSTRING_PTR(addr),
             (socklen_t)RSTRING_LEN(addr)); /* overflow should be checked already */
     }
     else
-	rsock_syserr_fail_raddrinfo(err, mesg, rai);
+        rsock_syserr_fail_raddrinfo(err, mesg, rai);
 }
 
 static void
@@ -256,7 +256,7 @@ rsock_sock_s_socketpair(int argc, VALUE *argv, VALUE klass)
     p = NUM2INT(protocol);
     ret = rsock_socketpair(d, t, p, sp);
     if (ret < 0) {
-	rb_sys_fail("socketpair(2)");
+        rb_sys_fail("socketpair(2)");
     }
 
     s1 = rsock_init_sock(rb_obj_alloc(klass), sp[0]);
@@ -395,7 +395,7 @@ sock_connect(VALUE sock, VALUE addr)
     fd = fptr->fd;
     n = rsock_connect(fd, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_SOCKLEN(addr), 0, NULL);
     if (n < 0) {
-	rsock_sys_fail_raddrinfo_or_sockaddr("connect(2)", addr, rai);
+        rsock_sys_fail_raddrinfo_or_sockaddr("connect(2)", addr, rai);
     }
 
     return INT2FIX(n);
@@ -415,19 +415,19 @@ sock_connect_nonblock(VALUE sock, VALUE addr, VALUE ex)
     rb_io_set_nonblock(fptr);
     n = connect(fptr->fd, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_SOCKLEN(addr));
     if (n < 0) {
-	int e = errno;
-	if (e == EINPROGRESS) {
+        int e = errno;
+        if (e == EINPROGRESS) {
             if (ex == Qfalse) {
                 return sym_wait_writable;
             }
             rb_readwrite_syserr_fail(RB_IO_WAIT_WRITABLE, e, "connect(2) would block");
-	}
-	if (e == EISCONN) {
+        }
+        if (e == EISCONN) {
             if (ex == Qfalse) {
                 return INT2FIX(0);
             }
-	}
-	rsock_syserr_fail_raddrinfo_or_sockaddr(e, "connect(2)", addr, rai);
+        }
+        rsock_syserr_fail_raddrinfo_or_sockaddr(e, "connect(2)", addr, rai);
     }
 
     return INT2FIX(n);
@@ -528,7 +528,7 @@ sock_bind(VALUE sock, VALUE addr)
     SockAddrStringValueWithAddrinfo(addr, rai);
     GetOpenFile(sock, fptr);
     if (bind(fptr->fd, (struct sockaddr*)RSTRING_PTR(addr), RSTRING_SOCKLEN(addr)) < 0)
-	rsock_sys_fail_raddrinfo_or_sockaddr("bind(2)", addr, rai);
+        rsock_sys_fail_raddrinfo_or_sockaddr("bind(2)", addr, rai);
 
     return INT2FIX(0);
 }
@@ -612,7 +612,7 @@ rsock_sock_listen(VALUE sock, VALUE log)
     backlog = NUM2INT(log);
     GetOpenFile(sock, fptr);
     if (listen(fptr->fd, backlog) < 0)
-	rb_sys_fail("listen(2)");
+        rb_sys_fail("listen(2)");
 
     return INT2FIX(0);
 }
@@ -774,7 +774,7 @@ sock_accept_nonblock(VALUE sock, VALUE ex)
     sock2 = rsock_s_accept_nonblock(rb_cSocket, ex, fptr, addr, &len);
 
     if (SYMBOL_P(sock2)) /* :wait_readable */
-	return sock2;
+        return sock2;
     return rb_assoc_new(sock2, rsock_io_socket_addrinfo(sock2, &buf.addr, len));
 }
 
@@ -855,19 +855,19 @@ sock_gethostname(VALUE obj)
 
     name = rb_str_new(0, len);
     while (gethostname(RSTRING_PTR(name), len) < 0) {
-	int e = errno;
-	switch (e) {
-	  case ENAMETOOLONG:
+        int e = errno;
+        switch (e) {
+          case ENAMETOOLONG:
 #ifdef __linux__
-	  case EINVAL:
-	    /* glibc before version 2.1 uses EINVAL instead of ENAMETOOLONG */
+          case EINVAL:
+            /* glibc before version 2.1 uses EINVAL instead of ENAMETOOLONG */
 #endif
-	    break;
-	  default:
-	    rb_syserr_fail(e, "gethostname(3)");
-	}
-	rb_str_modify_expand(name, len);
-	len += len;
+            break;
+          default:
+            rb_syserr_fail(e, "gethostname(3)");
+        }
+        rb_str_modify_expand(name, len);
+        len += len;
     }
     rb_str_resize(name, strlen(RSTRING_PTR(name)));
     return name;
@@ -897,18 +897,18 @@ make_addrinfo(struct rb_addrinfo *res0, int norevlookup)
     struct addrinfo *res;
 
     if (res0 == NULL) {
-	rb_raise(rb_eSocket, "host not found");
+        rb_raise(rb_eSocket, "host not found");
     }
     base = rb_ary_new();
     for (res = res0->ai; res; res = res->ai_next) {
-	ary = rsock_ipaddr(res->ai_addr, res->ai_addrlen, norevlookup);
-	if (res->ai_canonname) {
-	    RARRAY_ASET(ary, 2, rb_str_new2(res->ai_canonname));
-	}
-	rb_ary_push(ary, INT2FIX(res->ai_family));
-	rb_ary_push(ary, INT2FIX(res->ai_socktype));
-	rb_ary_push(ary, INT2FIX(res->ai_protocol));
-	rb_ary_push(base, ary);
+        ary = rsock_ipaddr(res->ai_addr, res->ai_addrlen, norevlookup);
+        if (res->ai_canonname) {
+            RARRAY_ASET(ary, 2, rb_str_new2(res->ai_canonname));
+        }
+        rb_ary_push(ary, INT2FIX(res->ai_family));
+        rb_ary_push(ary, INT2FIX(res->ai_socktype));
+        rb_ary_push(ary, INT2FIX(res->ai_protocol));
+        rb_ary_push(base, ary);
     }
     return base;
 }
@@ -920,18 +920,18 @@ sock_sockaddr(struct sockaddr *addr, socklen_t len)
 
     switch (addr->sa_family) {
       case AF_INET:
-	ptr = (char*)&((struct sockaddr_in*)addr)->sin_addr.s_addr;
-	len = (socklen_t)sizeof(((struct sockaddr_in*)addr)->sin_addr.s_addr);
-	break;
+        ptr = (char*)&((struct sockaddr_in*)addr)->sin_addr.s_addr;
+        len = (socklen_t)sizeof(((struct sockaddr_in*)addr)->sin_addr.s_addr);
+        break;
 #ifdef AF_INET6
       case AF_INET6:
-	ptr = (char*)&((struct sockaddr_in6*)addr)->sin6_addr.s6_addr;
-	len = (socklen_t)sizeof(((struct sockaddr_in6*)addr)->sin6_addr.s6_addr);
-	break;
+        ptr = (char*)&((struct sockaddr_in6*)addr)->sin6_addr.s6_addr;
+        len = (socklen_t)sizeof(((struct sockaddr_in6*)addr)->sin6_addr.s6_addr);
+        break;
 #endif
       default:
         rb_raise(rb_eSocket, "unknown socket family:%d", addr->sa_family);
-	break;
+        break;
     }
     return rb_str_new(ptr, len);
 }
@@ -961,7 +961,7 @@ sock_s_gethostbyname(VALUE obj, VALUE host)
 {
     rb_warn("Socket.gethostbyname is deprecated; use Addrinfo.getaddrinfo instead.");
     struct rb_addrinfo *res =
-	rsock_addrinfo(host, Qnil, AF_UNSPEC, SOCK_STREAM, AI_CANONNAME);
+        rsock_addrinfo(host, Qnil, AF_UNSPEC, SOCK_STREAM, AI_CANONNAME);
     return rsock_make_hostent(host, res, sock_sockaddr);
 }
 
@@ -1004,20 +1004,20 @@ sock_s_gethostbyaddr(int argc, VALUE *argv, VALUE _)
     rb_scan_args(argc, argv, "11", &addr, &family);
     StringValue(addr);
     if (!NIL_P(family)) {
-	t = rsock_family_arg(family);
+        t = rsock_family_arg(family);
     }
 #ifdef AF_INET6
     else if (RSTRING_LEN(addr) == 16) {
-	t = AF_INET6;
+        t = AF_INET6;
     }
 #endif
     h = gethostbyaddr(RSTRING_PTR(addr), RSTRING_SOCKLEN(addr), t);
     if (h == NULL) {
 #ifdef HAVE_HSTRERROR
-	extern int h_errno;
-	rb_raise(rb_eSocket, "%s", (char*)hstrerror(h_errno));
+        extern int h_errno;
+        rb_raise(rb_eSocket, "%s", (char*)hstrerror(h_errno));
 #else
-	rb_raise(rb_eSocket, "host not found");
+        rb_raise(rb_eSocket, "host not found");
 #endif
     }
     ary = rb_ary_new();
@@ -1025,14 +1025,14 @@ sock_s_gethostbyaddr(int argc, VALUE *argv, VALUE _)
     names = rb_ary_new();
     rb_ary_push(ary, names);
     if (h->h_aliases != NULL) {
-	for (pch = h->h_aliases; *pch; pch++) {
-	    rb_ary_push(names, rb_str_new2(*pch));
-	}
+        for (pch = h->h_aliases; *pch; pch++) {
+            rb_ary_push(names, rb_str_new2(*pch));
+        }
     }
     rb_ary_push(ary, INT2NUM(h->h_addrtype));
 #ifdef h_addr
     for (pch = h->h_addr_list; *pch; pch++) {
-	rb_ary_push(ary, rb_str_new(*pch, h->h_length));
+        rb_ary_push(ary, rb_str_new(*pch, h->h_length));
     }
 #else
     rb_ary_push(ary, rb_str_new(h->h_addr, h->h_length));
@@ -1069,15 +1069,15 @@ sock_s_getservbyname(int argc, VALUE *argv, VALUE _)
     if (!NIL_P(proto)) protoname = StringValueCStr(proto);
     sp = getservbyname(servicename, protoname);
     if (sp) {
-	port = ntohs(sp->s_port);
+        port = ntohs(sp->s_port);
     }
     else {
-	char *end;
+        char *end;
 
-	port = STRTOUL(servicename, &end, 0);
-	if (*end != '\0') {
-	    rb_raise(rb_eSocket, "no such service %s/%s", servicename, protoname);
-	}
+        port = STRTOUL(servicename, &end, 0);
+        if (*end != '\0') {
+            rb_raise(rb_eSocket, "no such service %s/%s", servicename, protoname);
+        }
     }
     return INT2FIX(port);
 }
@@ -1106,14 +1106,14 @@ sock_s_getservbyport(int argc, VALUE *argv, VALUE _)
     rb_scan_args(argc, argv, "11", &port, &proto);
     portnum = NUM2LONG(port);
     if (portnum != (uint16_t)portnum) {
-	const char *s = portnum > 0 ? "big" : "small";
-	rb_raise(rb_eRangeError, "integer %ld too %s to convert into `int16_t'", portnum, s);
+        const char *s = portnum > 0 ? "big" : "small";
+        rb_raise(rb_eRangeError, "integer %ld too %s to convert into `int16_t'", portnum, s);
     }
     if (!NIL_P(proto)) protoname = StringValueCStr(proto);
 
     sp = getservbyport((int)htons((uint16_t)portnum), protoname);
     if (!sp) {
-	rb_raise(rb_eSocket, "no such service for port %d/%s", (int)portnum, protoname);
+        rb_raise(rb_eSocket, "no such service for port %d/%s", (int)portnum, protoname);
     }
     return rb_str_new2(sp->s_name);
 }
@@ -1167,16 +1167,16 @@ sock_s_getaddrinfo(int argc, VALUE *argv, VALUE _)
     hints.ai_family = NIL_P(family) ? PF_UNSPEC : rsock_family_arg(family);
 
     if (!NIL_P(socktype)) {
-	hints.ai_socktype = rsock_socktype_arg(socktype);
+        hints.ai_socktype = rsock_socktype_arg(socktype);
     }
     if (!NIL_P(protocol)) {
-	hints.ai_protocol = NUM2INT(protocol);
+        hints.ai_protocol = NUM2INT(protocol);
     }
     if (!NIL_P(flags)) {
-	hints.ai_flags = NUM2INT(flags);
+        hints.ai_flags = NUM2INT(flags);
     }
     if (NIL_P(revlookup) || !rsock_revlookup_flag(revlookup, &norevlookup)) {
-	norevlookup = rsock_do_not_reverse_lookup;
+        norevlookup = rsock_do_not_reverse_lookup;
     }
 
     res = rsock_getaddrinfo(host, port, &hints, 0);
@@ -1226,82 +1226,82 @@ sock_s_getnameinfo(int argc, VALUE *argv, VALUE _)
 
     fl = 0;
     if (!NIL_P(flags)) {
-	fl = NUM2INT(flags);
+        fl = NUM2INT(flags);
     }
     tmp = rb_check_sockaddr_string_type(sa);
     if (!NIL_P(tmp)) {
-	sa = tmp;
-	if (sizeof(ss) < (size_t)RSTRING_LEN(sa)) {
-	    rb_raise(rb_eTypeError, "sockaddr length too big");
-	}
-	memcpy(&ss, RSTRING_PTR(sa), RSTRING_LEN(sa));
+        sa = tmp;
+        if (sizeof(ss) < (size_t)RSTRING_LEN(sa)) {
+            rb_raise(rb_eTypeError, "sockaddr length too big");
+        }
+        memcpy(&ss, RSTRING_PTR(sa), RSTRING_LEN(sa));
         if (!VALIDATE_SOCKLEN(&ss.addr, RSTRING_LEN(sa))) {
-	    rb_raise(rb_eTypeError, "sockaddr size differs - should not happen");
-	}
-	sap = &ss.addr;
+            rb_raise(rb_eTypeError, "sockaddr size differs - should not happen");
+        }
+        sap = &ss.addr;
         salen = RSTRING_SOCKLEN(sa);
-	goto call_nameinfo;
+        goto call_nameinfo;
     }
     tmp = rb_check_array_type(sa);
     if (!NIL_P(tmp)) {
-	sa = tmp;
-	MEMZERO(&hints, struct addrinfo, 1);
-	if (RARRAY_LEN(sa) == 3) {
-	    af = RARRAY_AREF(sa, 0);
-	    port = RARRAY_AREF(sa, 1);
-	    host = RARRAY_AREF(sa, 2);
-	}
-	else if (RARRAY_LEN(sa) >= 4) {
-	    af = RARRAY_AREF(sa, 0);
-	    port = RARRAY_AREF(sa, 1);
-	    host = RARRAY_AREF(sa, 3);
-	    if (NIL_P(host)) {
-		host = RARRAY_AREF(sa, 2);
-	    }
-	    else {
-		/*
-		 * 4th element holds numeric form, don't resolve.
-		 * see rsock_ipaddr().
-		 */
+        sa = tmp;
+        MEMZERO(&hints, struct addrinfo, 1);
+        if (RARRAY_LEN(sa) == 3) {
+            af = RARRAY_AREF(sa, 0);
+            port = RARRAY_AREF(sa, 1);
+            host = RARRAY_AREF(sa, 2);
+        }
+        else if (RARRAY_LEN(sa) >= 4) {
+            af = RARRAY_AREF(sa, 0);
+            port = RARRAY_AREF(sa, 1);
+            host = RARRAY_AREF(sa, 3);
+            if (NIL_P(host)) {
+                host = RARRAY_AREF(sa, 2);
+            }
+            else {
+                /*
+                 * 4th element holds numeric form, don't resolve.
+                 * see rsock_ipaddr().
+                 */
 #ifdef AI_NUMERICHOST /* AIX 4.3.3 doesn't have AI_NUMERICHOST. */
-		hints.ai_flags |= AI_NUMERICHOST;
+                hints.ai_flags |= AI_NUMERICHOST;
 #endif
-	    }
-	}
-	else {
-	    rb_raise(rb_eArgError, "array size should be 3 or 4, %ld given",
-		     RARRAY_LEN(sa));
-	}
-	hints.ai_socktype = (fl & NI_DGRAM) ? SOCK_DGRAM : SOCK_STREAM;
-	/* af */
+            }
+        }
+        else {
+            rb_raise(rb_eArgError, "array size should be 3 or 4, %ld given",
+                     RARRAY_LEN(sa));
+        }
+        hints.ai_socktype = (fl & NI_DGRAM) ? SOCK_DGRAM : SOCK_STREAM;
+        /* af */
         hints.ai_family = NIL_P(af) ? PF_UNSPEC : rsock_family_arg(af);
-	res = rsock_getaddrinfo(host, port, &hints, 0);
-	sap = res->ai->ai_addr;
+        res = rsock_getaddrinfo(host, port, &hints, 0);
+        sap = res->ai->ai_addr;
         salen = res->ai->ai_addrlen;
     }
     else {
-	rb_raise(rb_eTypeError, "expecting String or Array");
+        rb_raise(rb_eTypeError, "expecting String or Array");
     }
 
   call_nameinfo:
     error = rb_getnameinfo(sap, salen, hbuf, sizeof(hbuf),
-			   pbuf, sizeof(pbuf), fl);
+                           pbuf, sizeof(pbuf), fl);
     if (error) goto error_exit_name;
     if (res) {
-	for (r = res->ai->ai_next; r; r = r->ai_next) {
-	    char hbuf2[1024], pbuf2[1024];
+        for (r = res->ai->ai_next; r; r = r->ai_next) {
+            char hbuf2[1024], pbuf2[1024];
 
-	    sap = r->ai_addr;
+            sap = r->ai_addr;
             salen = r->ai_addrlen;
-	    error = rb_getnameinfo(sap, salen, hbuf2, sizeof(hbuf2),
-				   pbuf2, sizeof(pbuf2), fl);
-	    if (error) goto error_exit_name;
-	    if (strcmp(hbuf, hbuf2) != 0|| strcmp(pbuf, pbuf2) != 0) {
-		rb_freeaddrinfo(res);
-		rb_raise(rb_eSocket, "sockaddr resolved to multiple nodename");
-	    }
-	}
-	rb_freeaddrinfo(res);
+            error = rb_getnameinfo(sap, salen, hbuf2, sizeof(hbuf2),
+                                   pbuf2, sizeof(pbuf2), fl);
+            if (error) goto error_exit_name;
+            if (strcmp(hbuf, hbuf2) != 0|| strcmp(pbuf, pbuf2) != 0) {
+                rb_freeaddrinfo(res);
+                rb_raise(rb_eSocket, "sockaddr resolved to multiple nodename");
+            }
+        }
+        rb_freeaddrinfo(res);
     }
     return rb_assoc_new(rb_str_new2(hbuf), rb_str_new2(pbuf));
 
@@ -1437,8 +1437,8 @@ sock_s_unpack_sockaddr_un(VALUE self, VALUE addr)
         rb_raise(rb_eArgError, "not an AF_UNIX sockaddr");
     }
     if (sizeof(struct sockaddr_un) < (size_t)RSTRING_LEN(addr)) {
-	rb_raise(rb_eTypeError, "too long sockaddr_un - %ld longer than %d",
-		 RSTRING_LEN(addr), (int)sizeof(struct sockaddr_un));
+        rb_raise(rb_eTypeError, "too long sockaddr_un - %ld longer than %d",
+                 RSTRING_LEN(addr), (int)sizeof(struct sockaddr_un));
     }
     path = rsock_unixpath_str(sockaddr, RSTRING_SOCKLEN(addr));
     return path;
@@ -1502,19 +1502,19 @@ sockaddr_obj(struct sockaddr *addr, socklen_t len)
 
 #if defined(__KAME__) && defined(AF_INET6)
     if (addr->sa_family == AF_INET6) {
-	/* KAME uses the 2nd 16bit word of link local IPv6 address as interface index internally */
+        /* KAME uses the 2nd 16bit word of link local IPv6 address as interface index internally */
         /* http://orange.kame.net/dev/cvsweb.cgi/kame/IMPLEMENTATION */
-	/* convert fe80:1::1 to fe80::1%1 */
+        /* convert fe80:1::1 to fe80::1%1 */
         len = (socklen_t)sizeof(struct sockaddr_in6);
-	memcpy(&addr6, addr, len);
-	addr = (struct sockaddr *)&addr6;
-	if (IN6_IS_ADDR_LINKLOCAL(&addr6.sin6_addr) &&
-	    addr6.sin6_scope_id == 0 &&
-	    (addr6.sin6_addr.s6_addr[2] || addr6.sin6_addr.s6_addr[3])) {
-	    addr6.sin6_scope_id = (addr6.sin6_addr.s6_addr[2] << 8) | addr6.sin6_addr.s6_addr[3];
-	    addr6.sin6_addr.s6_addr[2] = 0;
-	    addr6.sin6_addr.s6_addr[3] = 0;
-	}
+        memcpy(&addr6, addr, len);
+        addr = (struct sockaddr *)&addr6;
+        if (IN6_IS_ADDR_LINKLOCAL(&addr6.sin6_addr) &&
+            addr6.sin6_scope_id == 0 &&
+            (addr6.sin6_addr.s6_addr[2] || addr6.sin6_addr.s6_addr[3])) {
+            addr6.sin6_scope_id = (addr6.sin6_addr.s6_addr[2] << 8) | addr6.sin6_addr.s6_addr[3];
+            addr6.sin6_addr.s6_addr[2] = 0;
+            addr6.sin6_addr.s6_addr[3] = 0;
+        }
     }
 #endif
 
@@ -1612,8 +1612,8 @@ socket_s_ip_address_list(VALUE self)
 
     ret = ioctl(fd, SIOCGLIFNUM, &ln);
     if (ret == -1) {
-	reason = "SIOCGLIFNUM";
-	goto finish;
+        reason = "SIOCGLIFNUM";
+        goto finish;
     }
 
     memset(&lc, 0, sizeof(lc));
@@ -1624,13 +1624,13 @@ socket_s_ip_address_list(VALUE self)
 
     ret = ioctl(fd, SIOCGLIFCONF, &lc);
     if (ret == -1) {
-	reason = "SIOCGLIFCONF";
-	goto finish;
+        reason = "SIOCGLIFCONF";
+        goto finish;
     }
 
     list = rb_ary_new();
     for (i = 0; i < ln.lifn_count; i++) {
-	struct lifreq *req = &lc.lifc_req[i];
+        struct lifreq *req = &lc.lifc_req[i];
         if (IS_IP_FAMILY(req->lifr_addr.ss_family)) {
             if (req->lifr_addr.ss_family == AF_INET6 &&
                 IN6_IS_ADDR_LINKLOCAL(&((struct sockaddr_in6 *)(&req->lifr_addr))->sin6_addr) &&
@@ -1651,13 +1651,13 @@ socket_s_ip_address_list(VALUE self)
   finish:
     save_errno = errno;
     if (lc.lifc_buf != NULL)
-	xfree(lc.lifc_req);
+        xfree(lc.lifc_req);
     if (fd != -1)
-	close(fd);
+        close(fd);
     errno = save_errno;
 
     if (reason)
-	rb_syserr_fail(save_errno, reason);
+        rb_syserr_fail(save_errno, reason);
     return list;
 
 #elif defined(SIOCGIFCONF)
@@ -1695,17 +1695,17 @@ socket_s_ip_address_list(VALUE self)
     /* fprintf(stderr, "conf.ifc_len: %d\n", conf.ifc_len); */
 
     if (bufsize - EXTRA_SPACE < conf.ifc_len) {
-	if (bufsize < conf.ifc_len) {
-	    /* NetBSD returns required size for all interfaces. */
-	    bufsize = conf.ifc_len + EXTRA_SPACE;
-	}
-	else {
-	    bufsize = bufsize << 1;
-	}
-	if (buf == initbuf)
-	    buf = NULL;
-	buf = xrealloc(buf, bufsize);
-	goto retry;
+        if (bufsize < conf.ifc_len) {
+            /* NetBSD returns required size for all interfaces. */
+            bufsize = conf.ifc_len + EXTRA_SPACE;
+        }
+        else {
+            bufsize = bufsize << 1;
+        }
+        if (buf == initbuf)
+            buf = NULL;
+        buf = xrealloc(buf, bufsize);
+        goto retry;
     }
 
     close(fd);
@@ -1714,10 +1714,10 @@ socket_s_ip_address_list(VALUE self)
     list = rb_ary_new();
     req = conf.ifc_req;
     while ((char*)req < (char*)conf.ifc_req + conf.ifc_len) {
-	struct sockaddr *addr = &req->ifr_addr;
+        struct sockaddr *addr = &req->ifr_addr;
         if (IS_IP_FAMILY(addr->sa_family)) {
-	    rb_ary_push(list, sockaddr_obj(addr, sockaddr_len(addr)));
-	}
+            rb_ary_push(list, sockaddr_obj(addr, sockaddr_len(addr)));
+        }
 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
 # ifndef _SIZEOF_ADDR_IFREQ
 #  define _SIZEOF_ADDR_IFREQ(r) \
@@ -1726,9 +1726,9 @@ socket_s_ip_address_list(VALUE self)
             (r).ifr_addr.sa_len - sizeof(struct sockaddr) : \
             0))
 # endif
-	req = (struct ifreq *)((char*)req + _SIZEOF_ADDR_IFREQ(*req));
+        req = (struct ifreq *)((char*)req + _SIZEOF_ADDR_IFREQ(*req));
 #else
-	req = (struct ifreq *)((char*)req + sizeof(struct ifreq));
+        req = (struct ifreq *)((char*)req + sizeof(struct ifreq));
 #endif
     }
 
@@ -1738,57 +1738,57 @@ socket_s_ip_address_list(VALUE self)
     if (buf != initbuf)
         xfree(buf);
     if (fd != -1)
-	close(fd);
+        close(fd);
     errno = save_errno;
 
     if (reason)
-	rb_syserr_fail(save_errno, reason);
+        rb_syserr_fail(save_errno, reason);
     return list;
 
 #undef EXTRA_SPACE
 #elif defined(_WIN32)
     typedef struct ip_adapter_unicast_address_st {
-	unsigned LONG_LONG dummy0;
-	struct ip_adapter_unicast_address_st *Next;
-	struct {
-	    struct sockaddr *lpSockaddr;
-	    int iSockaddrLength;
-	} Address;
-	int dummy1;
-	int dummy2;
-	int dummy3;
-	long dummy4;
-	long dummy5;
-	long dummy6;
+        unsigned LONG_LONG dummy0;
+        struct ip_adapter_unicast_address_st *Next;
+        struct {
+            struct sockaddr *lpSockaddr;
+            int iSockaddrLength;
+        } Address;
+        int dummy1;
+        int dummy2;
+        int dummy3;
+        long dummy4;
+        long dummy5;
+        long dummy6;
     } ip_adapter_unicast_address_t;
     typedef struct ip_adapter_anycast_address_st {
-	unsigned LONG_LONG dummy0;
-	struct ip_adapter_anycast_address_st *Next;
-	struct {
-	    struct sockaddr *lpSockaddr;
-	    int iSockaddrLength;
-	} Address;
+        unsigned LONG_LONG dummy0;
+        struct ip_adapter_anycast_address_st *Next;
+        struct {
+            struct sockaddr *lpSockaddr;
+            int iSockaddrLength;
+        } Address;
     } ip_adapter_anycast_address_t;
     typedef struct ip_adapter_addresses_st {
-	unsigned LONG_LONG dummy0;
-	struct ip_adapter_addresses_st *Next;
-	void *dummy1;
-	ip_adapter_unicast_address_t *FirstUnicastAddress;
-	ip_adapter_anycast_address_t *FirstAnycastAddress;
-	void *dummy2;
-	void *dummy3;
-	void *dummy4;
-	void *dummy5;
-	void *dummy6;
-	BYTE dummy7[8];
-	DWORD dummy8;
-	DWORD dummy9;
-	DWORD dummy10;
-	DWORD IfType;
-	int OperStatus;
-	DWORD dummy12;
-	DWORD dummy13[16];
-	void *dummy14;
+        unsigned LONG_LONG dummy0;
+        struct ip_adapter_addresses_st *Next;
+        void *dummy1;
+        ip_adapter_unicast_address_t *FirstUnicastAddress;
+        ip_adapter_anycast_address_t *FirstAnycastAddress;
+        void *dummy2;
+        void *dummy3;
+        void *dummy4;
+        void *dummy5;
+        void *dummy6;
+        BYTE dummy7[8];
+        DWORD dummy8;
+        DWORD dummy9;
+        DWORD dummy10;
+        DWORD IfType;
+        int OperStatus;
+        DWORD dummy12;
+        DWORD dummy13[16];
+        void *dummy14;
     } ip_adapter_addresses_t;
     typedef ULONG (WINAPI *GetAdaptersAddresses_t)(ULONG, ULONG, PVOID, ip_adapter_addresses_t *, PULONG);
     HMODULE h;
@@ -1800,49 +1800,49 @@ socket_s_ip_address_list(VALUE self)
 
     h = LoadLibrary("iphlpapi.dll");
     if (!h)
-	rb_notimplement();
+        rb_notimplement();
     pGetAdaptersAddresses = (GetAdaptersAddresses_t)GetProcAddress(h, "GetAdaptersAddresses");
     if (!pGetAdaptersAddresses) {
-	FreeLibrary(h);
-	rb_notimplement();
+        FreeLibrary(h);
+        rb_notimplement();
     }
 
     ret = pGetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &len);
     if (ret != ERROR_SUCCESS && ret != ERROR_BUFFER_OVERFLOW) {
-	errno = rb_w32_map_errno(ret);
-	FreeLibrary(h);
-	rb_sys_fail("GetAdaptersAddresses");
+        errno = rb_w32_map_errno(ret);
+        FreeLibrary(h);
+        rb_sys_fail("GetAdaptersAddresses");
     }
     adapters = (ip_adapter_addresses_t *)ALLOCA_N(BYTE, len);
     ret = pGetAdaptersAddresses(AF_UNSPEC, 0, NULL, adapters, &len);
     if (ret != ERROR_SUCCESS) {
-	errno = rb_w32_map_errno(ret);
-	FreeLibrary(h);
-	rb_sys_fail("GetAdaptersAddresses");
+        errno = rb_w32_map_errno(ret);
+        FreeLibrary(h);
+        rb_sys_fail("GetAdaptersAddresses");
     }
 
     list = rb_ary_new();
     for (; adapters; adapters = adapters->Next) {
-	ip_adapter_unicast_address_t *uni;
-	ip_adapter_anycast_address_t *any;
-	if (adapters->OperStatus != 1)	/* 1 means IfOperStatusUp */
-	    continue;
-	for (uni = adapters->FirstUnicastAddress; uni; uni = uni->Next) {
+        ip_adapter_unicast_address_t *uni;
+        ip_adapter_anycast_address_t *any;
+        if (adapters->OperStatus != 1)	/* 1 means IfOperStatusUp */
+            continue;
+        for (uni = adapters->FirstUnicastAddress; uni; uni = uni->Next) {
 #ifndef INET6
-	    if (uni->Address.lpSockaddr->sa_family == AF_INET)
+            if (uni->Address.lpSockaddr->sa_family == AF_INET)
 #else
-	    if (IS_IP_FAMILY(uni->Address.lpSockaddr->sa_family))
+            if (IS_IP_FAMILY(uni->Address.lpSockaddr->sa_family))
 #endif
-		rb_ary_push(list, sockaddr_obj(uni->Address.lpSockaddr, uni->Address.iSockaddrLength));
-	}
-	for (any = adapters->FirstAnycastAddress; any; any = any->Next) {
+                rb_ary_push(list, sockaddr_obj(uni->Address.lpSockaddr, uni->Address.iSockaddrLength));
+        }
+        for (any = adapters->FirstAnycastAddress; any; any = any->Next) {
 #ifndef INET6
-	    if (any->Address.lpSockaddr->sa_family == AF_INET)
+            if (any->Address.lpSockaddr->sa_family == AF_INET)
 #else
-	    if (IS_IP_FAMILY(any->Address.lpSockaddr->sa_family))
+            if (IS_IP_FAMILY(any->Address.lpSockaddr->sa_family))
 #endif
-		rb_ary_push(list, sockaddr_obj(any->Address.lpSockaddr, any->Address.iSockaddrLength));
-	}
+                rb_ary_push(list, sockaddr_obj(any->Address.lpSockaddr, any->Address.iSockaddrLength));
+        }
     }
 
     FreeLibrary(h);
@@ -1986,7 +1986,7 @@ Init_socket(void)
 
     /* for ext/socket/lib/socket.rb use only: */
     rb_define_private_method(rb_cSocket,
-			     "__connect_nonblock", sock_connect_nonblock, 2);
+                             "__connect_nonblock", sock_connect_nonblock, 2);
 
     rb_define_method(rb_cSocket, "bind", sock_bind, 1);
     rb_define_method(rb_cSocket, "listen", rsock_sock_listen, 1);
@@ -1994,7 +1994,7 @@ Init_socket(void)
 
     /* for ext/socket/lib/socket.rb use only: */
     rb_define_private_method(rb_cSocket,
-			     "__accept_nonblock", sock_accept_nonblock, 1);
+                             "__accept_nonblock", sock_accept_nonblock, 1);
 
     rb_define_method(rb_cSocket, "sysaccept", sock_sysaccept, 0);
 
@@ -2002,7 +2002,7 @@ Init_socket(void)
 
     /* for ext/socket/lib/socket.rb use only: */
     rb_define_private_method(rb_cSocket,
-			     "__recvfrom_nonblock", sock_recvfrom_nonblock, 4);
+                             "__recvfrom_nonblock", sock_recvfrom_nonblock, 4);
 
     rb_define_singleton_method(rb_cSocket, "socketpair", rsock_sock_s_socketpair, -1);
     rb_define_singleton_method(rb_cSocket, "pair", rsock_sock_s_socketpair, -1);
diff --git a/ext/socket/sockssocket.c b/ext/socket/sockssocket.c
index b8b7e12998..f263ac3804 100644
--- a/ext/socket/sockssocket.c
+++ b/ext/socket/sockssocket.c
@@ -30,8 +30,8 @@ socks_init(VALUE sock, VALUE host, VALUE port)
     static int init = 0;
 
     if (init == 0) {
-	SOCKSinit("ruby");
-	init = 1;
+        SOCKSinit("ruby");
+        init = 1;
     }
 
     return rsock_init_inetsock(sock, host, port, Qnil, Qnil, INET_SOCKS, Qnil, Qnil);
diff --git a/ext/socket/tcpserver.c b/ext/socket/tcpserver.c
index 675733c6f9..04e5a0bb51 100644
--- a/ext/socket/tcpserver.c
+++ b/ext/socket/tcpserver.c
@@ -133,7 +133,7 @@ rsock_init_tcpserver(void)
     rb_cTCPServer = rb_define_class("TCPServer", rb_cTCPSocket);
     rb_define_method(rb_cTCPServer, "accept", tcp_accept, 0);
     rb_define_private_method(rb_cTCPServer,
-			     "__accept_nonblock", tcp_accept_nonblock, 1);
+                             "__accept_nonblock", tcp_accept_nonblock, 1);
     rb_define_method(rb_cTCPServer, "sysaccept", tcp_sysaccept, 0);
     rb_define_method(rb_cTCPServer, "initialize", tcp_svr_init, -1);
     rb_define_method(rb_cTCPServer, "listen", rsock_sock_listen, 1); /* in socket.c */
diff --git a/ext/socket/tcpsocket.c b/ext/socket/tcpsocket.c
index 51e77a0de9..03787272f3 100644
--- a/ext/socket/tcpsocket.c
+++ b/ext/socket/tcpsocket.c
@@ -32,22 +32,22 @@ tcp_init(int argc, VALUE *argv, VALUE sock)
     VALUE connect_timeout = Qnil;
 
     if (!keyword_ids[0]) {
-	CONST_ID(keyword_ids[0], "resolv_timeout");
-	CONST_ID(keyword_ids[1], "connect_timeout");
+        CONST_ID(keyword_ids[0], "resolv_timeout");
+        CONST_ID(keyword_ids[1], "connect_timeout");
     }
 
     rb_scan_args(argc, argv, "22:", &remote_host, &remote_serv,
-			&local_host, &local_serv, &opt);
+                        &local_host, &local_serv, &opt);
 
     if (!NIL_P(opt)) {
-	rb_get_kwargs(opt, keyword_ids, 0, 2, kwargs);
-	if (kwargs[0] != Qundef) { resolv_timeout = kwargs[0]; }
-	if (kwargs[1] != Qundef) { connect_timeout = kwargs[1]; }
+        rb_get_kwargs(opt, keyword_ids, 0, 2, kwargs);
+        if (kwargs[0] != Qundef) { resolv_timeout = kwargs[0]; }
+        if (kwargs[1] != Qundef) { connect_timeout = kwargs[1]; }
     }
 
     return rsock_init_inetsock(sock, remote_host, remote_serv,
-			       local_host, local_serv, INET_CLIENT,
-			       resolv_timeout, connect_timeout);
+                               local_host, local_serv, INET_CLIENT,
+                               resolv_timeout, connect_timeout);
 }
 
 static VALUE
@@ -80,7 +80,7 @@ tcp_s_gethostbyname(VALUE obj, VALUE host)
 {
     rb_warn("TCPSocket.gethostbyname is deprecated; use Addrinfo.getaddrinfo instead.");
     struct rb_addrinfo *res =
-	rsock_addrinfo(host, Qnil, AF_UNSPEC, SOCK_STREAM, AI_CANONNAME);
+        rsock_addrinfo(host, Qnil, AF_UNSPEC, SOCK_STREAM, AI_CANONNAME);
     return rsock_make_hostent(host, res, tcp_sockaddr);
 }
 
diff --git a/ext/socket/udpsocket.c b/ext/socket/udpsocket.c
index 2bfd7c8560..3500107972 100644
--- a/ext/socket/udpsocket.c
+++ b/ext/socket/udpsocket.c
@@ -33,11 +33,11 @@ udp_init(int argc, VALUE *argv, VALUE sock)
     int fd;
 
     if (rb_scan_args(argc, argv, "01", &arg) == 1) {
-	family = rsock_family_arg(arg);
+        family = rsock_family_arg(arg);
     }
     fd = rsock_socket(family, SOCK_DGRAM, 0);
     if (fd < 0) {
-	rb_sys_fail("socket(2) - udp");
+        rb_sys_fail("socket(2) - udp");
     }
 
     return rsock_init_sock(sock, fd);
@@ -60,9 +60,9 @@ udp_connect_internal(VALUE v)
     rb_io_check_closed(fptr = arg->fptr);
     fd = fptr->fd;
     for (res = arg->res->ai; res; res = res->ai_next) {
-	if (rsock_connect(fd, res->ai_addr, res->ai_addrlen, 0, NULL) >= 0) {
-	    return Qtrue;
-	}
+        if (rsock_connect(fd, res->ai_addr, res->ai_addrlen, 0, NULL) >= 0) {
+            return Qtrue;
+        }
     }
     return Qfalse;
 }
@@ -92,7 +92,7 @@ udp_connect(VALUE sock, VALUE host, VALUE port)
     GetOpenFile(sock, arg.fptr);
     arg.res = rsock_addrinfo(host, port, rsock_fd_family(arg.fptr->fd), SOCK_DGRAM, 0);
     ret = rb_ensure(udp_connect_internal, (VALUE)&arg,
-		    rsock_freeaddrinfo, (VALUE)arg.res);
+                    rsock_freeaddrinfo, (VALUE)arg.res);
     if (!ret) rsock_sys_fail_host_port("connect(2)", host, port);
     return INT2FIX(0);
 }
@@ -108,10 +108,10 @@ udp_bind_internal(VALUE v)
     rb_io_check_closed(fptr = arg->fptr);
     fd = fptr->fd;
     for (res = arg->res->ai; res; res = res->ai_next) {
-	if (bind(fd, res->ai_addr, res->ai_addrlen) < 0) {
-	    continue;
-	}
-	return Qtrue;
+        if (bind(fd, res->ai_addr, res->ai_addrlen) < 0) {
+            continue;
+        }
+        return Qtrue;
     }
     return Qfalse;
 }
@@ -137,7 +137,7 @@ udp_bind(VALUE sock, VALUE host, VALUE port)
     GetOpenFile(sock, arg.fptr);
     arg.res = rsock_addrinfo(host, port, rsock_fd_family(arg.fptr->fd), SOCK_DGRAM, 0);
     ret = rb_ensure(udp_bind_internal, (VALUE)&arg,
-		    rsock_freeaddrinfo, (VALUE)arg.res);
+                    rsock_freeaddrinfo, (VALUE)arg.res);
     if (!ret) rsock_sys_fail_host_port("bind(2)", host, port);
     return INT2FIX(0);
 }
@@ -207,7 +207,7 @@ udp_send(int argc, VALUE *argv, VALUE sock)
     VALUE ret;
 
     if (argc == 2 || argc == 3) {
-	return rsock_bsock_send(argc, argv, sock);
+        return rsock_bsock_send(argc, argv, sock);
     }
     rb_scan_args(argc, argv, "4", &arg.sarg.mesg, &flags, &host, &port);
 
@@ -217,7 +217,7 @@ udp_send(int argc, VALUE *argv, VALUE sock)
     arg.sarg.flags = NUM2INT(flags);
     arg.res = rsock_addrinfo(host, port, rsock_fd_family(arg.fptr->fd), SOCK_DGRAM, 0);
     ret = rb_ensure(udp_send_internal, (VALUE)&arg,
-		    rsock_freeaddrinfo, (VALUE)arg.res);
+                    rsock_freeaddrinfo, (VALUE)arg.res);
     if (!ret) rsock_sys_fail_host_port("sendto(2)", host, port);
     return ret;
 }
@@ -246,5 +246,5 @@ rsock_init_udpsocket(void)
 
     /* for ext/socket/lib/socket.rb use only: */
     rb_define_private_method(rb_cUDPSocket,
-			     "__recvfrom_nonblock", udp_recvfrom_nonblock, 4);
+                             "__recvfrom_nonblock", udp_recvfrom_nonblock, 4);
 }
diff --git a/ext/socket/unixserver.c b/ext/socket/unixserver.c
index 890f9d3fae..3a899cca1f 100644
--- a/ext/socket/unixserver.c
+++ b/ext/socket/unixserver.c
@@ -66,7 +66,7 @@ unix_accept_nonblock(VALUE sock, VALUE ex)
     GetOpenFile(sock, fptr);
     fromlen = (socklen_t)sizeof(from);
     return rsock_s_accept_nonblock(rb_cUNIXSocket, ex, fptr,
-			           (struct sockaddr *)&from, &fromlen);
+                                   (struct sockaddr *)&from, &fromlen);
 }
 
 /*
@@ -113,7 +113,7 @@ rsock_init_unixserver(void)
     rb_define_method(rb_cUNIXServer, "accept", unix_accept, 0);
 
     rb_define_private_method(rb_cUNIXServer,
-			     "__accept_nonblock", unix_accept_nonblock, 1);
+                             "__accept_nonblock", unix_accept_nonblock, 1);
 
     rb_define_method(rb_cUNIXServer, "sysaccept", unix_sysaccept, 0);
     rb_define_method(rb_cUNIXServer, "listen", rsock_sock_listen, 1); /* in socket.c */
diff --git a/ext/socket/unixsocket.c b/ext/socket/unixsocket.c
index 857cfa6002..ecffbd4e92 100644
--- a/ext/socket/unixsocket.c
+++ b/ext/socket/unixsocket.c
@@ -22,7 +22,7 @@ unixsock_connect_internal(VALUE a)
 {
     struct unixsock_arg *arg = (struct unixsock_arg *)a;
     return (VALUE)rsock_connect(arg->fd, (struct sockaddr*)arg->sockaddr,
-			        arg->sockaddrlen, 0, NULL);
+                                arg->sockaddrlen, 0, NULL);
 }
 
 static VALUE
@@ -66,42 +66,42 @@ rsock_init_unixsock(VALUE sock, VALUE path, int server)
 
     fd = rsock_socket(AF_UNIX, SOCK_STREAM, 0);
     if (fd < 0) {
-	rsock_sys_fail_path("socket(2)", path);
+        rsock_sys_fail_path("socket(2)", path);
     }
 
     if (server) {
         status = bind(fd, (struct sockaddr*)&sockaddr, sockaddrlen);
     }
     else {
-	int prot;
-	struct unixsock_arg arg;
-	arg.sockaddr = &sockaddr;
-	arg.sockaddrlen = sockaddrlen;
-	arg.fd = fd;
+        int prot;
+        struct unixsock_arg arg;
+        arg.sockaddr = &sockaddr;
+        arg.sockaddrlen = sockaddrlen;
+        arg.fd = fd;
         status = (int)rb_protect(unixsock_connect_internal, (VALUE)&arg, &prot);
-	if (prot) {
-	    close(fd);
-	    rb_jump_tag(prot);
-	}
+        if (prot) {
+            close(fd);
+            rb_jump_tag(prot);
+        }
     }
 
     if (status < 0) {
-	int e = errno;
-	close(fd);
-	rsock_syserr_fail_path(e, "connect(2)", path);
+        int e = errno;
+        close(fd);
+        rsock_syserr_fail_path(e, "connect(2)", path);
     }
 
     if (server) {
-	if (listen(fd, SOMAXCONN) < 0) {
-	    int e = errno;
-	    close(fd);
-	    rsock_syserr_fail_path(e, "listen(2)", path);
-	}
+        if (listen(fd, SOMAXCONN) < 0) {
+            int e = errno;
+            close(fd);
+            rsock_syserr_fail_path(e, "listen(2)", path);
+        }
     }
 
     rsock_init_sock(sock, fd);
     if (server) {
-	GetOpenFile(sock, fptr);
+        GetOpenFile(sock, fptr);
         fptr->pathv = rb_str_new_frozen(path);
     }
 
@@ -143,13 +143,13 @@ unix_path(VALUE sock)
 
     GetOpenFile(sock, fptr);
     if (NIL_P(fptr->pathv)) {
-	struct sockaddr_un addr;
-	socklen_t len = (socklen_t)sizeof(addr);
-	socklen_t len0 = len;
-	if (getsockname(fptr->fd, (struct sockaddr*)&addr, &len) < 0)
+        struct sockaddr_un addr;
+        socklen_t len = (socklen_t)sizeof(addr);
+        socklen_t len0 = len;
+        if (getsockname(fptr->fd, (struct sockaddr*)&addr, &len) < 0)
             rsock_sys_fail_path("getsockname(2)", fptr->pathv);
         if (len0 < len) len = len0;
-	fptr->pathv = rb_obj_freeze(rsock_unixpath_str(&addr, len));
+        fptr->pathv = rb_obj_freeze(rsock_unixpath_str(&addr, len));
     }
     return rb_str_dup(fptr->pathv);
 }
@@ -240,21 +240,21 @@ unix_send_io(VALUE sock, VALUE val)
 
 #if FD_PASSING_BY_MSG_CONTROL
     union {
-	struct cmsghdr hdr;
-	char pad[sizeof(struct cmsghdr)+8+sizeof(int)+8];
+        struct cmsghdr hdr;
+        char pad[sizeof(struct cmsghdr)+8+sizeof(int)+8];
     } cmsg;
 #endif
 
     if (rb_obj_is_kind_of(val, rb_cIO)) {
         rb_io_t *valfptr;
-	GetOpenFile(val, valfptr);
-	fd = valfptr->fd;
+        GetOpenFile(val, valfptr);
+        fd = valfptr->fd;
     }
     else if (FIXNUM_P(val)) {
         fd = FIX2INT(val);
     }
     else {
-	rb_raise(rb_eTypeError, "neither IO nor file descriptor");
+        rb_raise(rb_eTypeError, "neither IO nor file descriptor");
     }
 
     GetOpenFile(sock, fptr);
@@ -285,8 +285,8 @@ unix_send_io(VALUE sock, VALUE val)
 
     arg.fd = fptr->fd;
     while ((int)BLOCKING_REGION_FD(sendmsg_blocking, &arg) == -1) {
-	if (!rb_io_wait_writable(arg.fd))
-	    rsock_sys_fail_path("sendmsg(2)", fptr->pathv);
+        if (!rb_io_wait_writable(arg.fd))
+            rsock_sys_fail_path("sendmsg(2)", fptr->pathv);
     }
 
     return Qnil;
@@ -348,16 +348,16 @@ unix_recv_io(int argc, VALUE *argv, VALUE sock)
     int fd;
 #if FD_PASSING_BY_MSG_CONTROL
     union {
-	struct cmsghdr hdr;
-	char pad[sizeof(struct cmsghdr)+8+sizeof(int)+8];
+        struct cmsghdr hdr;
+        char pad[sizeof(struct cmsghdr)+8+sizeof(int)+8];
     } cmsg;
 #endif
 
     rb_scan_args(argc, argv, "02", &klass, &mode);
     if (argc == 0)
-	klass = rb_cIO;
+        klass = rb_cIO;
     if (argc <= 1)
-	mode = Qnil;
+        mode = Qnil;
 
 retry:
     GetOpenFile(sock, fptr);
@@ -400,8 +400,8 @@ retry:
             rb_gc_for_fd(e);
             goto retry;
         }
-	if (!rb_io_wait_readable(arg.fd))
-	    rsock_syserr_fail_path(e, "recvmsg(2)", fptr->pathv);
+        if (!rb_io_wait_readable(arg.fd))
+            rsock_syserr_fail_path(e, "recvmsg(2)", fptr->pathv);
     }
 
 #if FD_PASSING_BY_MSG_CONTROL
@@ -412,41 +412,41 @@ retry:
             rb_gc_for_fd(EMFILE);
             goto retry;
         }
-	rb_raise(rb_eSocket,
-		 "file descriptor was not passed (msg_controllen=%d smaller than sizeof(struct cmsghdr)=%d)",
-		 (int)arg.msg.msg_controllen, (int)sizeof(struct cmsghdr));
+        rb_raise(rb_eSocket,
+                 "file descriptor was not passed (msg_controllen=%d smaller than sizeof(struct cmsghdr)=%d)",
+                 (int)arg.msg.msg_controllen, (int)sizeof(struct cmsghdr));
     }
     if (cmsg.hdr.cmsg_level != SOL_SOCKET) {
-	rb_raise(rb_eSocket,
-		 "file descriptor was not passed (cmsg_level=%d, %d expected)",
-		 cmsg.hdr.cmsg_level, SOL_SOCKET);
+        rb_raise(rb_eSocket,
+                 "file descriptor was not passed (cmsg_level=%d, %d expected)",
+                 cmsg.hdr.cmsg_level, SOL_SOCKET);
     }
     if (cmsg.hdr.cmsg_type != SCM_RIGHTS) {
-	rb_raise(rb_eSocket,
-		 "file descriptor was not passed (cmsg_type=%d, %d expected)",
-		 cmsg.hdr.cmsg_type, SCM_RIGHTS);
+        rb_raise(rb_eSocket,
+                 "file descriptor was not passed (cmsg_type=%d, %d expected)",
+                 cmsg.hdr.cmsg_type, SCM_RIGHTS);
     }
     if (arg.msg.msg_controllen < (socklen_t)CMSG_LEN(sizeof(int))) {
-	rb_raise(rb_eSocket,
-		 "file descriptor was not passed (msg_controllen=%d smaller than CMSG_LEN(sizeof(int))=%d)",
-		 (int)arg.msg.msg_controllen, (int)CMSG_LEN(sizeof(int)));
+        rb_raise(rb_eSocket,
+                 "file descriptor was not passed (msg_controllen=%d smaller than CMSG_LEN(sizeof(int))=%d)",
+                 (int)arg.msg.msg_controllen, (int)CMSG_LEN(sizeof(int)));
     }
     if ((socklen_t)CMSG_SPACE(sizeof(int)) < arg.msg.msg_controllen) {
-	rb_raise(rb_eSocket,
-		 "file descriptor was not passed (msg_controllen=%d bigger than CMSG_SPACE(sizeof(int))=%d)",
-		 (int)arg.msg.msg_controllen, (int)CMSG_SPACE(sizeof(int)));
+        rb_raise(rb_eSocket,
+                 "file descriptor was not passed (msg_controllen=%d bigger than CMSG_SPACE(sizeof(int))=%d)",
+                 (int)arg.msg.msg_controllen, (int)CMSG_SPACE(sizeof(int)));
     }
     if (cmsg.hdr.cmsg_len != CMSG_LEN(sizeof(int))) {
-	rsock_discard_cmsg_resource(&arg.msg, 0);
-	rb_raise(rb_eSocket,
-		 "file descriptor was not passed (cmsg_len=%d, %d expected)",
-		 (int)cmsg.hdr.cmsg_len, (int)CMSG_LEN(sizeof(int)));
+        rsock_discard_cmsg_resource(&arg.msg, 0);
+        rb_raise(rb_eSocket,
+                 "file descriptor was not passed (cmsg_len=%d, %d expected)",
+                 (int)cmsg.hdr.cmsg_len, (int)CMSG_LEN(sizeof(int)));
     }
 #else
     if (arg.msg.msg_accrightslen != sizeof(fd)) {
-	rb_raise(rb_eSocket,
-		 "file descriptor was not passed (accrightslen=%d, %d expected)",
-		 arg.msg.msg_accrightslen, (int)sizeof(fd));
+        rb_raise(rb_eSocket,
+                 "file descriptor was not passed (accrightslen=%d, %d expected)",
+                 arg.msg.msg_accrightslen, (int)sizeof(fd));
     }
 #endif
 
@@ -458,15 +458,15 @@ retry:
     rb_maygvl_fd_fix_cloexec(fd);
 
     if (klass == Qnil)
-	return INT2FIX(fd);
+        return INT2FIX(fd);
     else {
-	ID for_fd;
-	int ff_argc;
-	VALUE ff_argv[2];
-	CONST_ID(for_fd, "for_fd");
-	ff_argc = mode == Qnil ? 1 : 2;
-	ff_argv[0] = INT2FIX(fd);
-	ff_argv[1] = mode;
+        ID for_fd;
+        int ff_argc;
+        VALUE ff_argv[2];
+        CONST_ID(for_fd, "for_fd");
+        ff_argc = mode == Qnil ? 1 : 2;
+        ff_argv[0] = INT2FIX(fd);
+        ff_argv[1] = mode;
         return rb_funcallv(klass, for_fd, ff_argc, ff_argv);
     }
 }
@@ -556,9 +556,9 @@ unix_s_socketpair(int argc, VALUE *argv, VALUE klass)
     domain = INT2FIX(PF_UNIX);
     rb_scan_args(argc, argv, "02", &type, &protocol);
     if (argc == 0)
-	type = INT2FIX(SOCK_STREAM);
+        type = INT2FIX(SOCK_STREAM);
     if (argc <= 1)
-	protocol = INT2FIX(0);
+        protocol = INT2FIX(0);
 
     args[0] = domain;
     args[1] = type;