include/libssh/callbacks.h

/*
 * This file is part of the SSH Library
 *
 * Copyright (c) 2009 Aris Adamantiadis <aris@0xbadc0de.be>
 *
 * This 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.
 *
 * This 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/* callback.h
 * This file includes the public declarations for the libssh callback mechanism
 */

#ifndef _SSH_CALLBACK_H
#define _SSH_CALLBACK_H

#include <libssh/libssh.h>
#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void (*ssh_callback_int) (int code, void *user);

typedef int (*ssh_callback_data) (const void *data, size_t len, void *user);

typedef void (*ssh_callback_int_int) (int code, int errno_code, void *user);

typedef int (*ssh_message_callback) (ssh_session, ssh_message message, void *user);
typedef int (*ssh_channel_callback_int) (ssh_channel channel, int code, void *user);
typedef int (*ssh_channel_callback_data) (ssh_channel channel, int code, void *data, size_t len, void *user);

typedef void (*ssh_log_callback) (ssh_session session, int priority,
    const char *message, void *userdata);

typedef void (*ssh_logging_callback) (int priority,
                                      const char *function,
                                      const char *buffer,
                                      void *userdata);

typedef void (*ssh_status_callback) (ssh_session session, float status,
    void *userdata);

typedef void (*ssh_global_request_callback) (ssh_session session,
                                        ssh_message message, void *userdata);

typedef ssh_channel (*ssh_channel_open_request_x11_callback) (ssh_session session,
      const char * originator_address, int originator_port, void *userdata);

struct ssh_callbacks_struct {
  size_t size;
  void *userdata;
  ssh_auth_callback auth_function;
  ssh_log_callback log_function;
  void (*connect_status_function)(void *userdata, float status);
  ssh_global_request_callback global_request_function;
  ssh_channel_open_request_x11_callback channel_open_request_x11_function;
};
typedef struct ssh_callbacks_struct *ssh_callbacks;

typedef int (*ssh_auth_password_callback) (ssh_session session, const char *user, const char *password,
    void *userdata);

typedef int (*ssh_auth_none_callback) (ssh_session session, const char *user, void *userdata);

typedef int (*ssh_auth_gssapi_mic_callback) (ssh_session session, const char *user, const char *principal,
    void *userdata);

typedef int (*ssh_auth_pubkey_callback) (ssh_session session, const char *user, struct ssh_key_struct *pubkey,
    char signature_state, void *userdata);


typedef int (*ssh_service_request_callback) (ssh_session session, const char *service, void *userdata);

typedef ssh_channel (*ssh_channel_open_request_session_callback) (ssh_session session, void *userdata);

/*
 * @brief handle the beginning of a GSSAPI authentication, server side.
 * @param session current session handler
 * @param user the username of the client
 * @param n_oid number of available oids
 * @param oids OIDs provided by the client
 * @returns an ssh_string containing the chosen OID, that's supported by both
 * client and server.
 * @warning It is not necessary to fill this callback in if libssh is linked
 * with libgssapi.
 */
typedef ssh_string (*ssh_gssapi_select_oid_callback) (ssh_session session, const char *user,
    int n_oid, ssh_string *oids, void *userdata);

/*
 * @brief handle the negociation of a security context, server side.
 * @param session current session handler
 * @param[in] input_token input token provided by client
 * @param[out] output_token output of the gssapi accept_sec_context method,
 *        NULL after completion.
 * @returns SSH_OK if the token was generated correctly or accept_sec_context
 * returned GSS_S_COMPLETE
 * @returns SSH_ERROR in case of error
 * @warning It is not necessary to fill this callback in if libssh is linked
 * with libgssapi.
 */
typedef int (*ssh_gssapi_accept_sec_ctx_callback) (ssh_session session,
    ssh_string input_token, ssh_string *output_token, void *userdata);

/*
 * @brief Verify and authenticates a MIC, server side.
 * @param session current session handler
 * @param[in] mic input mic to be verified provided by client
 * @param[in] mic_buffer buffer of data to be signed.
 * @param[in] mic_buffer_size size of mic_buffer
 * @returns SSH_OK if the MIC was authenticated correctly
 * @returns SSH_ERROR in case of error
 * @warning It is not necessary to fill this callback in if libssh is linked
 * with libgssapi.
 */
typedef int (*ssh_gssapi_verify_mic_callback) (ssh_session session,
    ssh_string mic, void *mic_buffer, size_t mic_buffer_size, void *userdata);


struct ssh_server_callbacks_struct {
  size_t size;
  void *userdata;
  ssh_auth_password_callback auth_password_function;

  ssh_auth_none_callback auth_none_function;

  ssh_auth_gssapi_mic_callback auth_gssapi_mic_function;

  ssh_auth_pubkey_callback auth_pubkey_function;

  ssh_service_request_callback service_request_function;
  ssh_channel_open_request_session_callback channel_open_request_session_function;
  ssh_gssapi_select_oid_callback gssapi_select_oid_function;
  ssh_gssapi_accept_sec_ctx_callback gssapi_accept_sec_ctx_function;
  /* This function will be called when a MIC needs to be verified.
   */
  ssh_gssapi_verify_mic_callback gssapi_verify_mic_function;
};
typedef struct ssh_server_callbacks_struct *ssh_server_callbacks;

LIBSSH_API int ssh_set_server_callbacks(ssh_session session, ssh_server_callbacks cb);

struct ssh_socket_callbacks_struct {
  void *userdata;
  ssh_callback_data data;
  ssh_callback_int controlflow;
  ssh_callback_int_int exception;
  ssh_callback_int_int connected;
};
typedef struct ssh_socket_callbacks_struct *ssh_socket_callbacks;

#define SSH_SOCKET_FLOW_WRITEWILLBLOCK 1
#define SSH_SOCKET_FLOW_WRITEWONTBLOCK 2

#define SSH_SOCKET_EXCEPTION_EOF       1
#define SSH_SOCKET_EXCEPTION_ERROR     2

#define SSH_SOCKET_CONNECTED_OK       1
#define SSH_SOCKET_CONNECTED_ERROR    2
#define SSH_SOCKET_CONNECTED_TIMEOUT  3

#define ssh_callbacks_init(p) do {\
  (p)->size=sizeof(*(p)); \
} while(0);

#define ssh_callbacks_exists(p,c) (\
  (p != NULL) && ( (char *)&((p)-> c) < (char *)(p) + (p)->size ) && \
  ((p)-> c != NULL) \
  )

typedef int (*ssh_packet_callback) (ssh_session session, uint8_t type, ssh_buffer packet, void *user);

#define SSH_PACKET_USED 1

#define SSH_PACKET_NOT_USED 2


#define SSH_PACKET_CALLBACK(name) \
  int name (ssh_session session, uint8_t type, ssh_buffer packet, void *user)

struct ssh_packet_callbacks_struct {
  uint8_t start;
  uint8_t n_callbacks;
  ssh_packet_callback *callbacks;
  void *user;
};

typedef struct ssh_packet_callbacks_struct *ssh_packet_callbacks;

LIBSSH_API int ssh_set_callbacks(ssh_session session, ssh_callbacks cb);

typedef int (*ssh_channel_data_callback) (ssh_session session,
                                           ssh_channel channel,
                                           void *data,
                                           uint32_t len,
                                           int is_stderr,
                                           void *userdata);

typedef void (*ssh_channel_eof_callback) (ssh_session session,
                                           ssh_channel channel,
                                           void *userdata);

typedef void (*ssh_channel_close_callback) (ssh_session session,
                                            ssh_channel channel,
                                            void *userdata);

typedef void (*ssh_channel_signal_callback) (ssh_session session,
                                            ssh_channel channel,
                                            const char *signal,
                                            void *userdata);

typedef void (*ssh_channel_exit_status_callback) (ssh_session session,
                                            ssh_channel channel,
                                            int exit_status,
                                            void *userdata);

typedef void (*ssh_channel_exit_signal_callback) (ssh_session session,
                                            ssh_channel channel,
                                            const char *signal,
                                            int core,
                                            const char *errmsg,
                                            const char *lang,
                                            void *userdata);

typedef int (*ssh_channel_pty_request_callback) (ssh_session session,
                                            ssh_channel channel,
                                            const char *term,
                                            int width, int height,
                                            int pxwidth, int pwheight,
                                            void *userdata);

typedef int (*ssh_channel_shell_request_callback) (ssh_session session,
                                            ssh_channel channel,
                                            void *userdata);
typedef void (*ssh_channel_auth_agent_req_callback) (ssh_session session,
                                            ssh_channel channel,
                                            void *userdata);

typedef void (*ssh_channel_x11_req_callback) (ssh_session session,
                                            ssh_channel channel,
                                            int single_connection,
                                            const char *auth_protocol,
                                            const char *auth_cookie,
                                            uint32_t screen_number,
                                            void *userdata);
typedef int (*ssh_channel_pty_window_change_callback) (ssh_session session,
                                            ssh_channel channel,
                                            int width, int height,
                                            int pxwidth, int pwheight,
                                            void *userdata);

typedef int (*ssh_channel_exec_request_callback) (ssh_session session,
                                            ssh_channel channel,
                                            const char *command,
                                            void *userdata);

typedef int (*ssh_channel_env_request_callback) (ssh_session session,
                                            ssh_channel channel,
                                            const char *env_name,
                                            const char *env_value,
                                            void *userdata);
typedef int (*ssh_channel_subsystem_request_callback) (ssh_session session,
                                            ssh_channel channel,
                                            const char *subsystem,
                                            void *userdata);


struct ssh_channel_callbacks_struct {
  size_t size;
  void *userdata;
  ssh_channel_data_callback channel_data_function;
  ssh_channel_eof_callback channel_eof_function;
  ssh_channel_close_callback channel_close_function;
  ssh_channel_signal_callback channel_signal_function;
  ssh_channel_exit_status_callback channel_exit_status_function;
  ssh_channel_exit_signal_callback channel_exit_signal_function;
  ssh_channel_pty_request_callback channel_pty_request_function;
  ssh_channel_shell_request_callback channel_shell_request_function;
  ssh_channel_auth_agent_req_callback channel_auth_agent_req_function;
  ssh_channel_x11_req_callback channel_x11_req_function;
  ssh_channel_pty_window_change_callback channel_pty_window_change_function;
  ssh_channel_exec_request_callback channel_exec_request_function;
  ssh_channel_env_request_callback channel_env_request_function;
  ssh_channel_subsystem_request_callback channel_subsystem_request_function;
};

typedef struct ssh_channel_callbacks_struct *ssh_channel_callbacks;

LIBSSH_API int ssh_set_channel_callbacks(ssh_channel channel,
                                         ssh_channel_callbacks cb);

typedef int (*ssh_thread_callback) (void **lock);

typedef unsigned long (*ssh_thread_id_callback) (void);
struct ssh_threads_callbacks_struct {
  const char *type;
  ssh_thread_callback mutex_init;
  ssh_thread_callback mutex_destroy;
  ssh_thread_callback mutex_lock;
  ssh_thread_callback mutex_unlock;
  ssh_thread_id_callback thread_id;
};

LIBSSH_API int ssh_threads_set_callbacks(struct ssh_threads_callbacks_struct
    *cb);

LIBSSH_API struct ssh_threads_callbacks_struct *ssh_threads_get_pthread(void);

LIBSSH_API struct ssh_threads_callbacks_struct *ssh_threads_get_noop(void);

LIBSSH_API int ssh_set_log_callback(ssh_logging_callback cb);

LIBSSH_API ssh_logging_callback ssh_get_log_callback(void);

#ifdef __cplusplus
}
#endif

#endif /*_SSH_CALLBACK_H */

/* @} */