/*
*
* Copyright (c) 2018 Huawei Technologies Co.,Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

#ifndef __NSTACK_SOCKET_H__
#define __NSTACK_SOCKET_H__
#include <sys/socket.h>
#include <poll.h>
#include <sys/epoll.h>
#include <netdb.h>
#include "dmm_spinlock.h"
#include "nstack_fd_mng.h"

#undef NSTACK_MK_DECL
#define NSTACK_MK_DECL(ret, fn, args)   extern ret nstack_##fn args
#include "declare_syscalls.h.tmpl"

int release_fd(int fd, nstack_fd_local_lock_info_t * local_lock);
int nstack_posix_api_init();
int nstack_close(int fd);
int nstack_socket(int domain, int itype, int protocol);

#define NSTACK_EPOLL_FD_CHECK_RET_UNLOCK(fdVal, fun, inf, err, local_lock, unlock) \
    if ((NULL == inf) || ((inf)->attr & NSTACK_FD_ATTR_EPOLL_SOCKET)) \
    {  \
        nstack_set_errno(err); \
        NSSOC_LOGERR("nstack [%s] call, fd=0x%x is epoll fd return fail errno=%d [return]", #fun, fdVal, err); \
        unlock(fdVal, inf, local_lock);\
        return -1;\
    }

#define NSTACK_EPOLL_FD_CHECK_RET_UNLOCK_COMMON(fdVal, fun, inf, err, local_lock) \
    /*do not need return value*/NSTACK_EPOLL_FD_CHECK_RET_UNLOCK(fdVal, fun, inf, err, local_lock, UNLOCK_COMMON)

#define LOCK_CONNECT(fd, fd_inf, local_lock) \
    LOCK_BASE(fd, fd_inf, local_lock)

#define UNLOCK_CONNECT(fd, fd_inf, local_lock) \
    /*do not need return value*/UNLOCK_BASE(fd, fd_inf, local_lock)

#define NSTACK_EPOLL_FD_CHECK_RET_UNLOCK_CONNECT(fdVal, fun, inf, err, local_lock) \
    NSTACK_EPOLL_FD_CHECK_RET_UNLOCK(fdVal, fun, inf, err, local_lock, UNLOCK_CONNECT)

#define LOCK_ACCEPT(fd, fd_inf, local_lock) \
    LOCK_BASE(fd, fd_inf, local_lock)

#define UNLOCK_ACCEPT(fd, fd_inf, local_lock) \
    /*do not need return value*/UNLOCK_BASE(fd, fd_inf, local_lock)

#define NSTACK_EPOLL_FD_CHECK_RET_UNLOCK_ACCEPT(fdVal, fun, inf, err, local_lock) \
    /*do not need return value*/NSTACK_EPOLL_FD_CHECK_RET_UNLOCK(fdVal, fun, inf, err, local_lock, UNLOCK_ACCEPT)

#define LOCK_EPOLL(fd, fd_inf, local_lock) INC_FD_REF_RETURN(fd, fd_inf, local_lock)

static inline void UNLOCK_EPOLL(int fd,
                                nstack_fd_local_lock_info_t * local_lock)
{
    if ((NULL != local_lock) && atomic_dec(&local_lock->fd_ref) == 0)
    {
        release_fd(fd, local_lock);
    }
}

#define LOCK_EPOLL_CTRL_RETURN(fd_val, local_lock, epoll_fd, epoll_local_lock){\
    if (local_lock)\
    {\
        atomic_inc(&local_lock->fd_ref);\
        dmm_spin_lock(&local_lock->close_lock);\
        nstack_fd_Inf* fd_inf = nstack_get_valid_inf(fd_val);\
        if (fd_inf)\
        {\
            if (local_lock->fd_status != FD_OPEN)\
            {\
                NSSOC_LOGWAR("fd %d is not open [return]", fd_val);\
                nstack_set_errno(EBADF);\
                dmm_spin_unlock(&local_lock->close_lock);\
                if(atomic_dec(&local_lock->fd_ref)==0){   \
                    release_fd(fd_val, local_lock);\
                }\
                UNLOCK_EPOLL(epoll_fd, epoll_local_lock);\
                return -1;\
            }\
        }\
    }\
}

static inline void UNLOCK_EPOLL_CTRL(int fd,
                                     nstack_fd_local_lock_info_t * local_lock)
{
    if (local_lock)
    {
        dmm_spin_unlock(&local_lock->close_lock);
        if (atomic_dec(&local_lock->fd_ref) == 0)
        {
            release_fd(fd, local_lock);
        }
    }
}

#define INC_FD_REF_RETURN(fd, fd_inf, local_lock){ \
    if (local_lock)\
    {\
        atomic_inc(&local_lock->fd_ref);\
        if (local_lock->fd_status != FD_OPEN)\
        {\
            nstack_set_errno(EBADF);\
            NSSOC_LOGERR("nstack call, nfd = %d, fd_status=%d [return]",fd, local_lock->fd_status); \
            if(atomic_dec(&local_lock->fd_ref) == 0){ \
            	release_fd(fd, local_lock);\
            }\
            return -1;\
        }\
    } \
}

#define LOCK_BASE(fd, fd_inf, local_lock){\
    INC_FD_REF_RETURN(fd, fd_inf, local_lock);\
}

/* if is kernel fd, don't need to lock */
#define LOCK_BASE_WITHOUT_KERNEL(fd, fd_inf, local_lock){\
    INC_FD_REF_RETURN(fd, fd_inf, local_lock);\
}

static inline void UNLOCK_BASE(int fd, nstack_fd_Inf * inf,
                               nstack_fd_local_lock_info_t * local_lock)
{
    if ((NULL != local_lock) && (atomic_dec(&local_lock->fd_ref) == 0))
    {
        release_fd(fd, local_lock);
    }
}

#define LOCK_COMMON(fd, fd_inf, local_lock) \
    LOCK_BASE(fd, fd_inf, local_lock)

#define UNLOCK_COMMON(fd, fd_inf, local_lock) \
    /*do not need return value*/UNLOCK_BASE(fd, fd_inf, local_lock)

#define LOCK_CLOSE(local_lock){\
    if (local_lock)\
    {\
        dmm_spin_lock(&local_lock->close_lock);\
    }\
}

static inline void UNLOCK_CLOSE(nstack_fd_local_lock_info_t * local_lock)
{
    if (local_lock)
    {
        dmm_spin_unlock(&local_lock->close_lock);
    }
}

#define LOCK_FOR_EP(local_lock) LOCK_CLOSE(local_lock)

#define UNLOCK_FOR_EP(local_lock) UNLOCK_CLOSE(local_lock)

#define NSTACK_INIT_CHECK_RET(fun, args...) \
    do { \
        if (NSTACK_MODULE_INITING == g_nStackInfo.fwInited) { \
            NSSOC_LOGINF ("call kernel func %s", #fun); \
            return nsfw_base_##fun(args); \
            } \
        if (nstack_fw_init()) { \
            NSSOC_LOGERR("nstack %s call, but initial not finished yet, errno %d [return]", #fun,get_fw_init_err()); \
            nstack_set_errno(ENOSYS); \
            return -1; \
        } \
    }while(0)

#define NSTACK_MODULE_ERROR_SET(Index)

extern int nstack_create_kernel_socket();

#endif /* __NSTACK_SOCKET_H__ */