/*
 * session.c - non-networking functions
 *
 * This file is part of the SSH Library
 *
 * Copyright (c) 2005-2008 by Aris Adamantiadis
 *
 * The SSH Library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * The SSH Library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with the SSH Library; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#include "config.h"
#include <string.h>
#include <stdlib.h>
#include "libssh/libssh.h"
#include "libssh/priv.h"
#include "libssh/server.h"
#include "libssh/socket.h"
#include "libssh/ssh2.h"
#include "libssh/agent.h"
#include "libssh/packet.h"
#include "libssh/session.h"
#include "libssh/misc.h"
#include "libssh/buffer.h"
#include "libssh/poll.h"

#define FIRST_CHANNEL 42 // why not ? it helps to find bugs.

/** \defgroup ssh_session SSH Session
 * \brief functions that manage a session
 */
/** \addtogroup ssh_session
 * @{ */

/** \brief creates a new ssh session
 * \returns new ssh_session pointer
 */
ssh_session ssh_new(void) {
  ssh_session session;

  session = malloc(sizeof (struct ssh_session_struct));
  if (session == NULL) {
    return NULL;
  }
  ZERO_STRUCTP(session);

  session->next_crypto = crypto_new();
  if (session->next_crypto == NULL) {
    goto err;
  }

  session->socket = ssh_socket_new(session);
  if (session->socket == NULL) {
    goto err;
  }

  session->out_buffer = buffer_new();
  if (session->out_buffer == NULL) {
    goto err;
  }

  session->in_buffer=buffer_new();
  if (session->in_buffer == NULL) {
    goto err;
  }

  session->alive = 0;
  session->auth_methods = 0;
  session->blocking = 1;
  session->log_indent = 0;
  session->maxchannel = FIRST_CHANNEL;

  /* options */
  session->port = 22;
  session->fd = -1;
  session->ssh2 = 1;
#ifdef WITH_SSH1
  session->ssh1 = 1;
#else
  session->ssh1 = 0;
#endif

#ifndef _WIN32
    session->agent = agent_new(session);
    if (session->agent == NULL) {
      goto err;
    }
#endif /* _WIN32 */
    return session;

err:
    ssh_free(session);
    return NULL;
}

/**
 * @brief deallocate a session handle
 * @see ssh_disconnect()
 * @see ssh_new()
 */
void ssh_free(ssh_session session) {
  int i;
  enter_function();

  if (session == NULL) {
    return;
  }

  SAFE_FREE(session->serverbanner);
  SAFE_FREE(session->clientbanner);
  SAFE_FREE(session->banner);
#ifdef WITH_PCAP
  if(session->pcap_ctx){
  	ssh_pcap_context_free(session->pcap_ctx);
  	session->pcap_ctx=NULL;
  }
#endif
  buffer_free(session->in_buffer);
  buffer_free(session->out_buffer);
  session->in_buffer=session->out_buffer=NULL;
  crypto_free(session->current_crypto);
  crypto_free(session->next_crypto);
  ssh_socket_free(session->socket);
  /* delete all channels */
  while (session->channels) {
    channel_free(session->channels);
  }
#ifndef _WIN32
  agent_free(session->agent);
#endif /* _WIN32 */
  if (session->client_kex.methods) {
    for (i = 0; i < 10; i++) {
      SAFE_FREE(session->client_kex.methods[i]);
    }
  }

  if (session->server_kex.methods) {
    for (i = 0; i < 10; i++) {
      SAFE_FREE(session->server_kex.methods[i]);
    }
  }
  SAFE_FREE(session->client_kex.methods);
  SAFE_FREE(session->server_kex.methods);

  privatekey_free(session->dsa_key);
  privatekey_free(session->rsa_key);
  if(session->ssh_message_list){
    ssh_message msg;
    while((msg=ssh_list_get_head(ssh_message ,session->ssh_message_list))
        != NULL){
      ssh_message_free(msg);
    }
    ssh_list_free(session->ssh_message_list);
  }

  /* options */
  SAFE_FREE(session->username);
  SAFE_FREE(session->host);
  SAFE_FREE(session->identity);
  SAFE_FREE(session->sshdir);
  SAFE_FREE(session->knownhosts);

  for (i = 0; i < 10; i++) {
    if (session->wanted_methods[i]) {
      SAFE_FREE(session->wanted_methods[i]);
    }
  }

  /* burn connection, it could hang sensitive datas */
  ZERO_STRUCTP(session);
  SAFE_FREE(session);
}

/** \brief disconnect impolitely from remote host by closing the socket.
 * Suitable if you forked and want to destroy this session.
 * \param session current ssh session
 */
void ssh_silent_disconnect(ssh_session session) {
  enter_function();

  if (session == NULL) {
    return;
  }

  ssh_socket_close(session->socket);
  session->alive = 0;
  ssh_disconnect(session);
  leave_function();
}

/** \brief set the session in blocking/nonblocking mode
 * \param session ssh session
 * \param blocking zero for nonblocking mode
 * \bug nonblocking code is in development and won't work as expected
 */
void ssh_set_blocking(ssh_session session, int blocking) {
  if (session == NULL) {
    return;
  }

  session->blocking = blocking ? 1 : 0;
}

/** In case you'd need the file descriptor of the connection
 * to the server/client
 * \brief recover the fd of connection
 * \param session ssh session
 * \return file descriptor of the connection, or -1 if it is
 * not connected
 */
socket_t ssh_get_fd(ssh_session session) {
  if (session == NULL) {
    return -1;
  }

  return ssh_socket_get_fd(session->socket);
}

/** \brief say to the session it has data to read on the file descriptor without blocking
 * \param session ssh session
 */
void ssh_set_fd_toread(ssh_session session) {
  if (session == NULL) {
    return;
  }

  ssh_socket_set_toread(session->socket);
}

/** \brief say the session it may write to the file descriptor without blocking
 * \param session ssh session
 */
void ssh_set_fd_towrite(ssh_session session) {
  if (session == NULL) {
    return;
  }

  ssh_socket_set_towrite(session->socket);
}

/** \brief say the session it has an exception to catch on the file descriptor
 * \param session ssh session
 */
void ssh_set_fd_except(ssh_session session) {
  if (session == NULL) {
    return;
  }

  ssh_socket_set_except(session->socket);
}

/** @internal
 * @brief polls the current session for an event and call the
 * appropriate callbacks. Will block until one event happens.
 * @param session session handle.
 * @return SSH_OK if there are no error, SSH_ERROR otherwise.
 */
int ssh_handle_packets(ssh_session session) {
	ssh_poll_handle spoll;
	ssh_poll_ctx ctx;
  if(session==NULL || session->socket==NULL)
  	return SSH_ERROR;
  enter_function();
  spoll=ssh_socket_get_poll_handle(session->socket);
  ctx=ssh_poll_get_ctx(spoll);
  if(ctx==NULL){
  	ctx=ssh_get_global_poll_ctx(session);
  	ssh_poll_ctx_add(ctx,spoll);
  }
  ssh_poll_ctx_dopoll(ctx,-1);
  leave_function();
  if (session->session_state != SSH_SESSION_STATE_ERROR)
  	return SSH_OK;
  else
  	return SSH_ERROR;
}

/**
 * @brief Get session status
 *
 * @param session       The ssh session to use.
 *
 * @returns A bitmask including SSH_CLOSED, SSH_READ_PENDING or SSH_CLOSED_ERROR
 *          which respectively means the session is closed, has data to read on
 *          the connection socket and session was closed due to an error.
 */
int ssh_get_status(ssh_session session) {
  int socketstate;
  int r = 0;

  if (session == NULL) {
    return 0;
  }

  socketstate = ssh_socket_get_status(session->socket);

  if (session->closed) {
    r |= SSH_CLOSED;
  }
  if (socketstate & SSH_READ_PENDING) {
    r |= SSH_READ_PENDING;
  }
  if (session->closed && (socketstate & SSH_CLOSED_ERROR)) {
    r |= SSH_CLOSED_ERROR;
  }

  return r;
}

/** \brief get the disconnect message from the server
 * \param session ssh session
 * \return message sent by the server along with the disconnect, or NULL in which case the reason of the disconnect may be found with ssh_get_error.
 * \see ssh_get_error()
 */
const char *ssh_get_disconnect_message(ssh_session session) {
  if (session == NULL) {
    return NULL;
  }

  if (!session->closed) {
    ssh_set_error(session, SSH_REQUEST_DENIED,
        "Connection not closed yet");
  } else if(session->closed_by_except) {
    ssh_set_error(session, SSH_REQUEST_DENIED,
        "Connection closed by socket error");
  } else if(!session->discon_msg) {
    ssh_set_error(session, SSH_FATAL,
        "Connection correctly closed but no disconnect message");
  } else {
    return session->discon_msg;
  }

  return NULL;
}

/**
 * @brief Get the protocol version of the session.
 *
 * @param session       The ssh session to use.
 *
 * @return 1 or 2, for ssh1 or ssh2, < 0 on error.
 */
int ssh_get_version(ssh_session session) {
  if (session == NULL) {
    return -1;
  }

  return session->version;
}

/**
 * @internal
 * @brief handles a SSH_DISCONNECT packet
 */
SSH_PACKET_CALLBACK(ssh_packet_disconnect_callback){
	uint32_t code;
	char *error=NULL;
	ssh_string error_s;
	(void)user;
	(void)type;
  buffer_get_u32(packet, &code);
  error_s = buffer_get_ssh_string(packet);
  if (error_s != NULL) {
    error = string_to_char(error_s);
    string_free(error_s);
  }
  ssh_log(session, SSH_LOG_PACKET, "Received SSH_MSG_DISCONNECT %d:%s",code,
      error != NULL ? error : "no error");
  ssh_set_error(session, SSH_FATAL,
      "Received SSH_MSG_DISCONNECT: %d:%s",code,
      error != NULL ? error : "no error");
  SAFE_FREE(error);

  ssh_socket_close(session->socket);
  session->alive = 0;
	/* TODO: handle a graceful disconnect */
	return SSH_PACKET_USED;
}

/**
 * @internal
 * @brief handles a SSH_IGNORE and SSH_DEBUG packet
 */
SSH_PACKET_CALLBACK(ssh_packet_ignore_callback){
	(void)user;
	(void)type;
	(void)packet;
	ssh_log(session,SSH_LOG_PROTOCOL,"Received %s packet",type==SSH2_MSG_IGNORE ? "SSH_MSG_IGNORE" : "SSH_MSG_DEBUG");
	/* TODO: handle a graceful disconnect */
	return SSH_PACKET_USED;
}
/** @} */
/* vim: set ts=2 sw=2 et cindent: */