/*
 * .============.
 * // M A K E / \
 * // C++ DEV / \
 * // E A S Y / \/ \
 * ++ ----------. \/\ .
 * \\ \ \ /\ /
 * \\ \ \ /
 * \\ \ \ /
 * -============'
 *
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include "socket_fd.h"

#include <errno.h>
#include <sys/socket.h>
#include <cstring>
#include <tbox/base/log.h>

namespace tbox {
namespace network {

SocketFd::SocketFd() { }

SocketFd::SocketFd(int fd) : Fd(fd) { }

SocketFd::SocketFd(const Fd &fd) : Fd(fd) { }

SocketFd SocketFd::CreateSocket(int domain, int type, int protocal)
{
 int fd = ::socket(domain, type, protocal);
 if (fd < 0) {
 LogDbg("create socket fail, errno:%d, %s", errno, strerror(errno));
 return SocketFd();
 }

 return SocketFd(fd);
}

SocketFd SocketFd::CreateUdpSocket()
{
 return CreateSocket(AF_INET, SOCK_DGRAM, 0);
}

SocketFd SocketFd::CreateTcpSocket()
{
 return CreateSocket(AF_INET, SOCK_STREAM, 0);
}

int SocketFd::connect(const struct sockaddr *addr, socklen_t addrlen)
{
 int ret = ::connect(get(), addr, addrlen);
 if (ret < 0)
 LogDbg("fail, errno:%d, %s", errno, strerror(errno));
 return ret;
}

int SocketFd::bind(const struct sockaddr *addr, socklen_t addrlen)
{
 int ret = ::bind(get(), addr, addrlen);
 if (ret < 0)
 LogDbg("fail, errno:%d, %s", errno, strerror(errno));
 return ret;
}

int SocketFd::listen(int backlog)
{
 int ret = ::listen(get(), backlog);
 if (ret < 0)
 LogDbg("fail, errno:%d, %s", errno, strerror(errno));
 return ret;
}

int SocketFd::accept(struct sockaddr *addr, socklen_t *addrlen)
{
 int ret = ::accept(get(), addr, addrlen);
 if (ret < 0)
 LogDbg("fail, errno:%d, %s", errno, strerror(errno));
 return ret;
}

ssize_t SocketFd::send(const void* data_ptr, size_t data_size, int flag)
{
 ssize_t ret = ::send(get(), data_ptr, data_size, flag);
 if (ret < 0)
 LogDbg("fail, errno:%d, %s", errno, strerror(errno));
 return ret;
}

ssize_t SocketFd::recv(void* data_ptr, size_t data_size, int flag)
{
 ssize_t ret = ::recv(get(), data_ptr, data_size, flag);
 if (ret < 0)
 LogDbg("fail, errno:%d, %s", errno, strerror(errno));
 return ret;
}

ssize_t SocketFd::sendTo(const void* data_ptr, size_t data_size, int flag, const sockaddr *dest_addr, socklen_t addrlen)
{
 ssize_t ret = ::sendto(get(), data_ptr, data_size, flag, dest_addr, addrlen);
 if (ret < 0)
 LogDbg("fail, errno:%d, %s", errno, strerror(errno));
 return ret;
}

ssize_t SocketFd::recvFrom(void* data_ptr, size_t data_size, int flag, sockaddr *dest_addr, socklen_t *addrlen)
{
 ssize_t ret = ::recvfrom(get(), data_ptr, data_size, flag, dest_addr, addrlen);
 if (ret < 0)
 LogDbg("fail, errno:%d, %s", errno, strerror(errno));
 return ret;
}

int SocketFd::shutdown(int howto)
{
 int ret = ::shutdown(get(), howto);
 if (ret < 0)
 LogDbg("fail, errno:%d, %s", errno, strerror(errno));
 return ret;
}

bool SocketFd::getSocketOpt(int level, int optname, void *optval, socklen_t *optlen)
{
 if (::getsockopt(get(), level, optname, optval, optlen) != 0) {
 LogDbg("fail, opt:%d, errno:%d, %s", optname, errno, strerror(errno));
 return false;
 }
 return true;
}

bool SocketFd::setSocketOpt(int level, int optname, int optval)
{
 if (::setsockopt(get(), level, optname, &optval, sizeof(optval)) != 0) {
 LogDbg("fail, opt:%d, val:%d, errno:%d, %s", optname, optval, errno, strerror(errno));
 return false;
 }
 return true;
}

bool SocketFd::setSocketOpt(int level, int optname, const void *optval, socklen_t optlen)
{
 if (::setsockopt(get(), level, optname, optval, optlen) != 0) {
 LogDbg("fail, opt:%d, errno:%d, %s", optname, errno, strerror(errno));
 return false;
 }
 return true;
}

bool SocketFd::setReuseAddress(bool enable)
{
 return setSocketOpt(SOL_SOCKET, SO_REUSEADDR, enable);
}

bool SocketFd::setBroadcast(bool enable)
{
 return setSocketOpt(SOL_SOCKET, SO_BROADCAST, enable);
}

bool SocketFd::setKeepalive(bool enable)
{
 return setSocketOpt(SOL_SOCKET, SO_KEEPALIVE, enable);
}

bool SocketFd::setRecvBufferSize(int size)
{
 return setSocketOpt(SOL_SOCKET, SO_RCVBUF, size);
}

bool SocketFd::setSendBufferSize(int size)
{
 return setSocketOpt(SOL_SOCKET, SO_SNDBUF, size);
}

bool SocketFd::setRecvLowWater(int size)
{
 return setSocketOpt(SOL_SOCKET, SO_RCVLOWAT, size);
}

bool SocketFd::setSendLowWater(int size)
{
 return setSocketOpt(SOL_SOCKET, SO_SNDLOWAT, size);
}

bool SocketFd::setLinger(bool enable, int linger)
{
 struct linger value = {
 .l_onoff = enable,
 .l_linger = linger
 };
 return setSocketOpt(SOL_SOCKET, SO_LINGER, &value, sizeof(value));
}

}
}