common.h

Go to the documentation of this file.

/*
 * Copyright (c) 2024 Grant Ramsay <grant.ramsay@hotmail.com>
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_SSH_COMMON_H_
#define ZEPHYR_INCLUDE_NET_SSH_COMMON_H_

 
#include <zephyr/kernel.h>
#include <zephyr/sys/slist.h>
 
#ifdef __cplusplus
extern "C" {
#endif

 
struct ssh_transport;
struct ssh_channel;
struct ssh_client;
struct ssh_server;


enum ssh_auth_type {
        SSH_AUTH_NONE,
        SSH_AUTH_PASSWORD,
        SSH_AUTH_PUBKEY
};

enum ssh_channel_request_type {
        SSH_CHANNEL_REQUEST_UNKNOWN,
        SSH_CHANNEL_REQUEST_PSEUDO_TERMINAL,
        SSH_CHANNEL_REQUEST_X11_FORWARD,
        SSH_CHANNEL_REQUEST_ENV_VAR,
        SSH_CHANNEL_REQUEST_SHELL,
        SSH_CHANNEL_REQUEST_EXEC,
        SSH_CHANNEL_REQUEST_SUBSYSTEM,
        SSH_CHANNEL_REQUEST_WINDOW_CHANGE,
        SSH_CHANNEL_REQUEST_FLOW_CONTROL,
        SSH_CHANNEL_REQUEST_SIGNAL,
        SSH_CHANNEL_REQUEST_EXIT_STATUS,
        SSH_CHANNEL_REQUEST_EXIT_SIGNAL
};

enum ssh_channel_event_type {
        SSH_CHANNEL_EVENT_OPEN_RESULT,          /* Client only */
        SSH_CHANNEL_EVENT_REQUEST,              /* Server only */
        SSH_CHANNEL_EVENT_REQUEST_RESULT,       /* Client only */
        SSH_CHANNEL_EVENT_RX_DATA_READY,
        SSH_CHANNEL_EVENT_TX_DATA_READY,
        SSH_CHANNEL_EVENT_RX_STDERR_DATA_READY,
        SSH_CHANNEL_EVENT_EOF,
        SSH_CHANNEL_EVENT_CLOSED
};

struct ssh_channel_event_channel_request {
        enum ssh_channel_request_type type;
        bool want_reply;
        /* TODO: Union of request type data */
};

struct ssh_channel_event_channel_request_result {
        bool success;
};

struct ssh_channel_event {
        enum ssh_channel_event_type type;

        union {
                struct ssh_channel_event_channel_request channel_request;

                struct ssh_channel_event_channel_request_result channel_request_result;
        };
};

typedef int (*ssh_channel_event_callback_t)(struct ssh_channel *channel,
                                            const struct ssh_channel_event *event,
                                            void *user_data);

enum ssh_transport_event_type {
        SSH_TRANSPORT_EVENT_CLOSED,                     /* Server and client */
        SSH_TRANSPORT_EVENT_SERVICE_ACCEPTED,           /* Client only */
        SSH_TRANSPORT_EVENT_AUTHENTICATE_RESULT,        /* Client only */
        SSH_TRANSPORT_EVENT_CHANNEL_OPEN,               /* Server only */
};

struct ssh_transport_event_authenticate_result {
        bool success;
};

struct ssh_transport_event_channel_open {
        struct ssh_channel *channel;
};

struct ssh_transport_event {
        enum ssh_transport_event_type type;

        union {
                struct ssh_transport_event_authenticate_result authenticate_result;

                struct ssh_transport_event_channel_open channel_open;
        };
};

typedef int (*ssh_transport_event_callback_t)(struct ssh_transport *transport,
                                              const struct ssh_transport_event *event,
                                              void *user_data);

struct ssh_transport_conf {
        sys_snode_t node;

        ssh_transport_event_callback_t cb;

        void *user_data;
};

#define SSH_EXTENDED_DATA_STDERR 1
 
#if defined(CONFIG_SSH_CLIENT) || defined(__DOXYGEN__)
const char *ssh_transport_client_user_name(struct ssh_transport *transport);

int ssh_transport_auth_password(struct ssh_transport *transport, const char *user_name,
                                const char *password);

int ssh_transport_channel_open(struct ssh_transport *transport,
                               ssh_channel_event_callback_t callback, void *user_data);
 
#endif /* CONFIG_SSH_CLIENT || __DOXYGEN__ */
 
#if defined(CONFIG_SSH_SERVER) || defined(__DOXYGEN__)
int ssh_channel_open_result(struct ssh_channel *channel, bool success,
                            ssh_channel_event_callback_t callback, void *user_data);
 
#endif /* CONFIG_SSH_SERVER || __DOXYGEN__ */

int ssh_channel_request_result(struct ssh_channel *channel, bool success);
 
#if defined(CONFIG_SSH_CLIENT) || defined(__DOXYGEN__)
int ssh_channel_request_shell(struct ssh_channel *channel);
 
#endif /* CONFIG_SSH_CLIENT || __DOXYGEN__ */

int ssh_channel_read(struct ssh_channel *channel, void *data, uint32_t len);

int ssh_channel_write(struct ssh_channel *channel, const void *data, uint32_t len);

int ssh_channel_read_stderr(struct ssh_channel *channel, void *data, uint32_t len);

int ssh_channel_write_stderr(struct ssh_channel *channel, const void *data, uint32_t len);

int ssh_channel_close(struct ssh_channel *channel);

typedef void (*ssh_service_client_cb_t)(struct ssh_client *ssh,
                                        int instance,
                                        void *user_data);

void ssh_client_foreach(ssh_service_client_cb_t cb, void *user_data);

typedef void (*ssh_service_server_cb_t)(struct ssh_server *sshd,
                                        int instance,
                                        void *user_data);

void ssh_server_foreach(ssh_service_server_cb_t cb, void *user_data);

int ssh_transport_traverse_callbacks(bool is_server, struct ssh_transport *transport,
                                     const struct ssh_transport_event *event);
 
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_NET_SSH_COMMON_H_ */