bool CPeerBase::Accept(socket_t fd_accept)
{
	struct sockaddr_in peer;

	if ((m_fd = socket_accept(fd_accept, &peer)) == INVALID_SOCKET)
	{
		Destroy();
		return false;
	} 

	//socket_block(m_fd);
	socket_sndbuf(m_fd, 233016);
	socket_rcvbuf(m_fd, 233016);

	strlcpymt(m_host, inet_ntoa(peer.sin_addr), sizeof(m_host));
	m_outBuffer = buffer_new(DEFAULT_PACKET_BUFFER_SIZE);
	m_inBuffer = buffer_new(MAX_INPUT_LEN);

	if (!m_outBuffer || !m_inBuffer)
	{
		Destroy();
		return false;
	}

	fdwatch_add_fd(m_fdWatcher, m_fd, this, FDW_READ, false);

	OnAccept();
	sys_log(0, "ACCEPT FROM %s", inet_ntoa(peer.sin_addr));
	return true;
}

connection *connection_new(enum connection_status status, int fd)
{
  // Allocate memory
  connection *c = xmalloc(sizeof(connection));

  // Get connection timestamp
  struct timeval connecttime;
  gettimeofday(&connecttime, NULL);

  // Fill in fields
  c->status          = status;
  c->version         = CONNECTION_VERSION_1_2;
  c->error           = 0;
  c->fd              = fd;
  c->inheartbeat     = 0;
  c->outheartbeat    = 0;
  c->readtime        = connecttime;
  c->writetime       = connecttime;
  c->inbuffer        = buffer_new(4096);
  c->outbuffer       = buffer_new(4096);
  c->frameparser     = frameparser_new();
  c->frameserializer = frameserializer_new();

  return c;
}

int
main(int argc, char **argv, const char *ZEBRA_VTYSH_PATH)
{
  struct buffer *b1, *b2;
  int n;
  char junk[3];
  char c = 'a';

  memory_init();
  
  if ((argc != 2) || (sscanf(argv[1], "%d%1s", &n, junk) != 1))
    {
      fprintf(stderr, "Usage: %s <number of chars to simulate>\n", *argv);
      return 1;
    }

  b1 = buffer_new(0);
  b2 = buffer_new(1024);
  
  while (n-- > 0)
    {
      buffer_put(b1, &c, 1);
      buffer_put(b2, &c, 1);
      if (c++ == 'z')
        c = 'a';
      buffer_reset(b1);
      buffer_reset(b2);
    }
  buffer_free(b1);
  buffer_free(b2);
  return 0;
}

TEST(Buffer, UTF8)
{
	buffer * buf, * utf8;
	unsigned char* copy;
	size_t len;

	buf = buffer_new(1);
	buffer_append_string(buf, "诶");
	EXPECT_EQ(buf->size, 5);
	EXPECT_EQ(buf->used, 3);
	
	len = buf->used;
	copy = (unsigned char*) malloc(len + 1);
	memcpy( copy, buf->data, len);
	copy[len] = '\0';
	buffer_destroy(buf);
	
	buf = buffer_new(len);
	buffer_append_data(buf, copy, len);
	utf8 = buffer_to_buffer_utf8(buf);
	buffer_destroy(buf);
	EXPECT_EQ(utf8->used, len * 2);

	buf = buffer_utf8_to_buffer(utf8);
	EXPECT_EQ(buf->used, len);
	EXPECT_TRUE(strcmp((char*)buf->data, (char*)copy) == 0);
	EXPECT_EQ(buf->size, 4);
	EXPECT_EQ(buf->used, 3);
	
	buffer_destroy(buf);
	buffer_destroy(utf8);
	free(copy);
	
}

struct fast_session *fast_session_new(struct fast_session_cfg *cfg)
{
	struct fast_session *self = calloc(1, sizeof *self);
	struct stat statbuf;

	if (!self)
		return NULL;

	self->rx_buffer		= buffer_new(FAST_RECV_BUFFER_SIZE);
	if (!self->rx_buffer) {
		fast_session_free(self);
		return NULL;
	}

	self->tx_message_buffer		= buffer_new(FAST_TX_BUFFER_SIZE);
	if (!self->tx_message_buffer) {
		fast_session_free(self);
		return NULL;
	}

	self->tx_pmap_buffer		= buffer_new(FAST_TX_BUFFER_SIZE);
	if (!self->tx_pmap_buffer) {
		fast_session_free(self);
		return NULL;
	}

	self->rx_messages	= fast_message_new(FAST_TEMPLATE_MAX_NUMBER);
	if (!self->rx_messages) {
		fast_session_free(self);
		return NULL;
	}

	if (cfg->preamble_bytes > FAST_PREAMBLE_MAX_BYTES) {
		fast_session_free(self);
		return NULL;
	} else
		self->preamble.nr_bytes = cfg->preamble_bytes;

	if (fstat(cfg->sockfd, &statbuf))
		return NULL;

	if (!S_ISSOCK(statbuf.st_mode)) {
		self->send = xwritev0;
		self->recv = buffer_nread0;
	} else {
		self->send = sendmsg;
		self->recv = buffer_recv;
	}

	self->sockfd		= cfg->sockfd;
	self->reset		= cfg->reset;
	self->rx_message	= NULL;
	self->last_tid		= 0;
	self->nr_messages	= 0;

	return self;
}

tcp_connection_t* tcp_connection_new
(
    loop_t *loop, int fd, on_data_f datacb, on_close_f closecb, void* userdata, const inetaddr_t *peer_addr
)
{
    tcp_connection_t *connection;
    struct sockaddr_in addr;
    socklen_t addr_len;
    
    struct linger linger_info;
    int flag;

    if (NULL == loop || fd < 0 || NULL == datacb || NULL == closecb || NULL == peer_addr)
    {
        log_error("tcp_connection_new: bad loop(%p) or bad fd(%d) or bad datacb(%p) or bad closecb(%p) or bad peer_addr(%p)", 
            loop, fd, datacb, closecb, peer_addr);
        return NULL;
    }

    connection = (tcp_connection_t*)malloc(sizeof(*connection));
	memset(connection, 0, sizeof(*connection));

    flag = 1;
    setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &flag, sizeof(flag));
    
    memset(&linger_info, 0, sizeof(linger_info));
    linger_info.l_onoff = 1;
    linger_info.l_linger = 3;
    setsockopt(fd, SOL_SOCKET, SO_LINGER, &linger_info, sizeof(linger_info));

    connection->loop = loop;
    connection->fd = fd;
    connection->datacb = datacb;
    connection->closecb = closecb;
    connection->userdata = userdata;

    connection->channel = channel_new(fd, loop, connection_onevent, connection);

    connection->in_buffer = buffer_new(4096);
    connection->out_buffer = buffer_new(4096);

    connection->is_in_callback = 0;
    connection->is_alive = 1;
    connection->is_connected = 1;
    connection->need_closed_after_sent_done = 0;
    connection->peer_addr = *peer_addr;

    memset(&addr, 0, sizeof(addr));
    addr_len = sizeof(addr);
    getsockname(fd, (struct sockaddr*)&addr, &addr_len);
    inetaddr_init(&connection->local_addr, &addr);

    channel_setevent(connection->channel, EPOLLIN);

    return connection;
}

/* Define procedures cadr, caddr, etc. */
static void define_pair_procedures(env_hashtable *env)
{
    buffer *a = buffer_new(""),
           *b = buffer_new("x");
           
    define_recursive(a, b, 0, env);
    
    buffer_free(a);
    buffer_free(b);
}

VOID tunet_init()
{
	main_socket_buffer = buffer_new(1024);
	keepalive_socket_buffer = buffer_new(1024);
	logout_socket_buffer = buffer_new(1024);

	thread_tunet = NULL;
	keepalive_timeout = os_tick_new(5 * 60 * 1000, FALSE);

	tunet_state = TUNET_STATE_NONE;
}

bool DESC::Setup(LPFDWATCH _fdw, socket_t _fd, const struct sockaddr_in & c_rSockAddr, DWORD _handle, DWORD _handshake)
{
	m_lpFdw		= _fdw;
	m_sock		= _fd;

	m_stHost		= inet_ntoa(c_rSockAddr.sin_addr);
	m_wPort			= c_rSockAddr.sin_port;
	m_dwHandle		= _handle;

	//if (LC_IsEurope() == true || LC_IsNewCIBN())
	//	m_lpOutputBuffer = buffer_new(DEFAULT_PACKET_BUFFER_SIZE * 2);
	//else
	//NOTE: 이걸 나라별로 다르게 잡아야할 이유가 있나?
	m_lpOutputBuffer = buffer_new(DEFAULT_PACKET_BUFFER_SIZE * 2);

	m_iMinInputBufferLen = MAX_INPUT_LEN >> 1;
	m_lpInputBuffer = buffer_new(MAX_INPUT_LEN);

	m_SockAddr = c_rSockAddr;

	fdwatch_add_fd(m_lpFdw, m_sock, this, FDW_READ, false);

	// Ping Event 
	desc_event_info* info = AllocEventInfo<desc_event_info>();

	info->desc = this;
	assert(m_pkPingEvent == NULL);

	m_pkPingEvent = event_create(ping_event, info, ping_event_second_cycle);

#ifndef _IMPROVED_PACKET_ENCRYPTION_
	if (LC_IsEurope())	
	{
		thecore_memcpy(m_adwEncryptionKey, "1234abcd5678efgh", sizeof(DWORD) * 4);
		thecore_memcpy(m_adwDecryptionKey, "1234abcd5678efgh", sizeof(DWORD) * 4);
	}
	else
	{
		thecore_memcpy(m_adwEncryptionKey, "testtesttesttest", sizeof(DWORD) * 4);
		thecore_memcpy(m_adwDecryptionKey, "testtesttesttest", sizeof(DWORD) * 4);
	}
#endif // _IMPROVED_PACKET_ENCRYPTION_

	// Set Phase to handshake
	SetPhase(PHASE_HANDSHAKE);
	StartHandshake(_handshake);

	sys_log(0, "SYSTEM: new connection from [%s] fd: %d handshake %u output input_len %d, ptr %p",
			m_stHost.c_str(), m_sock, m_dwHandshake, buffer_size(m_lpInputBuffer), this);

	Log("SYSTEM: new connection from [%s] fd: %d handshake %u ptr %p", m_stHost.c_str(), m_sock, m_dwHandshake, this);
	return true;
}

void ape_array_add_n(ape_array_t *array, const char *key, int klen, const char *value, int vlen)
{
	buffer *k, *v;
	
	k = buffer_new(klen+1);
	v = buffer_new(vlen+1);
	
	buffer_append_string_n(k, key, klen);
	buffer_append_string_n(v, value, vlen);
	
	ape_array_add_b(array, k, v);
}

Buffer *pcp_keyblob(void *k, int type) {
  if(type == PCP_KEY_TYPE_PUBLIC) {
    Buffer *b = buffer_new(PCP_RAW_PUBKEYSIZE, "bp");
    pcp_pubkeyblob(b, (pcp_pubkey_t *)k);
    return b;
  }
  else {
    Buffer *b = buffer_new(PCP_RAW_KEYSIZE, "bs");
    pcp_seckeyblob(b, (pcp_key_t *)k);
    return b;
  }
}

CcnetPacketIO*
ccnet_packet_io_new (evutil_socket_t fd)
{
    CcnetPacketIO *io;

    io = g_malloc (sizeof(CcnetPacketIO));
    io->fd = fd;
    io->buffer = buffer_new ();
    io->in_buf = buffer_new ();
   
    return io;
}

int 
handle_connect_addr(struct ludis_handle *h, const struct net_addr addr)
{
    int fd;

    if ((fd = fd_connect_addr(addr)) < 0)
        return fd;

    h->fd = fd;
    h->rb = buffer_new(0);
    h->wb = buffer_new(0);

    return LUDIS_OK;
}

int 
handle_connect_gai(struct ludis_handle *h, int family, const char *host, 
                   int port, struct net_addr *addr) 
{
    int fd;

    if ((fd = fd_connect_gai(family, host, port, addr)) < 0)
        return fd;

    h->fd = fd;
    h->rb = buffer_new(0);
    h->wb = buffer_new(0);

    return LUDIS_OK;
}

BUFFER *buffer_append(BUFFER *buf, BYTE *newdata, INT len)
{
	BYTE *p;
	INT newlen;
	
	if (len <= 0) return buf;
	if (!buf) buf = buffer_new(len);

	if (len + buf->len > buf->allocated_len)
	{
		newlen = (len + buf->len) * 3 / 2 + 1;
		p = (BYTE *)os_new(CHAR, newlen);
		buf->allocated_len = newlen;
		memcpy(p, buf->data, buf->len);
	}
	else
	{
		p = buf->data;
	}

	memcpy(p + buf->len, newdata, len);

	if (buf->data != p)
	{
		os_free(buf->data);
		buf->data = p;
	}

	buf->len += len;
	return buf;
}

/* this is a public key in openssh's format */
static STRING *make_rsa1_string(STRING *e, STRING *n){
  BUFFER *buffer = NULL;
  STRING *rsa = NULL;
  STRING *ret = NULL;

  buffer = buffer_new();
  rsa = string_from_char("ssh-rsa1");

  if (buffer_add_ssh_string(buffer, rsa) < 0) {
    goto error;
  }
  if (buffer_add_ssh_string(buffer, e) < 0) {
    goto error;
  }
  if (buffer_add_ssh_string(buffer, n) < 0) {
    goto error;
  }

  ret = string_new(buffer_get_len(buffer));
  if (ret == NULL) {
    goto error;
  }

  string_fill(ret, buffer_get(buffer), buffer_get_len(buffer));
error:
  buffer_free(buffer);
  string_free(rsa);

  return ret;
}

void test_boe_replay_complete(void)
{
	struct boe_message *msg = (void *) recv_buffer;
	struct buffer *buf;
	int fd;

	buf = buffer_new(1024);

	fd = open(DATA_PATH "replay-complete-message.bin", O_RDONLY);
	fail_if(fd < 0);

	fail_if(buffer_xread(buf, fd) < 0);

	fail_if(boe_message_decode(buf, msg, BOE_MAX_MESSAGE_LEN) < 0);

	assert_int_equals(BOE_MAGIC, msg->header.StartOfMessage);
	assert_int_equals(8, msg->header.MessageLength);
	assert_int_equals(ReplayComplete, msg->header.MessageType);
	assert_int_equals(0, msg->header.MatchingUnit);
	assert_int_equals(0, msg->header.SequenceNumber);

	buffer_delete(buf);

	fail_if(close(fd) < 0);
}

static buffer_t *
buffer_new_read(const void *data, zip_uint64_t length, int free_data)
{
    buffer_t *buffer;

    if ((buffer = buffer_new(length)) == NULL) {
	return NULL;
    }

    buffer->size = length;

    if (length > 0) {
	if ((buffer->fragments = malloc(sizeof(*(buffer->fragments)))) == NULL) {
	    buffer_free(buffer);
	    return NULL;
	}
	buffer->fragments_capacity = 1;

	buffer->nfragments = 1;
	buffer->fragments[0] = (zip_uint8_t *)data;
	buffer->free_data = free_data;
    }

    return buffer;
}

/**
 * @brief Request a subsystem (for example "sftp").
 *
 * @param channel       The channel to send the request.
 *
 * @param system        The subsystem to request (for example "sftp").
 *
 * @return SSH_SUCCESS on success, SSH_ERROR on error.
 *
 * @warning You normally don't have to call it for sftp, see sftp_new().
 */
int channel_request_subsystem(CHANNEL *channel, const char *sys) {
  BUFFER *buffer = NULL;
  STRING *subsystem = NULL;
  int rc = SSH_ERROR;

  buffer = buffer_new();
  if (buffer == NULL) {
    goto error;
  }

  subsystem = string_from_char(sys);
  if (subsystem == NULL) {
    goto error;
  }

  if (buffer_add_ssh_string(buffer, subsystem) < 0) {
    goto error;
  }

  rc = channel_request(channel, "subsystem", buffer, 1);
error:
  buffer_free(buffer);
  string_free(subsystem);

  return rc;
}

/**
 * @brief Change the size of the terminal associated to a channel.
 *
 * @param channel       The channel to change the size.
 *
 * @param cols          The new number of columns.
 *
 * @param rows          The new number of rows.
 *
 * @warning Do not call it from a signal handler if you are not
 * sure any other libssh function using the same channel/session
 * is running at same time (not 100% threadsafe).
 */
int channel_change_pty_size(CHANNEL *channel, int cols, int rows) {
  SSH_SESSION *session = channel->session;
  BUFFER *buffer = NULL;
  int rc = SSH_ERROR;

  enter_function();

#ifdef HAVE_SSH1
  if (channel->version == 1) {
    rc = channel_change_pty_size1(channel,cols,rows);
    leave_function();
    return rc;
  }
#endif

  buffer = buffer_new();
  if (buffer == NULL) {
    goto error;
  }

  if (buffer_add_u32(buffer, htonl(cols)) < 0 ||
      buffer_add_u32(buffer, htonl(rows)) < 0 ||
      buffer_add_u32(buffer, 0) < 0 ||
      buffer_add_u32(buffer, 0) < 0) {
    goto error;
  }

  rc = channel_request(channel, "window-change", buffer, 0);
error:
  buffer_free(buffer);

  leave_function();
  return rc;
}