diff --git a/src/arch/x86/linux/process.cc b/src/arch/x86/linux/process.cc
index 49d3e5a..3684597 100644
--- a/src/arch/x86/linux/process.cc
+++ b/src/arch/x86/linux/process.cc
@@ -263,19 +263,19 @@
     /*  38 */ SyscallDesc("setitimer", unimplementedFunc),
     /*  39 */ SyscallDesc("getpid", getpidFunc),
     /*  40 */ SyscallDesc("sendfile", unimplementedFunc),
-    /*  41 */ SyscallDesc("socket", unimplementedFunc),
-    /*  42 */ SyscallDesc("connect", unimplementedFunc),
+    /*  41 */ SyscallDesc("socket", socketFunc<X86Linux64>),
+    /*  42 */ SyscallDesc("connect", connectFunc),
     /*  43 */ SyscallDesc("accept", unimplementedFunc),
     /*  44 */ SyscallDesc("sendto", unimplementedFunc),
     /*  45 */ SyscallDesc("recvfrom", unimplementedFunc),
     /*  46 */ SyscallDesc("sendmsg", unimplementedFunc),
     /*  47 */ SyscallDesc("recvmsg", unimplementedFunc),
-    /*  48 */ SyscallDesc("shutdown", unimplementedFunc),
-    /*  49 */ SyscallDesc("bind", unimplementedFunc),
-    /*  50 */ SyscallDesc("listen", unimplementedFunc),
+    /*  48 */ SyscallDesc("shutdown", shutdownFunc),
+    /*  49 */ SyscallDesc("bind", bindFunc),
+    /*  50 */ SyscallDesc("listen", listenFunc),
     /*  51 */ SyscallDesc("getsockname", unimplementedFunc),
     /*  52 */ SyscallDesc("getpeername", unimplementedFunc),
-    /*  53 */ SyscallDesc("socketpair", unimplementedFunc),
+    /*  53 */ SyscallDesc("socketpair", socketpairFunc<X86Linux64>),
     /*  54 */ SyscallDesc("setsockopt", unimplementedFunc),
     /*  55 */ SyscallDesc("getsockopt", unimplementedFunc),
     /*  56 */ SyscallDesc("clone", cloneFunc<X86Linux64>),
diff --git a/src/sim/fd_entry.hh b/src/sim/fd_entry.hh
index 9800119..6b2b2da 100644
--- a/src/sim/fd_entry.hh
+++ b/src/sim/fd_entry.hh
@@ -211,4 +211,30 @@
     std::string _fileName;
 };
 
+class SocketFDEntry: public HBFDEntry
+{
+  public:
+    SocketFDEntry(int sim_fd, int domain, int type, int protocol,
+                  bool close_on_exec = false)
+        : HBFDEntry(0, sim_fd, close_on_exec),
+          _domain(domain), _type(type), _protocol(protocol)
+    { }
+
+    SocketFDEntry(SocketFDEntry const& reg, bool close_on_exec = false)
+        : HBFDEntry(reg._flags, reg._simFD, close_on_exec),
+          _domain(reg._domain), _type(reg._type), _protocol(reg._protocol)
+    { }
+
+    std::shared_ptr<FDEntry>
+    clone() const override
+    {
+        return std::make_shared<SocketFDEntry>(*this);
+    }
+
+  private:
+    int _domain;
+    int _type;
+    int _protocol;
+};
+
 #endif // __FD_ENTRY_HH__
diff --git a/src/sim/syscall_emul.cc b/src/sim/syscall_emul.cc
index e79e79c..3b35d34 100644
--- a/src/sim/syscall_emul.cc
+++ b/src/sim/syscall_emul.cc
@@ -1224,3 +1224,83 @@
     return getdentsImpl<LinDent64, SYS_getdents64>(desc, callnum, p, tc);
 }
 #endif
+
+SyscallReturn
+shutdownFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+{
+    int index = 0;
+    int tgt_fd = p->getSyscallArg(tc, index);
+    int how = p->getSyscallArg(tc, index);
+
+    auto sfdp = std::dynamic_pointer_cast<SocketFDEntry>((*p->fds)[tgt_fd]);
+    if (!sfdp)
+        return -EBADF;
+    int sim_fd = sfdp->getSimFD();
+
+    int retval = shutdown(sim_fd, how);
+
+    return (retval == -1) ? -errno : retval;
+}
+
+SyscallReturn
+bindFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+{
+    int index = 0;
+    int tgt_fd = p->getSyscallArg(tc, index);
+    Addr buf_ptr = p->getSyscallArg(tc, index);
+    int addrlen = p->getSyscallArg(tc, index);
+
+    BufferArg bufSock(buf_ptr, addrlen);
+    bufSock.copyIn(tc->getMemProxy());
+
+    auto sfdp = std::dynamic_pointer_cast<SocketFDEntry>((*p->fds)[tgt_fd]);
+    if (!sfdp)
+        return -EBADF;
+    int sim_fd = sfdp->getSimFD();
+
+    int status = ::bind(sim_fd,
+                        (struct sockaddr *)bufSock.bufferPtr(),
+                        addrlen);
+
+    return (status == -1) ? -errno : status;
+}
+
+SyscallReturn
+listenFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+{
+    int index = 0;
+    int tgt_fd = p->getSyscallArg(tc, index);
+    int backlog = p->getSyscallArg(tc, index);
+
+    auto sfdp = std::dynamic_pointer_cast<SocketFDEntry>((*p->fds)[tgt_fd]);
+    if (!sfdp)
+        return -EBADF;
+    int sim_fd = sfdp->getSimFD();
+
+    int status = listen(sim_fd, backlog);
+
+    return (status == -1) ? -errno : status;
+}
+
+SyscallReturn
+connectFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+{
+    int index = 0;
+    int tgt_fd = p->getSyscallArg(tc, index);
+    Addr buf_ptr = p->getSyscallArg(tc, index);
+    int addrlen = p->getSyscallArg(tc, index);
+
+    BufferArg addr(buf_ptr, addrlen);
+    addr.copyIn(tc->getMemProxy());
+
+    auto sfdp = std::dynamic_pointer_cast<SocketFDEntry>((*p->fds)[tgt_fd]);
+    if (!sfdp)
+        return -EBADF;
+    int sim_fd = sfdp->getSimFD();
+
+    int status = connect(sim_fd,
+                         (struct sockaddr *)addr.bufferPtr(),
+                         (socklen_t)addrlen);
+
+    return (status == -1) ? -errno : status;
+}
diff --git a/src/sim/syscall_emul.hh b/src/sim/syscall_emul.hh
index 3f06869..9329f7a 100644
--- a/src/sim/syscall_emul.hh
+++ b/src/sim/syscall_emul.hh
@@ -79,6 +79,7 @@
 #endif
 #include <fcntl.h>
 #include <sys/mman.h>
+#include <sys/socket.h>
 #include <sys/stat.h>
 #if (NO_STATFS == 0)
 #include <sys/statfs.h>
@@ -181,6 +182,10 @@
 SyscallReturn munmapFunc(SyscallDesc *desc, int num,
                          Process *p, ThreadContext *tc);
 
+/// Target shutdown() handler.
+SyscallReturn shutdownFunc(SyscallDesc *desc, int num,
+                           Process *p, ThreadContext *tc);
+
 /// Target gethostname() handler.
 SyscallReturn gethostnameFunc(SyscallDesc *desc, int num,
                               Process *p, ThreadContext *tc);
@@ -303,6 +308,18 @@
 SyscallReturn getpidFunc(SyscallDesc *desc, int num,
                          Process *p, ThreadContext *tc);
 
+// Target bind() handler.
+SyscallReturn bindFunc(SyscallDesc *desc, int num,
+                       Process *p, ThreadContext *tc);
+
+// Target listen() handler.
+SyscallReturn listenFunc(SyscallDesc *desc, int num,
+                         Process *p, ThreadContext *tc);
+
+// Target connect() handler.
+SyscallReturn connectFunc(SyscallDesc *desc, int num,
+                          Process *p, ThreadContext *tc);
+
 #if defined(SYS_getdents)
 // Target getdents() handler.
 SyscallReturn getdentsFunc(SyscallDesc *desc, int num,
@@ -2080,5 +2097,49 @@
     return 0;
 }
 
+template <class OS>
+SyscallReturn
+socketFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+{
+    int index = 0;
+    int domain = p->getSyscallArg(tc, index);
+    int type = p->getSyscallArg(tc, index);
+    int prot = p->getSyscallArg(tc, index);
+
+    int sim_fd = socket(domain, type, prot);
+    if (sim_fd == -1)
+        return -errno;
+
+    auto sfdp = std::make_shared<SocketFDEntry>(sim_fd, domain, type, prot);
+    int tgt_fd = p->fds->allocFD(sfdp);
+
+    return tgt_fd;
+}
+
+template <class OS>
+SyscallReturn
+socketpairFunc(SyscallDesc *desc, int num, Process *p, ThreadContext *tc)
+{
+    int index = 0;
+    int domain = p->getSyscallArg(tc, index);
+    int type = p->getSyscallArg(tc, index);
+    int prot = p->getSyscallArg(tc, index);
+    Addr svPtr = p->getSyscallArg(tc, index);
+
+    BufferArg svBuf((Addr)svPtr, 2 * sizeof(int));
+    int status = socketpair(domain, type, prot, (int *)svBuf.bufferPtr());
+    if (status == -1)
+        return -errno;
+
+    int *fds = (int *)svBuf.bufferPtr();
+
+    auto sfdp1 = std::make_shared<SocketFDEntry>(fds[0], domain, type, prot);
+    fds[0] = p->fds->allocFD(sfdp1);
+    auto sfdp2 = std::make_shared<SocketFDEntry>(fds[1], domain, type, prot);
+    fds[1] = p->fds->allocFD(sfdp2);
+    svBuf.copyOut(tc->getMemProxy());
+
+    return status;
+}
 
 #endif // __SIM_SYSCALL_EMUL_HH__