/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.
 */
#include <log4cxx/helpers/socket.h>
#include <log4cxx/helpers/bytebuffer.h>
#include <log4cxx/helpers/transcoder.h>
#include "apr_network_io.h"
#include "apr_signal.h"


using namespace log4cxx;
using namespace log4cxx::helpers;

IMPLEMENT_LOG4CXX_OBJECT(Socket)

/** Creates a stream socket and connects it to the specified port
number at the specified IP address.
*/
Socket::Socket(InetAddressPtr& addr, int prt) : pool(), socket(0), address(addr), port(prt) 
{
  apr_status_t status =
    apr_socket_create(&socket, APR_INET, SOCK_STREAM, 
                      APR_PROTO_TCP, pool.getAPRPool());
  if (status != APR_SUCCESS) {
    throw SocketException(status);
  }
  
  LOG4CXX_ENCODE_CHAR(host, addr->getHostAddress());

  // create socket address (including port)
  apr_sockaddr_t *client_addr;
  status =
      apr_sockaddr_info_get(&client_addr, host.c_str(), APR_INET,
                                  prt, 0, pool.getAPRPool());
  if (status != APR_SUCCESS) {
      throw ConnectException(status);
  }

        // connect the socket
  status =  apr_socket_connect(socket, client_addr);
  if (status != APR_SUCCESS) {
      throw ConnectException(status);
  }
}

Socket::Socket(apr_socket_t* s, apr_pool_t* p) :
    pool(p, true), socket(s) {
    apr_sockaddr_t* sa;
    apr_status_t status = apr_socket_addr_get(&sa, APR_REMOTE, s);
    if (status == APR_SUCCESS) {
        port = sa->port;
        LogString remotename;
        LogString remoteip;
        if (sa->hostname != NULL) {
            Transcoder::decode(sa->hostname, remotename);
        }
        char* buf = 0;
        status = apr_sockaddr_ip_get(&buf, sa);
        if (status == APR_SUCCESS) {
            Transcoder::decode(buf, remoteip);
        }
        address = new InetAddress(remotename, remoteip);
    }
}

Socket::~Socket() {
}

size_t Socket::write(ByteBuffer& buf) {
    if (socket == 0) {
            throw ClosedChannelException();
    }
    int totalWritten = 0;
    while(buf.remaining() > 0) {
        apr_size_t written = buf.remaining();

        // while writing to the socket, we need to ignore the SIGPIPE
        // signal. Otherwise, when the client has closed the connection,
        // the send() function would not return an error but call the
        // SIGPIPE handler.
#if APR_HAVE_SIGACTION
        apr_sigfunc_t* old = apr_signal(SIGPIPE, SIG_IGN);
        apr_status_t status = apr_socket_send(socket, buf.current(), &written);
        apr_signal(SIGPIPE, old);
#else
        apr_status_t status = apr_socket_send(socket, buf.current(), &written);
#endif
        
        buf.position(buf.position() + written);
        totalWritten += written;
        if (status != APR_SUCCESS) {
            throw SocketException(status);
        }
    }
    return totalWritten;
}


void Socket::close() {
    if (socket != 0) {
        apr_status_t status = apr_socket_close(socket);
        if (status != APR_SUCCESS) {
            throw SocketException(status);
        }        
        socket = 0;
    }
}

InetAddressPtr Socket::getInetAddress() const {
    return address;
}

int Socket::getPort() const {
    return port;
}