diff --git a/hongweiz/adcapp/src/EINTR_wrappers.c b/hongweiz/adcapp/src/EINTR_wrappers.c
new file mode 100644
index 0000000..b60622e
--- /dev/null
+++ b/hongweiz/adcapp/src/EINTR_wrappers.c
@@ -0,0 +1,826 @@
+
+/*
+* File: EINTR_wrappers.c
+*
+* This file implements the wrapper functions for some of the System APIs
+*
+* Copyright (C) <2019>  <American Megatrends International LLC>
+*
+*/
+
+#include "EINTR_wrappers.h"
+#if defined(__linux__)
+#include <sys/msg.h>
+#include <sys/file.h>
+#endif
+#include <errno.h>
+#include <unistd.h>
+
+static const int OneSecondasNS = 1000000000;
+
+#ifndef bool
+typedef int bool;
+#endif
+
+#ifndef TRUE
+#define TRUE (1)
+#endif
+
+#ifndef FALSE
+#define FALSE (0)
+#endif
+
+typedef struct
+{
+    bool OnePoll;
+    struct timespec EndTime, Timeout;
+} SIGWRAP_TIMEOUT;
+
+static void sigwrap_InitTimeout(SIGWRAP_TIMEOUT *pDst, const struct timespec *timeout)
+{
+    pDst->Timeout = *timeout;
+
+    if ((timeout->tv_sec == 0) && (timeout->tv_nsec == 0))                  // If both value are zero than only a single poll is requested!
+    {
+        pDst->OnePoll = 1;
+        return;
+    }
+
+    pDst->OnePoll = 0;
+
+    struct timespec Now;
+
+    (void)clock_gettime(CLOCK_MONOTONIC_RAW, &Now);                         // CLOCK_MONOTONIC_RAW is not affected by NTP etc.
+
+    pDst->EndTime.tv_sec = Now.tv_sec + pDst->Timeout.tv_sec;               // Check necessary in 2038 due to signed integer variables
+    pDst->EndTime.tv_nsec = Now.tv_nsec + pDst->Timeout.tv_nsec;
+
+    if (pDst->EndTime.tv_nsec >= OneSecondasNS)
+    {
+        pDst->EndTime.tv_sec += (pDst->EndTime.tv_nsec / OneSecondasNS);
+        pDst->EndTime.tv_nsec = (pDst->EndTime.tv_nsec % OneSecondasNS);
+    }
+}
+
+
+static bool sigwrap_CheckTimeout(SIGWRAP_TIMEOUT *pTo)
+{
+    if (pTo->OnePoll == TRUE) // Make sure, that in the case that a single poll is requested at least one call is not terminated with EINTR
+        return FALSE;
+
+    struct timespec Now;
+
+    (void)clock_gettime(CLOCK_MONOTONIC_RAW, &Now);
+
+    if (Now.tv_sec > pTo->EndTime.tv_sec) // Can become a problem already in 2038 due to signed integer variables
+        return TRUE;
+
+    pTo->Timeout.tv_nsec = pTo->EndTime.tv_nsec - Now.tv_nsec;
+    pTo->Timeout.tv_sec = pTo->EndTime.tv_sec - Now.tv_sec;
+
+    if (pTo->Timeout.tv_sec == 0)
+    {
+        if (pTo->Timeout.tv_nsec <= 0)
+            return TRUE;
+    }
+    else if (pTo->Timeout.tv_nsec < 0)
+    {
+        pTo->Timeout.tv_nsec += OneSecondasNS;
+        pTo->Timeout.tv_sec--;
+    }
+
+    return FALSE;
+}
+
+
+
+int sigwrap_semop(int semid, struct sembuf *sops, size_t nsops)
+{
+    while (1)
+    {
+        if (semop(semid, sops, nsops) == 0)
+            return 0;
+
+        if (errno != EINTR)
+            return -1;
+    }
+}
+
+#if 0
+int sigwrap_semtimedop(int semid, struct sembuf *sops, size_t nsops, const struct timespec *timeout)
+{
+    SIGWRAP_TIMEOUT To;
+
+    if (timeout == NULL)
+        return (sigwrap_semop(semid, sops, nsops));
+
+    sigwrap_InitTimeout(&To, timeout);
+
+    while (1)
+    {
+        if (semtimedop(semid, sops, nsops, &To.Timeout) == 0)
+            return 0;
+
+        if (errno != EINTR)
+            return -1;
+
+        if (sigwrap_CheckTimeout(&To))
+        {
+            errno = EAGAIN;
+            return -1;
+        }
+    }
+}
+#endif
+
+int sigwrap_epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
+{
+    SIGWRAP_TIMEOUT To;
+
+    if (timeout != -1)
+    {
+        struct timespec Timeout;
+
+        Timeout.tv_sec = timeout / 1000;
+        Timeout.tv_nsec = (timeout % 1000) * 1000000; // Convert msec to nsec
+
+        sigwrap_InitTimeout(&To, &Timeout);
+    }
+
+    while (1)
+    {
+        int Result = epoll_wait(epfd, events, maxevents, timeout);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+
+        if (timeout == -1)
+            continue;
+
+        if (sigwrap_CheckTimeout(&To))
+            return 0;
+
+        timeout = To.Timeout.tv_sec * 1000 + To.Timeout.tv_nsec / 1000000;
+    }
+}
+
+
+int sigwrap_epoll_pwait(int epfd, struct epoll_event *events, int maxevents, int timeout, const sigset_t *sigmask)
+{
+    SIGWRAP_TIMEOUT To;
+
+    if (timeout != -1)
+    {
+        struct timespec Timeout;
+
+        Timeout.tv_sec = timeout / 1000;
+        Timeout.tv_nsec = (timeout % 1000) * 1000000; // Convert msec to nsec
+
+        sigwrap_InitTimeout(&To, &Timeout);
+    }
+
+    while (1)
+    {
+        int Result = epoll_pwait(epfd, events, maxevents, timeout, sigmask);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+
+        if (timeout == -1)
+            continue;
+
+        if (sigwrap_CheckTimeout(&To))
+            return 0;
+
+        timeout = To.Timeout.tv_sec * 1000 + To.Timeout.tv_nsec / 1000000;
+    }
+}
+
+
+int sigwrap_sigwaitinfo(const sigset_t *set, siginfo_t *info)
+{
+    while (1)
+    {
+        int Result = sigwaitinfo(set, info);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+    }
+}
+
+
+int sigwrap_sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout)
+{
+    SIGWRAP_TIMEOUT To;
+
+    sigwrap_InitTimeout(&To, timeout);
+
+    while (1)
+    {
+        int Result = sigtimedwait(set, info, &To.Timeout);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+
+        if (sigwrap_CheckTimeout(&To))
+            return 0;
+    }
+}
+
+
+int sigwrap_nanosleep(const struct timespec *req, struct timespec *rem)
+{
+    struct timespec Wait, Remain;
+
+    if (!rem)
+        rem = &Remain;
+
+    Wait = *req;
+
+    while (1)
+    {
+        if (nanosleep(&Wait, rem) == 0)
+            return 0;
+
+        if (errno != EINTR)
+            return -1;
+
+        Wait = *rem;
+    }
+}
+
+
+int sigwrap_clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *request, struct timespec *remain)
+{
+    struct timespec Wait, Remain;
+
+    if (!remain)
+        remain = &Remain;
+
+    Wait = *request;
+
+    while (1)
+    {
+        int Result = clock_nanosleep(clock_id, flags, &Wait, remain);
+        
+        if (Result == 0)
+            return Result;
+
+        if (Result != EINTR)
+            return Result;
+
+        if (flags != TIMER_ABSTIME)
+            Wait = *remain;
+    }
+}
+
+
+int sigwrap_usleep(useconds_t usec)
+{
+    SIGWRAP_TIMEOUT To;
+
+    struct timespec Timeout;
+
+    Timeout.tv_sec = usec / 1000000;
+    Timeout.tv_nsec = (usec % 1000000) * 1000;
+
+    sigwrap_InitTimeout(&To, &Timeout);
+
+    while (1)
+    {
+        if (usleep(usec) == 0)
+            return 0;
+
+        if (errno != EINTR)
+            return -1;
+
+        if (sigwrap_CheckTimeout(&To))
+            return 0;
+
+        usec = To.Timeout.tv_sec * 1000000 + To.Timeout.tv_nsec / 1000;
+    }
+}
+
+
+int sigwrap_poll(struct pollfd *fds, nfds_t nfds, int timeout)
+{
+    SIGWRAP_TIMEOUT To;
+
+    if (timeout > 0)
+    {
+        struct timespec Timeout;
+
+        Timeout.tv_sec = timeout / 1000;
+        Timeout.tv_nsec = (timeout % 1000) * 1000000;
+
+        sigwrap_InitTimeout(&To, &Timeout);
+    }
+
+    while (1)
+    {
+        int Result = poll(fds, nfds, timeout);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+
+        if (timeout < 0) // Specifying a negative value in timeout means an infinite/no timeout. 
+            continue;
+        else if (timeout == 0)
+            continue; // We want to make sure that at least one check was not aborted with EINTR
+
+        if (sigwrap_CheckTimeout(&To))
+            return 0;
+
+        timeout = To.Timeout.tv_sec * 1000 + To.Timeout.tv_nsec / 1000000;
+    }
+}
+
+#if 0
+int sigwrap_ppoll(struct pollfd *fds, nfds_t nfds, const struct timespec *tmo_p, const sigset_t *sigmask)
+{
+    SIGWRAP_TIMEOUT To;
+
+    if (tmo_p != NULL)
+    {
+        sigwrap_InitTimeout(&To, tmo_p);
+        tmo_p = &To.Timeout;
+    }
+
+    while (1)
+    {
+        int Result = ppoll(fds, nfds, tmo_p, sigmask);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+
+        if (tmo_p == NULL)
+            continue;
+
+        if (sigwrap_CheckTimeout(&To))
+            return 0;
+    }
+}
+#endif
+
+int sigwrap_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
+{
+    while (1)
+    {
+        int Result = select(nfds, readfds, writefds, exceptfds, timeout);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+    }
+}
+
+
+int sigwrap_pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout,
+                    const sigset_t *sigmask)
+{
+    SIGWRAP_TIMEOUT To;
+
+    if (timeout != NULL)
+    {
+        sigwrap_InitTimeout(&To, timeout);
+        timeout = &To.Timeout;
+    }
+
+    while (1)
+    {
+        int Result = pselect(nfds, readfds, writefds, exceptfds, timeout, sigmask);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+
+        if (timeout == NULL)
+            continue;
+
+        if (sigwrap_CheckTimeout(&To))
+            return 0;
+    }
+}
+
+
+int sigwrap_msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg)
+{
+    while (1)
+    {
+        int Result = msgsnd(msqid, msgp, msgsz, msgflg);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+    }
+}
+
+
+ssize_t sigwrap_msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg)
+{
+    while (1)
+    {
+        ssize_t Result = msgrcv(msqid, msgp, msgsz, msgtyp, msgflg);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+    }
+}
+
+
+int sigwrap_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
+{
+    while (1)
+    {
+        int Result = connect(sockfd, addr, addrlen);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+    }
+}
+
+
+ssize_t sigwrap_send(int sockfd, const void *buf, size_t len, int flags)
+{
+    while (1)
+    {
+        ssize_t Result = send(sockfd, buf, len, flags);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+    }
+}
+
+
+ssize_t sigwrap_sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr,
+                       socklen_t addrlen)
+{
+    while (1)
+    {
+        ssize_t Result = sendto(sockfd, buf, len, flags, dest_addr, addrlen);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+    }
+}
+
+
+ssize_t sigwrap_sendsendmsg(int sockfd, const struct msghdr *msg, int flags)
+{
+    while (1)
+    {
+        ssize_t Result = sendmsg(sockfd, msg, flags);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+    }
+}
+
+
+int sigwrap_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
+{
+    while (1)
+    {
+        int Result = accept(sockfd, addr, addrlen);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+    }
+}
+
+#if 0
+int sigwrap_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags)
+{
+    while (1)
+    {
+        int Result = accept4(sockfd, addr, addrlen, flags);
+
+        if (Result != -1)
+            return Result;
+
+        if (errno != EINTR)
+            return Result;
+    }
+}
+#endif
+
+// EINTR wrapper for the standard read() function. Can be used for sockets that are the to non-blocking mode.
+// The length of the returned data can be shorter than the requested one!
+
+ssize_t sigwrap_read(int fd, void *buf, size_t count)
+{
+    while (1)
+    {
+        ssize_t Result = read(fd, buf, count);
+
+        if (Result != -1)
+            return (Result);
+
+        if (errno != EINTR)
+            return (Result);
+    }
+}
+
+
+// EINTR wrapper for the standard read() function. Waits until ALL requested data is available. Use the non-blocking version (sigwrap_read)
+// for sockets that are set to non-blocking mode or when partial data is okay
+// Although the description for the read() function describes it differently, it seems possible that the original function may already return
+// even though partial data has already been read. This implementation makes sure that all requested data have been read.
+// See the comment in the signal description https://linux.die.net/man/7/signal
+//* read(2), readv(2), write(2), writev(2), and ioctl(2) calls on "slow" devices. 
+//* A "slow" device is one where the I/O call may block for an indefinite time, for example, a terminal, pipe, or socket. 
+//* (A disk is not a slow device according to this definition.) If an I/O call on a slow device has already transferred
+//* some data by the time it is interrupted by a signal handler, then the call will return a success status (normally, the number of bytes transferred). 
+
+ssize_t sigwrap_blocking_read(int hFile, void *pData, size_t RdLen)
+{
+    ssize_t Transfered;
+    ssize_t Len = RdLen;
+
+    while ((Transfered = read(hFile, pData, Len)) != Len)
+    {
+        if (Transfered == 0) // EOF reached?
+            return 0;
+
+        if (Transfered != -1)
+        {
+            pData += Transfered;
+            Len -= Transfered;
+            continue;
+        }
+
+        if (errno != EINTR)
+            return -1;
+    }
+
+    return RdLen;
+}
+
+
+ssize_t sigwrap_readv(int fd, const struct iovec *iov, int iovcnt)
+{
+    while (1)
+    {
+        ssize_t Result = readv(fd, iov, iovcnt);
+
+        if (Result != -1)
+            return (Result);
+
+        if (errno != EINTR)
+            return (Result);
+    }
+}
+
+
+ssize_t sigwrap_recv(int sockfd, void *buf, size_t len, int flags)
+{
+    while (1)
+    {
+        ssize_t Result = recv(sockfd, buf, len, flags);
+
+        if (Result != -1)
+            return (Result);
+
+        if (errno != EINTR)
+            return (Result);
+    }
+}
+
+
+ssize_t sigwrap_recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen)
+{
+    while (1)
+    {
+        ssize_t Result = recvfrom(sockfd, buf, len, flags, src_addr, addrlen);
+
+        if (Result != -1)
+            return (Result);
+
+        if (errno != EINTR)
+            return (Result);
+    }
+}
+
+
+ssize_t sigwrap_recvmsg(int sockfd, struct msghdr *msg, int flags)
+{
+    while (1)
+    {
+        ssize_t Result = recvmsg(sockfd, msg, flags);
+
+        if (Result != -1)
+            return (Result);
+
+        if (errno != EINTR)
+            return (Result);
+    }
+}
+
+
+// EINTR wrapper for the standard write() function. Can be used for sockets that are the to non-blocking mode.
+// The length of the effectively written data can be shorter than the length specified at the function call!
+
+ssize_t sigwrap_write(int fd, const void *buf, size_t count)
+{
+    while (1)
+    {
+        ssize_t Result = write(fd, buf, count);
+
+        if (Result != -1)
+            return (Result);
+
+        if (errno != EINTR)
+            return (Result);
+    }
+}
+
+// EINTR wrapper for the standard write() function. Waits until ALL data is written! Use the non-blocking version (sigwrap_write)
+// for sockets that are set to non-blocking mode, or when it is OK to write only partial data.
+// Although the description for the write() function describes it differently, it seems possible that the original function may already return
+// even though partial data has already been written. This implementation makes sure that all requested data have been written.
+// See the comment in the signal description https://linux.die.net/man/7/signal
+//* read(2), readv(2), write(2), writev(2), and ioctl(2) calls on "slow" devices. 
+//* A "slow" device is one where the I/O call may block for an indefinite time, for example, a terminal, pipe, or socket. 
+//* (A disk is not a slow device according to this definition.) If an I/O call on a slow device has already transferred
+//* some data by the time it is interrupted by a signal handler, then the call will return a success status (normally, the number of bytes transferred). 
+        
+ssize_t sigwrap_blocking_write(int hFile, const void *pData, ssize_t WrtLen)
+{
+    ssize_t Written;
+    ssize_t Len = WrtLen;
+
+    while ((Written = write(hFile, pData, Len)) != Len)
+    {
+        if (Written != -1)
+        {
+            pData += Written;
+            Len -= Written;
+            continue;
+        }
+
+        if (errno != EINTR)
+            return -1;
+    }
+
+    return WrtLen;
+}
+
+
+ssize_t sigwrap_writev(int fd, const struct iovec *iov, int iovcnt)
+{
+    while (1)
+    {
+        ssize_t Result = writev(fd, iov, iovcnt);
+
+        if (Result != -1)
+            return (Result);
+
+        if (errno != EINTR)
+            return (Result);
+    }
+}
+
+
+int sigwrap_close(int hFile)
+{
+    while (close(hFile) == -1)
+    {
+        if (errno != EINTR)
+            return -1;
+    }
+
+    return 0;
+}
+
+
+int sigwrap_open_mode(const char *pathname, int flags, mode_t mode)
+{
+    while (1)
+    {
+        int hFile = open(pathname, flags, mode);
+        
+        if(hFile != -1)
+            return hFile;
+        
+        if (errno != EINTR)
+            return hFile;
+    }
+}
+
+int sigwrap_open(const char *pathname, int flags)
+{
+    while (1)
+    {
+        int hFile = open(pathname, flags);
+        
+        if(hFile != -1)
+            return hFile;
+        
+        if (errno != EINTR)
+            return hFile;
+    }
+}
+
+
+pid_t sigwrap_wait(int *status)
+{
+    while(1)
+    {
+        pid_t Result = wait(status);
+        
+        if(Result != -1)
+            return Result;
+        
+        if(errno != EINTR)
+            return Result;
+    }
+}
+
+
+pid_t sigwrap_waitpid(pid_t pid, int *status, int options)
+{
+    while(1)
+    {
+        pid_t Result = waitpid(pid, status, options);
+        
+        if(Result != -1)
+            return Result;
+        
+        if(errno != EINTR)
+            return Result;
+    }
+}
+
+
+int sigwrap_waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options)
+{
+    while(1)
+    {
+        int Result = waitid(idtype, id, infop, options);
+        
+        if(Result != -1)
+            return Result;
+        
+        if(errno != EINTR)
+            return Result;
+    }
+}
+
+
+int sigwrap_flock(int fd, int operation) 
+{
+    while(1)
+    {
+        int Result = flock(fd, operation);
+        
+        if(Result != -1)
+            return Result;
+        
+        if(errno != EINTR)
+            return Result;
+    }
+}
+
+
diff --git a/hongweiz/adcapp/src/EINTR_wrappers.h b/hongweiz/adcapp/src/EINTR_wrappers.h
new file mode 100644
index 0000000..c39fa34
--- /dev/null
+++ b/hongweiz/adcapp/src/EINTR_wrappers.h
@@ -0,0 +1,124 @@
+
+/*File:EINTR_wrappers.h
+*
+* Wrapper functions header file.
+*
+* Copyright (C) <2019>  <American Megatrends International LLC>
+*
+*/
+
+#ifndef EINTR_WRAPPERS_H__
+#define EINTR_WRAPPERS_H__
+
+#if defined(__linux__)
+#ifndef _SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#ifndef _SYS_PC_H
+#include <sys/ipc.h>
+#endif
+
+#ifndef _SYS_SEM_H
+#include <sys/sem.h>
+#endif
+
+#ifndef _SYS_EPOLL_H
+#include <sys/epoll.h>
+#endif
+
+#ifndef _SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+
+#ifndef _SIGNAL_H
+#include <signal.h>
+#endif
+
+#ifndef _TIME_H
+#include <time.h>
+#endif
+
+#ifndef _POLL_H
+#include <poll.h>
+#endif
+
+#ifndef _WAIT_H
+#include <wait.h>
+#endif
+
+#ifndef _UNISTD_H
+#include <unistd.h>
+#endif
+
+int  sigwrap_semop(int semid, struct sembuf *sops, size_t nsops);
+int  sigwrap_semtimedop(int semid, struct sembuf *sops, size_t nsops, const struct timespec *timeout);
+int  sigwrap_epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
+int  sigwrap_epoll_pwait(int epfd, struct epoll_event *events, int maxevents, int timeout, const sigset_t *sigmask);
+int  sigwrap_sigwaitinfo(const sigset_t *set, siginfo_t *info);
+int  sigwrap_sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout);
+int  sigwrap_nanosleep(const struct timespec *req, struct timespec *rem);
+int  sigwrap_clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *request, struct timespec *remain);
+int  sigwrap_usleep(useconds_t usec);
+int  sigwrap_poll(struct pollfd *fds, nfds_t nfds, int timeout);
+int  sigwrap_ppoll(struct pollfd *fds, nfds_t nfds, const struct timespec *tmo_p, const sigset_t *sigmask);
+int  sigwrap_select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
+int  sigwrap_pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, const struct timespec *timeout, const sigset_t *sigmask);
+int  sigwrap_msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
+int  sigwrap_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
+int  sigwrap_accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
+int  sigwrap_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);
+int  sigwrap_close(int hFile);
+int sigwrap_open_mode(const char *pathname, int flags, mode_t mode);
+int  sigwrap_open(const char *pathname, int flags);
+
+
+pid_t sigwrap_wait(int *status);
+pid_t sigwrap_waitpid(pid_t pid, int *status, int options);
+int   sigwrap_waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
+
+
+ssize_t sigwrap_msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
+ssize_t sigwrap_send(int sockfd, const void *buf, size_t len, int flags);
+ssize_t sigwrap_sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
+ssize_t sigwrap_sendsendmsg(int sockfd, const struct msghdr *msg, int flags);
+
+ssize_t sigwrap_read(int fd, void *buf, size_t count);
+// EINTR wrapper for the standard read() function. Waits until ALL requested data is available. Use the non-blocking version (sigwrap_read)
+// for sockets that are set to non-blocking mode or when partial data is okay
+// Although the description for the read() function describes it differently, it seems possible that the original function may already return
+// even though partial data has already been read. This implementation makes sure that all requested data have been read.
+// See the comment in the signal description https://linux.die.net/man/7/signal
+//* read(2), readv(2), write(2), writev(2), and ioctl(2) calls on "slow" devices. 
+//* A "slow" device is one where the I/O call may block for an indefinite time, for example, a terminal, pipe, or socket. 
+//* (A disk is not a slow device according to this definition.) If an I/O call on a slow device has already transferred
+//* some data by the time it is interrupted by a signal handler, then the call will return a success status (normally, the number of bytes transferred). 
+ssize_t sigwrap_blocking_read(int hFile, void *pData, size_t RdLen);
+
+ssize_t sigwrap_readv(int fd, const struct iovec *iov, int iovcnt);
+
+ssize_t sigwrap_write(int fd, const void *buf, size_t count);
+// EINTR wrapper for the standard write() function. Waits until ALL data is written! Use the non-blocking version (sigwrap_write)
+// for sockets that are set to non-blocking mode, or when it is OK to write only partial data.
+// Although the description for the write() function describes it differently, it seems possible that the original function may already return
+// even though partial data has already been written. This implementation makes sure that all requested data have been written.
+// See the comment in the signal description https://linux.die.net/man/7/signal
+//* read(2), readv(2), write(2), writev(2), and ioctl(2) calls on "slow" devices. 
+//* A "slow" device is one where the I/O call may block for an indefinite time, for example, a terminal, pipe, or socket. 
+//* (A disk is not a slow device according to this definition.) If an I/O call on a slow device has already transferred
+//* some data by the time it is interrupted by a signal handler, then the call will return a success status (normally, the number of bytes transferred). 
+ssize_t sigwrap_blocking_write(int hFile, const void *pData, ssize_t WrtLen);
+
+ssize_t sigwrap_writev(int fd, const struct iovec *iov, int iovcnt);
+
+ssize_t sigwrap_recv(int sockfd, void *buf, size_t len, int flags);
+
+ssize_t sigwrap_recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
+
+ssize_t sigwrap_recvmsg(int sockfd, struct msghdr *msg, int flags);
+
+int sigwrap_flock(int fd, int operation);
+
+
+#endif
+#endif
diff --git a/hongweiz/adcapp/src/Makefile.am b/hongweiz/adcapp/src/Makefile.am
new file mode 100644
index 0000000..07896c2
--- /dev/null
+++ b/hongweiz/adcapp/src/Makefile.am
@@ -0,0 +1,2 @@
+bin_PROGRAMS = adcapp
+adcapp_SOURCES = adcapp.c adcifc.c adcifc.h adc.h EINTR_wrappers.c EINTR_wrappers.h
diff --git a/hongweiz/adcapp/src/adc.h b/hongweiz/adcapp/src/adc.h
new file mode 100644
index 0000000..51c967f
--- /dev/null
+++ b/hongweiz/adcapp/src/adc.h
@@ -0,0 +1,56 @@
+/*****************************************************************
+ *
+ * adcapp.c
+ * application specific driver header.
+ *
+ * Author: Rama Rao Bisa <ramab@ami.com>
+ *
+ * Copyright (C) <2019> <American Megatrends International LLC>
+ *
+ *****************************************************************/
+
+#ifndef __ADC_H__
+#define __ADC_H__
+
+#define READ_ADC_CHANNEL            _IOC(_IOC_WRITE,'K',0x100,0x3FFF)
+#define READ_ADC_REF_VOLATGE        _IOC(_IOC_WRITE,'K',0x101,0x3FFF)
+#define READ_ADC_RESOLUTION         _IOC(_IOC_WRITE,'K',0x102,0x3FFF)
+#define ENABLE_EXT_REF_VOLTAGE      _IOC(_IOC_WRITE,'K',0x103,0x3FFF)
+#define DISABLE_EXT_REF_VOLTAGE     _IOC(_IOC_WRITE,'K',0x104,0x3FFF)
+#define ENABLE_ADC_CHANNEL          _IOC(_IOC_WRITE,'K',0x105,0x3FFF)
+#define DISABLE_ADC_CHANNEL         _IOC(_IOC_WRITE,'K',0x106,0x3FFF)
+
+#define PACKED __attribute__ ((packed))
+
+typedef struct
+{
+	uint8_t 	channel_num;
+	uint16_t	channel_value;
+
+} PACKED get_adc_value_t;
+#if 0
+typedef struct
+{
+	int (*adc_read_channel) (uint16_t *adc_value, int channel);
+	int (*adc_get_resolution) (uint16_t *adc_resolution);
+	int (*adc_get_reference_voltage) (uint16_t *adc_ref_volatge);
+	int (*adc_reboot_notifier) (void);
+}adc_hal_operations_t;
+
+typedef struct
+{
+} adc_core_funcs_t;
+
+
+struct adc_hal
+{
+	adc_hal_operations_t *padc_hal_ops;
+};
+
+struct adc_dev
+{
+	struct adc_hal *padc_hal;
+};
+#endif
+
+#endif /* !__ADC_H__ */
diff --git a/hongweiz/adcapp/src/adcapp.c b/hongweiz/adcapp/src/adcapp.c
new file mode 100644
index 0000000..b7b2e44
--- /dev/null
+++ b/hongweiz/adcapp/src/adcapp.c
@@ -0,0 +1,105 @@
+/*****************************************************************
+ *
+ * adcapp.c
+ * application to acess ADC adriver
+ *
+ * Author: Rama Rao Bisa <ramab@ami.com>
+ *
+ * Copyright (C) <2019> <American Megatrends International LLC>
+ *
+ *****************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <sys/select.h>
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <sys/time.h>
+#include <stdint.h>
+#include "EINTR_wrappers.h"
+#include "adc.h"
+#include "adcifc.h"
+
+typedef enum {
+	GET_ADC_VALUE,
+	END_OF_FUNCLIST
+
+}e_adc_actions;
+
+e_adc_actions action = END_OF_FUNCLIST;
+
+static void ShowUsuage ( void )
+{
+	printf ("ADC Test Tool - Copyright (c) 2009-2015 American Megatrends Inc.\n");
+	printf( "Usage : addapp NumOfMaxChannels <option> \n" );
+	printf( "option: \n" );
+	printf( "\t--read-adc-channel 	\tGet ADC value for all the ADC channels\n" );
+	printf( "\n" );
+}
+
+static int process_arguments( int argc, char **argv )
+{
+	int i=2;
+	if( strcmp( argv[ i ], "--read-adc-channel" ) == 0 )
+	{
+		action = GET_ADC_VALUE;
+	}
+	else
+	{
+		action = END_OF_FUNCLIST;
+	}
+	return 0;
+}
+
+int
+main ( int argc , char* argv [] )
+{
+
+	get_adc_value_t get_adc_value;
+	int max_adc_channels;
+	int i,ret_val;
+	unsigned short reading=0;
+	if ( !(argc >= 3 ) )
+	{
+		ShowUsuage () ;
+		return 0;
+	}
+	max_adc_channels = (unsigned char)strtol( argv[1], NULL, 10);
+	process_arguments( argc , argv);
+	if ( (END_OF_FUNCLIST == action))
+	{
+		ShowUsuage ();
+		return 0;
+	}
+
+	switch ( action )
+	{
+		case GET_ADC_VALUE:
+			for (i = 0; i < max_adc_channels; i++)
+			{	
+				get_adc_value.channel_num  = i;
+				get_adc_value.channel_value = 0;
+
+				ret_val = get_adc_val(get_adc_value.channel_num, &reading);
+
+				if (ret_val == -1)
+				{
+					printf ("Read ADC channel failed\n");
+					return -1;
+				}
+				printf ("ADC Channel Value =%5d for channel %d\n", reading, get_adc_value.channel_num);
+			}
+			break;
+
+		default:
+			printf("Invalid ADC Function Call ");
+			break;
+	}
+
+	return 0;
+}
diff --git a/hongweiz/adcapp/src/adcifc.c b/hongweiz/adcapp/src/adcifc.c
new file mode 100644
index 0000000..9627b28
--- /dev/null
+++ b/hongweiz/adcapp/src/adcifc.c
@@ -0,0 +1,88 @@
+ /*****************************************************************
+ *
+ * adcapp.c
+ * Simple interface to read and write adc.
+ *
+ * Author: Rama Rao Bisa <ramab@ami.com>
+ *
+ * Copyright (C) <2019> <American Megatrends International LLC>
+ *
+ *****************************************************************/
+
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <errno.h>
+#include <string.h>
+#include <stdint.h>
+#include "adc.h"
+#include "adcifc.h"
+#include "EINTR_wrappers.h"
+
+/** \file adcifc.c
+  \brief Source for all adc interface code
+ */
+
+static int adc_directory_check()
+{
+	int retval = 0;
+	struct stat sb;
+	if (!(stat("/sys/bus/iio/devices/iio:device0", &sb) == 0 && S_ISDIR(sb.st_mode)))
+	{
+		printf("\"/sys/bus/iio/devices/iio:device0\" is not exist!\n");
+		retval = -1;
+	}
+	return retval;
+}
+
+static int sys_get_adc_vol( get_adc_value_t *argp )
+{
+	int retval = -1;
+	int fd;
+	int tmp;
+	char stringArray[50];
+	char val[5];
+	if(argp->channel_num > 15)	retval = -1;
+	retval = adc_directory_check();
+	if(retval != 0)
+	{
+		return retval;
+	}
+	snprintf(stringArray, sizeof(stringArray), "%s%s%d%s", "/sys/bus/iio/devices/iio:device0","/in_voltage", argp->channel_num,"_raw");
+	retval = access(stringArray,F_OK);
+	if(retval != 0)
+	{
+		return retval;
+	}
+	fd = sigwrap_open(stringArray, O_RDONLY);
+	if (fd < 0) {
+		return fd;
+	}
+	read(fd, val, 5);
+	tmp = atoi(val);
+	(void)sigwrap_close(fd);
+	argp->channel_value = (uint16_t)(tmp);
+	retval = 0;
+	return( retval );
+}
+
+/**
+ * get_adc_val
+ *
+ **/
+int get_adc_val( int channel , unsigned short *data)
+{
+	get_adc_value_t adc_arg;
+
+	/* Set the adc channel to read */
+	adc_arg.channel_num   = channel;
+	adc_arg.channel_value = 0;
+
+	if ( -1 == sys_get_adc_vol(&adc_arg)) { return -1; }
+	*data = (unsigned short)(adc_arg.channel_value);
+
+	return ( 0 );
+}
diff --git a/hongweiz/adcapp/src/adcifc.h b/hongweiz/adcapp/src/adcifc.h
new file mode 100644
index 0000000..586ea62
--- /dev/null
+++ b/hongweiz/adcapp/src/adcifc.h
@@ -0,0 +1,51 @@
+/****************************************************************
+
+ **                                                            **
+
+ **    (C)Copyright 2006-2009, American Megatrends Inc.        **
+
+ **                                                            **
+
+ **            All Rights Reserved.                            **
+
+ **                                                            **
+
+ **        5555 Oakbrook Pkwy Suite 200, Norcross,             **
+
+ **                                                            **
+
+ **        Georgia - 30093, USA. Phone-(770)-246-8600.         **
+
+ **                                                            **
+
+****************************************************************/
+/*****************************-*- ********-*-********************************/
+/* Filename:    adcifc.h                                                    */
+/* Description: Library interface to adc access                             */
+/*****************************************************************************/
+
+#ifndef ADCIFC_H
+#define ADCIFC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "adc.h"
+
+	/** \file adcifc.h
+	 *  \brief Public headers for the adc interface library
+	 *  
+	 *  This library contains friendly function call interfaces for getting 
+	 *  adc channel data.  It hides all the details of playing with
+	 *  adc through the adc manager (opening the device file, calling ioctl,
+	 *  etc.)
+	 */
+
+	extern  int get_adc_val( int channel , unsigned short *data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //ADCIFC_H