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>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef void (*ssh_callback_int) (int code, void *user);
 
typedef size_t (*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);
 
typedef ssh_channel (*ssh_channel_open_request_auth_agent_callback) (ssh_session session,
      void *userdata);
 
typedef ssh_channel (*ssh_channel_open_request_forwarded_tcpip_callback) (ssh_session session,
      const char *destination_address, int destination_port,
      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;
  ssh_channel_open_request_auth_agent_callback channel_open_request_auth_agent_function;
  ssh_channel_open_request_forwarded_tcpip_callback channel_open_request_forwarded_tcpip_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.
 *        Callback should select the oid and also acquire the server credential.
 * @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 negotiation 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) \
  )
 
#define ssh_callbacks_execute_list(list, cbtype, c, ...)      \
    do {                                                      \
        struct ssh_iterator *i = ssh_list_get_iterator(list); \
        cbtype cb;                                            \
        while (i != NULL){                                    \
            cb = ssh_iterator_value(cbtype, i);               \
            if (ssh_callbacks_exists(cb, c))                  \
                cb-> c (__VA_ARGS__, cb->userdata);           \
            i = i->next;                                      \
        }                                                     \
    } while(0)
 
#define ssh_callbacks_iterate(_cb_list, _cb_type, _cb_name)           \
    do {                                                              \
        struct ssh_iterator *_cb_i = ssh_list_get_iterator(_cb_list); \
        _cb_type _cb;                                                 \
        for (; _cb_i != NULL; _cb_i = _cb_i->next) {                  \
            _cb = ssh_iterator_value(_cb_type, _cb_i);                \
            if (ssh_callbacks_exists(_cb, _cb_name))
 
#define ssh_callbacks_iterate_exec(_cb_name, ...) \
                _cb->_cb_name(__VA_ARGS__, _cb->userdata)
 
#define ssh_callbacks_iterate_end() \
        }                           \
    } while(0)
 
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);
 
typedef int (*ssh_channel_write_wontblock_callback) (ssh_session session,
                                                     ssh_channel channel,
                                                     uint32_t bytes,
                                                     void *userdata);
 
typedef void (*ssh_channel_open_resp_callback) (ssh_session session,
                                                ssh_channel channel,
                                                bool is_success,
                                                void *userdata);
 
typedef void (*ssh_channel_request_resp_callback) (ssh_session session,
                                                   ssh_channel channel,
                                                   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;
  ssh_channel_write_wontblock_callback channel_write_wontblock_function;
  ssh_channel_open_resp_callback channel_open_response_function;
  ssh_channel_request_resp_callback channel_request_response_function;
};
 
typedef struct ssh_channel_callbacks_struct *ssh_channel_callbacks;
 
LIBSSH_API int ssh_set_channel_callbacks(ssh_channel channel,
                                         ssh_channel_callbacks cb);
 
LIBSSH_API int ssh_add_channel_callbacks(ssh_channel channel,
                                         ssh_channel_callbacks cb);
 
LIBSSH_API int ssh_remove_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_default(void);
 
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);
 
typedef int (*ssh_jump_before_connection_callback)(ssh_session session,
                                                   void *userdata);
 
typedef int (*ssh_jump_verify_knownhost_callback)(ssh_session session,
                                                  void *userdata);
 
typedef int (*ssh_jump_authenticate_callback)(ssh_session session,
                                              void *userdata);
 
struct ssh_jump_callbacks_struct {
    void *userdata;
    ssh_jump_before_connection_callback before_connection;
    ssh_jump_verify_knownhost_callback verify_knownhost;
    ssh_jump_authenticate_callback authenticate;
};
 
#ifdef __cplusplus
}
#endif
 
#endif /*_SSH_CALLBACK_H */
 
/* @} */