diff --git a/lib/libgfarm/gfarm/config.c b/lib/libgfarm/gfarm/config.c
index 7669437..bfb1f9f 100644
--- a/lib/libgfarm/gfarm/config.c
+++ b/lib/libgfarm/gfarm/config.c
@@ -1056,7 +1056,8 @@ int gfarm_iostat_max_client = GFARM_CONFIG_MISC_DEFAULT;
 #define GFARM_METADB_SERVER_NFS_ROOT_SQUASH_SUPPORT_DEFAULT	1 /* enable */
 #define GFARM_METADB_SERVER_LONG_TERM_LOCK_TYPE_DEFAULT	\
 	GFARM_LOCK_TYPE_TICKETLOCK
-#define GFARM_NETWORK_RECEIVE_TIMEOUT_DEFAULT  60 /* 60 seconds */
+#define GFARM_NETWORK_RECEIVE_TIMEOUT_DEFAULT	60 /* 60 seconds */
+#define GFARM_NETWORK_SEND_TIMEOUT_DEFAULT	0 /* seconds (disabled) */
 #define GFARM_FILE_TRACE_DEFAULT 0 /* disable */
 #define GFARM_FATAL_ACTION_DEFAULT GFLOG_FATAL_ACTION_ABORT_BACKTRACE
 #ifdef HAVE_INFINIBAND
@@ -3625,6 +3626,8 @@ parse_one_line(const char *s, char *p,
 		e = parse_set_misc_enabled(p, &metadb_server_force_slave);
 	} else if (strcmp(s, o = "network_receive_timeout") == 0) {
 		e = parse_set_misc_int(p, &gfarm_ctxp->network_receive_timeout);
+	} else if (strcmp(s, o = "network_send_timeout") == 0) {
+		e = parse_set_misc_int(p, &gfarm_ctxp->network_send_timeout);
 	} else if (strcmp(s, o = "file_trace") == 0) {
 		e = parse_set_misc_enabled(p, &gfarm_ctxp->file_trace);
 	} else if (strcmp(s, o = "debug_command") == 0) {
@@ -4034,6 +4037,9 @@ gfarm_config_set_default_misc(void)
 	if (gfarm_ctxp->network_receive_timeout == GFARM_CONFIG_MISC_DEFAULT)
 		gfarm_ctxp->network_receive_timeout =
 		    GFARM_NETWORK_RECEIVE_TIMEOUT_DEFAULT;
+	if (gfarm_ctxp->network_send_timeout == GFARM_CONFIG_MISC_DEFAULT)
+		gfarm_ctxp->network_send_timeout =
+		    GFARM_NETWORK_SEND_TIMEOUT_DEFAULT;
 	if (gfarm_ctxp->file_trace == GFARM_CONFIG_MISC_DEFAULT)
 		gfarm_ctxp->file_trace = GFARM_FILE_TRACE_DEFAULT;
 	if (gfarm_ctxp->fatal_action == GFARM_CONFIG_MISC_DEFAULT)
diff --git a/lib/libgfarm/gfarm/config.h b/lib/libgfarm/gfarm/config.h
index 2b589ce..a0f469a 100644
--- a/lib/libgfarm/gfarm/config.h
+++ b/lib/libgfarm/gfarm/config.h
@@ -230,7 +230,6 @@ gfarm_error_t gfm_client_config_get_vars_result(struct gfm_connection *,
 	int, void **);
 
 /* miscellaneous */
-extern int gfarm_network_receive_timeout;
 extern int gfarm_file_trace;
 
 void gfarm_config_set_filename(char *);
diff --git a/lib/libgfarm/gfarm/context.c b/lib/libgfarm/gfarm/context.c
index 5b8272e..085e41a 100644
--- a/lib/libgfarm/gfarm/context.c
+++ b/lib/libgfarm/gfarm/context.c
@@ -156,6 +156,7 @@ gfarm_context_init(void)
 	ctxp->client_parallel_copy = GFARM_CONFIG_MISC_DEFAULT;
 	ctxp->client_parallel_max = GFARM_CONFIG_MISC_DEFAULT;
 	ctxp->network_receive_timeout = GFARM_CONFIG_MISC_DEFAULT;
+	ctxp->network_send_timeout = GFARM_CONFIG_MISC_DEFAULT;
 	ctxp->file_trace = GFARM_CONFIG_MISC_DEFAULT;
 	ctxp->ib_rdma = GFARM_CONFIG_MISC_DEFAULT;
 	ctxp->rdma_min_size = GFARM_CONFIG_MISC_DEFAULT;
diff --git a/lib/libgfarm/gfarm/context.h b/lib/libgfarm/gfarm/context.h
index c085c8d..da135c2 100644
--- a/lib/libgfarm/gfarm/context.h
+++ b/lib/libgfarm/gfarm/context.h
@@ -39,6 +39,7 @@ struct gfarm_context {
 	int on_demand_replication;
 	int call_rpc_instead_syscall;
 	int network_receive_timeout;
+	int network_send_timeout;
 	int file_trace;
 	int fatal_action;
 	int ib_rdma;
diff --git a/lib/libgfarm/gfarm/gfm_client.c b/lib/libgfarm/gfarm/gfm_client.c
index a599fb3..b4833a2 100644
--- a/lib/libgfarm/gfarm/gfm_client.c
+++ b/lib/libgfarm/gfarm/gfm_client.c
@@ -1048,7 +1048,7 @@ gfm_client_xdr_send(struct gfm_connection *gfm_server, const char *format, ...)
 	gfarm_error_t e;
 
 	va_start(ap, format);
-	e = gfp_xdr_vsend(gfm_server->conn, &format, &ap);
+	e = gfp_xdr_vsend(gfm_server->conn, 1, &format, &ap); /* do timeout */
 	va_end(ap);
 
 	check_connection_or_purge(gfm_server, e);
diff --git a/lib/libgfarm/gfarm/gfp_xdr.c b/lib/libgfarm/gfarm/gfp_xdr.c
index 749bb99..a9cbc4d 100644
--- a/lib/libgfarm/gfarm/gfp_xdr.c
+++ b/lib/libgfarm/gfarm/gfp_xdr.c
@@ -64,9 +64,12 @@ gfp_xdr_set(struct gfp_xdr *conn,
 		gfarm_iobuffer_set_read_notimeout(conn->recvbuffer,
 		    ops->blocking_read_notimeout, cookie, fd);
 	}
-	if (conn->sendbuffer)
-		gfarm_iobuffer_set_write(conn->sendbuffer, ops->blocking_write,
-		    cookie, fd);
+	if (conn->sendbuffer) {
+		gfarm_iobuffer_set_write_timeout(conn->sendbuffer,
+		    ops->blocking_write_timeout, cookie, fd);
+		gfarm_iobuffer_set_write_notimeout(conn->sendbuffer,
+		    ops->blocking_write_notimeout, cookie, fd);
+	}
 }
 
 #define GFP_XDR_NEW_RECV	1
@@ -210,7 +213,16 @@ gfp_xdr_flush(struct gfp_xdr *conn)
 {
 	if (conn->sendbuffer == NULL)
 		return (GFARM_ERR_NO_ERROR);
-	gfarm_iobuffer_flush_write(conn->sendbuffer);
+	gfarm_iobuffer_flush_write(conn->sendbuffer, 1);
+	return (gfarm_iobuffer_get_error(conn->sendbuffer));
+}
+
+gfarm_error_t
+gfp_xdr_flush_notimeout(struct gfp_xdr *conn)
+{
+	if (conn->sendbuffer == NULL)
+		return (GFARM_ERR_NO_ERROR);
+	gfarm_iobuffer_flush_write(conn->sendbuffer, 0);
 	return (gfarm_iobuffer_get_error(conn->sendbuffer));
 }
 
@@ -357,7 +369,7 @@ gfp_xdr_vsend_size_add(size_t *sizep, const char **formatp, va_list *app)
 }
 
 gfarm_error_t
-gfp_xdr_vsend(struct gfp_xdr *conn,
+gfp_xdr_vsend(struct gfp_xdr *conn, int do_timeout,
 	const char **formatp, va_list *app)
 {
 	const char *format = *formatp;
@@ -384,19 +396,19 @@ gfp_xdr_vsend(struct gfp_xdr *conn,
 		case 'c':
 			c = va_arg(*app, int);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    &c, sizeof(c));
+			    &c, sizeof(c), do_timeout);
 			continue;
 		case 'h':
 			h = va_arg(*app, int);
 			h = htons(h);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    &h, sizeof(h));
+			    &h, sizeof(h), do_timeout);
 			continue;
 		case 'i':
 			i = va_arg(*app, gfarm_int32_t);
 			i = htonl(i);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    &i, sizeof(i));
+			    &i, sizeof(i), do_timeout);
 			continue;
 		case 'l':
 			/*
@@ -424,25 +436,25 @@ gfp_xdr_vsend(struct gfp_xdr *conn,
 			lv[0] = htonl(lv[0]);
 			lv[1] = htonl(lv[1]);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    lv, sizeof(lv));
+			    lv, sizeof(lv), do_timeout);
 			continue;
 		case 's':
 			s = va_arg(*app, const char *);
 			n = strlen(s);
 			i = htonl(n);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    &i, sizeof(i));
+			    &i, sizeof(i), do_timeout);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    s, n);
+			    s, n, do_timeout);
 			continue;
 		case 'S':
 			s = va_arg(*app, const char *);
 			n = va_arg(*app, size_t);
 			i = htonl(n);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    &i, sizeof(i));
+			    &i, sizeof(i), do_timeout);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    s, n);
+			    s, n, do_timeout);
 			continue;
 		case 'b':
 			/*
@@ -454,15 +466,15 @@ gfp_xdr_vsend(struct gfp_xdr *conn,
 			i = htonl(n);
 			s = va_arg(*app, const char *);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    &i, sizeof(i));
+			    &i, sizeof(i), do_timeout);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    s, n);
+			    s, n, do_timeout);
 			continue;
 		case 'r':
 			n = va_arg(*app, size_t);
 			s = va_arg(*app, const char *);
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    s, n);
+			    s, n, do_timeout);
 			continue;
 		case 'f':
 #ifndef __KERNEL__	/* double */
@@ -472,7 +484,7 @@ gfp_xdr_vsend(struct gfp_xdr *conn,
 			swab(&d, &nd, sizeof(nd));
 #endif
 			gfarm_iobuffer_put_write(conn->sendbuffer,
-			    &nd, sizeof(nd));
+			    &nd, sizeof(nd), do_timeout);
 			continue;
 #else /* __KERNEL__ */
 			gflog_fatal(GFARM_MSG_1003868,
@@ -902,7 +914,7 @@ gfp_xdr_send(struct gfp_xdr *conn, const char *format, ...)
 	gfarm_error_t e;
 
 	va_start(ap, format);
-	e = gfp_xdr_vsend(conn, &format, &ap);
+	e = gfp_xdr_vsend(conn, 1, &format, &ap); /* do timeout */
 	va_end(ap);
 
 	if (e != GFARM_ERR_NO_ERROR) {
@@ -919,6 +931,30 @@ gfp_xdr_send(struct gfp_xdr *conn, const char *format, ...)
 	return (GFARM_ERR_NO_ERROR);
 }
 
+gfarm_error_t
+gfp_xdr_send_notimeout(struct gfp_xdr *conn, const char *format, ...)
+{
+	va_list ap;
+	gfarm_error_t e;
+
+	va_start(ap, format);
+	e = gfp_xdr_vsend(conn, 0, &format, &ap); /* notimeout */
+	va_end(ap);
+
+	if (e != GFARM_ERR_NO_ERROR) {
+		gflog_debug(GFARM_MSG_UNFIXED,
+			"gfp_xdr_vsend_notimeout() failed: %s",
+			gfarm_error_string(e));
+		return (e);
+	}
+	if (*format != '\0') {
+		gflog_debug(GFARM_MSG_UNFIXED, "gfp_xdr_send_size: "
+		    "invalid format character: %c(%x)", *format, *format);
+		return (GFARM_ERRMSG_GFP_XDR_SEND_INVALID_FORMAT_CHARACTER);
+	}
+	return (GFARM_ERR_NO_ERROR);
+}
+
 gfarm_uint32_t
 gfp_xdr_send_calc_crc32(struct gfp_xdr *conn, gfarm_uint32_t crc, int offset,
 	size_t length)
@@ -1042,7 +1078,7 @@ gfp_xdr_vrpc_request(struct gfp_xdr *conn, gfarm_int32_t command,
 	/*
 	 * send request
 	 */
-	e = gfp_xdr_send(conn, "i", command);
+	e = gfp_xdr_send(conn, "i", command); /* do timeout */
 	if (e != GFARM_ERR_NO_ERROR) {
 		gflog_debug(GFARM_MSG_1001009,
 			"sending command (%d) failed: %s",
@@ -1050,7 +1086,27 @@ gfp_xdr_vrpc_request(struct gfp_xdr *conn, gfarm_int32_t command,
 			gfarm_error_string(e));
 		return (e);
 	}
-	return (gfp_xdr_vsend(conn, formatp, app));
+	return (gfp_xdr_vsend(conn, 1, formatp, app)); /* do timeout */
+}
+
+gfarm_error_t
+gfp_xdr_vrpc_request_notimeout(struct gfp_xdr *conn, gfarm_int32_t command,
+	const char **formatp, va_list *app)
+{
+	gfarm_error_t e;
+
+	/*
+	 * send request
+	 */
+	e = gfp_xdr_send_notimeout(conn, "i", command);
+	if (e != GFARM_ERR_NO_ERROR) {
+		gflog_debug(GFARM_MSG_UNFIXED,
+			"sending command (%d) failed: %s",
+			command,
+			gfarm_error_string(e));
+		return (e);
+	}
+	return (gfp_xdr_vsend(conn, 0, formatp, app)); /* notimeout */
 }
 
 /*
diff --git a/lib/libgfarm/gfarm/gfp_xdr.h b/lib/libgfarm/gfarm/gfp_xdr.h
index e6b7a8a..f234fd4 100644
--- a/lib/libgfarm/gfarm/gfp_xdr.h
+++ b/lib/libgfarm/gfarm/gfp_xdr.h
@@ -10,7 +10,9 @@ struct gfp_iobuffer_ops {
 	    void *, int);
 	int (*blocking_read_notimeout)(struct gfarm_iobuffer *, void *, int,
 	    void *, int);
-	int (*blocking_write)(struct gfarm_iobuffer *, void *, int,
+	int (*blocking_write_timeout)(struct gfarm_iobuffer *, void *, int,
+	    void *, int);
+	int (*blocking_write_notimeout)(struct gfarm_iobuffer *, void *, int,
 	    void *, int);
 };
 
@@ -59,10 +61,11 @@ void gfarm_iobuffer_set_nonblocking_write_xxx(struct gfarm_iobuffer *,
 int gfp_xdr_recv_is_ready(struct gfp_xdr *);
 int gfp_xdr_is_empty(struct gfp_xdr *);
 gfarm_error_t gfp_xdr_flush(struct gfp_xdr *);
+gfarm_error_t gfp_xdr_flush_notimeout(struct gfp_xdr *);
 gfarm_error_t gfp_xdr_purge(struct gfp_xdr *, int, int);
 void gfp_xdr_purge_all(struct gfp_xdr *);
 gfarm_error_t gfp_xdr_vsend_size_add(size_t *, const char **, va_list *);
-gfarm_error_t gfp_xdr_vsend(struct gfp_xdr *,
+gfarm_error_t gfp_xdr_vsend(struct gfp_xdr *, int,
 	const char **, va_list *);
 gfarm_error_t gfp_xdr_vrecv_sized_x(struct gfp_xdr *, int, int, size_t *,
 	int *, const char **, va_list *);
@@ -73,6 +76,7 @@ gfarm_error_t gfp_xdr_vrecv(struct gfp_xdr *, int, int,
 
 gfarm_error_t gfp_xdr_send_size_add(size_t *, const char *, ...);
 gfarm_error_t gfp_xdr_send(struct gfp_xdr *, const char *, ...);
+gfarm_error_t gfp_xdr_send_notimeout(struct gfp_xdr *, const char *, ...);
 gfarm_uint32_t gfp_xdr_send_calc_crc32(struct gfp_xdr *, gfarm_uint32_t,
 	int, size_t);
 gfarm_error_t gfp_xdr_recv_sized(struct gfp_xdr *, int, int, size_t *,
@@ -87,6 +91,8 @@ gfarm_uint32_t gfp_xdr_recv_get_crc32_ahead(struct gfp_xdr *, int);
 gfarm_error_t gfp_xdr_recv_ahead(struct gfp_xdr *, int, size_t *);
 gfarm_error_t gfp_xdr_vrpc_request(struct gfp_xdr *, gfarm_int32_t,
 	const char **, va_list *);
+gfarm_error_t gfp_xdr_vrpc_request_notimeout(struct gfp_xdr *, gfarm_int32_t,
+	const char **, va_list *);
 gfarm_error_t gfp_xdr_vrpc_result_sized(struct gfp_xdr *, int, size_t *,
 	gfarm_int32_t *, const char **, va_list *);
 gfarm_error_t gfp_xdr_vrpc_result(struct gfp_xdr *, int, int,
@@ -111,7 +117,7 @@ void gfp_xdr_async_peer_free(gfp_xdr_async_peer_t, void *);
 
 gfarm_error_t gfp_xdr_callback_async_result(gfp_xdr_async_peer_t,
 	void *, gfp_xdr_xid_t, size_t, gfarm_int32_t *);
-gfarm_error_t gfp_xdr_vsend_async_request(struct gfp_xdr *,
+gfarm_error_t gfp_xdr_vsend_async_request_notimeout(struct gfp_xdr *,
 	gfp_xdr_async_peer_t,
 	result_callback_t, disconnect_callback_t, void *,
 	gfarm_int32_t, const char *, va_list *);
@@ -122,10 +128,10 @@ gfarm_error_t gfp_xdr_recv_request_command(struct gfp_xdr *, int, size_t *,
 	gfarm_int32_t *);
 gfarm_error_t gfp_xdr_vrecv_request_parameters(struct gfp_xdr *, int, size_t *,
 	const char *, va_list *);
-gfarm_error_t gfp_xdr_vsend_result(struct gfp_xdr *,
-	gfarm_int32_t, const char *, va_list *);
-gfarm_error_t gfp_xdr_vsend_async_result(struct gfp_xdr *, gfp_xdr_xid_t,
+gfarm_error_t gfp_xdr_vsend_result(struct gfp_xdr *, int,
 	gfarm_int32_t, const char *, va_list *);
+gfarm_error_t gfp_xdr_vsend_async_result_notimeout(struct gfp_xdr *,
+	gfp_xdr_xid_t, gfarm_int32_t, const char *, va_list *);
 void gfp_xdr_begin_sendbuffer_pindown(struct gfp_xdr *);
 void gfp_xdr_end_sendbuffer_pindown(struct gfp_xdr *);
 
diff --git a/lib/libgfarm/gfarm/gfp_xdr_server.c b/lib/libgfarm/gfarm/gfp_xdr_server.c
index dce1bb6..2879422 100644
--- a/lib/libgfarm/gfarm/gfp_xdr_server.c
+++ b/lib/libgfarm/gfarm/gfp_xdr_server.c
@@ -142,7 +142,8 @@ gfp_xdr_send_async_request_header(struct gfp_xdr *server,
 
 	xid_and_type = (xid | XID_TYPE_REQUEST);
 #define ASYNC_REQUEST_HEADER_SIZE	(4+4)	/* size of "ii" */
-	e = gfp_xdr_send(server, "ii", xid_and_type, (gfarm_int32_t)size);
+	e = gfp_xdr_send_notimeout(server, "ii",
+	    xid_and_type, (gfarm_int32_t)size);
 	if (e != GFARM_ERR_NO_ERROR) {
 		gfp_xdr_send_async_request_error(async_server, xid, diag);
 		return (e);
@@ -151,9 +152,9 @@ gfp_xdr_send_async_request_header(struct gfp_xdr *server,
 	return (GFARM_ERR_NO_ERROR);
 }
 
-/* this does gfp_xdr_flush() too, for freeing xid in an error case */
+/* this does gfp_xdr_flush_notimeout() too, for freeing xid in an error case */
 static gfarm_error_t
-gfp_xdr_vsend_async_request_internal(struct gfp_xdr *server,
+gfp_xdr_vsend_async_request_notimeout_internal(struct gfp_xdr *server,
 	gfp_xdr_async_peer_t async_server,
 	result_callback_t result_callback,
 	disconnect_callback_t disconnect_callback,
@@ -186,7 +187,7 @@ gfp_xdr_vsend_async_request_internal(struct gfp_xdr *server,
 	    result_callback, disconnect_callback, closure, &xid);
 	if (e != GFARM_ERR_NO_ERROR)
 		return (e);
-	e = gfp_xdr_vrpc_request(server, command, &format, app);
+	e = gfp_xdr_vrpc_request_notimeout(server, command, &format, app);
 	if (e != GFARM_ERR_NO_ERROR) {
 		gfp_xdr_send_async_request_error(async_server, xid,
 		    "gfp_xdr_vrpc_request");
@@ -196,7 +197,7 @@ gfp_xdr_vsend_async_request_internal(struct gfp_xdr *server,
 		gflog_fatal(GFARM_MSG_1001016, "gfp_xdr_vsend_async_request: "
 		    "invalid format character: %c(%x)", *format, *format);
 
-	e = gfp_xdr_flush(server);
+	e = gfp_xdr_flush_notimeout(server);
 	if (e != GFARM_ERR_NO_ERROR) {
 		gfp_xdr_send_async_request_error(async_server, xid,
 		    "gfp_xdr_flush");
@@ -207,27 +208,27 @@ gfp_xdr_vsend_async_request_internal(struct gfp_xdr *server,
 }
 
 gfarm_error_t
-gfp_xdr_vsend_async_nonblocking_request(struct gfp_xdr *server,
+gfp_xdr_vsend_async_nonblocking_request_notimeout(struct gfp_xdr *server,
 	gfp_xdr_async_peer_t async_server,
 	result_callback_t result_callback,
 	disconnect_callback_t disconnect_callback,
 	void *closure,
 	gfarm_int32_t command, const char *format, va_list *app)
 {
-	return (gfp_xdr_vsend_async_request_internal(server,
+	return (gfp_xdr_vsend_async_request_notimeout_internal(server,
 	    async_server, result_callback, disconnect_callback, closure, 1,
 	    command, format, app));
 }
 
 gfarm_error_t
-gfp_xdr_vsend_async_request(struct gfp_xdr *server,
+gfp_xdr_vsend_async_request_notimeout(struct gfp_xdr *server,
 	gfp_xdr_async_peer_t async_server,
 	result_callback_t result_callback,
 	disconnect_callback_t disconnect_callback,
 	void *closure,
 	gfarm_int32_t command, const char *format, va_list *app)
 {
-	return (gfp_xdr_vsend_async_request_internal(server,
+	return (gfp_xdr_vsend_async_request_notimeout_internal(server,
 	    async_server, result_callback, disconnect_callback, closure, 0,
 	    command, format, app));
 }
@@ -262,11 +263,11 @@ gfp_xdr_recv_async_header(struct gfp_xdr *conn, int just,
  */
 
 static gfarm_error_t
-gfp_xdr_send_async_result_header(struct gfp_xdr *server,
+gfp_xdr_send_async_result_header_notimeout(struct gfp_xdr *server,
 	gfarm_int32_t xid, size_t size)
 {
 	xid = (xid | XID_TYPE_RESULT);
-	return (gfp_xdr_send(server, "ii", xid, (gfarm_int32_t)size));
+	return (gfp_xdr_send_notimeout(server, "ii", xid, (gfarm_int32_t)size));
 }
 
 /*
@@ -327,18 +328,19 @@ gfp_xdr_vrecv_request_parameters(struct gfp_xdr *client, int just,
 	return (GFARM_ERR_NO_ERROR);
 }
 
-/* the caller should call gfp_xdr_flush() after this function */
+/* the caller should call gfp_xdr_flush{,_notimeout}() after this function */
 gfarm_error_t
-gfp_xdr_vsend_result(struct gfp_xdr *client,
+gfp_xdr_vsend_result(struct gfp_xdr *client, int do_timeout,
 	gfarm_int32_t ecode, const char *format, va_list *app)
 {
 	gfarm_error_t e;
 
-	e = gfp_xdr_send(client, "i", ecode);
+	e = (*(do_timeout ? gfp_xdr_send : gfp_xdr_send_notimeout))(
+	    client, "i", ecode);
 	if (e != GFARM_ERR_NO_ERROR)
 		return (e);
 	if (ecode == GFARM_ERR_NO_ERROR) {
-		e = gfp_xdr_vsend(client, &format, app);
+		e = gfp_xdr_vsend(client, do_timeout, &format, app);
 		if (e != GFARM_ERR_NO_ERROR)
 			return (e);
 		if (*format != '\0') {
@@ -353,7 +355,7 @@ gfp_xdr_vsend_result(struct gfp_xdr *client,
 
 /* used by asynchronous protocol */
 gfarm_error_t
-gfp_xdr_vsend_async_result(struct gfp_xdr *client, gfp_xdr_xid_t xid,
+gfp_xdr_vsend_async_result_notimeout(struct gfp_xdr *client, gfp_xdr_xid_t xid,
 	gfarm_int32_t ecode, const char *format, va_list *app)
 {
 	gfarm_error_t e;
@@ -373,8 +375,9 @@ gfp_xdr_vsend_async_result(struct gfp_xdr *client, gfp_xdr_xid_t xid,
 		if (e != GFARM_ERR_NO_ERROR)
 			return (e);
 	}
-	e = gfp_xdr_send_async_result_header(client, xid, size);
+	e = gfp_xdr_send_async_result_header_notimeout(client, xid, size);
 	if (e != GFARM_ERR_NO_ERROR)
 		return (e);
-	return (gfp_xdr_vsend_result(client, ecode, format, app));
+	return (gfp_xdr_vsend_result(client, 0, ecode, format, app));
+		/* notimeout */
 }
diff --git a/lib/libgfarm/gfarm/io_fd.c b/lib/libgfarm/gfarm/io_fd.c
index c6d501b..3da17ea 100644
--- a/lib/libgfarm/gfarm/io_fd.c
+++ b/lib/libgfarm/gfarm/io_fd.c
@@ -41,11 +41,9 @@ gfarm_iobuffer_blocking_read_timeout_fd_op(struct gfarm_iobuffer *b,
 	void *cookie, int fd, void *data, int length)
 {
 	ssize_t rv;
-	int gai_error, avail, timeout = gfarm_ctxp->network_receive_timeout;
+	int avail, timeout = gfarm_ctxp->network_receive_timeout;
 	const char *hostaddr_prefix, *hostaddr;
 	char hostbuf[NI_MAXHOST];
-	struct sockaddr_storage sa;
-	socklen_t sa_len = sizeof(sa);
 
 	for (;;) {
 #ifdef HAVE_POLL
@@ -67,21 +65,9 @@ gfarm_iobuffer_blocking_read_timeout_fd_op(struct gfarm_iobuffer *b,
 		if (avail == 0) {
 			gfarm_iobuffer_set_error(b,
 			    GFARM_ERR_OPERATION_TIMED_OUT);
-			if (getpeername(fd, (struct sockaddr *)&sa, &sa_len)
-			    == -1) {
-				hostaddr = strerror(errno);
-				hostaddr_prefix = "cannot get peer address: ";
-			} else if ((gai_error = gfarm_getnameinfo(
-			    (struct sockaddr *)&sa, sa_len,
-			    hostbuf, sizeof(hostbuf), NULL, 0,
-			    NI_NUMERICHOST | NI_NUMERICSERV)) != 0) {
-				hostaddr = gai_strerror(gai_error);
-				hostaddr_prefix =
-				    "cannot convert peer address to string: ";
-			} else {
-				hostaddr = hostbuf;
-				hostaddr_prefix = "";
-			}
+			gfarm_peer_name_string(fd, hostbuf, sizeof(hostbuf),
+			    NI_NUMERICHOST | NI_NUMERICSERV,
+			    &hostaddr_prefix, &hostaddr);
 			gflog_error(GFARM_MSG_1003449,
 			    "closing network connection due to "
 			    "no response within %d seconds "
@@ -150,7 +136,7 @@ gfarm_iobuffer_blocking_read_notimeout_fd_op(struct gfarm_iobuffer *b,
 }
 
 int
-gfarm_iobuffer_blocking_write_socket_op(struct gfarm_iobuffer *b,
+gfarm_iobuffer_blocking_write_notimeout_socket_op(struct gfarm_iobuffer *b,
 	void *cookie, int fd, void *data, int length)
 {
 	ssize_t rv;
@@ -184,6 +170,68 @@ gfarm_iobuffer_blocking_write_socket_op(struct gfarm_iobuffer *b,
 	}
 }
 
+int
+gfarm_iobuffer_blocking_write_timeout_socket_op(struct gfarm_iobuffer *b,
+	void *cookie, int fd, void *data, int length)
+{
+	ssize_t rv;
+	int avail, timeout = gfarm_ctxp->network_send_timeout;
+	const char *hostaddr_prefix, *hostaddr;
+	char hostbuf[NI_MAXHOST];
+
+	if (timeout == 0) {
+		return (gfarm_iobuffer_blocking_write_notimeout_socket_op(
+		    b, cookie, fd, data, length));
+	}
+
+	for (;;) {
+#ifdef HAVE_POLL
+		struct pollfd fds[1];
+
+		fds[0].fd = fd;
+		fds[0].events = POLLOUT;
+		avail = poll(fds, 1, timeout * 1000);
+#else
+		fd_set writable;
+		struct timeval tv;
+
+		FD_ZERO(&writable);
+		FD_SET(fd, &writable);
+		tv.tv_sec = timeout;
+		tv.tv_usec = 0;
+		avail = select(fd + 1, NULL, &writable, NULL, &tv);
+#endif
+		if (avail == 0) {
+			gfarm_iobuffer_set_error(b,
+			    GFARM_ERR_OPERATION_TIMED_OUT);
+			gfarm_peer_name_string(fd, hostbuf, sizeof(hostbuf),
+			    NI_NUMERICHOST | NI_NUMERICSERV,
+			    &hostaddr_prefix, &hostaddr);
+			gflog_error(GFARM_MSG_UNFIXED,
+			    "closing network connection due to "
+			    "send blocking more than %d seconds "
+			    "(network_send_timeout) to %s%s",
+			    timeout, hostaddr_prefix, hostaddr);
+			return (-1);
+		} else if (avail == -1) {
+			if (errno == EINTR)
+				continue;
+			gfarm_iobuffer_set_error(b,
+			    gfarm_errno_to_error(errno));
+			return (-1);
+		}
+
+		rv = gfarm_send_no_sigpipe(fd, data, length);
+		if (rv == -1) {
+			if (errno == EINTR || errno == EAGAIN)
+				continue;
+			gfarm_iobuffer_set_error(b,
+			    gfarm_errno_to_error(errno));
+		}
+		return (rv);
+	}
+}
+
 /*
  * an option for gfarm_iobuffer_set_write_close()
  */
@@ -244,7 +292,8 @@ struct gfp_iobuffer_ops gfp_xdr_socket_iobuffer_ops = {
 	gfp_iobuffer_env_for_credential_fd_op,
 	gfarm_iobuffer_blocking_read_timeout_fd_op,
 	gfarm_iobuffer_blocking_read_notimeout_fd_op,
-	gfarm_iobuffer_blocking_write_socket_op
+	gfarm_iobuffer_blocking_write_timeout_socket_op,
+	gfarm_iobuffer_blocking_write_notimeout_socket_op
 };
 
 gfarm_error_t
diff --git a/lib/libgfarm/gfarm/io_fd.h b/lib/libgfarm/gfarm/io_fd.h
index 1f6e174..ea29cc4 100644
--- a/lib/libgfarm/gfarm/io_fd.h
+++ b/lib/libgfarm/gfarm/io_fd.h
@@ -16,5 +16,7 @@ int gfarm_iobuffer_blocking_read_timeout_fd_op(struct gfarm_iobuffer *,
 	void *, int, void *, int);
 int gfarm_iobuffer_blocking_read_notimeout_fd_op(struct gfarm_iobuffer *,
 	void *, int, void *, int);
-int gfarm_iobuffer_blocking_write_socket_op(struct gfarm_iobuffer *,
+int gfarm_iobuffer_blocking_write_timeout_socket_op(struct gfarm_iobuffer *,
+	void *, int, void *, int);
+int gfarm_iobuffer_blocking_write_notimeout_socket_op(struct gfarm_iobuffer *,
 	void *, int, void *, int);
diff --git a/lib/libgfarm/gfarm/io_gfsl.c b/lib/libgfarm/gfarm/io_gfsl.c
index 1b6f50a..d8bee85 100644
--- a/lib/libgfarm/gfarm/io_gfsl.c
+++ b/lib/libgfarm/gfarm/io_gfsl.c
@@ -110,18 +110,24 @@ gfarm_iobuffer_read_notimeout_secsession_op(struct gfarm_iobuffer *b,
 	return (gfarm_iobuffer_read_session_x(b, cookie, fd, data, length, 0));
 }
 
-int
-gfarm_iobuffer_write_secsession_op(struct gfarm_iobuffer *b,
-	void *cookie, int fd, void *data, int length)
+static int
+gfarm_iobuffer_write_secsession_x(struct gfarm_iobuffer *b,
+	void *cookie, int fd, void *data, int length, int do_timeout)
 {
 	struct io_gfsl *io = cookie;
 	int rv, flag = fcntl(fd, F_GETFL, NULL);
+	int msec;
+
+	if (do_timeout && gfarm_ctxp->network_send_timeout != 0)
+		msec = gfarm_ctxp->network_send_timeout * 1000;
+	else
+		msec = GFARM_GSS_TIMEOUT_INFINITE;
 
 	/* temporary drop O_NONBLOCK flag to prevent EAGAIN */
 	if (flag & O_NONBLOCK)
 		fcntl(fd, F_SETFL, flag & ~O_NONBLOCK);
 
-	rv = gfarmSecSessionSendInt8(io->session, data, length);
+	rv = gfarmSecSessionSendInt8(io->session, data, length, msec);
 
 	if (flag & O_NONBLOCK)
 		fcntl(fd, F_SETFL, flag);
@@ -135,6 +141,22 @@ gfarm_iobuffer_write_secsession_op(struct gfarm_iobuffer *b,
 	return (rv);
 }
 
+int
+gfarm_iobuffer_write_timeout_secsession_op(struct gfarm_iobuffer *b,
+	void *cookie, int fd, void *data, int length)
+{
+	return (gfarm_iobuffer_write_secsession_x(
+	    b, cookie, fd, data, length, 1));
+}
+
+int
+gfarm_iobuffer_write_notimeout_secsession_op(struct gfarm_iobuffer *b,
+	void *cookie, int fd, void *data, int length)
+{
+	return (gfarm_iobuffer_write_secsession_x(
+	    b, cookie, fd, data, length, 0));
+}
+
 static void
 free_secsession(struct io_gfsl *io)
 {
@@ -231,7 +253,8 @@ struct gfp_iobuffer_ops gfp_xdr_secsession_iobuffer_ops = {
 	gfp_iobuffer_env_for_credential_secsession_op,
 	gfarm_iobuffer_read_timeout_secsession_op,
 	gfarm_iobuffer_read_notimeout_secsession_op,
-	gfarm_iobuffer_write_secsession_op
+	gfarm_iobuffer_write_timeout_secsession_op,
+	gfarm_iobuffer_write_notimeout_secsession_op,
 };
 
 gfarm_error_t
@@ -308,7 +331,8 @@ static struct gfp_iobuffer_ops gfp_xdr_insecure_gsi_session_iobuffer_ops = {
 	/* NOTE: the following assumes that these functions don't use cookie */
 	gfarm_iobuffer_blocking_read_timeout_fd_op,
 	gfarm_iobuffer_blocking_read_notimeout_fd_op,
-	gfarm_iobuffer_blocking_write_socket_op
+	gfarm_iobuffer_blocking_write_timeout_socket_op,
+	gfarm_iobuffer_blocking_write_notimeout_socket_op,
 };
 
 /*
diff --git a/lib/libgfarm/gfarm/iobuffer.c b/lib/libgfarm/gfarm/iobuffer.c
index 8cacb6a..c247896 100644
--- a/lib/libgfarm/gfarm/iobuffer.c
+++ b/lib/libgfarm/gfarm/iobuffer.c
@@ -20,7 +20,10 @@ struct gfarm_iobuffer {
 	void *read_cookie;
 	int read_fd; /* for file descriptor i/o */
 
-	int (*write_func)(struct gfarm_iobuffer *, void *, int, void *, int);
+	int (*write_timeout_func)(struct gfarm_iobuffer *,
+				  void *, int, void *, int);
+	int (*write_notimeout_func)(struct gfarm_iobuffer *,
+				  void *, int, void *, int);
 	void *write_cookie;
 	int write_fd; /* for file descriptor i/o */
 
@@ -67,7 +70,8 @@ gfarm_iobuffer_alloc(int bufsize)
 	b->read_cookie = NULL;
 	b->read_fd = -1;
 
-	b->write_func = NULL;
+	b->write_timeout_func = NULL;
+	b->write_notimeout_func = NULL;
 	b->write_cookie = NULL;
 	b->write_fd = -1;
 
@@ -180,11 +184,21 @@ gfarm_iobuffer_set_write_close(struct gfarm_iobuffer *b,
 }
 
 void
-gfarm_iobuffer_set_write(struct gfarm_iobuffer *b,
+gfarm_iobuffer_set_write_timeout(struct gfarm_iobuffer *b,
 	int (*wf)(struct gfarm_iobuffer *, void *, int, void *, int),
 	void *cookie, int fd)
 {
-	b->write_func = wf;
+	b->write_timeout_func = wf;
+	b->write_cookie = cookie;
+	b->write_fd = fd;
+}
+
+void
+gfarm_iobuffer_set_write_notimeout(struct gfarm_iobuffer *b,
+	int (*wf)(struct gfarm_iobuffer *, void *, int, void *, int),
+	void *cookie, int fd)
+{
+	b->write_notimeout_func = wf;
 	b->write_cookie = cookie;
 	b->write_fd = fd;
 }
@@ -303,7 +317,7 @@ gfarm_iobuffer_end_pindown(struct gfarm_iobuffer *b)
 
 /* enqueue */
 static void
-gfarm_iobuffer_read(struct gfarm_iobuffer *b, int *residualp, int do_timeout)
+gfarm_iobuffer_read(struct gfarm_iobuffer *b, int do_timeout, int *residualp)
 {
 	int space, rv;
 	int (*func)(struct gfarm_iobuffer *, void *, int, void *, int);
@@ -376,9 +390,10 @@ gfarm_iobuffer_write_close(struct gfarm_iobuffer *b)
 
 /* dequeue */
 static void
-gfarm_iobuffer_write(struct gfarm_iobuffer *b, int *residualp)
+gfarm_iobuffer_write(struct gfarm_iobuffer *b, int do_timeout, int *residualp)
 {
 	int avail, rv;
+	int (*func)(struct gfarm_iobuffer *, void *, int, void *, int);
 
 	if (IOBUFFER_IS_EMPTY(b)) {
 		if (b->read_eof)
@@ -392,9 +407,9 @@ gfarm_iobuffer_write(struct gfarm_iobuffer *b, int *residualp)
 	if (*residualp <= 0)
 		return;
 
-	rv = (*b->write_func)(b, b->write_cookie, b->write_fd,
-			      b->buffer + b->head,
-			      *residualp < avail ? *residualp : avail);
+	func = do_timeout ? b->write_timeout_func : b->write_notimeout_func;
+	rv = (*func)(b, b->write_cookie, b->write_fd, b->buffer + b->head,
+	    *residualp < avail ? *residualp : avail);
 	if (rv > 0) {
 		b->head += rv;
 		*residualp -= rv;
@@ -493,41 +508,46 @@ gfarm_iobuffer_get(struct gfarm_iobuffer *b, void *data, int len)
 }
 
 void
-gfarm_iobuffer_flush_write(struct gfarm_iobuffer *b)
+gfarm_iobuffer_flush_write(struct gfarm_iobuffer *b, int do_timeout)
 {
 	while (!IOBUFFER_IS_EMPTY(b) && b->error == 0)
-		gfarm_iobuffer_write(b, NULL);
+		gfarm_iobuffer_write(b, do_timeout, NULL);
 }
 
 static int
-gfarm_iobuffer_write_direct(struct gfarm_iobuffer *b, void *data, int len)
+gfarm_iobuffer_write_direct(struct gfarm_iobuffer *b, void *data, int len,
+	int do_timeout)
 {
-	return ((*b->write_func)(b, b->write_cookie, b->write_fd, data, len));
+	int (*func)(struct gfarm_iobuffer *, void *, int, void *, int);
+
+	func = do_timeout ? b->write_timeout_func : b->write_notimeout_func;
+	return ((*func)(b, b->write_cookie, b->write_fd, data, len));
 }
 
 int
-gfarm_iobuffer_put_write(struct gfarm_iobuffer *b, const void *data, int len)
+gfarm_iobuffer_put_write(struct gfarm_iobuffer *b, const void *data, int len,
+	int do_timeout)
 {
 	const char *p;
 	int rv, residual;
 	void *d = (void *)data;
 
 	if (!b->pindown && len > gfarm_iobuffer_get_size(b)) {
-		gfarm_iobuffer_flush_write(b);
+		gfarm_iobuffer_flush_write(b, do_timeout);
 		if (gfarm_iobuffer_get_error(b))
 			return (0);
-		rv = gfarm_iobuffer_write_direct(b, d, len);
+		rv = gfarm_iobuffer_write_direct(b, d, len, do_timeout);
 		return (rv < 0 ? 0 : rv);
 	}
 	for (p = data, residual = len; residual > 0; residual -= rv, p += rv) {
 		if (!b->pindown && IOBUFFER_IS_FULL(b))
-			gfarm_iobuffer_write(b, NULL);
+			gfarm_iobuffer_write(b, do_timeout, NULL);
 		rv = gfarm_iobuffer_put(b, p, residual);
 		if (rv == 0) /* error */
 			break;
 	}
 	if (!b->pindown && IOBUFFER_IS_FULL(b))
-		gfarm_iobuffer_write(b, NULL);
+		gfarm_iobuffer_write(b, do_timeout, NULL);
 	return (len - residual);
 }
 
@@ -540,7 +560,7 @@ gfarm_iobuffer_purge_read_x(struct gfarm_iobuffer *b, int len, int just,
 	for (residual = len; residual > 0; ) {
 		if (IOBUFFER_IS_EMPTY(b)) {
 			tmp = residual;
-			gfarm_iobuffer_read(b, justp, do_timeout);
+			gfarm_iobuffer_read(b, do_timeout, justp);
 		}
 		rv = gfarm_iobuffer_purge(b, &residual);
 		if (rv == 0) /* EOF or error */
@@ -559,7 +579,7 @@ gfarm_iobuffer_get_read_x(struct gfarm_iobuffer *b, void *data,
 	for (p = data, residual = len; residual > 0; residual -= rv, p += rv) {
 		if (IOBUFFER_IS_EMPTY(b)) {
 			tmp = residual;
-			gfarm_iobuffer_read(b, justp, do_timeout);
+			gfarm_iobuffer_read(b, do_timeout, justp);
 		}
 		rv = gfarm_iobuffer_get(b, p, residual);
 		if (rv == 0) /* EOF or error */
@@ -582,7 +602,7 @@ gfarm_iobuffer_get_read_partial_x(struct gfarm_iobuffer *b, void *data,
 	if (IOBUFFER_IS_EMPTY(b)) {
 		int tmp = len;
 
-		gfarm_iobuffer_read(b, just ? &tmp : NULL, do_timeout);
+		gfarm_iobuffer_read(b, do_timeout, just ? &tmp : NULL);
 	}
 	return (gfarm_iobuffer_get(b, data, len));
 }
@@ -639,6 +659,6 @@ gfarm_iobuffer_read_ahead(struct gfarm_iobuffer *b, int len)
 		return (alen);
 	rlen = len - alen;
 	while (rlen > 0 && gfarm_iobuffer_is_readable(b) && b->error == 0)
-		gfarm_iobuffer_read(b, &rlen, 0);
+		gfarm_iobuffer_read(b, 0, &rlen);
 	return (len - rlen);
 }
diff --git a/lib/libgfarm/gfarm/iobuffer.h b/lib/libgfarm/gfarm/iobuffer.h
index ae6e37d..009e2c3 100644
--- a/lib/libgfarm/gfarm/iobuffer.h
+++ b/lib/libgfarm/gfarm/iobuffer.h
@@ -90,16 +90,19 @@ int gfarm_iobuffer_read_ahead(struct gfarm_iobuffer *, int);
 /* dequeue */
 void gfarm_iobuffer_set_write_close(struct gfarm_iobuffer *,
 	void (*)(struct gfarm_iobuffer *, void *, int));
-void gfarm_iobuffer_set_write(struct gfarm_iobuffer *,
+void gfarm_iobuffer_set_write_timeout(struct gfarm_iobuffer *,
+	int (*)(struct gfarm_iobuffer *, void *, int, void *, int),
+	void *, int);
+void gfarm_iobuffer_set_write_notimeout(struct gfarm_iobuffer *,
 	int (*)(struct gfarm_iobuffer *, void *, int, void *, int),
 	void *, int);
 void *gfarm_iobuffer_get_write_cookie(struct gfarm_iobuffer *);
 int gfarm_iobuffer_get_write_fd(struct gfarm_iobuffer *);
 int gfarm_iobuffer_purge(struct gfarm_iobuffer *, int *);
-void gfarm_iobuffer_flush_write(struct gfarm_iobuffer *);
+void gfarm_iobuffer_flush_write(struct gfarm_iobuffer *, int);
 
 /* enqueue by memory copy, dequeue by write */
-int gfarm_iobuffer_put_write(struct gfarm_iobuffer *, const void *, int);
+int gfarm_iobuffer_put_write(struct gfarm_iobuffer *, const void *, int, int);
 /* enqueue by read, dequeue by purge */
 int gfarm_iobuffer_purge_read_x(struct gfarm_iobuffer *, int, int, int);
 /* enqueue by read, dequeue by memory copy */
diff --git a/lib/libgfarm/gfsl/client2.c b/lib/libgfarm/gfsl/client2.c
index 2d70d77..56f0f53 100644
--- a/lib/libgfarm/gfsl/client2.c
+++ b/lib/libgfarm/gfsl/client2.c
@@ -133,9 +133,11 @@ main(int argc, char *argv[])
 	    len--;
 	}
 	if (z % 2 == 0) {
-	    (void)gfarmSecSessionSendInt8(ss0, buf, len);
+	    (void)gfarmSecSessionSendInt8(ss0, buf, len,
+					  GFARM_GSS_TIMEOUT_INFINITE);
 	} else {
-	    (void)gfarmSecSessionSendInt8(ss1, buf, len);
+	    (void)gfarmSecSessionSendInt8(ss1, buf, len,
+					  GFARM_GSS_TIMEOUT_INFINITE);
 	}
 	z++;
     }
diff --git a/lib/libgfarm/gfsl/gfarm_gsi.h b/lib/libgfarm/gfsl/gfarm_gsi.h
index 0c96f6d..d98c84d 100644
--- a/lib/libgfarm/gfsl/gfarm_gsi.h
+++ b/lib/libgfarm/gfsl/gfarm_gsi.h
@@ -13,7 +13,7 @@ extern void	gfarmGssFreeCrackedStatus(char **strPtr);
 extern void	gfarmGssPrintMajorStatus(OM_uint32 majStat);
 extern void	gfarmGssPrintMinorStatus(OM_uint32 minStat);
 
-extern int	gfarmGssSendToken(int fd, gss_buffer_t gsBuf);
+extern int	gfarmGssSendToken(int fd, gss_buffer_t gsBuf, int timeoutMsec);
 extern int	gfarmGssReceiveToken(int fd, gss_buffer_t gsBuf,
 				     int timeoutMsec);
 
@@ -85,10 +85,11 @@ extern int	gfarmGssSend(int fd, gss_ctx_id_t sCtx,
 			     int doEncrypt,
 			     gss_qop_t qopReq,
 			     gfarm_int8_t *buf, int n, int chunkSz,
+			     int timeoutMsec,
 			     OM_uint32 *statPtr);
-extern int	gfarmGssReceive(int fd, gss_ctx_id_t sCtx,
+extern int	gfarmGssReceive(int fd, gss_ctx_id_t sCtx, int timeoutMsec,
 				gfarm_int8_t **bufPtr, int *lenPtr,
-				OM_uint32 *statPtr, int timeoutMsec);
+				OM_uint32 *statPtr);
 
 /* multiplexed version */
 
diff --git a/lib/libgfarm/gfsl/gfarm_secure_session.h b/lib/libgfarm/gfsl/gfarm_secure_session.h
index 924a54f..ff69317 100644
--- a/lib/libgfarm/gfsl/gfarm_secure_session.h
+++ b/lib/libgfarm/gfsl/gfarm_secure_session.h
@@ -196,7 +196,8 @@ extern int			gfarmSecSessionDedicate(gfarmSecSession *ssPtr);
 
 extern int			gfarmSecSessionSendInt32(gfarmSecSession *ssPtr,
 							 gfarm_int32_t *buf,
-							 int n);
+							 int n,
+							 int timeoutMsec);
 extern int			gfarmSecSessionReceiveInt32(gfarmSecSession *ssPtr,
 							    gfarm_int32_t **bufPtr,
 							    int *lenPtr,
@@ -204,7 +205,8 @@ extern int			gfarmSecSessionReceiveInt32(gfarmSecSession *ssPtr,
 
 extern int			gfarmSecSessionSendInt16(gfarmSecSession *ssPtr,
 							 gfarm_int16_t *buf,
-							  int n);
+							 int n,
+							 int timeoutMsec);
 extern int			gfarmSecSessionReceiveInt16(gfarmSecSession *ssPtr,
 							    gfarm_int16_t **bufPtr,
 							    int *lenPtr,
@@ -212,7 +214,8 @@ extern int			gfarmSecSessionReceiveInt16(gfarmSecSession *ssPtr,
 
 extern int			gfarmSecSessionSendInt8(gfarmSecSession *ssPtr,
 							gfarm_int8_t *buf,
-							int n);
+							int n,
+							int timeoutMsec);
 extern int			gfarmSecSessionReceiveInt8(gfarmSecSession *ssPtr,
 							   gfarm_int8_t **bufPtr,
 							   int *lenPtr,
diff --git a/lib/libgfarm/gfsl/gsi.c b/lib/libgfarm/gfsl/gsi.c
index 9e4c862..588d439 100644
--- a/lib/libgfarm/gfsl/gsi.c
+++ b/lib/libgfarm/gfsl/gsi.c
@@ -498,18 +498,18 @@ gfarmGssDeleteCredential(gss_cred_id_t *credPtr, OM_uint32 *majStatPtr,
 
 
 int
-gfarmGssSendToken(int fd, gss_buffer_t gsBuf)
+gfarmGssSendToken(int fd, gss_buffer_t gsBuf, int timeoutMsec)
 {
     gfarm_int32_t iLen = gsBuf->length;
     int save_errno;
 
-    if (gfarmWriteInt32(fd, &iLen, 1) != 1) {
+    if (gfarmWriteInt32(fd, &iLen, 1, timeoutMsec) != 1) {
 	save_errno = errno;
 	gflog_debug(GFARM_MSG_1000792, "gfarmWriteInt32() failed");
 	errno = save_errno;
 	return -1;
     }
-    if (gfarmWriteInt8(fd, gsBuf->value, iLen) != iLen) {
+    if (gfarmWriteInt8(fd, gsBuf->value, iLen, timeoutMsec) != iLen) {
 	save_errno = errno;
 	gflog_debug(GFARM_MSG_1000793, "gfarmWriteInt8() failed");
 	errno = save_errno;
@@ -619,7 +619,8 @@ gfarmGssAcceptSecurityContext(int fd, gss_cred_id_t cred, gss_ctx_id_t *scPtr,
 	    gss_release_buffer(&minStat2, itPtr);
 
 	if (otPtr->length > 0) {
-	    tknStat = gfarmGssSendToken(fd, otPtr);
+	    tknStat = gfarmGssSendToken(fd, otPtr,
+					GFARM_GSS_AUTH_TIMEOUT_MSEC);
 	    gsiErrNo = errno;
 	    gss_release_buffer(&minStat2, otPtr);
 	    if (tknStat > 0) {
@@ -732,7 +733,8 @@ gfarmGssInitiateSecurityContext(int fd, const gss_name_t acceptorName,
 	    gss_release_buffer(&minStat2, itPtr);
 
 	if (otPtr->length > 0) {
-	    tknStat = gfarmGssSendToken(fd, otPtr);
+	    tknStat = gfarmGssSendToken(fd, otPtr,
+					GFARM_GSS_AUTH_TIMEOUT_MSEC);
 	    gsiErrNo = errno;
 	    gss_release_buffer(&minStat2, otPtr);
 	    if (tknStat > 0) {
@@ -846,7 +848,7 @@ gfarmGssConfigureMessageSize(gss_ctx_id_t sCtx, int doEncrypt,
 
 int
 gfarmGssSend(int fd, gss_ctx_id_t sCtx, int doEncrypt, gss_qop_t qopReq,
-    gfarm_int8_t *buf, int n, int chunkSz, OM_uint32 *statPtr)
+    gfarm_int8_t *buf, int n, int chunkSz, int timeoutMsec, OM_uint32 *statPtr)
 {
     int ret = -1;
     OM_uint32 majStat;
@@ -876,7 +878,7 @@ gfarmGssSend(int fd, gss_ctx_id_t sCtx, int doEncrypt, gss_qop_t qopReq,
 	goto Done;
     }
 
-    if (gfarmWriteInt32(fd, &n_buf, 1) != 1) {
+    if (gfarmWriteInt32(fd, &n_buf, 1, timeoutMsec) != 1) {
 	gflog_info(GFARM_MSG_1004283, "%s: %s", diag, strerror(errno));
 	majStat = GSS_S_CALL_INACCESSIBLE_WRITE;
 	goto Done;
@@ -892,7 +894,7 @@ gfarmGssSend(int fd, gss_ctx_id_t sCtx, int doEncrypt, gss_qop_t qopReq,
 			   otPtr);
 	if (majStat == GSS_S_COMPLETE) {
 	    if (otPtr->length > 0) {
-		tknStat = gfarmGssSendToken(fd, otPtr);
+		tknStat = gfarmGssSendToken(fd, otPtr, timeoutMsec);
 		save_errno = errno;
 		gss_release_buffer(&minStat, otPtr);
 		if (tknStat <= 0) {
@@ -935,8 +937,8 @@ gfarmGssSend(int fd, gss_ctx_id_t sCtx, int doEncrypt, gss_qop_t qopReq,
 
 
 int
-gfarmGssReceive(int fd, gss_ctx_id_t sCtx, gfarm_int8_t **bufPtr,
-    int *lenPtr, OM_uint32 *statPtr, int timeoutMsec)
+gfarmGssReceive(int fd, gss_ctx_id_t sCtx, int timeoutMsec,
+    gfarm_int8_t **bufPtr, int *lenPtr, OM_uint32 *statPtr)
 {
     int ret = -1;
     OM_uint32 majStat;
@@ -1266,7 +1268,7 @@ gfarmGssInitiateSecurityContextSendToken(int events, int fd, void *closure,
     int tknStat;
     OM_uint32 minStat2;
 
-    tknStat = gfarmGssSendToken(fd, state->otPtr);
+    tknStat = gfarmGssSendToken(fd, state->otPtr, GFARM_GSS_AUTH_TIMEOUT_MSEC);
     gss_release_buffer(&minStat2, state->otPtr);
     if (tknStat <= 0) {
 	gflog_auth_error(GFARM_MSG_1000623,
diff --git a/lib/libgfarm/gfsl/scsub.c b/lib/libgfarm/gfsl/scsub.c
index 759803c..1936f78 100644
--- a/lib/libgfarm/gfsl/scsub.c
+++ b/lib/libgfarm/gfsl/scsub.c
@@ -109,7 +109,8 @@ doServer(int fd, char *hostname, int port, gss_cred_id_t myCred,
 	goto Done;
     }
 
-    if (gfarmSecSessionSendInt8(initialSession, rBuf, rSz) != rSz) {
+    if (gfarmSecSessionSendInt8(initialSession, rBuf, rSz,
+				GFARM_GSS_TIMEOUT_INFINITE) != rSz) {
 	fprintf(stderr, "test buffer send failed because of:\n");
 	gfarmSecSessionPrintStatus(initialSession);
 	goto Done;
@@ -198,14 +199,16 @@ doClient(char *hostname, int port, gss_name_t acceptorName,
     }
     randomizeIt(sBuf, testBufSize);
 
-    if (gfarmSecSessionSendInt32(ss, &testBufSize, 1) != 1) {
+    if (gfarmSecSessionSendInt32(ss, &testBufSize, 1,
+				 GFARM_GSS_TIMEOUT_INFINITE) != 1) {
 	fprintf(stderr, "can't send test buffer size because of:\n");
 	gfarmSecSessionPrintStatus(ss);
 	goto Done;
     }
     fprintf(stderr, "Send buffer size: %ld\n", (long)testBufSize);
 
-    if (gfarmSecSessionSendInt8(ss, sBuf, testBufSize) != testBufSize) {
+    if (gfarmSecSessionSendInt8(ss, sBuf, testBufSize,
+				GFARM_GSS_TIMEOUT_INFINITE) != testBufSize) {
 	fprintf(stderr, "test buffer send failed because of:\n");
 	gfarmSecSessionPrintStatus(ss);
 	goto Done;
@@ -234,7 +237,8 @@ doClient(char *hostname, int port, gss_name_t acceptorName,
 	fprintf(stderr, "test buffer check OK.\n");
     }
 
-    if (gfarmSecSessionSendInt32(ss, &deleCheck, 1) != 1) {
+    if (gfarmSecSessionSendInt32(ss, &deleCheck, 1,
+				 GFARM_GSS_TIMEOUT_INFINITE) != 1) {
 	fprintf(stderr, "can't send delegation check flag.\n");
 	goto Done;
     }
diff --git a/lib/libgfarm/gfsl/session.c b/lib/libgfarm/gfsl/session.c
index 2ff81d9..82d4db5 100644
--- a/lib/libgfarm/gfsl/session.c
+++ b/lib/libgfarm/gfsl/session.c
@@ -466,7 +466,9 @@ negotiateConfigParam(int fd, gss_ctx_id_t sCtx, int which,
 
 	    param[NEGO_PARAM_OTHER_CONFIG] = retConf;
 
-	    if (gfarmWriteInt32(fd, param, NUM_NEGO_PARAM) != NUM_NEGO_PARAM) {
+	    if (gfarmWriteInt32(fd, param, NUM_NEGO_PARAM,
+				GFARM_GSS_AUTH_TIMEOUT_MSEC)
+		!= NUM_NEGO_PARAM) {
 		gsiErrNo = errno;
 		gflog_auth_info(GFARM_MSG_1003850,
 		    "gfarmSecSession:negotiateConfigParam(): "
@@ -486,7 +488,9 @@ negotiateConfigParam(int fd, gss_ctx_id_t sCtx, int which,
 	    param[NEGO_PARAM_OTHER_CONFIG] = canPtr->configReq;
 	    param[NEGO_PARAM_OTHER_CONFIG_FORCE] = canPtr->configForce;
 
-	    if (gfarmWriteInt32(fd, param, NUM_NEGO_PARAM) != NUM_NEGO_PARAM) {
+	    if (gfarmWriteInt32(fd, param, NUM_NEGO_PARAM,
+				GFARM_GSS_AUTH_TIMEOUT_MSEC)
+		!= NUM_NEGO_PARAM) {
 		gsiErrNo = errno;
 		gflog_auth_error(GFARM_MSG_1003851,
 		    "gfarmSecSession:negotiateConfigParam(): "
@@ -1015,13 +1019,15 @@ gfarmSecSessionAccept(int fd, gss_cred_id_t cred,
 	if (type == GFARM_AUTH_USER) {
 	    /* Send ACK. */
 	    acknack = GFARM_SS_AUTH_ACK;
-	    (void)gfarmWriteInt32(fd, &acknack, 1);
+	    (void)gfarmWriteInt32(fd, &acknack, 1,
+				  GFARM_GSS_AUTH_TIMEOUT_MSEC);
 	} else if (type == GFARM_AUTH_HOST) {
 	    /* check peer name is actually allowed */
 	    if (strcmp(peerName, gfarmAuthGetFQDN(entry)) == 0) {
 		/* Send ACK. */
 		acknack = GFARM_SS_AUTH_ACK;
-		(void)gfarmWriteInt32(fd, &acknack, 1);
+		(void)gfarmWriteInt32(fd, &acknack, 1,
+				      GFARM_GSS_AUTH_TIMEOUT_MSEC);
 	    } else {
 		gflog_auth_error(GFARM_MSG_1000673,
 		    "%s: hostname doesn't match: "
@@ -1073,7 +1079,7 @@ gfarmSecSessionAccept(int fd, gss_cred_id_t cred,
 SendNack:
     /* Send NACK. */
     acknack = GFARM_SS_AUTH_NACK;
-    gfarmWriteInt32(fd, &acknack, 1);
+    gfarmWriteInt32(fd, &acknack, 1, GFARM_GSS_AUTH_TIMEOUT_MSEC);
 Fail:
     if (ret != NULL) {
 	destroySecSession(ret);
@@ -1397,7 +1403,8 @@ gfarmSecSessionDedicate(gfarmSecSession *ssPtr)
 }
 
 int
-gfarmSecSessionSendInt8(gfarmSecSession *ssPtr, gfarm_int8_t *buf, int n)
+gfarmSecSessionSendInt8(gfarmSecSession *ssPtr, gfarm_int8_t *buf, int n,
+	int timeoutMsec)
 {
     int doEncrypt = GFARM_GSS_ENCRYPTION_ENABLED &
     		    (isBitSet(ssPtr->config,
@@ -1409,25 +1416,26 @@ gfarmSecSessionSendInt8(gfarmSecSession *ssPtr, gfarm_int8_t *buf, int n)
 			buf,
 			n,
 			ssPtr->maxTransSize,
+			timeoutMsec,
 			&(ssPtr->gssLastStat));
 }
 
-
 int
 gfarmSecSessionReceiveInt8(gfarmSecSession *ssPtr, gfarm_int8_t **bufPtr,
     int *lenPtr, int timeoutMsec)
 {
     return gfarmGssReceive(ssPtr->fd,
 			   ssPtr->sCtx,
+			   timeoutMsec,
 			   bufPtr,
 			   lenPtr,
-			   &(ssPtr->gssLastStat),
-			   timeoutMsec);
+			   &(ssPtr->gssLastStat));
 }
 
 
 int
-gfarmSecSessionSendInt32(gfarmSecSession *ssPtr, gfarm_int32_t *buf, int n)
+gfarmSecSessionSendInt32(gfarmSecSession *ssPtr, gfarm_int32_t *buf, int n,
+	int timeoutMsec)
 {
     gfarm_int32_t *lBuf;
     int i;
@@ -1444,7 +1452,7 @@ gfarmSecSessionSendInt32(gfarmSecSession *ssPtr, gfarm_int32_t *buf, int n)
     }
 
     ret = gfarmSecSessionSendInt8(ssPtr, (gfarm_int8_t *)lBuf,
-				  n * GFARM_OCTETS_PER_32BIT);
+				  n * GFARM_OCTETS_PER_32BIT, timeoutMsec);
     (void)free(lBuf);
     if (ret > 0) {
 	ret /= GFARM_OCTETS_PER_32BIT;
@@ -1504,7 +1512,8 @@ gfarmSecSessionReceiveInt32(gfarmSecSession *ssPtr, gfarm_int32_t **bufPtr,
 
 
 int
-gfarmSecSessionSendInt16(gfarmSecSession *ssPtr, gfarm_int16_t *buf, int n)
+gfarmSecSessionSendInt16(gfarmSecSession *ssPtr, gfarm_int16_t *buf, int n,
+	int timeoutMsec)
 {
     gfarm_int16_t *lBuf;
     int i;
@@ -1521,7 +1530,7 @@ gfarmSecSessionSendInt16(gfarmSecSession *ssPtr, gfarm_int16_t *buf, int n)
     }
 
     ret = gfarmSecSessionSendInt8(ssPtr, (gfarm_int8_t *)lBuf,
-				   n * GFARM_OCTETS_PER_16BIT);
+				  n * GFARM_OCTETS_PER_16BIT, timeoutMsec);
     (void)free(lBuf);
     if (ret > 0) {
 	ret /= GFARM_OCTETS_PER_16BIT;
@@ -1725,7 +1734,8 @@ negotiateConfigParamInitiatorSend(int events, int fd, void *closure,
     param[NEGO_PARAM_OTHER_CONFIG] = canPtr->configReq;
     param[NEGO_PARAM_OTHER_CONFIG_FORCE] = canPtr->configForce;
 
-    if (gfarmWriteInt32(fd, param, NUM_NEGO_PARAM) != NUM_NEGO_PARAM) {
+    if (gfarmWriteInt32(fd, param, NUM_NEGO_PARAM,
+			GFARM_GSS_AUTH_TIMEOUT_MSEC) != NUM_NEGO_PARAM) {
 	gflog_auth_error(GFARM_MSG_1000681,
 	    "gfarmSecSession:negotiateConfigParamInitiatorSend(): "
 	    "acceptor disappered");
diff --git a/lib/libgfarm/gfsl/tcputil.c b/lib/libgfarm/gfsl/tcputil.c
index 2fd4234..959e370 100644
--- a/lib/libgfarm/gfsl/tcputil.c
+++ b/lib/libgfarm/gfsl/tcputil.c
@@ -204,10 +204,9 @@ gfarmGetNameOfSocket(int sock, int *portPtr)
 int
 gfarmWaitReadable(int fd, int timeoutMsec)
 {
-    int sel, err, save_errno;
-    char hostbuf[NI_MAXHOST], *hostaddr_prefix, *hostaddr;
-    struct sockaddr_in sin;
-    socklen_t slen = sizeof(sin);
+    int sel, save_errno;
+    char hostbuf[NI_MAXHOST];
+    const char *hostaddr_prefix, *hostaddr;
 
     for (;;) {
 #ifdef HAVE_POLL
@@ -235,20 +234,9 @@ gfarmWaitReadable(int fd, int timeoutMsec)
 	sel = select(fd + 1, &rFd, NULL, NULL, tvPtr);
 #endif /* ! HAVE_POLL */
 	if (sel == 0) {
-	    if (getpeername(fd, (struct sockaddr *)&sin, &slen) == -1) {
-		hostaddr = strerror(errno);
-		hostaddr_prefix = "cannot get peer address: ";
-	    } else if ((err = gfarm_getnameinfo((struct sockaddr *)&sin, slen,
-						hostbuf, sizeof(hostbuf),
-						NULL, 0,
-						NI_NUMERICHOST|NI_NUMERICSERV)
-			!= 0)) {
-		hostaddr = strerror(err);
-		hostaddr_prefix = "cannot convert peer address to string: ";
-	    } else {
-		hostaddr = hostbuf;
-		hostaddr_prefix= "";
-	    }
+	    gfarm_peer_name_string(fd, hostbuf, sizeof(hostbuf),
+				   NI_NUMERICHOST | NI_NUMERICSERV,
+				   &hostaddr_prefix, &hostaddr);
 	    gflog_error(GFARM_MSG_1003439,
 			"closing network connection due to "
 			"no response within %d milliseconds from %s%s",
@@ -337,13 +325,71 @@ gfarmReadInt32(int fd, gfarm_int32_t *buf, int len, int timeoutMsec)
 
 
 int
-gfarmWriteInt8(int fd, gfarm_int8_t *buf, int len)
+gfarmWaitWritable(int fd, int timeoutMsec)
+{
+    int sel, save_errno;
+    char hostbuf[NI_MAXHOST];
+    const char *hostaddr_prefix, *hostaddr;
+
+    for (;;) {
+#ifdef HAVE_POLL
+	struct pollfd fds[1];
+
+	fds[0].fd = fd;
+	fds[0].events = POLLOUT;
+	errno = 0;
+	sel = poll(fds, 1, timeoutMsec);
+#else /* ! HAVE_POLL */
+	fd_set wFd;
+	struct timeval tv, *tvPtr;
+
+	FD_ZERO(&rFd);
+	FD_SET(fd, &rFd);
+	if (timeoutMsec == GFARM_GSS_TIMEOUT_INFINITE)
+	    tvPtr = NULL;
+	else {
+	    tv.tv_sec = timeoutMsec / 1000;
+	    tv.tv_usec = timeoutMsec % 1000 * 1000;
+	    tvPtr = &tv;
+	}
+
+	errno = 0;
+	sel = select(fd + 1, NULL, &wFd, NULL, tvPtr);
+#endif /* ! HAVE_POLL */
+	if (sel == 0) {
+	    gfarm_peer_name_string(fd, hostbuf, sizeof(hostbuf),
+				   NI_NUMERICHOST | NI_NUMERICSERV,
+				   &hostaddr_prefix, &hostaddr);
+	    gflog_error(GFARM_MSG_UNFIXED,
+			"closing network connection due to "
+			"send blocking more than %d milliseconds from %s%s",
+			timeoutMsec, hostaddr_prefix, hostaddr);
+	} else if (sel < 0) {
+	    if (errno == EINTR || errno == EAGAIN)
+		continue;
+	    save_errno = errno;
+	    gflog_error(GFARM_MSG_1000639, "select: %s", strerror(errno));
+	    errno = save_errno;
+	}
+	return sel;
+    }
+}
+
+
+int
+gfarmWriteInt8(int fd, gfarm_int8_t *buf, int len, int timeoutMsec)
 {
     int sum = 0;
     int cur = 0;
-    int save_errno;
+    int sel, save_errno;
 
     do {
+	sel = gfarmWaitWritable(fd, timeoutMsec);
+	if (sel <= 0) {
+	    if (sel == 0)
+		errno = ETIMEDOUT;
+	    return sum;
+	}
 	cur = gfarm_send_no_sigpipe(fd, buf + sum, len - sum);
 	if (cur < 0) {
 	    save_errno = errno;
@@ -358,7 +404,7 @@ gfarmWriteInt8(int fd, gfarm_int8_t *buf, int len)
 
 
 int
-gfarmWriteInt16(int fd, gfarm_int16_t *buf, int len)
+gfarmWriteInt16(int fd, gfarm_int16_t *buf, int len, int timeoutMsec)
 {
     int i;
     int n;
@@ -366,7 +412,8 @@ gfarmWriteInt16(int fd, gfarm_int16_t *buf, int len)
 
     for (i = 0; i < len; i++) {
 	s = htons(buf[i]);
-	n = gfarmWriteInt8(fd, (gfarm_int8_t *)&s, GFARM_OCTETS_PER_16BIT);
+	n = gfarmWriteInt8(fd, (gfarm_int8_t *)&s, GFARM_OCTETS_PER_16BIT,
+			   timeoutMsec);
 	if (n != GFARM_OCTETS_PER_16BIT) {
 	    return i;
 	}
@@ -376,7 +423,7 @@ gfarmWriteInt16(int fd, gfarm_int16_t *buf, int len)
 
 
 int
-gfarmWriteInt32(int fd, gfarm_int32_t *buf, int len)
+gfarmWriteInt32(int fd, gfarm_int32_t *buf, int len, int timeoutMsec)
 {
     int i;
     int n;
@@ -384,7 +431,8 @@ gfarmWriteInt32(int fd, gfarm_int32_t *buf, int len)
 
     for (i = 0; i < len; i++) {
 	l = htonl(buf[i]);
-	n = gfarmWriteInt8(fd, (gfarm_int8_t *)&l, GFARM_OCTETS_PER_32BIT);
+	n = gfarmWriteInt8(fd, (gfarm_int8_t *)&l, GFARM_OCTETS_PER_32BIT,
+			   timeoutMsec);
 	if (n != GFARM_OCTETS_PER_32BIT) {
 	    return i;
 	}
diff --git a/lib/libgfarm/gfsl/tcputil.h b/lib/libgfarm/gfsl/tcputil.h
index 48fd0e1..fc0581a 100644
--- a/lib/libgfarm/gfsl/tcputil.h
+++ b/lib/libgfarm/gfsl/tcputil.h
@@ -15,6 +15,9 @@ extern int	gfarmReadInt16(int fd, gfarm_int16_t *buf, int len,
 			      int timtoueMsec);
 extern int	gfarmReadInt32(int fd, gfarm_int32_t *buf, int len,
 			      int timtoueMsec);
-extern int	gfarmWriteInt8(int fd, gfarm_int8_t *buf, int len);
-extern int	gfarmWriteInt16(int fd, gfarm_int16_t *buf, int len);
-extern int	gfarmWriteInt32(int fd, gfarm_int32_t *buf, int len);
+extern int	gfarmWriteInt8(int fd, gfarm_int8_t *buf, int len,
+				int timeoutMsec);
+extern int	gfarmWriteInt16(int fd, gfarm_int16_t *buf, int len,
+				int timeoutMsec);
+extern int	gfarmWriteInt32(int fd, gfarm_int32_t *buf, int len,
+				int timeoutMsec);
diff --git a/lib/libgfarm/gfutil/gfutil.h b/lib/libgfarm/gfutil/gfutil.h
index 0dd4f57..3a4d776 100644
--- a/lib/libgfarm/gfutil/gfutil.h
+++ b/lib/libgfarm/gfutil/gfutil.h
@@ -34,6 +34,9 @@ enum gflog_fatal_actions {
 void gflog_set_fatal_action(int);
 int gflog_fatal_action_name_to_number(const char *);
 
+void gfarm_peer_name_string(int, char *, size_t, int,
+	const char **, const char **);
+
 /* privlock */
 
 void gfarm_privilege_lock_disable(void);
diff --git a/lib/libgfarm/gfutil/logutil.c b/lib/libgfarm/gfutil/logutil.c
index 1ab54e6..343d20e 100644
--- a/lib/libgfarm/gfutil/logutil.c
+++ b/lib/libgfarm/gfutil/logutil.c
@@ -8,6 +8,10 @@
 #include <time.h>
 #include <pthread.h>
 
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h> /* gai_strerror() */
+
 #include <gfarm/error.h>
 #include <gfarm/gfarm_misc.h>
 
@@ -18,6 +22,8 @@
 #include "gfutil.h"
 #include "gflog_reduced.h"
 
+#include "gfnetdb.h"
+
 #define LOG_LENGTH_MAX	2048
 
 #define GFARM_CATALOG_SET_NO 1
@@ -639,3 +645,29 @@ gflog_reduced_message(int msg_no, int priority, const char *file, int line_no,
 		state->stat_start = current_time;
 	}
 }
+
+/* utilit for logging */
+void
+gfarm_peer_name_string(int sock, char *hostbuf, size_t hostlen, int flags,
+	const char **prefixp, const char **addrp)
+{
+	int gai_error;
+	struct sockaddr_storage sa;
+	socklen_t sa_len = sizeof(sa);
+	const char *prefix, *addr;
+
+	if (getpeername(sock, (struct sockaddr *)&sa, &sa_len) == -1) {
+		prefix = "cannot get peer address: ";
+		addr = strerror(errno);
+	} else if ((gai_error = gfarm_getnameinfo(
+	    (struct sockaddr *)&sa, sa_len, hostbuf, hostlen, NULL, 0, flags))
+	    != 0) {
+		prefix = "cannot convert peer address to string: ";
+		addr = gai_strerror(gai_error);
+	} else {
+		prefix = "";
+		addr = hostbuf;
+	}
+	*prefixp = prefix;
+	*addrp = addr;
+}
diff --git a/server/gfmd/abstract_host.c b/server/gfmd/abstract_host.c
index f5b83a7..9f79bf0 100644
--- a/server/gfmd/abstract_host.c
+++ b/server/gfmd/abstract_host.c
@@ -785,7 +785,7 @@ gfm_server_channel_disconnect_request(struct abstract_host *host,
  * synchronous mode of back_channel is only used before gfarm-2.4.0
  */
 gfarm_error_t
-gfm_client_channel_vsend_request(struct abstract_host *host,
+gfm_client_channel_vsend_request_notimeout(struct abstract_host *host,
 	struct peer *peer0, const char *diag,
 	result_callback_t result_callback,
 	disconnect_callback_t disconnect_callback, void *closure,
@@ -834,13 +834,14 @@ gfm_client_channel_vsend_request(struct abstract_host *host,
 	server = peer_get_conn(peer);
 
 	if (async != NULL) { /* is asynchronous mode? */
-		e = gfp_xdr_vsend_async_request(server,
+		e = gfp_xdr_vsend_async_request_notimeout(server,
 		    async, result_callback, disconnect_callback, closure,
 		    command, format, app);
 #ifdef COMPAT_GFARM_2_3
 	} else { /*  synchronous mode */
 		host_set_callback(host, peer,
 		    result_callback, disconnect_callback, closure);
+		/* *_notimeout() is unnecessary for synchronous protocol */
 		e = gfp_xdr_vrpc_request(server,
 		    command, &format, app);
 		if (*format != '\0') {
@@ -891,7 +892,7 @@ gfm_server_channel_vget_request(struct peer *peer, size_t size,
 /* XXX FIXME: currently called by threads in back_channel_recv_thread_pool or
  *            gfmdc_recv_thread_pool */
 gfarm_error_t
-gfm_server_channel_vput_reply(struct abstract_host *host,
+gfm_server_channel_vput_reply_notimeout(struct abstract_host *host,
 	struct peer *peer0, gfp_xdr_xid_t xid,
 	const char *diag, gfarm_error_t errcode, char *format, va_list *app)
 {
@@ -916,9 +917,10 @@ gfm_server_channel_vput_reply(struct abstract_host *host,
 		return (GFARM_ERR_CONNECTION_ABORTED);
 	}
 	client = peer_get_conn(peer);
-	e = gfp_xdr_vsend_async_result(client, xid, errcode, format, app);
+	e = gfp_xdr_vsend_async_result_notimeout(
+	    client, xid, errcode, format, app);
 	if (e == GFARM_ERR_NO_ERROR)
-		e = gfp_xdr_flush(client);
+		e = gfp_xdr_flush_notimeout(client);
 
 	abstract_host_sender_unlock(host, peer, diag);
 
diff --git a/server/gfmd/abstract_host.h b/server/gfmd/abstract_host.h
index 22bfc25..4f07ae9 100644
--- a/server/gfmd/abstract_host.h
+++ b/server/gfmd/abstract_host.h
@@ -85,12 +85,13 @@ void gfm_server_channel_already_disconnected_message(struct abstract_host *,
 	const char *, const char *, const char *);
 gfarm_error_t gfm_server_channel_vget_request(struct peer *, size_t,
 	const char *, const char *, va_list *);
-gfarm_error_t gfm_server_channel_vput_reply(struct abstract_host *,
+gfarm_error_t gfm_server_channel_vput_reply_notimeout(struct abstract_host *,
 	struct peer *, gfp_xdr_xid_t, const char *, gfarm_error_t,
 	char *, va_list *);
 
 #define GFM_CLIENT_CHANNEL_TIMEOUT_INFINITY	-1
-gfarm_error_t gfm_client_channel_vsend_request(struct abstract_host *,
+gfarm_error_t gfm_client_channel_vsend_request_notimeout(
+	struct abstract_host *,
 	struct peer *, const char *, result_callback_t, disconnect_callback_t,
 	void *,
 #ifdef COMPAT_GFARM_2_3
diff --git a/server/gfmd/back_channel.c b/server/gfmd/back_channel.c
index 9aaeceb..0982dbd 100644
--- a/server/gfmd/back_channel.c
+++ b/server/gfmd/back_channel.c
@@ -103,7 +103,7 @@ gfm_async_server_put_reply(struct host *host,
 	va_list ap;
 
 	va_start(ap, format);
-	e = gfm_server_channel_vput_reply(
+	e = gfm_server_channel_vput_reply_notimeout(
 	    host_to_abstract_host(host), peer, xid, diag,
 	    errcode, format, &ap);
 	va_end(ap);
@@ -199,7 +199,7 @@ gfs_client_status_free(void *p, void *arg)
 }
 
 static gfarm_error_t
-gfs_client_send_request(struct host *host,
+gfs_client_send_request_notimeout(struct host *host,
 	struct peer *peer0, const char *diag,
 	gfarm_int32_t (*result_callback)(void *, void *, size_t),
 	void (*disconnect_callback)(void *, void *),
@@ -210,7 +210,7 @@ gfs_client_send_request(struct host *host,
 	va_list ap;
 
 	va_start(ap, format);
-	e = gfm_client_channel_vsend_request(
+	e = gfm_client_channel_vsend_request_notimeout(
 	    host_to_abstract_host(host), peer0, diag,
 	    result_callback, disconnect_callback, closure,
 #ifdef COMPAT_GFARM_2_3
@@ -253,7 +253,7 @@ gfs_client_status_request(void *arg)
 
 	/*
 	 * schedule here instead of the end of gfs_client_status_result(),
-	 * because gfs_client_send_request() may block, and we should
+	 * because gfs_client_send_request_notimeout() may block, and we should
 	 * detect it at next call of gfs_client_status_request().
 	 */
 	callout_schedule(host_status_callout(host),
@@ -268,12 +268,12 @@ gfs_client_status_request(void *arg)
 		flags = host_flags(host);
 		giant_unlock();
 
-		e = gfs_client_send_request(host, NULL, diag,
+		e = gfs_client_send_request_notimeout(host, NULL, diag,
 		    result_callback, gfs_client_status_free, host,
 		    GFM_CLIENT_CHANNEL_TIMEOUT_INFINITY, GFS_PROTO_STATUS2,
 		    "i", flags);
 	} else
-		e = gfs_client_send_request(host, NULL, diag,
+		e = gfs_client_send_request_notimeout(host, NULL, diag,
 		    result_callback, gfs_client_status_free, host,
 		    GFM_CLIENT_CHANNEL_TIMEOUT_INFINITY, GFS_PROTO_STATUS, "");
 	if (e != GFARM_ERR_NO_ERROR) {
@@ -336,7 +336,7 @@ gfs_client_fhremove_request(void *closure)
 	gfarm_error_t e;
 	static const char diag[] = "GFS_PROTO_FHREMOVE";
 
-	e = gfs_client_send_request(host, NULL, diag,
+	e = gfs_client_send_request_notimeout(host, NULL, diag,
 	    gfs_client_fhremove_result, gfs_client_fhremove_free, dfc,
 	    GFS_PROTO_FHREMOVE_TIMEOUT, GFS_PROTO_FHREMOVE, "ll", ino, gen);
 	if (e == GFARM_ERR_NO_ERROR) {
@@ -535,7 +535,7 @@ gfs_client_replication_request_request(void *closure)
 	    "GFS_PROTO_REPLICATION_REQUEST request";
 
 	if (cksum_protocol) {
-		e = gfs_client_send_request(arg->dst, peer, diag,
+		e = gfs_client_send_request_notimeout(arg->dst, peer, diag,
 		    gfs_client_replication_cksum_request_result,
 		    gfs_client_replication_request_free, arg->fr,
 		    GFS_PROTO_REPLICATION_REQUEST_TIMEOUT,
@@ -547,7 +547,7 @@ gfs_client_replication_request_request(void *closure)
 		free(arg->cksum_type);
 		free(arg->cksum);
 	} else {
-		e = gfs_client_send_request(arg->dst, peer, diag,
+		e = gfs_client_send_request_notimeout(arg->dst, peer, diag,
 		    gfs_client_replication_request_result,
 		    gfs_client_replication_request_free, arg->fr,
 		    GFS_PROTO_REPLICATION_REQUEST_TIMEOUT,
@@ -820,8 +820,8 @@ gfm_server_switch_back_channel_common(struct peer *peer, int from_client,
 		return (e2);
 
 	if (debug_mode)
-		gflog_debug(GFARM_MSG_1000404, "gfp_xdr_flush");
-	e2 = gfp_xdr_flush(peer_get_conn(peer));
+		gflog_debug(GFARM_MSG_1000404, "gfp_xdr_flush_notimeout");
+	e2 = gfp_xdr_flush_notimeout(peer_get_conn(peer));
 	if (e2 != GFARM_ERR_NO_ERROR)
 		gflog_warning(GFARM_MSG_1000405,
 		    "%s: protocol flush: %s",
diff --git a/server/gfmd/gfmd_channel.c b/server/gfmd/gfmd_channel.c
index ba7fe3c..a23d14d 100644
--- a/server/gfmd/gfmd_channel.c
+++ b/server/gfmd/gfmd_channel.c
@@ -392,7 +392,7 @@ gfmdc_server_get_request(struct peer *peer, size_t size,
 }
 
 static gfarm_error_t
-gfmdc_server_put_reply(struct mdhost *mh,
+gfmdc_server_put_reply_notimeout(struct mdhost *mh,
 	struct peer *peer, gfp_xdr_xid_t xid,
 	const char *diag, gfarm_error_t errcode, char *format, ...)
 {
@@ -400,7 +400,7 @@ gfmdc_server_put_reply(struct mdhost *mh,
 	va_list ap;
 
 	va_start(ap, format);
-	e = gfm_server_channel_vput_reply(
+	e = gfm_server_channel_vput_reply_notimeout(
 	    mdhost_to_abstract_host(mh), peer, xid, diag,
 	    errcode, format, &ap);
 	va_end(ap);
@@ -443,7 +443,7 @@ gfmdc_client_send_request(struct mdhost *mh,
 
 	va_start(ap, format);
 	/* XXX FIXME gfm_client_channel_vsend_request must be async-request */
-	e = gfm_client_channel_vsend_request(
+	e = gfm_client_channel_vsend_request_notimeout(
 	    mdhost_to_abstract_host(mh), peer0, diag,
 	    result_callback, disconnect_callback, closure,
 #ifdef COMPAT_GFARM_2_3
@@ -653,7 +653,7 @@ gfmdc_server_journal_send(struct mdhost *mh, struct peer *peer,
 #endif
 	}
 
-	e = gfmdc_server_put_reply(mh, peer, xid, diag, er, "");
+	e = gfmdc_server_put_reply_notimeout(mh, peer, xid, diag, er, "");
 	return (e);
 }
 
@@ -724,7 +724,7 @@ gfmdc_server_journal_ready_to_recv(struct mdhost *mh, struct peer *peer,
 		if (inited)
 			gfmdc_peer_set_journal_file_reader(gfmdc_peer, reader);
 	}
-	e_rpc = gfmdc_server_put_reply(mh, peer, xid, diag, e, "");
+	e_rpc = gfmdc_server_put_reply_notimeout(mh, peer, xid, diag, e, "");
 	if (e == GFARM_ERR_NO_ERROR)
 		e = e_rpc;
 	if (e == GFARM_ERR_NO_ERROR && mdhost_is_sync_replication(mh)) {
diff --git a/server/gfmd/journal_file.c b/server/gfmd/journal_file.c
index dd419a6..0e010a2 100644
--- a/server/gfmd/journal_file.c
+++ b/server/gfmd/journal_file.c
@@ -1292,7 +1292,8 @@ static struct gfp_iobuffer_ops journal_iobuffer_ops = {
 	journal_env_for_credential_fd_op,
 	journal_blocking_read_op,
 	journal_blocking_read_op,
-	journal_blocking_write_op
+	journal_blocking_write_op,
+	journal_blocking_write_op,
 };
 
 static gfarm_error_t
diff --git a/server/gfmd/rpcsubr.c b/server/gfmd/rpcsubr.c
index 159ff16..45e306d 100644
--- a/server/gfmd/rpcsubr.c
+++ b/server/gfmd/rpcsubr.c
@@ -77,7 +77,7 @@ gfm_server_put_reply(struct peer *peer, const char *diag,
 		return (e);
 	}
 	if (ecode == GFARM_ERR_NO_ERROR) {
-		e = gfp_xdr_vsend(client, &format, &ap);
+		e = gfp_xdr_vsend(client, 1, &format, &ap); /* do timeout */
 		if (e != GFARM_ERR_NO_ERROR) {
 			va_end(ap);
 			gflog_notice(GFARM_MSG_1000231,
diff --git a/server/gfsd/gfsd.c b/server/gfsd/gfsd.c
index a3f8cc8..45afabf 100644
--- a/server/gfsd/gfsd.c
+++ b/server/gfsd/gfsd.c
@@ -1123,7 +1123,7 @@ gfs_server_put_reply_common(struct gfp_xdr *client, const char *diag,
 		gflog_debug(GFARM_MSG_1000458, "reply: %s: %d (%s)",
 		    diag, (int)ecode, gfarm_error_string(ecode));
 
-	e = gfp_xdr_vsend_result(client, ecode, format, app);
+	e = gfp_xdr_vsend_result(client, 1, ecode, format, app); /*do timeout*/
 	if (e == GFARM_ERR_NO_ERROR)
 		e = gfp_xdr_flush(client);
 	if (e != GFARM_ERR_NO_ERROR) {
@@ -1195,10 +1195,11 @@ gfs_async_server_put_reply_common(struct gfp_xdr *client, gfp_xdr_xid_t xid,
 		gflog_debug(GFARM_MSG_1002381, "async_reply: %s: %d (%s)",
 		    diag, (int)ecode, gfarm_error_string(ecode));
 
-	e = gfp_xdr_vsend_async_result(client, xid, ecode, format, app);
+	e = gfp_xdr_vsend_async_result_notimeout(
+	    client, xid, ecode, format, app);
 
 	if (e == GFARM_ERR_NO_ERROR)
-		e = gfp_xdr_flush(client);
+		e = gfp_xdr_flush_notimeout(client);
 	if (e != GFARM_ERR_NO_ERROR)
 		gflog_error(GFARM_MSG_1002382, "%s put reply: %s",
 		    diag, gfarm_error_string(e));
@@ -1249,7 +1250,7 @@ gfm_async_client_send_request(struct gfp_xdr *bc_conn,
 	va_list ap;
 
 	va_start(ap, format);
-	e = gfp_xdr_vsend_async_request(bc_conn, async,
+	e = gfp_xdr_vsend_async_request_notimeout(bc_conn, async,
 	    result_callback, disconnect_callback, closure,
 	    command, format, &ap);
 	va_end(ap);