clj-libssh2.libssh2.channel — clj-libssh2 0.1.193

JNA functions for calling functions in libssh2 with names libssh2_channel_*

close clj

(close channel)

int libssh2_channel_close(LIBSSH2_CHANNEL *channel);

direct-tcpip clj

(direct-tcpip session host port)

LIBSSH2_CHANNEL * libssh2_channel_direct_tcpip(LIBSSH2_SESSION *session, const char *host, int port);

direct-tcpip-ex clj

(direct-tcpip-ex session host port shost sport)

LIBSSH2_CHANNEL * libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session, const char *host, int port, const char *shost, int sport);

eof clj

(eof channel)

int libssh2_channel_eof(LIBSSH2_CHANNEL *channel);

exec clj

(exec channel command)

int libssh2_channel_exec(LIBSSH2_CHANNEL *channel, const char *command);

flush clj

(flush channel)

int libssh2_channel_flush(LIBSSH2_CHANNEL *channel);

flush-ex clj

(flush-ex channel streamid)

int libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel, int streamid);

flush-stderr clj

(flush-stderr channel)

int libssh2_channel_flush_stderr(LIBSSH2_CHANNEL *channel);

forward-accept clj

(forward-accept listener)

LIBSSH2_CHANNEL * libssh2_channel_forward_accept(LIBSSH2_LISTENER *listener);

forward-cancel clj

(forward-cancel listener)

int libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener);

forward-listen clj

(forward-listen session port)

LIBSSH2_LISTENER * libssh2_channel_forward_listen(LIBSSH2_SESSION *session, int port);

forward-listen-ex clj

(forward-listen-ex session host port bound-port queue-maxsize)

LIBSSH2_LISTENER * libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, char *host, int port, int *bound_port, int queue_maxsize);

free clj

(free channel)

int libssh2_channel_free(LIBSSH2_CHANNEL *channel);

get-exit-signal clj

(get-exit-signal channel
                 exit-signal
                 exit-signal-len
                 err-msg
                 err-msg-len
                 lang-tag
                 lang-tag-len)

int libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL *channel, char **exitsignal, size_t *exitsignal_len, char **errmsg, size_t *errmsg_len, char **langtag, size_t *langtag_len);

get-exit-status clj

(get-exit-status channel)

int libssh2_channel_get_exit_status(LIBSSH2_CHANNEL* channel)

handle-extended-data clj deprecated

(handle-extended-data channel ignore-mode)

void libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode);

handle-extended-data2 clj

(handle-extended-data2 channel ignore-mode)

int libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel, int ignore_mode);

ignore-extended-data clj deprecated

(ignore-extended-data channel ignore)

void libssh2_channel_ignore_extended_data(LIBSSH2_CHANNEL *channel, int ignore);

open-ex clj

(open-ex session
         channel-type
         channel-type-len
         window-size
         packet-size
         message
         message-len)

LIBSSH2_CHANNEL * libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *channel_type, unsigned int channel_type_len, unsigned int window_size, unsigned int packet_size, const char *message, unsigned int message_len);

open-session clj

(open-session session)

LIBSSH2_CHANNEL * libssh2_channel_open_session(LIBSSH2_SESSION *session);

process-startup clj

(process-startup channel request request-len message message-len)

int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel, const char *request, unsigned int request_len, const char *message, unsigned int message_len);

read clj

(read channel buf buflen)

ssize_t libssh2_channel_read(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);

read-ex clj

(read-ex channel stream-id buf buflen)

ssize_t libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id, char *buf, size_t buflen);

read-stderr clj

(read-stderr channel buf buflen)

ssize_t libssh2_channel_read_stderr(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);

receive-window-adjust clj deprecated

(receive-window-adjust channel adjustment force)

unsigned long libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel, unsigned long adjustment, unsigned char force);

receive-window-adjust2 clj

(receive-window-adjust2 channel adjustment force window)

int libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL * channel, unsigned long adjustment, unsigned char force, unsigned int *window);

request-pty clj

(request-pty channel term)

int libssh2_channel_request_pty(LIBSSH2_CHANNEL *channel, char *term);

request-pty-ex clj

(request-pty-ex channel
                term
                term-len
                modes
                modes-len
                width
                height
                width-px
                height-px)

int libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, const char *term, unsigned int term_len, const char *modes, unsigned int modes_len, int width, int height, int width_px, int height_px);

request-pty-size clj

(request-pty-size channel width height)

int libssh2_channel_request_pty_size(LIBSSH2_CHANNEL *channel, int width, int height);

request-pty-size-ex clj

(request-pty-size-ex channel width height width-px height-px)

LIBSSH2_API int libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL *channel, int width, int height, int width_px, int height_px);

send-eof clj

(send-eof channel)

int libssh2_channel_send_eof(LIBSSH2_CHANNEL *channel);

set-blocking clj

(set-blocking channel blocking)

void libssh2_channel_set_blocking(LIBSSH2_CHANNEL *channel, int blocking);

setenv clj

(setenv channel varname value)

int libssh2_channel_setenv(LIBSSH2_CHANNEL *channel, char *varname, const char *value);

setenv-ex clj

(setenv-ex channel varname varname-len value value-len)

int libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel, char *varname, unsigned int varname_len, const char *value, unsigned int value_len);

shell clj

(shell channel)

int libssh2_channel_shell(LIBSSH2_CHANNEL *channel);

subsystem clj

(subsystem channel subsystem)

int libssh2_channel_subsystem(LIBSSH2_CHANNEL *channel, const char *subsystem);

wait-closed clj

(wait-closed channel)

int libssh2_channel_wait_closed(LIBSSH2_CHANNEL *channel);

wait-eof clj

(wait-eof channel)

int libssh2_channel_wait_eof(LIBSSH2_CHANNEL *channel);

window-read clj

(window-read channel)

unsigned long libssh2_channel_window_read(LIBSSH2_CHANNEL *channel);

window-read-ex clj

(window-read-ex channel read-avail window-size-initial)

unsigned long libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel, unsigned long *read_avail, unsigned long *window_size_initial);

window-write clj

(window-write channel)

unsigned long libssh2_channel_window_write(LIBSSH2_CHANNEL *channel);

window-write-ex clj

(window-write-ex channel window-size-initial)

unsigned long libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel, unsigned long *window_size_initial);

write clj

(write channel buf buflen)

ssize_t libssh2_channel_write(LIBSSH2_CHANNEL *channel, const char *buf, size_t buflen);

write-ex clj

(write-ex channel stream-id buf buflen)

ssize_t libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel, int stream_id, char *buf, size_t buflen);

write-stderr clj

(write-stderr channel buf buflen)

ssize_t libssh2_channel_write_stderr(LIBSSH2_CHANNEL *channel, const char *buf, size_t buflen);

x11-req clj

(x11-req channel screen-number)

int libssh2_channel_x11_req(LIBSSH2_CHANNEL *channel, int screen_number);

x11-req-ex clj

(x11-req-ex channel single-connection auth-proto auth-cookie screen-number)

int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_connection, const char *auth_proto, const char *auth_cookie, int screen_number);