renamed xlator/protocol to xlator/protocol/legacy

Signed-off-by: Amar Tumballi <amar@gluster.com>
Signed-off-by: Raghavendra G <raghavendra@gluster.com>
Signed-off-by: Anand V. Avati <avati@dev.gluster.com>

BUG: 875 (Implement a new protocol to provide proper backward/forward compatibility)
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=875

5 files changed, 1769 insertions, 0 deletions

diff --git a/xlators/protocol/legacy/lib/src/Makefile.am b/xlators/protocol/legacy/lib/src/Makefile.am
new file mode 100644
index 000000000..1f0e93e30
--- /dev/null
+++ b/xlators/protocol/legacy/lib/src/Makefile.am
@@ -0,0 +1,14 @@
+lib_LTLIBRARIES = libgfproto.la
+
+libgfproto_la_CFLAGS = -fPIC  -Wall -g -shared -nostartfiles $(GF_CFLAGS) $(GF_DARWIN_LIBGLUSTERFS_CFLAGS)
+
+libgfproto_la_CPPFLAGS = -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64 -D_GNU_SOURCE  \
+	-D$(GF_HOST_OS) -DLIBDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/auth\"     \
+	-DTRANSPORTDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/transport\"          \
+	-I$(CONTRIBDIR)/rbtree -I$(top_srcdir)/libglusterfs/src/
+
+libgfproto_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
+
+libgfproto_la_SOURCES = transport.c protocol.c
+
+noinst_HEADERS = transport.h protocol.h
diff --git a/xlators/protocol/legacy/lib/src/protocol.c b/xlators/protocol/legacy/lib/src/protocol.c
new file mode 100644
index 000000000..63950f43d
--- /dev/null
+++ b/xlators/protocol/legacy/lib/src/protocol.c
@@ -0,0 +1,108 @@
+
+#include "globals.h"
+#include "compat.h"
+#include "protocol.h"
+
+char *gf_mop_list[GF_MOP_MAXVALUE];
+char *gf_cbk_list[GF_CBK_MAXVALUE];
+
+static int
+gf_dirent_nb_size (gf_dirent_t *entries)
+{
+	return (sizeof (struct gf_dirent_nb) + strlen (entries->d_name) + 1);
+}
+
+int
+gf_dirent_serialize (gf_dirent_t *entries, char *buf, size_t buf_size)
+{
+	struct gf_dirent_nb *entry_nb = NULL;
+	gf_dirent_t         *entry = NULL;
+	int                  size = 0;
+	int                  entry_size = 0;
+
+
+	list_for_each_entry (entry, &entries->list, list) {
+		entry_size = gf_dirent_nb_size (entry);
+
+		if (buf && (size + entry_size <= buf_size)) {
+			entry_nb = (void *) (buf + size);
+
+			entry_nb->d_ino  = hton64 (entry->d_ino);
+			entry_nb->d_off  = hton64 (entry->d_off);
+			entry_nb->d_len  = hton32 (entry->d_len);
+			entry_nb->d_type = hton32 (entry->d_type);
+
+                        gf_stat_from_iatt (&entry_nb->d_stat, &entry->d_stat);
+
+			strcpy (entry_nb->d_name, entry->d_name);
+		}
+		size += entry_size;
+	}
+
+	return size;
+}
+
+
+int
+gf_dirent_unserialize (gf_dirent_t *entries, const char *buf, size_t buf_size)
+{
+	struct gf_dirent_nb *entry_nb = NULL;
+	int                  remaining_size = 0;
+	int                  least_dirent_size = 0;
+	int                  count = 0;
+	gf_dirent_t         *entry = NULL;
+	int                  entry_strlen = 0;
+	int                  entry_len = 0;
+
+
+	remaining_size = buf_size;
+	least_dirent_size = (sizeof (struct gf_dirent_nb) + 2);
+
+	while (remaining_size >= least_dirent_size) {
+		entry_nb = (void *)(buf + (buf_size - remaining_size));
+
+		entry_strlen = strnlen (entry_nb->d_name, remaining_size);
+		if (entry_strlen == remaining_size) {
+			break;
+		}
+
+		entry_len = sizeof (gf_dirent_t) + entry_strlen + 1;
+		entry = GF_CALLOC (1, entry_len, gf_common_mt_gf_dirent_t);
+		if (!entry) {
+			break;
+		}
+
+		entry->d_ino  = ntoh64 (entry_nb->d_ino);
+		entry->d_off  = ntoh64 (entry_nb->d_off);
+		entry->d_len  = ntoh32 (entry_nb->d_len);
+		entry->d_type = ntoh32 (entry_nb->d_type);
+
+                gf_stat_to_iatt (&entry_nb->d_stat, &entry->d_stat);
+
+		strcpy (entry->d_name, entry_nb->d_name);
+
+		list_add_tail (&entry->list, &entries->list);
+
+		remaining_size -= (sizeof (*entry_nb) + entry_strlen + 1);
+		count++;
+	}
+
+	return count;
+}
+
+int
+protocol_common_init (void)
+{
+        gf_mop_list[GF_MOP_SETVOLUME]   = "SETVOLUME";
+        gf_mop_list[GF_MOP_GETVOLUME]   = "GETVOLUME";
+        gf_mop_list[GF_MOP_SETSPEC]     = "SETSPEC";
+        gf_mop_list[GF_MOP_GETSPEC]     = "GETSPEC";
+        gf_mop_list[GF_MOP_LOG]         = "LOG";
+        gf_mop_list[GF_MOP_PING]        = "PING";
+
+        gf_cbk_list[GF_CBK_FORGET]      = "FORGET";
+        gf_cbk_list[GF_CBK_RELEASE]     = "RELEASE";
+        gf_cbk_list[GF_CBK_RELEASEDIR]  = "RELEASEDIR";
+
+        return 0;
+}
diff --git a/xlators/protocol/legacy/lib/src/protocol.h b/xlators/protocol/legacy/lib/src/protocol.h
new file mode 100644
index 000000000..254e36e66
--- /dev/null
+++ b/xlators/protocol/legacy/lib/src/protocol.h
@@ -0,0 +1,1119 @@
+/*
+  Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.com>
+  This file is part of GlusterFS.
+
+  GlusterFS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published
+  by the Free Software Foundation; either version 3 of the License,
+  or (at your option) any later version.
+
+  GlusterFS is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _PROTOCOL_H
+#define _PROTOCOL_H
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include <inttypes.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "byte-order.h"
+#include "iatt.h"
+
+/* Any changes in the protocol structure or adding new '[f,m]ops' needs to 
+ * bump the protocol version by "0.1" 
+ */
+
+#define GF_PROTOCOL_VERSION "3.0"
+
+extern char *gf_mop_list[];
+extern char *gf_cbk_list[];
+
+/* NOTE: add members ONLY at the end (just before _MAXVALUE) */
+typedef enum {
+        GF_PROTO_FOP_STAT,       /* 0 */
+        GF_PROTO_FOP_READLINK,   /* 1 */
+        GF_PROTO_FOP_MKNOD,      /* 2 */
+        GF_PROTO_FOP_MKDIR,
+        GF_PROTO_FOP_UNLINK,
+        GF_PROTO_FOP_RMDIR,      /* 5 */
+        GF_PROTO_FOP_SYMLINK,
+        GF_PROTO_FOP_RENAME,
+        GF_PROTO_FOP_LINK,
+        GF_PROTO_FOP_TRUNCATE,
+        GF_PROTO_FOP_OPEN,       /* 10 */
+        GF_PROTO_FOP_READ,
+        GF_PROTO_FOP_WRITE,
+        GF_PROTO_FOP_STATFS,     /* 15 */
+        GF_PROTO_FOP_FLUSH,
+        GF_PROTO_FOP_FSYNC,
+        GF_PROTO_FOP_SETXATTR,
+        GF_PROTO_FOP_GETXATTR,
+        GF_PROTO_FOP_REMOVEXATTR,/* 20 */
+        GF_PROTO_FOP_OPENDIR,
+        GF_PROTO_FOP_GETDENTS,
+        GF_PROTO_FOP_FSYNCDIR,
+        GF_PROTO_FOP_ACCESS,
+        GF_PROTO_FOP_CREATE,     /* 25 */
+        GF_PROTO_FOP_FTRUNCATE,
+        GF_PROTO_FOP_FSTAT,
+        GF_PROTO_FOP_LK,
+        GF_PROTO_FOP_LOOKUP,
+        GF_PROTO_FOP_SETDENTS,
+        GF_PROTO_FOP_READDIR,
+        GF_PROTO_FOP_INODELK,   /* 35 */
+        GF_PROTO_FOP_FINODELK,
+	GF_PROTO_FOP_ENTRYLK,
+	GF_PROTO_FOP_FENTRYLK,
+        GF_PROTO_FOP_CHECKSUM,
+        GF_PROTO_FOP_XATTROP,  /* 40 */
+        GF_PROTO_FOP_FXATTROP,
+        GF_PROTO_FOP_LOCK_NOTIFY,
+        GF_PROTO_FOP_LOCK_FNOTIFY,
+        GF_PROTO_FOP_FGETXATTR,
+        GF_PROTO_FOP_FSETXATTR, /* 45 */
+        GF_PROTO_FOP_RCHECKSUM,
+        GF_PROTO_FOP_SETATTR,
+        GF_PROTO_FOP_FSETATTR,
+        GF_PROTO_FOP_READDIRP,
+        GF_PROTO_FOP_MAXVALUE,
+} glusterfs_proto_fop_t;
+
+/* NOTE: add members ONLY at the end (just before _MAXVALUE) */
+typedef enum {
+        GF_MOP_SETVOLUME, /* 0 */
+        GF_MOP_GETVOLUME, /* 1 */
+        GF_MOP_STATS,
+        GF_MOP_SETSPEC,
+        GF_MOP_GETSPEC,
+	GF_MOP_PING,      /* 5 */
+        GF_MOP_LOG,
+        GF_MOP_NOTIFY,
+        GF_MOP_MAXVALUE,   /* 8 */
+} glusterfs_mop_t;
+
+typedef enum {
+	GF_CBK_FORGET,      /* 0 */
+	GF_CBK_RELEASE,     /* 1 */
+	GF_CBK_RELEASEDIR,  /* 2 */
+	GF_CBK_MAXVALUE     /* 3 */
+} glusterfs_cbk_t;
+
+typedef enum {
+        GF_OP_TYPE_FOP_REQUEST = 1,
+        GF_OP_TYPE_MOP_REQUEST,
+	GF_OP_TYPE_CBK_REQUEST,
+        GF_OP_TYPE_FOP_REPLY,
+        GF_OP_TYPE_MOP_REPLY,
+	GF_OP_TYPE_CBK_REPLY
+} glusterfs_op_type_t;
+
+
+struct gf_stat {
+	uint64_t ino;
+	uint64_t size;
+	uint64_t blocks;
+	uint64_t dev;
+	uint32_t rdev;
+	uint32_t mode;
+	uint32_t nlink;
+	uint32_t uid;
+	uint32_t gid;
+	uint32_t blksize;
+	uint32_t atime;
+	uint32_t atime_nsec;
+	uint32_t mtime ;
+	uint32_t mtime_nsec;
+	uint32_t ctime;
+	uint32_t ctime_nsec;
+} __attribute__((packed));
+
+
+static inline void
+gf_stat_to_stat (struct gf_stat *gf_stat, struct stat *stat)
+{
+	stat->st_dev          = ntoh64 (gf_stat->dev);
+	stat->st_ino          = ntoh64 (gf_stat->ino);
+	stat->st_mode         = ntoh32 (gf_stat->mode);
+	stat->st_nlink        = ntoh32 (gf_stat->nlink);
+	stat->st_uid          = ntoh32 (gf_stat->uid);
+	stat->st_gid          = ntoh32 (gf_stat->gid);
+	stat->st_rdev         = ntoh32 (gf_stat->rdev);
+	stat->st_size         = ntoh64 (gf_stat->size);
+	stat->st_blksize      = ntoh32 (gf_stat->blksize);
+	stat->st_blocks       = ntoh64 (gf_stat->blocks);
+	stat->st_atime        = ntoh32 (gf_stat->atime);
+	stat->st_mtime        = ntoh32 (gf_stat->mtime);
+	stat->st_ctime        = ntoh32 (gf_stat->ctime);
+        ST_ATIM_NSEC_SET(stat, ntoh32 (gf_stat->atime_nsec));
+        ST_MTIM_NSEC_SET(stat, ntoh32 (gf_stat->mtime_nsec));
+        ST_CTIM_NSEC_SET(stat, ntoh32 (gf_stat->ctime_nsec));
+}
+
+
+static inline void
+gf_stat_from_stat (struct gf_stat *gf_stat, struct stat *stat)
+{
+	gf_stat->dev         = hton64 (stat->st_dev);
+	gf_stat->ino         = hton64 (stat->st_ino);
+	gf_stat->mode        = hton32 (stat->st_mode);
+	gf_stat->nlink       = hton32 (stat->st_nlink);
+	gf_stat->uid         = hton32 (stat->st_uid);
+	gf_stat->gid         = hton32 (stat->st_gid);
+	gf_stat->rdev        = hton32 (stat->st_rdev);
+	gf_stat->size        = hton64 (stat->st_size);
+	gf_stat->blksize     = hton32 (stat->st_blksize);
+	gf_stat->blocks      = hton64 (stat->st_blocks);
+	gf_stat->atime       = hton32 (stat->st_atime);
+	gf_stat->mtime       = hton32 (stat->st_mtime);
+	gf_stat->ctime       = hton32 (stat->st_ctime);
+        gf_stat->atime_nsec  = hton32 (ST_ATIM_NSEC(stat));
+        gf_stat->mtime_nsec  = hton32 (ST_MTIM_NSEC(stat));
+        gf_stat->ctime_nsec  = hton32 (ST_CTIM_NSEC(stat));
+}
+
+
+static inline void
+gf_stat_to_iatt (struct gf_stat *gf_stat, struct iatt *iatt)
+{
+        iatt->ia_ino        = ntoh64 (gf_stat->ino);
+        iatt->ia_dev        = ntoh64 (gf_stat->dev);
+        iatt->ia_type       = ia_type_from_st_mode (ntoh32 (gf_stat->mode));
+        iatt->ia_prot       = ia_prot_from_st_mode (ntoh32 (gf_stat->mode));
+        iatt->ia_nlink      = ntoh32 (gf_stat->nlink);
+        iatt->ia_uid        = ntoh32 (gf_stat->uid);
+        iatt->ia_gid        = ntoh32 (gf_stat->gid);
+        iatt->ia_rdev       = ntoh64 (gf_stat->rdev);
+        iatt->ia_size       = ntoh64 (gf_stat->size);
+        iatt->ia_blksize    = ntoh32 (gf_stat->blksize);
+        iatt->ia_blocks     = ntoh64 (gf_stat->blocks);
+        iatt->ia_atime      = ntoh32 (gf_stat->atime);
+        iatt->ia_atime_nsec = ntoh32 (gf_stat->atime_nsec);
+        iatt->ia_mtime      = ntoh32 (gf_stat->mtime);
+        iatt->ia_mtime_nsec = ntoh32 (gf_stat->mtime_nsec);
+        iatt->ia_ctime      = ntoh32 (gf_stat->ctime);
+        iatt->ia_ctime_nsec = ntoh32 (gf_stat->ctime_nsec);
+
+        iatt->ia_gen        = ntoh64 (gf_stat->dev);
+}
+
+
+static inline void
+gf_stat_from_iatt (struct gf_stat *gf_stat, struct iatt *iatt)
+{
+        gf_stat->ino        = hton64 (iatt->ia_ino);
+        gf_stat->dev        = hton64 (iatt->ia_dev);
+        gf_stat->mode       = hton32 (st_mode_from_ia (iatt->ia_prot,
+                                                       iatt->ia_type));
+        gf_stat->nlink      = hton32 (iatt->ia_nlink);
+        gf_stat->uid        = hton32 (iatt->ia_uid);
+        gf_stat->gid        = hton32 (iatt->ia_gid);
+        gf_stat->rdev       = hton32 (iatt->ia_rdev);
+        gf_stat->size       = hton64 (iatt->ia_size);
+        gf_stat->blksize    = hton32 (iatt->ia_blksize);
+        gf_stat->blocks     = hton64 (iatt->ia_blocks);
+        gf_stat->atime      = hton32 (iatt->ia_atime);
+        gf_stat->atime_nsec = hton32 (iatt->ia_atime_nsec);
+        gf_stat->mtime      = hton32 (iatt->ia_mtime);
+        gf_stat->mtime_nsec = hton32 (iatt->ia_mtime_nsec);
+        gf_stat->ctime      = hton32 (iatt->ia_ctime);
+        gf_stat->ctime_nsec = hton32 (iatt->ia_ctime_nsec);
+
+        gf_stat->dev        = hton64 (iatt->ia_gen);
+
+}
+
+
+struct gf_statfs {
+	uint64_t bsize;
+	uint64_t frsize;
+	uint64_t blocks;
+	uint64_t bfree;
+	uint64_t bavail;
+	uint64_t files;
+	uint64_t ffree;
+	uint64_t favail;
+	uint64_t fsid;
+	uint64_t flag;
+	uint64_t namemax;
+} __attribute__((packed));
+
+
+static inline void
+gf_statfs_to_statfs (struct gf_statfs *gf_stat, struct statvfs *stat)
+{
+	stat->f_bsize   = ntoh64 (gf_stat->bsize);
+	stat->f_frsize  = ntoh64 (gf_stat->frsize);
+	stat->f_blocks  = ntoh64 (gf_stat->blocks);
+	stat->f_bfree   = ntoh64 (gf_stat->bfree);
+	stat->f_bavail  = ntoh64 (gf_stat->bavail);
+	stat->f_files   = ntoh64 (gf_stat->files);
+	stat->f_ffree   = ntoh64 (gf_stat->ffree);
+	stat->f_favail  = ntoh64 (gf_stat->favail);
+	stat->f_fsid    = ntoh64 (gf_stat->fsid);
+	stat->f_flag    = ntoh64 (gf_stat->flag);
+	stat->f_namemax = ntoh64 (gf_stat->namemax);
+}
+
+
+static inline void
+gf_statfs_from_statfs (struct gf_statfs *gf_stat, struct statvfs *stat)
+{
+	gf_stat->bsize   = hton64 (stat->f_bsize);
+	gf_stat->frsize  = hton64 (stat->f_frsize);
+	gf_stat->blocks  = hton64 (stat->f_blocks);
+	gf_stat->bfree   = hton64 (stat->f_bfree);
+	gf_stat->bavail  = hton64 (stat->f_bavail);
+	gf_stat->files   = hton64 (stat->f_files);
+	gf_stat->ffree   = hton64 (stat->f_ffree);
+	gf_stat->favail  = hton64 (stat->f_favail);
+	gf_stat->fsid    = hton64 (stat->f_fsid);
+	gf_stat->flag    = hton64 (stat->f_flag);
+	gf_stat->namemax = hton64 (stat->f_namemax);
+}
+
+
+struct gf_flock {
+	uint16_t type;
+	uint16_t whence;
+	uint64_t start;
+	uint64_t len;
+	uint32_t pid;
+} __attribute__((packed));
+
+
+static inline void
+gf_flock_to_flock (struct gf_flock *gf_flock, struct flock *flock)
+{
+	flock->l_type   = ntoh16 (gf_flock->type);
+	flock->l_whence = ntoh16 (gf_flock->whence);
+	flock->l_start  = ntoh64 (gf_flock->start);
+	flock->l_len    = ntoh64 (gf_flock->len);
+	flock->l_pid    = ntoh32 (gf_flock->pid);
+}
+
+
+static inline void
+gf_flock_from_flock (struct gf_flock *gf_flock, struct flock *flock)
+{
+	gf_flock->type   = hton16 (flock->l_type);
+	gf_flock->whence = hton16 (flock->l_whence);
+	gf_flock->start  = hton64 (flock->l_start);
+	gf_flock->len    = hton64 (flock->l_len);
+	gf_flock->pid    = hton32 (flock->l_pid);
+}
+
+
+struct gf_timespec {
+	uint32_t tv_sec;
+	uint32_t tv_nsec;
+} __attribute__((packed));
+
+
+static inline void
+gf_timespec_to_timespec (struct gf_timespec *gf_ts, struct timespec *ts)
+{
+
+	ts[0].tv_sec  = ntoh32 (gf_ts[0].tv_sec);
+	ts[0].tv_nsec = ntoh32 (gf_ts[0].tv_nsec);
+	ts[1].tv_sec  = ntoh32 (gf_ts[1].tv_sec);
+	ts[1].tv_nsec = ntoh32 (gf_ts[1].tv_nsec);
+}
+
+
+static inline void
+gf_timespec_from_timespec (struct gf_timespec *gf_ts, struct timespec *ts)
+{
+	gf_ts[0].tv_sec  = hton32 (ts[0].tv_sec);
+	gf_ts[0].tv_nsec = hton32 (ts[0].tv_nsec);
+	gf_ts[1].tv_sec  = hton32 (ts[1].tv_sec);
+	gf_ts[1].tv_nsec = hton32 (ts[1].tv_nsec);
+}
+
+
+#define GF_O_ACCMODE           003
+#define GF_O_RDONLY             00
+#define GF_O_WRONLY             01
+#define GF_O_RDWR               02
+#define GF_O_CREAT            0100
+#define GF_O_EXCL             0200
+#define GF_O_NOCTTY           0400
+#define GF_O_TRUNC           01000
+#define GF_O_APPEND          02000
+#define GF_O_NONBLOCK        04000
+#define GF_O_SYNC           010000
+#define GF_O_ASYNC          020000
+
+#define GF_O_DIRECT         040000
+#define GF_O_DIRECTORY     0200000
+#define GF_O_NOFOLLOW      0400000
+#define GF_O_NOATIME      01000000
+#define GF_O_CLOEXEC      02000000
+
+#define GF_O_LARGEFILE     0100000
+
+#define XLATE_BIT(from, to, bit)    do {                \
+                if (from & bit)                         \
+                        to = to | GF_##bit;             \
+        } while (0)
+
+#define UNXLATE_BIT(from, to, bit)  do {                \
+                if (from & GF_##bit)                    \
+                        to = to | bit;                  \
+        } while (0)
+
+#define XLATE_ACCESSMODE(from, to) do {                 \
+                switch (from & O_ACCMODE) {             \
+                case O_RDONLY: to |= GF_O_RDONLY;       \
+                        break;                          \
+                case O_WRONLY: to |= GF_O_WRONLY;       \
+                        break;                          \
+                case O_RDWR: to |= GF_O_RDWR;           \
+                        break;                          \
+                }                                       \
+        } while (0)
+
+#define UNXLATE_ACCESSMODE(from, to) do {               \
+                switch (from & GF_O_ACCMODE) {          \
+                case GF_O_RDONLY: to |= O_RDONLY;       \
+                        break;                          \
+                case GF_O_WRONLY: to |= O_WRONLY;       \
+                        break;                          \
+                case GF_O_RDWR: to |= O_RDWR;           \
+                        break;                          \
+                }                                       \
+        } while (0)
+
+static inline uint32_t
+gf_flags_from_flags (uint32_t flags)
+{
+        uint32_t gf_flags = 0;
+
+        XLATE_ACCESSMODE (flags, gf_flags);
+
+        XLATE_BIT (flags, gf_flags, O_CREAT);
+        XLATE_BIT (flags, gf_flags, O_EXCL);
+        XLATE_BIT (flags, gf_flags, O_NOCTTY);
+        XLATE_BIT (flags, gf_flags, O_TRUNC);
+        XLATE_BIT (flags, gf_flags, O_APPEND);
+        XLATE_BIT (flags, gf_flags, O_NONBLOCK);
+        XLATE_BIT (flags, gf_flags, O_SYNC);
+        XLATE_BIT (flags, gf_flags, O_ASYNC);
+
+        XLATE_BIT (flags, gf_flags, O_DIRECT);
+        XLATE_BIT (flags, gf_flags, O_DIRECTORY);
+        XLATE_BIT (flags, gf_flags, O_NOFOLLOW);
+#ifdef O_NOATIME
+        XLATE_BIT (flags, gf_flags, O_NOATIME);
+#endif
+#ifdef O_CLOEXEC
+        XLATE_BIT (flags, gf_flags, O_CLOEXEC);
+#endif
+        XLATE_BIT (flags, gf_flags, O_LARGEFILE);
+
+        return gf_flags;
+}
+
+static inline uint32_t
+gf_flags_to_flags (uint32_t gf_flags)
+{
+        uint32_t flags = 0;
+
+        UNXLATE_ACCESSMODE (gf_flags, flags);
+
+        UNXLATE_BIT (gf_flags, flags, O_CREAT);
+        UNXLATE_BIT (gf_flags, flags, O_EXCL);
+        UNXLATE_BIT (gf_flags, flags, O_NOCTTY);
+        UNXLATE_BIT (gf_flags, flags, O_TRUNC);
+        UNXLATE_BIT (gf_flags, flags, O_APPEND);
+        UNXLATE_BIT (gf_flags, flags, O_NONBLOCK);
+        UNXLATE_BIT (gf_flags, flags, O_SYNC);
+        UNXLATE_BIT (gf_flags, flags, O_ASYNC);
+
+        UNXLATE_BIT (gf_flags, flags, O_DIRECT);
+        UNXLATE_BIT (gf_flags, flags, O_DIRECTORY);
+        UNXLATE_BIT (gf_flags, flags, O_NOFOLLOW);
+#ifdef O_NOATIME
+        UNXLATE_BIT (gf_flags, flags, O_NOATIME);
+#endif
+#ifdef O_CLOEXEC
+        UNXLATE_BIT (gf_flags, flags, O_CLOEXEC);
+#endif
+        UNXLATE_BIT (gf_flags, flags, O_LARGEFILE);
+
+        return flags;
+}
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	char     path[0];     /* NULL terminated */
+} __attribute__((packed)) gf_fop_stat_req_t;;
+typedef struct {
+	struct gf_stat stat;
+} __attribute__((packed)) gf_fop_stat_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	uint32_t size;
+	char     path[0];     /* NULL terminated */
+} __attribute__((packed)) gf_fop_readlink_req_t;
+typedef struct {
+        struct gf_stat buf;
+	char     path[0]; /* NULL terminated */
+} __attribute__((packed)) gf_fop_readlink_rsp_t;
+
+
+typedef struct {
+	uint64_t par;
+        uint64_t gen;
+	uint64_t dev;
+	uint32_t mode;
+	char     path[0];     /* NULL terminated */
+	char     bname[0]; /* NULL terminated */
+} __attribute__((packed)) gf_fop_mknod_req_t;
+typedef struct {
+	struct gf_stat stat;
+        struct gf_stat preparent;
+        struct gf_stat postparent;
+} __attribute__((packed)) gf_fop_mknod_rsp_t;
+
+
+typedef struct {
+	uint64_t par;
+        uint64_t gen;
+	uint32_t mode;
+	char     path[0];     /* NULL terminated */
+	char     bname[0]; /* NULL terminated */
+} __attribute__((packed)) gf_fop_mkdir_req_t;
+typedef struct {
+	struct gf_stat stat;
+        struct gf_stat preparent;
+        struct gf_stat postparent;
+} __attribute__((packed)) gf_fop_mkdir_rsp_t;
+
+
+typedef struct {
+	uint64_t par;
+        uint64_t gen;
+	char     path[0];     /* NULL terminated */
+	char     bname[0]; /* NULL terminated */
+} __attribute__((packed)) gf_fop_unlink_req_t;
+typedef struct {
+        struct gf_stat preparent;
+        struct gf_stat postparent;
+} __attribute__((packed)) gf_fop_unlink_rsp_t;
+
+
+typedef struct {
+	uint64_t par;
+        uint64_t gen;
+	char     path[0];
+	char     bname[0]; /* NULL terminated */
+} __attribute__((packed)) gf_fop_rmdir_req_t;
+typedef struct {
+        struct gf_stat preparent;
+        struct gf_stat postparent;
+} __attribute__((packed)) gf_fop_rmdir_rsp_t;
+
+
+typedef struct {
+	uint64_t par;
+        uint64_t gen;
+	char     path[0];
+	char     bname[0];
+	char     linkname[0];
+} __attribute__((packed)) gf_fop_symlink_req_t;
+typedef struct {
+	struct gf_stat stat;
+        struct gf_stat preparent;
+        struct gf_stat postparent;
+}__attribute__((packed)) gf_fop_symlink_rsp_t;
+
+
+typedef struct {
+	uint64_t   oldpar;
+        uint64_t   oldgen;
+	uint64_t   newpar;
+        uint64_t   newgen;
+	char       oldpath[0];
+	char       oldbname[0]; /* NULL terminated */
+	char       newpath[0];
+	char       newbname[0]; /* NULL terminated */
+} __attribute__((packed)) gf_fop_rename_req_t;
+typedef struct {
+	struct gf_stat stat;
+        struct gf_stat preoldparent;
+        struct gf_stat postoldparent;
+        struct gf_stat prenewparent;
+        struct gf_stat postnewparent;
+} __attribute__((packed)) gf_fop_rename_rsp_t;
+
+
+typedef struct {
+	uint64_t   oldino;
+        uint64_t   oldgen;
+	uint64_t   newpar;
+        uint64_t   newgen;
+	char       oldpath[0];
+	char       newpath[0];
+	char       newbname[0];
+}__attribute__((packed)) gf_fop_link_req_t;
+typedef struct {
+	struct gf_stat stat;
+        struct gf_stat preparent;
+        struct gf_stat postparent;
+} __attribute__((packed)) gf_fop_link_rsp_t;
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	uint64_t offset;
+	char     path[0];
+} __attribute__((packed)) gf_fop_truncate_req_t;
+typedef struct {
+	struct gf_stat prestat;
+        struct gf_stat poststat;
+} __attribute__((packed)) gf_fop_truncate_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	uint32_t flags;
+        uint32_t wbflags;
+	char     path[0];
+} __attribute__((packed)) gf_fop_open_req_t;
+typedef struct {
+	int64_t fd;
+} __attribute__((packed)) gf_fop_open_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+	uint64_t offset;
+	uint32_t size;
+} __attribute__((packed)) gf_fop_read_req_t;
+typedef struct {
+	struct gf_stat stat;
+	char buf[0];
+} __attribute__((packed)) gf_fop_read_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+	uint64_t offset;
+	uint32_t size;
+} __attribute__((packed)) gf_fop_write_req_t;
+typedef struct {
+	struct gf_stat prestat;
+        struct gf_stat poststat;
+} __attribute__((packed)) gf_fop_write_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	char     path[0];
+} __attribute__((packed)) gf_fop_statfs_req_t;
+typedef struct {
+	struct gf_statfs statfs;
+} __attribute__((packed)) gf_fop_statfs_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+} __attribute__((packed)) gf_fop_flush_req_t;
+typedef struct { } __attribute__((packed)) gf_fop_flush_rsp_t;
+
+
+typedef struct fsync_req {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+	uint32_t data;
+} __attribute__((packed)) gf_fop_fsync_req_t;
+typedef struct {
+        struct gf_stat prestat;
+        struct gf_stat poststat;
+} __attribute__((packed)) gf_fop_fsync_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	uint32_t flags;
+	uint32_t dict_len;
+	char     dict[0];
+	char     path[0];
+} __attribute__((packed)) gf_fop_setxattr_req_t;
+typedef struct { } __attribute__((packed)) gf_fop_setxattr_rsp_t;
+
+
+typedef struct {
+        uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+	uint32_t flags;
+	uint32_t dict_len;
+	char     dict[0];
+} __attribute__((packed)) gf_fop_fsetxattr_req_t;
+typedef struct { } __attribute__((packed)) gf_fop_fsetxattr_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	uint32_t flags;
+	uint32_t dict_len;
+	char     dict[0];
+	char     path[0];
+} __attribute__((packed)) gf_fop_xattrop_req_t;
+
+typedef struct {
+	uint32_t dict_len;
+	char  dict[0];
+} __attribute__((packed)) gf_fop_xattrop_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+	uint32_t flags;
+	uint32_t dict_len;
+	char     dict[0];
+} __attribute__((packed)) gf_fop_fxattrop_req_t;
+
+typedef struct {
+	uint32_t dict_len;
+	char  dict[0];
+} __attribute__((packed)) gf_fop_fxattrop_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	uint32_t namelen;
+	char     path[0];
+	char     name[0];
+} __attribute__((packed)) gf_fop_getxattr_req_t;
+typedef struct {
+	uint32_t dict_len;
+	char     dict[0];
+} __attribute__((packed)) gf_fop_getxattr_rsp_t;
+
+
+typedef struct {
+        uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+        uint32_t namelen;
+	char     name[0];
+} __attribute__((packed)) gf_fop_fgetxattr_req_t;
+typedef struct {
+	uint32_t dict_len;
+	char     dict[0];
+} __attribute__((packed)) gf_fop_fgetxattr_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	char     path[0];
+	char     name[0];
+} __attribute__((packed)) gf_fop_removexattr_req_t;
+typedef struct { } __attribute__((packed)) gf_fop_removexattr_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	char     path[0];
+} __attribute__((packed)) gf_fop_opendir_req_t;
+typedef struct {
+	int64_t fd;
+} __attribute__((packed)) gf_fop_opendir_rsp_t;
+
+
+typedef struct fsyncdir_req {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+	int32_t  data;
+} __attribute__((packed)) gf_fop_fsyncdir_req_t;
+typedef struct {
+} __attribute__((packed)) gf_fop_fsyncdir_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+	uint64_t offset;
+	uint32_t size;
+} __attribute__((packed)) gf_fop_readdir_req_t;
+typedef struct {
+	uint32_t size;
+	char     buf[0];
+} __attribute__((packed)) gf_fop_readdir_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+	uint64_t offset;
+	uint32_t size;
+} __attribute__((packed)) gf_fop_readdirp_req_t;
+typedef struct {
+	uint32_t size;
+	char     buf[0];
+} __attribute__((packed)) gf_fop_readdirp_rsp_t;
+
+
+typedef struct  {
+	uint64_t ino;
+        uint64_t gen;
+	uint32_t mask;
+	char     path[0];
+} __attribute__((packed)) gf_fop_access_req_t;
+typedef struct {
+} __attribute__((packed)) gf_fop_access_rsp_t;
+
+
+typedef struct {
+	uint64_t par;
+        uint64_t gen;
+	uint32_t flags;
+	uint32_t mode;
+	char     path[0];
+	char     bname[0];
+} __attribute__((packed)) gf_fop_create_req_t;
+typedef struct {
+	struct gf_stat stat;
+	uint64_t       fd;
+        struct gf_stat preparent;
+        struct gf_stat postparent;
+} __attribute__((packed)) gf_fop_create_rsp_t;
+
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+	uint64_t offset;
+} __attribute__((packed)) gf_fop_ftruncate_req_t;
+typedef struct {
+	struct gf_stat prestat;
+        struct gf_stat poststat;
+} __attribute__((packed)) gf_fop_ftruncate_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+} __attribute__((packed)) gf_fop_fstat_req_t;
+typedef struct {
+	struct gf_stat stat;
+} __attribute__((packed)) gf_fop_fstat_rsp_t;
+
+
+typedef struct {
+	uint64_t        ino;
+        uint64_t        gen;
+	int64_t         fd;
+	uint32_t        cmd;
+	uint32_t        type;
+	struct gf_flock flock;
+} __attribute__((packed)) gf_fop_lk_req_t;
+typedef struct {
+	struct gf_flock flock;
+} __attribute__((packed)) gf_fop_lk_rsp_t;
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	uint32_t cmd;
+	uint32_t type;
+	struct gf_flock flock;
+	char     path[0];
+        char     volume[0];
+} __attribute__((packed)) gf_fop_inodelk_req_t;
+typedef struct {
+} __attribute__((packed)) gf_fop_inodelk_rsp_t;
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+	uint32_t cmd;
+	uint32_t type;
+	struct gf_flock flock;
+        char volume[0];
+} __attribute__((packed)) gf_fop_finodelk_req_t;
+typedef struct {
+} __attribute__((packed)) gf_fop_finodelk_rsp_t;
+
+typedef struct {
+	uint64_t  ino;
+        uint64_t  gen;
+	uint32_t  cmd;
+	uint32_t  type;
+	uint64_t  namelen;
+	char      path[0];
+	char      name[0];
+        char      volume[0];
+} __attribute__((packed)) gf_fop_entrylk_req_t;
+typedef struct {
+} __attribute__((packed)) gf_fop_entrylk_rsp_t;
+
+typedef struct {
+	uint64_t  ino;
+        uint64_t  gen;
+	int64_t   fd;
+	uint32_t  cmd;
+	uint32_t  type;
+	uint64_t  namelen;
+	char      name[0];
+        char      volume[0];
+} __attribute__((packed)) gf_fop_fentrylk_req_t;
+typedef struct {
+} __attribute__((packed)) gf_fop_fentrylk_rsp_t;
+
+typedef struct {
+	uint64_t ino; /* NOTE: used only in case of 'root' lookup */
+	uint64_t par;
+        uint64_t gen;
+	uint32_t flags;
+	uint32_t dictlen;
+	char     path[0];
+	char     bname[0];
+	char     dict[0];
+} __attribute__((packed)) gf_fop_lookup_req_t;
+typedef struct {
+	struct gf_stat stat;
+        struct gf_stat postparent;
+	uint32_t       dict_len;
+	char           dict[0];
+} __attribute__((packed)) gf_fop_lookup_rsp_t;
+
+typedef struct {
+	uint64_t  ino;
+        uint64_t  gen;
+	uint32_t  flag;
+	char      path[0];
+} __attribute__((packed)) gf_fop_checksum_req_t;
+typedef struct {
+	unsigned char fchecksum[0];
+	unsigned char dchecksum[0];
+} __attribute__((packed)) gf_fop_checksum_rsp_t;
+
+typedef struct {
+        uint64_t       ino;
+        uint64_t       gen;
+        struct gf_stat stbuf;
+        int32_t        valid;
+        char           path[0];
+} __attribute__((packed)) gf_fop_setattr_req_t;
+typedef struct {
+        struct gf_stat statpre;
+        struct gf_stat statpost;
+} __attribute__((packed)) gf_fop_setattr_rsp_t;
+
+typedef struct {
+        int64_t        fd;
+        struct gf_stat stbuf;
+        int32_t        valid;
+} __attribute__((packed)) gf_fop_fsetattr_req_t;
+typedef struct {
+        struct gf_stat statpre;
+        struct gf_stat statpost;
+} __attribute__((packed)) gf_fop_fsetattr_rsp_t;
+
+typedef struct {
+        int64_t   fd;
+        uint64_t  offset;
+        uint32_t  len;
+} __attribute__((packed)) gf_fop_rchecksum_req_t;
+typedef struct {
+        uint32_t weak_checksum;
+        unsigned char strong_checksum[0];
+} __attribute__((packed)) gf_fop_rchecksum_rsp_t;
+
+typedef struct {
+	uint32_t flags;
+	uint32_t keylen;
+	char     key[0];
+} __attribute__((packed)) gf_mop_getspec_req_t;
+typedef struct {
+	char spec[0];
+} __attribute__((packed)) gf_mop_getspec_rsp_t;
+
+
+typedef struct {
+        uint32_t msglen;
+	char     msg[0];
+} __attribute__((packed)) gf_mop_log_req_t;
+typedef struct {
+} __attribute__((packed)) gf_mop_log_rsp_t;
+
+
+typedef struct {
+	uint32_t dict_len;
+	char buf[0];
+} __attribute__((packed)) gf_mop_setvolume_req_t;
+typedef struct {
+	uint32_t dict_len;
+	char buf[0];
+} __attribute__((packed)) gf_mop_setvolume_rsp_t;
+
+
+typedef struct {
+} __attribute__((packed)) gf_mop_ping_req_t;
+typedef struct {
+} __attribute__((packed)) gf_mop_ping_rsp_t;
+
+typedef struct {
+	uint32_t  flags;
+        char buf[0];
+} __attribute__((packed)) gf_mop_notify_req_t;
+typedef struct {
+	uint32_t  flags;
+        char buf[0];
+} __attribute__((packed)) gf_mop_notify_rsp_t;
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+} __attribute__((packed)) gf_cbk_releasedir_req_t;
+typedef struct {
+} __attribute__((packed)) gf_cbk_releasedir_rsp_t;
+
+
+typedef struct {
+	uint64_t ino;
+        uint64_t gen;
+	int64_t  fd;
+} __attribute__((packed)) gf_cbk_release_req_t;
+typedef struct {
+} __attribute__((packed)) gf_cbk_release_rsp_t;
+
+
+typedef struct {
+	uint32_t count;
+	uint64_t ino_array[0];
+} __attribute__((packed)) gf_cbk_forget_req_t;
+typedef struct { } __attribute__((packed)) gf_cbk_forget_rsp_t;
+
+
+typedef struct {
+	uint32_t pid;
+	uint32_t uid;
+	uint32_t gid;
+
+        /* Number of groups being sent through the array above. */
+        uint32_t ngrps;
+
+        /* Array of groups to which the uid belongs apart from the primary group
+         * in gid.
+         */
+        uint32_t groups[GF_REQUEST_MAXGROUPS];
+
+        uint64_t lk_owner;
+} __attribute__ ((packed)) gf_hdr_req_t;
+
+
+typedef struct {
+	uint32_t op_ret;
+	uint32_t op_errno;
+} __attribute__ ((packed)) gf_hdr_rsp_t;
+
+
+typedef struct {
+	uint64_t callid;
+	uint32_t type;
+	uint32_t op;
+	uint32_t size;
+	union {
+		gf_hdr_req_t req;
+		gf_hdr_rsp_t rsp;
+	} __attribute__ ((packed));
+} __attribute__ ((packed)) gf_hdr_common_t;
+
+
+static inline gf_hdr_common_t *
+__gf_hdr_new (int size)
+{
+	gf_hdr_common_t *hdr = NULL;
+
+	/* TODO: use mem-pool */
+	hdr = GF_CALLOC (sizeof (gf_hdr_common_t) + size, 1,
+                         gf_common_mt_gf_hdr_common_t);
+
+	if (!hdr) {
+		return NULL;
+	}
+
+	hdr->size = hton32 (size);
+
+	return hdr;
+}
+
+
+#define gf_hdr_len(type, x) (sizeof (gf_hdr_common_t) + sizeof (*type) + x)
+#define gf_hdr_new(type, x) __gf_hdr_new (sizeof (*type) + x)
+
+
+static inline void *
+gf_param (gf_hdr_common_t *hdr)
+{
+	return ((void *)hdr) + sizeof (*hdr);
+}
+
+
+struct gf_dirent_nb {
+	uint64_t       d_ino;
+	uint64_t       d_off;
+	uint32_t       d_len;
+	uint32_t       d_type;
+        struct gf_stat d_stat;
+	char           d_name[0];
+} __attribute__((packed));
+
+int
+gf_dirent_unserialize (gf_dirent_t *entries, const char *buf, size_t buf_size);
+int
+gf_dirent_serialize (gf_dirent_t *entries, char *buf, size_t buf_size);
+
+int protocol_common_init (void);
+
+#endif
diff --git a/xlators/protocol/legacy/lib/src/transport.c b/xlators/protocol/legacy/lib/src/transport.c
new file mode 100644
index 000000000..d460d0209
--- /dev/null
+++ b/xlators/protocol/legacy/lib/src/transport.c
@@ -0,0 +1,422 @@
+/*
+  Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.com>
+  This file is part of GlusterFS.
+
+  GlusterFS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published
+  by the Free Software Foundation; either version 3 of the License,
+  or (at your option) any later version.
+
+  GlusterFS is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#include <dlfcn.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/poll.h>
+#include <fnmatch.h>
+#include <stdint.h>
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include "logging.h"
+#include "transport.h"
+#include "glusterfs.h"
+#include "xlator.h"
+#include "list.h"
+
+
+transport_t *
+transport_load (dict_t *options,
+		xlator_t *xl)
+{
+	struct transport *trans = NULL, *return_trans = NULL;
+	char *name = NULL;
+	void *handle = NULL;
+	char *type = NULL;
+	char str[] = "ERROR";
+	int32_t ret = -1;
+	int8_t is_tcp = 0, is_unix = 0, is_ibsdp = 0;
+	volume_opt_list_t *vol_opt = NULL;
+
+	GF_VALIDATE_OR_GOTO("transport", options, fail);
+	GF_VALIDATE_OR_GOTO("transport", xl, fail);
+  
+	trans = GF_CALLOC (1, sizeof (struct transport),
+                           gf_common_mt_transport);
+	GF_VALIDATE_OR_GOTO("transport", trans, fail);
+
+	trans->xl = xl;
+	type = str;
+
+	/* Backward compatibility */
+	ret = dict_get_str (options, "transport-type", &type);
+	if (ret < 0) {
+		ret = dict_set_str (options, "transport-type", "socket");
+		if (ret < 0)
+			gf_log ("dict", GF_LOG_DEBUG,
+				"setting transport-type failed");
+		gf_log ("transport", GF_LOG_WARNING,
+			"missing 'option transport-type'. defaulting to "
+			"\"socket\"");
+	} else {
+		{
+			/* Backword compatibility to handle * /client,
+			 * * /server. 
+			 */
+			char *tmp = strchr (type, '/');
+			if (tmp)
+				*tmp = '\0';
+		}
+		
+		is_tcp = strcmp (type, "tcp");
+		is_unix = strcmp (type, "unix");
+		is_ibsdp = strcmp (type, "ib-sdp");
+		if ((is_tcp == 0) ||
+		    (is_unix == 0) ||
+		    (is_ibsdp == 0)) {
+			if (is_unix == 0)
+				ret = dict_set_str (options, 
+						    "transport.address-family",
+						    "unix");
+			if (is_ibsdp == 0)
+				ret = dict_set_str (options, 
+						    "transport.address-family",
+						    "inet-sdp");
+
+			if (ret < 0)
+				gf_log ("dict", GF_LOG_DEBUG,
+					"setting address-family failed");
+
+			ret = dict_set_str (options, 
+					    "transport-type", "socket");
+			if (ret < 0)
+				gf_log ("dict", GF_LOG_DEBUG,
+					"setting transport-type failed");
+		}
+	}
+
+	ret = dict_get_str (options, "transport-type", &type);
+	if (ret < 0) {
+		GF_FREE (trans);
+		gf_log ("transport", GF_LOG_ERROR,
+			"'option transport-type <xx>' missing in volume '%s'",
+			xl->name);
+		goto fail;
+	}
+
+	ret = gf_asprintf (&name, "%s/%s.so", TRANSPORTDIR, type);
+        if (-1 == ret) {
+                gf_log ("transport", GF_LOG_ERROR, "asprintf failed");
+                goto fail;
+        }
+	gf_log ("transport", GF_LOG_DEBUG,
+		"attempt to load file %s", name);
+
+	handle = dlopen (name, RTLD_NOW|RTLD_GLOBAL);
+	if (handle == NULL) {
+		gf_log ("transport", GF_LOG_ERROR, "%s", dlerror ());
+		gf_log ("transport", GF_LOG_ERROR,
+			"volume '%s': transport-type '%s' is not valid or "
+			"not found on this machine", 
+			xl->name, type);
+		GF_FREE (name);
+		GF_FREE (trans);
+		goto fail;
+	}
+	GF_FREE (name);
+	
+	trans->ops = dlsym (handle, "tops");
+	if (trans->ops == NULL) {
+		gf_log ("transport", GF_LOG_ERROR,
+			"dlsym (transport_ops) on %s", dlerror ());
+		GF_FREE (trans);
+		goto fail;
+	}
+
+	trans->init = dlsym (handle, "init");
+	if (trans->init == NULL) {
+		gf_log ("transport", GF_LOG_ERROR,
+			"dlsym (gf_transport_init) on %s", dlerror ());
+		GF_FREE (trans);
+		goto fail;
+	}
+
+	trans->fini = dlsym (handle, "fini");
+	if (trans->fini == NULL) {
+		gf_log ("transport", GF_LOG_ERROR,
+			"dlsym (gf_transport_fini) on %s", dlerror ());
+		GF_FREE (trans);
+		goto fail;
+	}
+	
+	vol_opt = GF_CALLOC (1, sizeof (volume_opt_list_t),
+                             gf_common_mt_volume_opt_list_t);
+	vol_opt->given_opt = dlsym (handle, "options");
+	if (vol_opt->given_opt == NULL) {
+		gf_log ("transport", GF_LOG_DEBUG,
+			"volume option validation not specified");
+	} else {
+		list_add_tail (&vol_opt->list, &xl->volume_options);
+		if (-1 == 
+		    validate_xlator_volume_options (xl, 
+						    vol_opt->given_opt)) {
+			gf_log ("transport", GF_LOG_ERROR,
+				"volume option validation failed");
+			GF_FREE (trans);
+			goto fail;
+		}
+	}
+	
+	ret = trans->init (trans);
+	if (ret != 0) {
+		gf_log ("transport", GF_LOG_ERROR,
+			"'%s' initialization failed", type);
+		GF_FREE (trans);
+		goto fail;
+	}
+
+	pthread_mutex_init (&trans->lock, NULL);
+	return_trans = trans;
+fail:
+	return return_trans;
+}
+
+
+int32_t 
+transport_submit (transport_t *this, char *buf, int32_t len,
+		  struct iovec *vector, int count,
+                  struct iobref *iobref)
+{
+	int32_t               ret = -1;
+        transport_t          *peer_trans = NULL;
+        struct iobuf         *iobuf = NULL;
+        struct transport_msg *msg = NULL;
+
+        if (this->peer_trans) {
+                peer_trans = this->peer_trans;
+
+                msg = GF_CALLOC (1, sizeof (*msg),
+                                gf_common_mt_transport_msg);
+                if (!msg) {
+                        return -ENOMEM;
+                }
+
+                msg->hdr = buf;
+                msg->hdrlen = len;
+
+                if (vector) {
+                        iobuf = iobuf_get (this->xl->ctx->iobuf_pool);
+                        if (!iobuf) {
+                                GF_FREE (msg->hdr);
+                                GF_FREE (msg);
+                                return -ENOMEM;
+                        }
+
+                        iov_unload (iobuf->ptr, vector, count);
+                        msg->iobuf = iobuf;
+                }
+
+                pthread_mutex_lock (&peer_trans->handover.mutex);
+                {
+                        list_add_tail (&msg->list, &peer_trans->handover.msgs);
+                        pthread_cond_broadcast (&peer_trans->handover.cond);
+                }
+                pthread_mutex_unlock (&peer_trans->handover.mutex);
+
+                return 0;
+        }
+
+	GF_VALIDATE_OR_GOTO("transport", this, fail);
+	GF_VALIDATE_OR_GOTO("transport", this->ops, fail);
+	
+	ret = this->ops->submit (this, buf, len, vector, count, iobref);
+fail:
+	return ret;
+}
+
+
+int32_t 
+transport_connect (transport_t *this)
+{
+	int ret = -1;
+	
+	GF_VALIDATE_OR_GOTO("transport", this, fail);
+  
+	ret = this->ops->connect (this);
+fail:
+	return ret;
+}
+
+
+int32_t
+transport_listen (transport_t *this)
+{
+	int ret = -1;
+	
+	GF_VALIDATE_OR_GOTO("transport", this, fail);
+  
+	ret = this->ops->listen (this);
+fail:
+	return ret;
+}
+
+
+int32_t 
+transport_disconnect (transport_t *this)
+{
+	int32_t ret = -1;
+	
+	GF_VALIDATE_OR_GOTO("transport", this, fail);
+  
+	ret = this->ops->disconnect (this);
+fail:
+	return ret;
+}
+
+
+int32_t 
+transport_destroy (transport_t *this)
+{
+	int32_t ret = -1;
+
+	GF_VALIDATE_OR_GOTO("transport", this, fail);
+  
+	if (this->fini)
+		this->fini (this);
+
+	pthread_mutex_destroy (&this->lock);
+	GF_FREE (this);
+fail:
+	return ret;
+}
+
+
+transport_t *
+transport_ref (transport_t *this)
+{
+	transport_t *return_this = NULL;
+
+	GF_VALIDATE_OR_GOTO("transport", this, fail);
+	
+	pthread_mutex_lock (&this->lock);
+	{
+		this->refcount ++;
+	}
+	pthread_mutex_unlock (&this->lock);
+	
+	return_this = this;
+fail:
+	return return_this;
+}
+
+
+int32_t
+transport_receive (transport_t *this, char **hdr_p, size_t *hdrlen_p,
+		   struct iobuf **iobuf_p)
+{
+	int32_t ret = -1;
+
+	GF_VALIDATE_OR_GOTO("transport", this, fail);
+
+        if (this->peer_trans) {
+                *hdr_p = this->handover.msg->hdr;
+                *hdrlen_p = this->handover.msg->hdrlen;
+                *iobuf_p = this->handover.msg->iobuf;
+
+                return 0;
+        }
+
+	ret = this->ops->receive (this, hdr_p, hdrlen_p, iobuf_p);
+fail:
+	return ret;
+}
+
+
+int32_t
+transport_unref (transport_t *this)
+{
+	int32_t refcount = 0;
+	int32_t ret = -1;
+
+	GF_VALIDATE_OR_GOTO("transport", this, fail);
+  
+	pthread_mutex_lock (&this->lock);
+	{
+		refcount = --this->refcount;
+	}
+	pthread_mutex_unlock (&this->lock);
+
+	if (refcount == 0) {
+		xlator_notify (this->xl, GF_EVENT_TRANSPORT_CLEANUP, this);
+		transport_destroy (this);
+	}
+	
+	ret = 0;
+fail:
+	return ret;
+}
+
+
+void *
+transport_peerproc (void *trans_data)
+{
+        transport_t          *trans = NULL;
+        struct transport_msg *msg = NULL;
+
+        trans = trans_data;
+
+        while (1) {
+                pthread_mutex_lock (&trans->handover.mutex);
+                {
+                        while (list_empty (&trans->handover.msgs))
+                                pthread_cond_wait (&trans->handover.cond,
+                                                   &trans->handover.mutex);
+
+                        msg = list_entry (trans->handover.msgs.next,
+                                          struct transport_msg, list);
+
+                        list_del_init (&msg->list);
+                }
+                pthread_mutex_unlock (&trans->handover.mutex);
+
+                trans->handover.msg = msg;
+
+                xlator_notify (trans->xl, GF_EVENT_POLLIN, trans);
+
+                GF_FREE (msg);
+        }
+}
+
+
+int
+transport_setpeer (transport_t *trans, transport_t *peer_trans)
+{
+        trans->peer_trans = transport_ref (peer_trans);
+
+        INIT_LIST_HEAD (&trans->handover.msgs);
+        pthread_cond_init (&trans->handover.cond, NULL);
+        pthread_mutex_init (&trans->handover.mutex, NULL);
+        pthread_create (&trans->handover.thread, NULL,
+                        transport_peerproc, trans);
+
+        peer_trans->peer_trans = transport_ref (trans);
+
+        INIT_LIST_HEAD (&peer_trans->handover.msgs);
+        pthread_cond_init (&peer_trans->handover.cond, NULL);
+        pthread_mutex_init (&peer_trans->handover.mutex, NULL);
+        pthread_create (&peer_trans->handover.thread, NULL,
+                        transport_peerproc, peer_trans);
+
+        return 0;
+}
diff --git a/xlators/protocol/legacy/lib/src/transport.h b/xlators/protocol/legacy/lib/src/transport.h
new file mode 100644
index 000000000..f0623d5b4
--- /dev/null
+++ b/xlators/protocol/legacy/lib/src/transport.h
@@ -0,0 +1,106 @@
+/*
+  Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.com>
+  This file is part of GlusterFS.
+
+  GlusterFS is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published
+  by the Free Software Foundation; either version 3 of the License,
+  or (at your option) any later version.
+
+  GlusterFS is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see
+  <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __TRANSPORT_H__
+#define __TRANSPORT_H__
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include <inttypes.h>
+
+struct transport_ops;
+typedef struct transport transport_t;
+
+#include "xlator.h"
+#include "dict.h"
+#include "compat.h"
+
+typedef struct peer_info {
+	struct sockaddr_storage sockaddr;
+	socklen_t sockaddr_len;
+	char identifier[UNIX_PATH_MAX];
+}peer_info_t;
+
+struct transport_msg {
+        struct list_head  list;
+        char             *hdr;
+        int               hdrlen;
+        struct iobuf     *iobuf;
+};
+
+struct transport {
+	struct transport_ops  *ops;
+	void                  *private;
+	void                  *xl_private;
+	pthread_mutex_t        lock;
+	int32_t                refcount;
+
+	xlator_t              *xl;
+	void                  *dnscache;
+	data_t                *buf;
+	int32_t              (*init)   (transport_t *this);
+	void                 (*fini)   (transport_t *this);
+	/*  int                  (*notify) (transport_t *this, int event, void *data); */
+	peer_info_t     peerinfo;
+	peer_info_t     myinfo;
+
+        transport_t    *peer_trans;
+        struct {
+                pthread_mutex_t       mutex;
+                pthread_cond_t        cond;
+                pthread_t             thread;
+                struct list_head      msgs;
+                struct transport_msg *msg;
+        } handover;
+                
+};
+
+struct transport_ops {
+	int32_t (*receive)    (transport_t *this, char **hdr_p, size_t *hdrlen_p,
+                               struct iobuf **iobuf_p);
+	int32_t (*submit)     (transport_t *this, char *buf, int len,
+                               struct iovec *vector, int count,
+                               struct iobref *iobref);
+	int32_t (*connect)    (transport_t *this);
+	int32_t (*listen)     (transport_t *this);
+	int32_t (*disconnect) (transport_t *this);
+};
+
+
+int32_t transport_listen     (transport_t *this);
+int32_t transport_connect    (transport_t *this);
+int32_t transport_disconnect (transport_t *this);
+int32_t transport_notify     (transport_t *this, int event);
+int32_t transport_submit     (transport_t *this, char *buf, int len,
+                              struct iovec *vector, int count,
+                              struct iobref *iobref);
+int32_t transport_receive    (transport_t *this, char **hdr_p, size_t *hdrlen_p,
+                              struct iobuf **iobuf_p);
+int32_t transport_destroy    (transport_t *this);
+
+transport_t *transport_load  (dict_t *options, xlator_t *xl);
+transport_t *transport_ref   (transport_t *trans);
+int32_t      transport_unref (transport_t *trans);
+
+int transport_setpeer (transport_t *trans, transport_t *trans_peer);
+
+#endif /* __TRANSPORT_H__ */