aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--examples/exec.c18
-rw-r--r--examples/sample.c82
-rw-r--r--examples/scp_download.c14
-rw-r--r--include/libssh/buffer.h5
-rw-r--r--include/libssh/channels.h2
-rw-r--r--include/libssh/legacy.h98
-rw-r--r--include/libssh/libssh.h104
-rw-r--r--include/libssh/libsshpp.hpp6
-rw-r--r--libssh/CMakeLists.txt1
-rw-r--r--libssh/agent.c52
-rw-r--r--libssh/auth.c232
-rw-r--r--libssh/auth1.c24
-rw-r--r--libssh/base64.c4
-rw-r--r--libssh/buffer.c20
-rw-r--r--libssh/channels.c240
-rw-r--r--libssh/channels1.c20
-rw-r--r--libssh/client.c38
-rw-r--r--libssh/connect.c8
-rw-r--r--libssh/crypt.c4
-rw-r--r--libssh/dh.c66
-rw-r--r--libssh/gzip.c36
-rw-r--r--libssh/kex.c68
-rw-r--r--libssh/keyfiles.c148
-rw-r--r--libssh/keys.c448
-rw-r--r--libssh/legacy.c233
-rw-r--r--libssh/messages.c116
-rw-r--r--libssh/packet.c26
-rw-r--r--libssh/packet1.c36
-rw-r--r--libssh/pcap.c18
-rw-r--r--libssh/scp.c54
-rw-r--r--libssh/server.c36
-rw-r--r--libssh/session.c14
-rw-r--r--libssh/sftp.c500
-rw-r--r--libssh/sftpserver.c110
-rw-r--r--libssh/socket.c10
-rw-r--r--libssh/string.c20
-rw-r--r--tests/test_exec.c16
-rw-r--r--tests/test_pcap.c2
-rw-r--r--tests/test_tunnel.c14
-rw-r--r--tests/unittests/torture_keyfiles.c12
40 files changed, 1640 insertions, 1315 deletions
diff --git a/examples/exec.c b/examples/exec.c
index bff49fd0..1f6fa297 100644
--- a/examples/exec.c
+++ b/examples/exec.c
@@ -15,41 +15,41 @@ int main(void) {
return 1;
}
- channel = channel_new(session);;
+ channel = ssh_channel_new(session);;
if (channel == NULL) {
ssh_disconnect(session);
return 1;
}
- rc = channel_open_session(channel);
+ rc = ssh_channel_open_session(channel);
if (rc < 0) {
- channel_close(channel);
+ ssh_channel_close(channel);
ssh_disconnect(session);
return 1;
}
- rc = channel_request_exec(channel, "ps aux");
+ rc = ssh_channel_request_exec(channel, "ps aux");
if (rc < 0) {
- channel_close(channel);
+ ssh_channel_close(channel);
ssh_disconnect(session);
return 1;
}
- while ((rc = channel_read(channel, buffer, sizeof(buffer), 0)) > 0) {
+ while ((rc = ssh_channel_read(channel, buffer, sizeof(buffer), 0)) > 0) {
if (fwrite(buffer, 1, rc, stdout) != (unsigned int) rc) {
return 1;
}
}
if (rc < 0) {
- channel_close(channel);
+ ssh_channel_close(channel);
ssh_disconnect(session);
return 1;
}
- channel_send_eof(channel);
- channel_close(channel);
+ ssh_channel_send_eof(channel);
+ ssh_channel_close(channel);
ssh_disconnect(session);
diff --git a/examples/sample.c b/examples/sample.c
index b7f6074d..8f86f560 100644
--- a/examples/sample.c
+++ b/examples/sample.c
@@ -173,7 +173,7 @@ static void setsignal(void){
static void sizechanged(void){
struct winsize win = { 0, 0, 0, 0 };
ioctl(1, TIOCGWINSZ, &win);
- channel_change_pty_size(chan,win.ws_col, win.ws_row);
+ ssh_channel_change_pty_size(chan,win.ws_col, win.ws_row);
// printf("Changed pty size\n");
setsignal();
}
@@ -196,7 +196,7 @@ static void select_loop(ssh_session session,ssh_channel channel){
fd_set fds;
struct timeval timeout;
char buffer[4096];
- ssh_buffer readbuf=buffer_new();
+ ssh_buffer readbuf=ssh_buffer_new();
ssh_channel channels[2];
int lus;
int eof=0;
@@ -224,10 +224,10 @@ static void select_loop(ssh_session session,ssh_channel channel){
if(FD_ISSET(0,&fds)){
lus=read(0,buffer,sizeof(buffer));
if(lus)
- channel_write(channel,buffer,lus);
+ ssh_channel_write(channel,buffer,lus);
else {
eof=1;
- channel_send_eof(channel);
+ ssh_channel_send_eof(channel);
}
}
if(FD_ISSET(ssh_get_fd(session),&fds)){
@@ -235,22 +235,22 @@ static void select_loop(ssh_session session,ssh_channel channel){
}
channels[0]=channel; // set the first channel we want to read from
channels[1]=NULL;
- ret=channel_select(channels,NULL,NULL,NULL); // no specific timeout - just poll
+ ret=ssh_channel_select(channels,NULL,NULL,NULL); // no specific timeout - just poll
if(signal_delayed)
sizechanged();
} while (ret==EINTR || ret==SSH_EINTR);
// we already looked for input from stdin. Now, we are looking for input from the channel
- if(channel && channel_is_closed(channel)){
- ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",channel_get_exit_status(channel));
+ if(channel && ssh_channel_is_closed(channel)){
+ ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",ssh_channel_get_exit_status(channel));
- channel_free(channel);
+ ssh_channel_free(channel);
channel=NULL;
channels[0]=NULL;
}
if(channels[0]){
- while(channel && channel_is_open(channel) && channel_poll(channel,0)>0){
+ while(channel && ssh_channel_is_open(channel) && ssh_channel_poll(channel,0)>0){
lus=channel_read_buffer(channel,readbuf,0,0);
if(lus==-1){
fprintf(stderr, "Error reading channel: %s\n",
@@ -259,17 +259,17 @@ static void select_loop(ssh_session session,ssh_channel channel){
}
if(lus==0){
ssh_log(session,SSH_LOG_RARE,"EOF received\n");
- ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",channel_get_exit_status(channel));
+ ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",ssh_channel_get_exit_status(channel));
- channel_free(channel);
+ ssh_channel_free(channel);
channel=channels[0]=NULL;
} else
- if (write(1,buffer_get(readbuf),lus) < 0) {
+ if (write(1,ssh_buffer_get_begin(readbuf),lus) < 0) {
fprintf(stderr, "Error writing to buffer\n");
return;
}
}
- while(channel && channel_is_open(channel) && channel_poll(channel,1)>0){ /* stderr */
+ while(channel && ssh_channel_is_open(channel) && ssh_channel_poll(channel,1)>0){ /* stderr */
lus=channel_read_buffer(channel,readbuf,0,1);
if(lus==-1){
fprintf(stderr, "Error reading channel: %s\n",
@@ -278,22 +278,22 @@ static void select_loop(ssh_session session,ssh_channel channel){
}
if(lus==0){
ssh_log(session,SSH_LOG_RARE,"EOF received\n");
- ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",channel_get_exit_status(channel));
- channel_free(channel);
+ ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",ssh_channel_get_exit_status(channel));
+ ssh_channel_free(channel);
channel=channels[0]=NULL;
} else
- if (write(2,buffer_get(readbuf),lus) < 0) {
+ if (write(2,ssh_buffer_get_begin(readbuf),lus) < 0) {
fprintf(stderr, "Error writing to buffer\n");
return;
}
}
}
- if(channel && channel_is_closed(channel)){
- channel_free(channel);
+ if(channel && ssh_channel_is_closed(channel)){
+ ssh_channel_free(channel);
channel=NULL;
}
}
- buffer_free(readbuf);
+ ssh_buffer_free(readbuf);
}
#else /* CHANNEL_SELECT */
@@ -328,22 +328,22 @@ static void select_loop(ssh_session session,ssh_channel channel){
if(FD_ISSET(0,&fds)){
lus=read(0,buffer,sizeof(buffer));
if(lus)
- channel_write(channel,buffer,lus);
+ ssh_channel_write(channel,buffer,lus);
else {
eof=1;
- channel_send_eof(channel);
+ ssh_channel_send_eof(channel);
}
}
- if(channel && channel_is_closed(channel)){
- ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",channel_get_exit_status(channel));
+ if(channel && ssh_channel_is_closed(channel)){
+ ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",ssh_channel_get_exit_status(channel));
- channel_free(channel);
+ ssh_channel_free(channel);
channel=NULL;
channels[0]=NULL;
}
if(outchannels[0]){
- while(channel && channel_is_open(channel) && channel_poll(channel,0)!=0){
- lus=channel_read(channel,buffer,sizeof(buffer),0);
+ while(channel && ssh_channel_is_open(channel) && ssh_channel_poll(channel,0)!=0){
+ lus=ssh_channel_read(channel,buffer,sizeof(buffer),0);
if(lus==-1){
fprintf(stderr, "Error reading channel: %s\n",
ssh_get_error(session));
@@ -351,9 +351,9 @@ static void select_loop(ssh_session session,ssh_channel channel){
}
if(lus==0){
ssh_log(session,SSH_LOG_RARE,"EOF received\n");
- ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",channel_get_exit_status(channel));
+ ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",ssh_channel_get_exit_status(channel));
- channel_free(channel);
+ ssh_channel_free(channel);
channel=channels[0]=NULL;
} else
if (write(1,buffer,lus) < 0) {
@@ -361,8 +361,8 @@ static void select_loop(ssh_session session,ssh_channel channel){
return;
}
}
- while(channel && channel_is_open(channel) && channel_poll(channel,1)!=0){ /* stderr */
- lus=channel_read(channel,buffer,sizeof(buffer),1);
+ while(channel && ssh_channel_is_open(channel) && ssh_channel_poll(channel,1)!=0){ /* stderr */
+ lus=ssh_channel_read(channel,buffer,sizeof(buffer),1);
if(lus==-1){
fprintf(stderr, "Error reading channel: %s\n",
ssh_get_error(session));
@@ -370,8 +370,8 @@ static void select_loop(ssh_session session,ssh_channel channel){
}
if(lus==0){
ssh_log(session,SSH_LOG_RARE,"EOF received\n");
- ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",channel_get_exit_status(channel));
- channel_free(channel);
+ ssh_log(session,SSH_LOG_RARE,"exit-status : %d\n",ssh_channel_get_exit_status(channel));
+ ssh_channel_free(channel);
channel=channels[0]=NULL;
} else
if (write(2,buffer,lus) < 0) {
@@ -380,8 +380,8 @@ static void select_loop(ssh_session session,ssh_channel channel){
}
}
}
- if(channel && channel_is_closed(channel)){
- channel_free(channel);
+ if(channel && ssh_channel_is_closed(channel)){
+ ssh_channel_free(channel);
channel=NULL;
}
} while (ret==EINTR || ret==SSH_EINTR);
@@ -395,21 +395,21 @@ static void shell(ssh_session session){
ssh_channel channel;
struct termios terminal_local;
int interactive=isatty(0);
- channel = channel_new(session);
+ channel = ssh_channel_new(session);
if(interactive){
tcgetattr(0,&terminal_local);
memcpy(&terminal,&terminal_local,sizeof(struct termios));
}
- if(channel_open_session(channel)){
+ if(ssh_channel_open_session(channel)){
printf("error opening channel : %s\n",ssh_get_error(session));
return;
}
chan=channel;
if(interactive){
- channel_request_pty(channel);
+ ssh_channel_request_pty(channel);
sizechanged();
}
- if(channel_request_shell(channel)){
+ if(ssh_channel_request_shell(channel)){
printf("Requesting shell : %s\n",ssh_get_error(session));
return;
}
@@ -430,9 +430,9 @@ static void batch_shell(ssh_session session){
int i,s=0;
for(i=0;i<MAXCMD && cmds[i];++i)
s+=snprintf(buffer+s,sizeof(buffer)-s,"%s ",cmds[i]);
- channel=channel_new(session);
- channel_open_session(channel);
- if(channel_request_exec(channel,buffer)){
+ channel=ssh_channel_new(session);
+ ssh_channel_open_session(channel);
+ if(ssh_channel_request_exec(channel,buffer)){
printf("error executing \"%s\" : %s\n",buffer,ssh_get_error(session));
return;
}
diff --git a/examples/scp_download.c b/examples/scp_download.c
index b178757b..b6f16af1 100644
--- a/examples/scp_download.c
+++ b/examples/scp_download.c
@@ -56,29 +56,29 @@ static int opts(int argc, char **argv){
}
static void create_files(ssh_session session){
- ssh_channel channel=channel_new(session);
+ ssh_channel channel=ssh_channel_new(session);
char buffer[1];
if(channel == NULL){
fprintf(stderr,"Error creating channel: %s\n",ssh_get_error(session));
exit(EXIT_FAILURE);
}
- if(channel_open_session(channel) != SSH_OK){
+ if(ssh_channel_open_session(channel) != SSH_OK){
fprintf(stderr,"Error creating channel: %s\n",ssh_get_error(session));
exit(EXIT_FAILURE);
}
- if(channel_request_exec(channel,createcommand) != SSH_OK){
+ if(ssh_channel_request_exec(channel,createcommand) != SSH_OK){
fprintf(stderr,"Error executing command: %s\n",ssh_get_error(session));
exit(EXIT_FAILURE);
}
- while(!channel_is_eof(channel)){
- channel_read(channel,buffer,1,1);
+ while(!ssh_channel_is_eof(channel)){
+ ssh_channel_read(channel,buffer,1,1);
if (write(1,buffer,1) < 0) {
fprintf(stderr, "Error writing to buffer\n");
return;
}
}
- channel_close(channel);
- channel_free(channel);
+ ssh_channel_close(channel);
+ ssh_channel_free(channel);
}
diff --git a/include/libssh/buffer.h b/include/libssh/buffer.h
index 648a5b27..dec11739 100644
--- a/include/libssh/buffer.h
+++ b/include/libssh/buffer.h
@@ -22,6 +22,7 @@
#ifndef BUFFER_H_
#define BUFFER_H_
+#include "libssh/libssh.h"
/* Describes a buffer state */
struct ssh_buffer_struct {
char *data;
@@ -30,6 +31,10 @@ struct ssh_buffer_struct {
uint32_t pos;
};
+LIBSSH_API void ssh_buffer_free(ssh_buffer buffer);
+LIBSSH_API void *ssh_buffer_get_begin(ssh_buffer buffer);
+LIBSSH_API uint32_t ssh_buffer_get_len(ssh_buffer buffer);
+LIBSSH_API ssh_buffer ssh_buffer_new(void);
int buffer_add_ssh_string(ssh_buffer buffer, ssh_string string);
int buffer_add_u8(ssh_buffer buffer, uint8_t data);
int buffer_add_u16(ssh_buffer buffer, uint16_t data);
diff --git a/include/libssh/channels.h b/include/libssh/channels.h
index 56e660fc..7d8a05ba 100644
--- a/include/libssh/channels.h
+++ b/include/libssh/channels.h
@@ -78,7 +78,7 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_failure);
SSH_PACKET_CALLBACK(ssh_request_success);
SSH_PACKET_CALLBACK(ssh_request_denied);
-ssh_channel channel_new(ssh_session session);
+ssh_channel ssh_channel_new(ssh_session session);
int channel_default_bufferize(ssh_channel channel, void *data, int len,
int is_stderr);
uint32_t ssh_channel_new_id(ssh_session session);
diff --git a/include/libssh/legacy.h b/include/libssh/legacy.h
new file mode 100644
index 00000000..33ed3575
--- /dev/null
+++ b/include/libssh/legacy.h
@@ -0,0 +1,98 @@
+/*
+ * This file is part of the SSH Library
+ *
+ * Copyright (c) 2010 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.
+ */
+
+/* Since libssh.h includes legacy.h, it's important that libssh.h is included
+ * first. we don't define LEGACY_H now because we want it to be defined when
+ * included from libssh.h
+ */
+
+#include "libssh/libssh.h"
+
+#ifndef LEGACY_H_
+#define LEGACY_H_
+LIBSSH_API void buffer_free(ssh_buffer buffer);
+LIBSSH_API void *buffer_get(ssh_buffer buffer);
+LIBSSH_API uint32_t buffer_get_len(ssh_buffer buffer);
+LIBSSH_API ssh_buffer buffer_new(void);
+
+LIBSSH_API ssh_channel channel_accept_x11(ssh_channel channel, int timeout_ms);
+LIBSSH_API int channel_change_pty_size(ssh_channel channel,int cols,int rows);
+LIBSSH_API ssh_channel channel_forward_accept(ssh_session session, int timeout_ms);
+LIBSSH_API int channel_close(ssh_channel channel);
+LIBSSH_API int channel_forward_cancel(ssh_session session, const char *address, int port);
+LIBSSH_API int channel_forward_listen(ssh_session session, const char *address, int port, int *bound_port);
+LIBSSH_API void channel_free(ssh_channel channel);
+LIBSSH_API int channel_get_exit_status(ssh_channel channel);
+LIBSSH_API ssh_session channel_get_session(ssh_channel channel);
+LIBSSH_API int channel_is_closed(ssh_channel channel);
+LIBSSH_API int channel_is_eof(ssh_channel channel);
+LIBSSH_API int channel_is_open(ssh_channel channel);
+LIBSSH_API ssh_channel channel_new(ssh_session session);
+LIBSSH_API int channel_open_forward(ssh_channel channel, const char *remotehost,
+ int remoteport, const char *sourcehost, int localport);
+LIBSSH_API int channel_open_session(ssh_channel channel);
+LIBSSH_API int channel_poll(ssh_channel channel, int is_stderr);
+LIBSSH_API int channel_read(ssh_channel channel, void *dest, uint32_t count, int is_stderr);
+
+LIBSSH_API int channel_read_buffer(ssh_channel channel, ssh_buffer buffer, uint32_t count,
+ int is_stderr);
+
+LIBSSH_API int channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
+ int is_stderr);
+LIBSSH_API int channel_request_env(ssh_channel channel, const char *name, const char *value);
+LIBSSH_API int channel_request_exec(ssh_channel channel, const char *cmd);
+LIBSSH_API int channel_request_pty(ssh_channel channel);
+LIBSSH_API int channel_request_pty_size(ssh_channel channel, const char *term,
+ int cols, int rows);
+LIBSSH_API int channel_request_shell(ssh_channel channel);
+LIBSSH_API int channel_request_send_signal(ssh_channel channel, const char *signum);
+LIBSSH_API int channel_request_sftp(ssh_channel channel);
+LIBSSH_API int channel_request_subsystem(ssh_channel channel, const char *subsystem);
+LIBSSH_API int channel_request_x11(ssh_channel channel, int single_connection, const char *protocol,
+ const char *cookie, int screen_number);
+LIBSSH_API int channel_send_eof(ssh_channel channel);
+LIBSSH_API int channel_select(ssh_channel *readchans, ssh_channel *writechans, ssh_channel *exceptchans, struct
+ timeval * timeout);
+LIBSSH_API void channel_set_blocking(ssh_channel channel, int blocking);
+LIBSSH_API int channel_write(ssh_channel channel, const void *data, uint32_t len);
+
+LIBSSH_API void privatekey_free(ssh_private_key prv);
+LIBSSH_API ssh_private_key privatekey_from_file(ssh_session session, const char *filename,
+ int type, const char *passphrase);
+LIBSSH_API void publickey_free(ssh_public_key key);
+LIBSSH_API int ssh_publickey_to_file(ssh_session session, const char *file,
+ ssh_string pubkey, int type);
+LIBSSH_API ssh_string publickey_from_file(ssh_session session, const char *filename,
+ int *type);
+LIBSSH_API ssh_public_key publickey_from_privatekey(ssh_private_key prv);
+LIBSSH_API ssh_string publickey_to_string(ssh_public_key key);
+
+LIBSSH_API void string_burn(ssh_string str);
+LIBSSH_API ssh_string string_copy(ssh_string str);
+LIBSSH_API void *string_data(ssh_string str);
+LIBSSH_API int string_fill(ssh_string str, const void *data, size_t len);
+LIBSSH_API void string_free(ssh_string str);
+LIBSSH_API ssh_string string_from_char(const char *what);
+LIBSSH_API size_t string_len(ssh_string str);
+LIBSSH_API ssh_string string_new(size_t size);
+LIBSSH_API char *string_to_char(ssh_string str);
+
+#endif /* LEGACY_H_ */
diff --git a/include/libssh/libssh.h b/include/libssh/libssh.h
index d3ba1869..d2ad0e4d 100644
--- a/include/libssh/libssh.h
+++ b/include/libssh/libssh.h
@@ -307,60 +307,43 @@ enum ssh_scp_request_types {
SSH_SCP_REQUEST_WARNING
};
-LIBSSH_API void buffer_free(ssh_buffer buffer);
-LIBSSH_API void *buffer_get(ssh_buffer buffer);
-LIBSSH_API uint32_t buffer_get_len(ssh_buffer buffer);
-LIBSSH_API ssh_buffer buffer_new(void);
-
-LIBSSH_API ssh_channel channel_accept_x11(ssh_channel channel, int timeout_ms);
-LIBSSH_API int channel_change_pty_size(ssh_channel channel,int cols,int rows);
-LIBSSH_API ssh_channel channel_forward_accept(ssh_session session, int timeout_ms);
-LIBSSH_API int channel_close(ssh_channel channel);
-LIBSSH_API int channel_forward_cancel(ssh_session session, const char *address, int port);
-LIBSSH_API int channel_forward_listen(ssh_session session, const char *address, int port, int *bound_port);
-LIBSSH_API void channel_free(ssh_channel channel);
-LIBSSH_API int channel_get_exit_status(ssh_channel channel);
-LIBSSH_API ssh_session channel_get_session(ssh_channel channel);
-LIBSSH_API int channel_is_closed(ssh_channel channel);
-LIBSSH_API int channel_is_eof(ssh_channel channel);
-LIBSSH_API int channel_is_open(ssh_channel channel);
-LIBSSH_API ssh_channel channel_new(ssh_session session);
-LIBSSH_API int channel_open_forward(ssh_channel channel, const char *remotehost,
+LIBSSH_API ssh_channel ssh_channel_accept_x11(ssh_channel channel, int timeout_ms);
+LIBSSH_API int ssh_channel_change_pty_size(ssh_channel channel,int cols,int rows);
+LIBSSH_API ssh_channel ssh_channel_forward_accept(ssh_session session, int timeout_ms);
+LIBSSH_API int ssh_channel_close(ssh_channel channel);
+LIBSSH_API int ssh_channel_forward_cancel(ssh_session session, const char *address, int port);
+LIBSSH_API int ssh_channel_forward_listen(ssh_session session, const char *address, int port, int *bound_port);
+LIBSSH_API void ssh_channel_free(ssh_channel channel);
+LIBSSH_API int ssh_channel_get_exit_status(ssh_channel channel);
+LIBSSH_API ssh_session ssh_channel_get_session(ssh_channel channel);
+LIBSSH_API int ssh_channel_is_closed(ssh_channel channel);
+LIBSSH_API int ssh_channel_is_eof(ssh_channel channel);
+LIBSSH_API int ssh_channel_is_open(ssh_channel channel);
+LIBSSH_API ssh_channel ssh_channel_new(ssh_session session);
+LIBSSH_API int ssh_channel_open_forward(ssh_channel channel, const char *remotehost,
int remoteport, const char *sourcehost, int localport);
-LIBSSH_API int channel_open_session(ssh_channel channel);
-LIBSSH_API int channel_poll(ssh_channel channel, int is_stderr);
-LIBSSH_API int channel_read(ssh_channel channel, void *dest, uint32_t count, int is_stderr);
-LIBSSH_API int channel_read_buffer(ssh_channel channel, ssh_buffer buffer, uint32_t count,
+LIBSSH_API int ssh_channel_open_session(ssh_channel channel);
+LIBSSH_API int ssh_channel_poll(ssh_channel channel, int is_stderr);
+LIBSSH_API int ssh_channel_read(ssh_channel channel, void *dest, uint32_t count, int is_stderr);
+LIBSSH_API int ssh_channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
int is_stderr);
-LIBSSH_API int channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
- int is_stderr);
-LIBSSH_API int channel_request_env(ssh_channel channel, const char *name, const char *value);
-LIBSSH_API int channel_request_exec(ssh_channel channel, const char *cmd);
-LIBSSH_API int channel_request_pty(ssh_channel channel);
-LIBSSH_API int channel_request_pty_size(ssh_channel channel, const char *term,
+LIBSSH_API int ssh_channel_request_env(ssh_channel channel, const char *name, const char *value);
+LIBSSH_API int ssh_channel_request_exec(ssh_channel channel, const char *cmd);
+LIBSSH_API int ssh_channel_request_pty(ssh_channel channel);
+LIBSSH_API int ssh_channel_request_pty_size(ssh_channel channel, const char *term,
int cols, int rows);
-LIBSSH_API int channel_request_shell(ssh_channel channel);
-LIBSSH_API int channel_request_send_signal(ssh_channel channel, const char *signum);
-LIBSSH_API int channel_request_sftp(ssh_channel channel);
-LIBSSH_API int channel_request_subsystem(ssh_channel channel, const char *subsystem);
-LIBSSH_API int channel_request_x11(ssh_channel channel, int single_connection, const char *protocol,
+LIBSSH_API int ssh_channel_request_shell(ssh_channel channel);
+LIBSSH_API int ssh_channel_request_send_signal(ssh_channel channel, const char *signum);
+LIBSSH_API int ssh_channel_request_sftp(ssh_channel channel);
+LIBSSH_API int ssh_channel_request_subsystem(ssh_channel channel, const char *subsystem);
+LIBSSH_API int ssh_channel_request_x11(ssh_channel channel, int single_connection, const char *protocol,
const char *cookie, int screen_number);
-LIBSSH_API int channel_send_eof(ssh_channel channel);
-LIBSSH_API int channel_select(ssh_channel *readchans, ssh_channel *writechans, ssh_channel *exceptchans, struct
+LIBSSH_API int ssh_channel_send_eof(ssh_channel channel);
+LIBSSH_API int ssh_channel_select(ssh_channel *readchans, ssh_channel *writechans, ssh_channel *exceptchans, struct
timeval * timeout);
-LIBSSH_API void channel_set_blocking(ssh_channel channel, int blocking);
-LIBSSH_API int channel_write(ssh_channel channel, const void *data, uint32_t len);
-
-LIBSSH_API void privatekey_free(ssh_private_key prv);
-LIBSSH_API ssh_private_key privatekey_from_file(ssh_session session, const char *filename,
- int type, const char *passphrase);
-LIBSSH_API void publickey_free(ssh_public_key key);
-LIBSSH_API int ssh_publickey_to_file(ssh_session session, const char *file,
- ssh_string pubkey, int type);
-LIBSSH_API ssh_string publickey_from_file(ssh_session session, const char *filename,
- int *type);
-LIBSSH_API ssh_public_key publickey_from_privatekey(ssh_private_key prv);
-LIBSSH_API ssh_string publickey_to_string(ssh_public_key key);
+LIBSSH_API void ssh_channel_set_blocking(ssh_channel channel, int blocking);
+LIBSSH_API int ssh_channel_write(ssh_channel channel, const void *data, uint32_t len);
+
LIBSSH_API int ssh_try_publickey_from_file(ssh_session session, const char *keyfile,
ssh_string *publickey, int *type);
@@ -457,16 +440,19 @@ LIBSSH_API int ssh_userauth_privatekey_file(ssh_session session, const char *use
LIBSSH_API const char *ssh_version(int req_version);
LIBSSH_API int ssh_write_knownhost(ssh_session session);
-LIBSSH_API void string_burn(ssh_string str);
-LIBSSH_API ssh_string string_copy(ssh_string str);
-LIBSSH_API void *string_data(ssh_string str);
-LIBSSH_API int string_fill(ssh_string str, const void *data, size_t len);
-LIBSSH_API void string_free(ssh_string str);
-LIBSSH_API ssh_string string_from_char(const char *what);
-LIBSSH_API size_t string_len(ssh_string str);
-LIBSSH_API ssh_string string_new(size_t size);
-LIBSSH_API char *string_to_char(ssh_string str);
-
+LIBSSH_API void ssh_string_burn(ssh_string str);
+LIBSSH_API ssh_string ssh_string_copy(ssh_string str);
+LIBSSH_API void *ssh_string_data(ssh_string str);
+LIBSSH_API int ssh_string_fill(ssh_string str, const void *data, size_t len);
+LIBSSH_API void ssh_string_free(ssh_string str);
+LIBSSH_API ssh_string ssh_string_from_char(const char *what);
+LIBSSH_API size_t ssh_string_len(ssh_string str);
+LIBSSH_API ssh_string ssh_string_new(size_t size);
+LIBSSH_API char *ssh_string_to_char(ssh_string str);
+
+#ifndef LIBSSH_LEGACY_0_4
+#include "libssh/legacy.h"
+#endif
#ifdef __cplusplus
}
diff --git a/include/libssh/libsshpp.hpp b/include/libssh/libsshpp.hpp
index 086e8e2d..c3d93e2a 100644
--- a/include/libssh/libsshpp.hpp
+++ b/include/libssh/libsshpp.hpp
@@ -174,11 +174,11 @@ private:
class Channel {
public:
Channel(Session &session){
- channel=channel_new(session.getCSession());
+ channel=ssh_channel_new(session.getCSession());
this->session=&session;
}
~Channel(){
- channel_free(channel);
+ ssh_channel_free(channel);
channel=NULL;
}
int acceptX11(int timeout_ms);
@@ -223,7 +223,7 @@ public:
if(is_stderr){
ret=channel_write_stderr(channel,data,len);
} else {
- ret=channel_write(channel,data,len);
+ ret=ssh_channel_write(channel,data,len);
}
if(ret==SSH_ERROR)
ssh_throw(ret);
diff --git a/libssh/CMakeLists.txt b/libssh/CMakeLists.txt
index 7046180c..bd3390c8 100644
--- a/libssh/CMakeLists.txt
+++ b/libssh/CMakeLists.txt
@@ -92,6 +92,7 @@ set(libssh_SRCS
kex.c
keyfiles.c
keys.c
+ legacy.c
log.c
match.c
messages.c
diff --git a/libssh/agent.c b/libssh/agent.c
index ac9fe190..fb2e4639 100644
--- a/libssh/agent.c
+++ b/libssh/agent.c
@@ -154,7 +154,7 @@ void agent_close(struct ssh_agent_struct *agent) {
void agent_free(ssh_agent agent) {
if (agent) {
if (agent->ident) {
- buffer_free(agent->ident);
+ ssh_buffer_free(agent->ident);
}
if (agent->sock) {
agent_close(agent);
@@ -208,7 +208,7 @@ static int agent_talk(struct ssh_session_struct *session,
uint32_t len = 0;
uint8_t payload[1024] = {0};
- len = buffer_get_len(request);
+ len = ssh_buffer_get_len(request);
ssh_log(session, SSH_LOG_PACKET, "agent_talk - len of request: %u", len);
agent_put_u32(payload, len);
@@ -284,23 +284,23 @@ int agent_get_ident_count(struct ssh_session_struct *session) {
}
/* send message to the agent requesting the list of identities */
- request = buffer_new();
+ request = ssh_buffer_new();
if (buffer_add_u8(request, c1) < 0) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
return -1;
}
- reply = buffer_new();
+ reply = ssh_buffer_new();
if (reply == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
return -1;
}
if (agent_talk(session, request, reply) < 0) {
- buffer_free(request);
+ ssh_buffer_free(request);
return 0;
}
- buffer_free(request);
+ ssh_buffer_free(request);
/* get message type and verify the answer */
buffer_get_u8(reply, (uint8_t *) &type);
@@ -323,7 +323,7 @@ int agent_get_ident_count(struct ssh_session_struct *session) {
ssh_set_error(session, SSH_FATAL,
"Too many identities in authentication reply: %d",
session->agent->count);
- buffer_free(reply);
+ ssh_buffer_free(reply);
return -1;
}
@@ -369,24 +369,24 @@ struct ssh_public_key_struct *agent_get_next_ident(struct ssh_session_struct *se
/* get the comment */
tmp = buffer_get_ssh_string(session->agent->ident);
if (tmp == NULL) {
- string_free(blob);
+ ssh_string_free(blob);
return NULL;
}
if (comment) {
- *comment = string_to_char(tmp);
+ *comment = ssh_string_to_char(tmp);
} else {
- string_free(blob);
- string_free(tmp);
+ ssh_string_free(blob);
+ ssh_string_free(tmp);
return NULL;
}
- string_free(tmp);
+ ssh_string_free(tmp);
/* get key from blob */
pubkey = publickey_from_string(session, blob);
- string_free(blob);
+ ssh_string_free(blob);
break;
default:
return NULL;
@@ -409,7 +409,7 @@ ssh_string agent_sign_data(struct ssh_session_struct *session,
/* create blob from the pubkey */
blob = publickey_to_string(pubkey);
- request = buffer_new();
+ request = ssh_buffer_new();
if (request == NULL) {
goto error;
}
@@ -425,11 +425,11 @@ ssh_string agent_sign_data(struct ssh_session_struct *session,
}
/* Add data */
- dlen = buffer_get_len(data);
+ dlen = ssh_buffer_get_len(data);
if (buffer_add_u32(request, htonl(dlen)) < 0) {
goto error;
}
- if (buffer_add_data(request, buffer_get(data), dlen) < 0) {
+ if (buffer_add_data(request, ssh_buffer_get_begin(data), dlen) < 0) {
goto error;
}
@@ -437,19 +437,19 @@ ssh_string agent_sign_data(struct ssh_session_struct *session,
goto error;
}
- string_free(blob);
+ ssh_string_free(blob);
- reply = buffer_new();
+ reply = ssh_buffer_new();
if (reply == NULL) {
goto error;
}
/* send the request */
if (agent_talk(session, request, reply) < 0) {
- buffer_free(request);
+ ssh_buffer_free(request);
return NULL;
}
- buffer_free(request);
+ ssh_buffer_free(request);
/* check if reply is valid */
if (buffer_get_u8(reply, (uint8_t *) &type) != sizeof(uint8_t)) {
@@ -457,24 +457,24 @@ ssh_string agent_sign_data(struct ssh_session_struct *session,
}
if (agent_failed(type)) {
ssh_log(session, SSH_LOG_RARE, "Agent reports failure in signing the key");
- buffer_free(reply);
+ ssh_buffer_free(reply);
return NULL;
} else if (type != SSH2_AGENT_SIGN_RESPONSE) {
ssh_set_error(session, SSH_FATAL, "Bad authentication response: %d", type);
- buffer_free(reply);
+ ssh_buffer_free(reply);
return NULL;
}
sig = buffer_get_ssh_string(reply);
- buffer_free(reply);
+ ssh_buffer_free(reply);
return sig;
error:
ssh_set_error(session, SSH_FATAL, "Not enough memory");
- string_free(blob);
- buffer_free(request);
- buffer_free(reply);
+ ssh_string_free(blob);
+ ssh_buffer_free(request);
+ ssh_buffer_free(reply);
return NULL;
}
diff --git a/libssh/auth.c b/libssh/auth.c
index 2a56645a..cb38b426 100644
--- a/libssh/auth.c
+++ b/libssh/auth.c
@@ -94,7 +94,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_banner){
ssh_log(session, SSH_LOG_PACKET,
"Received SSH_USERAUTH_BANNER packet");
if(session->banner != NULL)
- string_free(session->banner);
+ ssh_string_free(session->banner);
session->banner = banner;
}
leave_function();
@@ -124,7 +124,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_failure){
goto end;
}
- auth_methods = string_to_char(auth);
+ auth_methods = ssh_string_to_char(auth);
if (auth_methods == NULL) {
ssh_set_error_oom(session);
goto end;
@@ -160,7 +160,7 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_failure){
}
end:
- string_free(auth);
+ ssh_string_free(auth);
SAFE_FREE(auth_methods);
leave_function();
return SSH_PACKET_USED;
@@ -314,9 +314,9 @@ int ssh_userauth_none(ssh_session session, const char *username) {
return rc;
}
}
- user = string_from_char(session->username);
+ user = ssh_string_from_char(session->username);
} else {
- user = string_from_char(username);
+ user = ssh_string_from_char(username);
}
if (user == NULL) {
@@ -325,16 +325,16 @@ int ssh_userauth_none(ssh_session session, const char *username) {
}
if (ask_userauth(session) < 0) {
- string_free(user);
+ ssh_string_free(user);
leave_function();
return rc;
}
- method = string_from_char("none");
+ method = ssh_string_from_char("none");
if (method == NULL) {
goto error;
}
- service = string_from_char("ssh-connection");
+ service = ssh_string_from_char("ssh-connection");
if (service == NULL) {
goto error;
}
@@ -346,9 +346,9 @@ int ssh_userauth_none(ssh_session session, const char *username) {
goto error;
}
- string_free(service);
- string_free(method);
- string_free(user);
+ ssh_string_free(service);
+ ssh_string_free(method);
+ ssh_string_free(user);
session->auth_state=SSH_AUTH_STATE_NONE;
if (packet_send(session) == SSH_ERROR) {
leave_function();
@@ -360,9 +360,9 @@ int ssh_userauth_none(ssh_session session, const char *username) {
return rc;
error:
buffer_reinit(session->out_buffer);
- string_free(service);
- string_free(method);
- string_free(user);
+ ssh_string_free(service);
+ ssh_string_free(method);
+ ssh_string_free(user);
leave_function();
return rc;
@@ -421,9 +421,9 @@ int ssh_userauth_offer_pubkey(ssh_session session, const char *username,
return rc;
}
}
- user = string_from_char(session->username);
+ user = ssh_string_from_char(session->username);
} else {
- user = string_from_char(username);
+ user = ssh_string_from_char(username);
}
if (user == NULL) {
@@ -432,20 +432,20 @@ int ssh_userauth_offer_pubkey(ssh_session session, const char *username,
}
if (ask_userauth(session) < 0) {
- string_free(user);
+ ssh_string_free(user);
leave_function();
return rc;
}
- service = string_from_char("ssh-connection");
+ service = ssh_string_from_char("ssh-connection");
if (service == NULL) {
goto error;
}
- method = string_from_char("publickey");
+ method = ssh_string_from_char("publickey");
if (method == NULL) {
goto error;
}
- algo = string_from_char(ssh_type_to_char(type));
+ algo = ssh_string_from_char(ssh_type_to_char(type));
if (algo == NULL) {
goto error;
}
@@ -460,10 +460,10 @@ int ssh_userauth_offer_pubkey(ssh_session session, const char *username,
goto error;
}
- string_free(user);
- string_free(method);
- string_free(service);
- string_free(algo);
+ ssh_string_free(user);
+ ssh_string_free(method);
+ ssh_string_free(service);
+ ssh_string_free(algo);
session->auth_state=SSH_AUTH_STATE_NONE;
if (packet_send(session) != SSH_OK) {
leave_function();
@@ -475,10 +475,10 @@ int ssh_userauth_offer_pubkey(ssh_session session, const char *username,
return rc;
error:
buffer_reinit(session->out_buffer);
- string_free(user);
- string_free(method);
- string_free(service);
- string_free(algo);
+ ssh_string_free(user);
+ ssh_string_free(method);
+ ssh_string_free(service);
+ ssh_string_free(algo);
leave_function();
return rc;
@@ -536,9 +536,9 @@ int ssh_userauth_pubkey(ssh_session session, const char *username,
return rc;
}
}
- user = string_from_char(session->username);
+ user = ssh_string_from_char(session->username);
} else {
- user = string_from_char(username);
+ user = ssh_string_from_char(username);
}
if (user == NULL) {
@@ -547,20 +547,20 @@ int ssh_userauth_pubkey(ssh_session session, const char *username,
}
if (ask_userauth(session) < 0) {
- string_free(user);
+ ssh_string_free(user);
leave_function();
return rc;
}
- service = string_from_char("ssh-connection");
+ service = ssh_string_from_char("ssh-connection");
if (service == NULL) {
goto error;
}
- method = string_from_char("publickey");
+ method = ssh_string_from_char("publickey");
if (method == NULL) {
goto error;
}
- algo = string_from_char(ssh_type_to_char(privatekey->type));
+ algo = ssh_string_from_char(ssh_type_to_char(privatekey->type));
if (algo == NULL) {
goto error;
}
@@ -587,18 +587,18 @@ int ssh_userauth_pubkey(ssh_session session, const char *username,
goto error;
}
- string_free(user);
- string_free(service);
- string_free(method);
- string_free(algo);
- string_free(pkstr);
+ ssh_string_free(user);
+ ssh_string_free(service);
+ ssh_string_free(method);
+ ssh_string_free(algo);
+ ssh_string_free(pkstr);
sign = ssh_do_sign(session,session->out_buffer, privatekey);
if (sign) {
if (buffer_add_ssh_string(session->out_buffer,sign) < 0) {
goto error;
}
- string_free(sign);
+ ssh_string_free(sign);
session->auth_state=SSH_AUTH_STATE_NONE;
if (packet_send(session) != SSH_OK) {
leave_function();
@@ -611,11 +611,11 @@ int ssh_userauth_pubkey(ssh_session session, const char *username,
return rc;
error:
buffer_reinit(session->out_buffer);
- string_free(user);
- string_free(service);
- string_free(method);
- string_free(algo);
- string_free(pkstr);
+ ssh_string_free(user);
+ ssh_string_free(service);
+ ssh_string_free(method);
+ ssh_string_free(algo);
+ ssh_string_free(pkstr);
leave_function();
return rc;
@@ -681,7 +681,7 @@ int ssh_userauth_privatekey_file(ssh_session session, const char *username,
error:
SAFE_FREE(pubkeyfile);
- string_free(pubkey);
+ ssh_string_free(pubkey);
leave_function();
return rc;
@@ -733,9 +733,9 @@ int ssh_userauth_agent_pubkey(ssh_session session, const char *username,
return rc;
}
}
- user = string_from_char(session->username);
+ user = ssh_string_from_char(session->username);
} else {
- user = string_from_char(username);
+ user = ssh_string_from_char(username);
}
if (user == NULL) {
@@ -744,20 +744,20 @@ int ssh_userauth_agent_pubkey(ssh_session session, const char *username,
}
if (ask_userauth(session) < 0) {
- string_free(user);
+ ssh_string_free(user);
leave_function();
return rc;
}
- service = string_from_char("ssh-connection");
+ service = ssh_string_from_char("ssh-connection");
if (service == NULL) {
goto error;
}
- method = string_from_char("publickey");
+ method = ssh_string_from_char("publickey");
if (method == NULL) {
goto error;
}
- algo = string_from_char(ssh_type_to_char(publickey->type));
+ algo = ssh_string_from_char(ssh_type_to_char(publickey->type));
if (algo == NULL) {
goto error;
}
@@ -783,7 +783,7 @@ int ssh_userauth_agent_pubkey(ssh_session session, const char *username,
if (buffer_add_ssh_string(session->out_buffer, sign) < 0) {
goto error;
}
- string_free(sign);
+ ssh_string_free(sign);
session->auth_state=SSH_AUTH_STATE_NONE;
if (packet_send(session) != SSH_OK) {
leave_function();
@@ -792,23 +792,23 @@ int ssh_userauth_agent_pubkey(ssh_session session, const char *username,
rc = wait_auth_status(session);
}
- string_free(user);
- string_free(service);
- string_free(method);
- string_free(algo);
- string_free(key);
+ ssh_string_free(user);
+ ssh_string_free(service);
+ ssh_string_free(method);
+ ssh_string_free(algo);
+ ssh_string_free(key);
leave_function();
return rc;
error:
buffer_reinit(session->out_buffer);
- string_free(sign);
- string_free(user);
- string_free(service);
- string_free(method);
- string_free(algo);
- string_free(key);
+ ssh_string_free(sign);
+ ssh_string_free(user);
+ ssh_string_free(service);
+ ssh_string_free(method);
+ ssh_string_free(algo);
+ ssh_string_free(key);
leave_function();
return rc;
@@ -861,9 +861,9 @@ int ssh_userauth_password(ssh_session session, const char *username,
return rc;
}
}
- user = string_from_char(session->username);
+ user = ssh_string_from_char(session->username);
} else {
- user = string_from_char(username);
+ user = ssh_string_from_char(username);
}
if (user == NULL) {
@@ -872,20 +872,20 @@ int ssh_userauth_password(ssh_session session, const char *username,
}
if (ask_userauth(session) < 0) {
- string_free(user);
+ ssh_string_free(user);
leave_function();
return rc;
}
- service = string_from_char("ssh-connection");
+ service = ssh_string_from_char("ssh-connection");
if (service == NULL) {
goto error;
}
- method = string_from_char("password");
+ method = ssh_string_from_char("password");
if (method == NULL) {
goto error;
}
- pwd = string_from_char(password);
+ pwd = ssh_string_from_char(password);
if (pwd == NULL) {
goto error;
}
@@ -899,11 +899,11 @@ int ssh_userauth_password(ssh_session session, const char *username,
goto error;
}
- string_free(user);
- string_free(service);
- string_free(method);
- string_burn(pwd);
- string_free(pwd);
+ ssh_string_free(user);
+ ssh_string_free(service);
+ ssh_string_free(method);
+ ssh_string_burn(pwd);
+ ssh_string_free(pwd);
session->auth_state=SSH_AUTH_STATE_NONE;
if (packet_send(session) != SSH_OK) {
leave_function();
@@ -915,11 +915,11 @@ int ssh_userauth_password(ssh_session session, const char *username,
return rc;
error:
buffer_reinit(session->out_buffer);
- string_free(user);
- string_free(service);
- string_free(method);
- string_burn(pwd);
- string_free(pwd);
+ ssh_string_free(user);
+ ssh_string_free(service);
+ ssh_string_free(method);
+ ssh_string_burn(pwd);
+ ssh_string_free(pwd);
leave_function();
return rc;
@@ -982,7 +982,7 @@ int ssh_userauth_autopubkey(ssh_session session, const char *passphrase) {
pubkey_string = publickey_to_string(pubkey);
if (pubkey_string) {
rc = ssh_userauth_offer_pubkey(session, NULL, pubkey->type, pubkey_string);
- string_free(pubkey_string);
+ ssh_string_free(pubkey_string);
if (rc == SSH_AUTH_ERROR) {
SAFE_FREE(privkey_file);
publickey_free(pubkey);
@@ -1091,14 +1091,14 @@ int ssh_userauth_autopubkey(ssh_session session, const char *passphrase) {
rc = ssh_userauth_offer_pubkey(session, NULL, type, pubkey_string);
if (rc == SSH_AUTH_ERROR){
- string_free(pubkey_string);
+ ssh_string_free(pubkey_string);
ssh_log(session, SSH_LOG_RARE, "Publickey authentication error");
leave_function();
return rc;
} else {
if (rc != SSH_AUTH_SUCCESS){
ssh_log(session, SSH_LOG_PROTOCOL, "Publickey refused by server");
- string_free(pubkey_string);
+ ssh_string_free(pubkey_string);
continue;
}
}
@@ -1112,14 +1112,14 @@ int ssh_userauth_autopubkey(ssh_session session, const char *passphrase) {
ssh_log(session, SSH_LOG_RARE,
"Reading private key %s failed (bad passphrase ?)",
privkey_file);
- string_free(pubkey_string);
+ ssh_string_free(pubkey_string);
continue; /* continue the loop with other pubkey */
}
}
rc = ssh_userauth_pubkey(session, NULL, pubkey_string, privkey);
if (rc == SSH_AUTH_ERROR) {
- string_free(pubkey_string);
+ ssh_string_free(pubkey_string);
privatekey_free(privkey);
leave_function();
return rc;
@@ -1127,7 +1127,7 @@ int ssh_userauth_autopubkey(ssh_session session, const char *passphrase) {
if (rc != SSH_AUTH_SUCCESS){
ssh_log(session, SSH_LOG_RARE,
"The server accepted the public key but refused the signature");
- string_free(pubkey_string);
+ ssh_string_free(pubkey_string);
privatekey_free(privkey);
continue;
}
@@ -1136,7 +1136,7 @@ int ssh_userauth_autopubkey(ssh_session session, const char *passphrase) {
/* auth success */
ssh_log(session, SSH_LOG_PROTOCOL,
"Successfully authenticated using %s", privkey_file);
- string_free(pubkey_string);
+ ssh_string_free(pubkey_string);
privatekey_free(privkey);
leave_function();
@@ -1249,19 +1249,19 @@ static int kbdauth_init(ssh_session session, const char *user,
enter_function();
- usr = string_from_char(user);
+ usr = ssh_string_from_char(user);
if (usr == NULL) {
goto error;
}
- sub = (submethods ? string_from_char(submethods) : string_from_char(""));
+ sub = (submethods ? ssh_string_from_char(submethods) : ssh_string_from_char(""));
if (sub == NULL) {
goto error;
}
- service = string_from_char("ssh-connection");
+ service = ssh_string_from_char("ssh-connection");
if (service == NULL) {
goto error;
}
- method = string_from_char("keyboard-interactive");
+ method = ssh_string_from_char("keyboard-interactive");
if (method == NULL) {
goto error;
}
@@ -1275,10 +1275,10 @@ static int kbdauth_init(ssh_session session, const char *user,
goto error;
}
- string_free(usr);
- string_free(service);
- string_free(method);
- string_free(sub);
+ ssh_string_free(usr);
+ ssh_string_free(service);
+ ssh_string_free(method);
+ ssh_string_free(sub);
session->auth_state=SSH_AUTH_STATE_NONE;
if (packet_send(session) != SSH_OK) {
leave_function();
@@ -1290,10 +1290,10 @@ static int kbdauth_init(ssh_session session, const char *user,
return rc;
error:
buffer_reinit(session->out_buffer);
- string_free(usr);
- string_free(service);
- string_free(method);
- string_free(sub);
+ ssh_string_free(usr);
+ ssh_string_free(service);
+ ssh_string_free(method);
+ ssh_string_free(sub);
leave_function();
return rc;
@@ -1314,21 +1314,21 @@ static int kbdauth_info_get(ssh_session session) {
buffer_get_u32(session->in_buffer, &nprompts);
if (name == NULL || instruction == NULL || tmp == NULL) {
- string_free(name);
- string_free(instruction);
+ ssh_string_free(name);
+ ssh_string_free(instruction);
/* tmp if empty if we got here */
ssh_set_error(session, SSH_FATAL, "Invalid USERAUTH_INFO_REQUEST msg");
leave_function();
return SSH_AUTH_ERROR;
}
- string_free(tmp);
+ ssh_string_free(tmp);
if (session->kbdint == NULL) {
session->kbdint = kbdint_new();
if (session->kbdint == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
- string_free(name);
- string_free(instruction);
+ ssh_string_free(name);
+ ssh_string_free(instruction);
leave_function();
return SSH_AUTH_ERROR;
@@ -1337,8 +1337,8 @@ static int kbdauth_info_get(ssh_session session) {
kbdint_clean(session->kbdint);
}
- session->kbdint->name = string_to_char(name);
- string_free(name);
+ session->kbdint->name = ssh_string_to_char(name);
+ ssh_string_free(name);
if (session->kbdint->name == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
kbdint_free(session->kbdint);
@@ -1346,8 +1346,8 @@ static int kbdauth_info_get(ssh_session session) {
return SSH_AUTH_ERROR;
}
- session->kbdint->instruction = string_to_char(instruction);
- string_free(instruction);
+ session->kbdint->instruction = ssh_string_to_char(instruction);
+ ssh_string_free(instruction);
if (session->kbdint->instruction == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
kbdint_free(session->kbdint);
@@ -1400,8 +1400,8 @@ static int kbdauth_info_get(ssh_session session) {
leave_function();
return SSH_AUTH_ERROR;
}
- session->kbdint->prompts[i] = string_to_char(tmp);
- string_free(tmp);
+ session->kbdint->prompts[i] = ssh_string_to_char(tmp);
+ ssh_string_free(tmp);
if (session->kbdint->prompts[i] == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
kbdint_free(session->kbdint);
@@ -1431,9 +1431,9 @@ static int kbdauth_send(ssh_session session) {
for (i = 0; i < session->kbdint->nprompts; i++) {
if (session->kbdint->answers[i]) {
- answer = string_from_char(session->kbdint->answers[i]);
+ answer = ssh_string_from_char(session->kbdint->answers[i]);
} else {
- answer = string_from_char("");
+ answer = ssh_string_from_char("");
}
if (answer == NULL) {
goto error;
@@ -1443,8 +1443,8 @@ static int kbdauth_send(ssh_session session) {
goto error;
}
- string_burn(answer);
- string_free(answer);
+ ssh_string_burn(answer);
+ ssh_string_free(answer);
}
session->auth_state=SSH_AUTH_STATE_NONE;
if (packet_send(session) != SSH_OK) {
@@ -1457,8 +1457,8 @@ static int kbdauth_send(ssh_session session) {
return rc;
error:
buffer_reinit(session->out_buffer);
- string_burn(answer);
- string_free(answer);
+ ssh_string_burn(answer);
+ ssh_string_free(answer);
leave_function();
return rc;
diff --git a/libssh/auth1.c b/libssh/auth1.c
index 4154728d..100e0c8b 100644
--- a/libssh/auth1.c
+++ b/libssh/auth1.c
@@ -86,20 +86,20 @@ static int send_username(ssh_session session, const char *username) {
}
}
}
- user = string_from_char(username);
+ user = ssh_string_from_char(username);
if (user == NULL) {
return SSH_AUTH_ERROR;
}
if (buffer_add_u8(session->out_buffer, SSH_CMSG_USER) < 0) {
- string_free(user);
+ ssh_string_free(user);
return SSH_AUTH_ERROR;
}
if (buffer_add_ssh_string(session->out_buffer, user) < 0) {
- string_free(user);
+ ssh_string_free(user);
return SSH_AUTH_ERROR;
}
- string_free(user);
+ ssh_string_free(user);
session->auth_state=SSH_AUTH_STATE_NONE;
if (packet_send(session) != SSH_OK) {
return SSH_AUTH_ERROR;
@@ -156,7 +156,7 @@ int ssh_userauth1_password(ssh_session session, const char *username,
/* cisco IOS doesn't like when a password is followed by zeroes and random pad. */
if(1 || strlen(password) >= 128) {
/* not risky to disclose the size of such a big password .. */
- pwd = string_from_char(password);
+ pwd = ssh_string_from_char(password);
if (pwd == NULL) {
leave_function();
return SSH_AUTH_ERROR;
@@ -168,7 +168,7 @@ int ssh_userauth1_password(ssh_session session, const char *username,
* why garbage ? because nul bytes will be compressed by
* gzip and disclose password len.
*/
- pwd = string_new(128);
+ pwd = ssh_string_new(128);
if (pwd == NULL) {
leave_function();
return SSH_AUTH_ERROR;
@@ -178,20 +178,20 @@ int ssh_userauth1_password(ssh_session session, const char *username,
}
if (buffer_add_u8(session->out_buffer, SSH_CMSG_AUTH_PASSWORD) < 0) {
- string_burn(pwd);
- string_free(pwd);
+ ssh_string_burn(pwd);
+ ssh_string_free(pwd);
leave_function();
return SSH_AUTH_ERROR;
}
if (buffer_add_ssh_string(session->out_buffer, pwd) < 0) {
- string_burn(pwd);
- string_free(pwd);
+ ssh_string_burn(pwd);
+ ssh_string_free(pwd);
leave_function();
return SSH_AUTH_ERROR;
}
- string_burn(pwd);
- string_free(pwd);
+ ssh_string_burn(pwd);
+ ssh_string_free(pwd);
session->auth_state=SSH_AUTH_STATE_NONE;
if (packet_send(session) != SSH_OK) {
leave_function();
diff --git a/libssh/base64.c b/libssh/base64.c
index 5f4f4405..262c97ca 100644
--- a/libssh/base64.c
+++ b/libssh/base64.c
@@ -77,7 +77,7 @@ ssh_buffer base64_to_bin(const char *source) {
return NULL;
}
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
SAFE_FREE(base64);
return NULL;
@@ -162,7 +162,7 @@ ssh_buffer base64_to_bin(const char *source) {
error:
SAFE_FREE(base64);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
diff --git a/libssh/buffer.c b/libssh/buffer.c
index 0dd65843..23aa33be 100644
--- a/libssh/buffer.c
+++ b/libssh/buffer.c
@@ -78,7 +78,7 @@ static void buffer_verify(struct buffer_struct *buf){
*
* @return A newly initialized SSH buffer, NULL on error.
*/
-struct ssh_buffer_struct *buffer_new(void) {
+struct ssh_buffer_struct *ssh_buffer_new(void) {
struct ssh_buffer_struct *buf = malloc(sizeof(struct ssh_buffer_struct));
if (buf == NULL) {
@@ -94,7 +94,7 @@ struct ssh_buffer_struct *buffer_new(void) {
*
* \param[in] buffer The buffer to free.
*/
-void buffer_free(struct ssh_buffer_struct *buffer) {
+void ssh_buffer_free(struct ssh_buffer_struct *buffer) {
if (buffer == NULL) {
return;
}
@@ -193,7 +193,7 @@ int buffer_add_ssh_string(struct ssh_buffer_struct *buffer,
struct ssh_string_struct *string) {
uint32_t len = 0;
- len = string_len(string);
+ len = ssh_string_len(string);
if (buffer_add_data(buffer, string, len + sizeof(uint32_t)) < 0) {
return -1;
}
@@ -319,7 +319,7 @@ int buffer_prepend_data(struct ssh_buffer_struct *buffer, const void *data,
*/
int buffer_add_buffer(struct ssh_buffer_struct *buffer,
struct ssh_buffer_struct *source) {
- if (buffer_add_data(buffer, buffer_get(source), buffer_get_len(source)) < 0) {
+ if (buffer_add_data(buffer, ssh_buffer_get_begin(source), ssh_buffer_get_len(source)) < 0) {
return -1;
}
@@ -339,7 +339,7 @@ int buffer_add_buffer(struct ssh_buffer_struct *buffer,
* @see buffer_get_rest()
* @see buffer_get_len()
*/
-void *buffer_get(struct ssh_buffer_struct *buffer){
+void *ssh_buffer_get_begin(struct ssh_buffer_struct *buffer){
return buffer->data;
}
@@ -368,7 +368,7 @@ void *buffer_get_rest(struct ssh_buffer_struct *buffer){
*
* @see buffer_get()
*/
-uint32_t buffer_get_len(struct ssh_buffer_struct *buffer){
+uint32_t ssh_buffer_get_len(struct ssh_buffer_struct *buffer){
return buffer->used;
}
@@ -525,11 +525,11 @@ struct ssh_string_struct *buffer_get_ssh_string(struct ssh_buffer_struct *buffer
if ((buffer->pos + hostlen) > buffer->used) {
return NULL; /* it is indeed */
}
- str = string_new(hostlen);
+ str = ssh_string_new(hostlen);
if (str == NULL) {
return NULL;
}
- if (buffer_get_data(buffer, string_data(str), hostlen) != hostlen) {
+ if (buffer_get_data(buffer, ssh_string_data(str), hostlen) != hostlen) {
/* should never happen */
SAFE_FREE(str);
return NULL;
@@ -562,11 +562,11 @@ struct ssh_string_struct *buffer_get_mpint(struct ssh_buffer_struct *buffer) {
if ((buffer->pos + len) > buffer->used) {
return NULL;
}
- str = string_new(len);
+ str = ssh_string_new(len);
if (str == NULL) {
return NULL;
}
- if (buffer_get_data(buffer, string_data(str), len) != len) {
+ if (buffer_get_data(buffer, ssh_string_data(str), len) != len) {
SAFE_FREE(str);
return NULL;
}
diff --git a/libssh/channels.c b/libssh/channels.c
index 2d89acff..9f105bed 100644
--- a/libssh/channels.c
+++ b/libssh/channels.c
@@ -63,7 +63,7 @@ static ssh_channel channel_from_msg(ssh_session session, ssh_buffer packet);
*
* @return A pointer to a newly allocated channel, NULL on error.
*/
-ssh_channel channel_new(ssh_session session) {
+ssh_channel ssh_channel_new(ssh_session session) {
ssh_channel channel = NULL;
channel = malloc(sizeof(struct ssh_channel_struct));
@@ -72,15 +72,15 @@ ssh_channel channel_new(ssh_session session) {
}
memset(channel,0,sizeof(struct ssh_channel_struct));
- channel->stdout_buffer = buffer_new();
+ channel->stdout_buffer = ssh_buffer_new();
if (channel->stdout_buffer == NULL) {
SAFE_FREE(channel);
return NULL;
}
- channel->stderr_buffer = buffer_new();
+ channel->stderr_buffer = ssh_buffer_new();
if (channel->stderr_buffer == NULL) {
- buffer_free(channel->stdout_buffer);
+ ssh_buffer_free(channel->stdout_buffer);
SAFE_FREE(channel);
return NULL;
}
@@ -188,8 +188,8 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open_fail){
error_s = buffer_get_ssh_string(packet);
if(error_s != NULL)
- error = string_to_char(error_s);
- string_free(error_s);
+ error = ssh_string_to_char(error_s);
+ ssh_string_free(error_s);
if (error == NULL) {
ssh_set_error_oom(session);
return SSH_PACKET_USED;
@@ -238,7 +238,7 @@ static int channel_open(ssh_channel channel, const char *type_c, int window,
"Creating a channel %d with %d window and %d max packet",
channel->local_channel, window, maxpacket);
- type = string_from_char(type_c);
+ type = ssh_string_from_char(type_c);
if (type == NULL) {
leave_function();
return err;
@@ -249,12 +249,12 @@ static int channel_open(ssh_channel channel, const char *type_c, int window,
buffer_add_u32(session->out_buffer, htonl(channel->local_channel)) < 0 ||
buffer_add_u32(session->out_buffer, htonl(channel->local_window)) < 0 ||
buffer_add_u32(session->out_buffer, htonl(channel->local_maxpacket)) < 0) {
- string_free(type);
+ ssh_string_free(type);
leave_function();
return err;
}
- string_free(type);
+ ssh_string_free(type);
if (payload != NULL) {
if (buffer_add_buffer(session->out_buffer, payload) < 0) {
@@ -444,7 +444,7 @@ SSH_PACKET_CALLBACK(channel_rcv_data){
leave_function();
return SSH_PACKET_USED;
}
- len = string_len(str);
+ len = ssh_string_len(str);
ssh_log(session, SSH_LOG_PROTOCOL,
"Channel receiving %zu bytes data in %d (local win=%d remote win=%d)",
@@ -461,9 +461,9 @@ SSH_PACKET_CALLBACK(channel_rcv_data){
channel->local_window);
}
- if (channel_default_bufferize(channel, string_data(str), len,
+ if (channel_default_bufferize(channel, ssh_string_data(str), len,
is_stderr) < 0) {
- string_free(str);
+ ssh_string_free(str);
leave_function();
return SSH_PACKET_USED;
}
@@ -479,7 +479,7 @@ SSH_PACKET_CALLBACK(channel_rcv_data){
channel->local_window,
channel->remote_window);
- string_free(str);
+ ssh_string_free(str);
leave_function();
return SSH_PACKET_USED;
}
@@ -573,8 +573,8 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
return SSH_PACKET_USED;
}
- request = string_to_char(request_s);
- string_free(request_s);
+ request = ssh_string_to_char(request_s);
+ ssh_string_free(request_s);
if (request == NULL) {
leave_function();
return SSH_PACKET_USED;
@@ -607,8 +607,8 @@ SSH_PACKET_CALLBACK(channel_rcv_request) {
return SSH_PACKET_USED;
}
- sig = string_to_char(signal_s);
- string_free(signal_s);
+ sig = ssh_string_to_char(signal_s);
+ ssh_string_free(signal_s);
if (sig == NULL) {
leave_function();
return SSH_PACKET_USED;
@@ -663,7 +663,7 @@ int channel_default_bufferize(ssh_channel channel, void *data, int len,
if (is_stderr == 0) {
/* stdout */
if (channel->stdout_buffer == NULL) {
- channel->stdout_buffer = buffer_new();
+ channel->stdout_buffer = ssh_buffer_new();
if (channel->stdout_buffer == NULL) {
ssh_set_error_oom(session);
return -1;
@@ -671,14 +671,14 @@ int channel_default_bufferize(ssh_channel channel, void *data, int len,
}
if (buffer_add_data(channel->stdout_buffer, data, len) < 0) {
- buffer_free(channel->stdout_buffer);
+ ssh_buffer_free(channel->stdout_buffer);
channel->stdout_buffer = NULL;
return -1;
}
} else {
/* stderr */
if (channel->stderr_buffer == NULL) {
- channel->stderr_buffer = buffer_new();
+ channel->stderr_buffer = ssh_buffer_new();
if (channel->stderr_buffer == NULL) {
ssh_set_error_oom(session);
return -1;
@@ -686,7 +686,7 @@ int channel_default_bufferize(ssh_channel channel, void *data, int len,
}
if (buffer_add_data(channel->stderr_buffer, data, len) < 0) {
- buffer_free(channel->stderr_buffer);
+ ssh_buffer_free(channel->stderr_buffer);
channel->stderr_buffer = NULL;
return -1;
}
@@ -707,7 +707,7 @@ int channel_default_bufferize(ssh_channel channel, void *data, int len,
* @see channel_request_shell()
* @see channel_request_exec()
*/
-int channel_open_session(ssh_channel channel) {
+int ssh_channel_open_session(ssh_channel channel) {
#ifdef WITH_SSH1
if (channel->session->version == 1) {
return channel_open_session1(channel);
@@ -738,7 +738,7 @@ int channel_open_session(ssh_channel channel) {
* forward the content of a socket to the channel. You still have to
* use channel_read and channel_write for this.
*/
-int channel_open_forward(ssh_channel channel, const char *remotehost,
+int ssh_channel_open_forward(ssh_channel channel, const char *remotehost,
int remoteport, const char *sourcehost, int localport) {
ssh_session session = channel->session;
ssh_buffer payload = NULL;
@@ -747,11 +747,11 @@ int channel_open_forward(ssh_channel channel, const char *remotehost,
enter_function();
- payload = buffer_new();
+ payload = ssh_buffer_new();
if (payload == NULL) {
goto error;
}
- str = string_from_char(remotehost);
+ str = ssh_string_from_char(remotehost);
if (str == NULL) {
goto error;
}
@@ -761,8 +761,8 @@ int channel_open_forward(ssh_channel channel, const char *remotehost,
goto error;
}
- string_free(str);
- str = string_from_char(sourcehost);
+ ssh_string_free(str);
+ str = ssh_string_from_char(sourcehost);
if (str == NULL) {
goto error;
}
@@ -775,8 +775,8 @@ int channel_open_forward(ssh_channel channel, const char *remotehost,
rc = channel_open(channel, "direct-tcpip", 64000, 32000, payload);
error:
- buffer_free(payload);
- string_free(str);
+ ssh_buffer_free(payload);
+ ssh_string_free(str);
leave_function();
return rc;
@@ -789,7 +789,7 @@ error:
*
* @warning Any data unread on this channel will be lost.
*/
-void channel_free(ssh_channel channel) {
+void ssh_channel_free(ssh_channel channel) {
ssh_session session = channel->session;
enter_function();
@@ -799,7 +799,7 @@ void channel_free(ssh_channel channel) {
}
if (session->alive && channel->state == SSH_CHANNEL_STATE_OPEN) {
- channel_close(channel);
+ ssh_channel_close(channel);
}
/* handle the "my channel is first on session list" case */
@@ -815,8 +815,8 @@ void channel_free(ssh_channel channel) {
channel->next->prev = channel->prev;
}
- buffer_free(channel->stdout_buffer);
- buffer_free(channel->stderr_buffer);
+ ssh_buffer_free(channel->stdout_buffer);
+ ssh_buffer_free(channel->stderr_buffer);
/* debug trick to catch use after frees */
memset(channel, 'X', sizeof(struct ssh_channel_struct));
@@ -837,7 +837,7 @@ void channel_free(ssh_channel channel) {
* @see channel_close()
* @see channel_free()
*/
-int channel_send_eof(ssh_channel channel){
+int ssh_channel_send_eof(ssh_channel channel){
ssh_session session = channel->session;
int rc = SSH_ERROR;
@@ -879,14 +879,14 @@ error:
* @see channel_free()
* @see channel_eof()
*/
-int channel_close(ssh_channel channel){
+int ssh_channel_close(ssh_channel channel){
ssh_session session = channel->session;
int rc = 0;
enter_function();
if (channel->local_eof == 0) {
- rc = channel_send_eof(channel);
+ rc = ssh_channel_send_eof(channel);
}
if (rc != SSH_OK) {
@@ -1014,7 +1014,7 @@ error:
*
* @see channel_read()
*/
-int channel_write(ssh_channel channel, const void *data, uint32_t len) {
+int ssh_channel_write(ssh_channel channel, const void *data, uint32_t len) {
return channel_write_common(channel, data, len, 0);
}
@@ -1027,7 +1027,7 @@ int channel_write(ssh_channel channel, const void *data, uint32_t len) {
*
* @see channel_is_closed()
*/
-int channel_is_open(ssh_channel channel) {
+int ssh_channel_is_open(ssh_channel channel) {
return (channel->state == SSH_CHANNEL_STATE_OPEN && channel->session->alive != 0);
}
@@ -1040,7 +1040,7 @@ int channel_is_open(ssh_channel channel) {
*
* @see channel_is_open()
*/
-int channel_is_closed(ssh_channel channel) {
+int ssh_channel_is_closed(ssh_channel channel) {
return (channel->state != SSH_CHANNEL_STATE_OPEN || channel->session->alive == 0);
}
@@ -1051,7 +1051,7 @@ int channel_is_closed(ssh_channel channel) {
*
* @return 0 if there is no EOF, nonzero otherwise.
*/
-int channel_is_eof(ssh_channel channel) {
+int ssh_channel_is_eof(ssh_channel channel) {
if ((channel->stdout_buffer &&
buffer_get_rest_len(channel->stdout_buffer) > 0) ||
(channel->stderr_buffer &&
@@ -1072,7 +1072,7 @@ int channel_is_eof(ssh_channel channel) {
* @bug This functionality is still under development and
* doesn't work correctly.
*/
-void channel_set_blocking(ssh_channel channel, int blocking) {
+void ssh_channel_set_blocking(ssh_channel channel, int blocking) {
channel->blocking = (blocking == 0 ? 0 : 1);
}
@@ -1156,7 +1156,7 @@ static int channel_request(ssh_channel channel, const char *request,
return SSH_ERROR;
}
- req = string_from_char(request);
+ req = ssh_string_from_char(request);
if (req == NULL) {
goto error;
}
@@ -1167,11 +1167,11 @@ static int channel_request(ssh_channel channel, const char *request,
buffer_add_u8(session->out_buffer, reply == 0 ? 0 : 1) < 0) {
goto error;
}
- string_free(req);
+ ssh_string_free(req);
if (buffer != NULL) {
- if (buffer_add_data(session->out_buffer, buffer_get(buffer),
- buffer_get_len(buffer)) < 0) {
+ if (buffer_add_data(session->out_buffer, ssh_buffer_get_begin(buffer),
+ ssh_buffer_get_len(buffer)) < 0) {
goto error;
}
}
@@ -1218,7 +1218,7 @@ static int channel_request(ssh_channel channel, const char *request,
return rc;
error:
buffer_reinit(session->out_buffer);
- string_free(req);
+ ssh_string_free(req);
leave_function();
return rc;
@@ -1237,7 +1237,7 @@ error:
*
* @return SSH_SUCCESS on success, SSH_ERROR if an error occured.
*/
-int channel_request_pty_size(ssh_channel channel, const char *terminal,
+int ssh_channel_request_pty_size(ssh_channel channel, const char *terminal,
int col, int row) {
ssh_session session = channel->session;
ssh_string term = NULL;
@@ -1252,12 +1252,12 @@ int channel_request_pty_size(ssh_channel channel, const char *terminal,
return rc;
}
#endif
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
goto error;
}
- term = string_from_char(terminal);
+ term = ssh_string_from_char(terminal);
if (term == NULL) {
goto error;
}
@@ -1274,8 +1274,8 @@ int channel_request_pty_size(ssh_channel channel, const char *terminal,
rc = channel_request(channel, "pty-req", buffer, 1);
error:
- buffer_free(buffer);
- string_free(term);
+ ssh_buffer_free(buffer);
+ ssh_string_free(term);
leave_function();
return rc;
@@ -1290,8 +1290,8 @@ error:
*
* @see channel_request_pty_size()
*/
-int channel_request_pty(ssh_channel channel) {
- return channel_request_pty_size(channel, "xterm", 80, 24);
+int ssh_channel_request_pty(ssh_channel channel) {
+ return ssh_channel_request_pty_size(channel, "xterm", 80, 24);
}
/**
@@ -1309,7 +1309,7 @@ int channel_request_pty(ssh_channel channel) {
* libssh function using the same channel/session is running at same
* time (not 100% threadsafe).
*/
-int channel_change_pty_size(ssh_channel channel, int cols, int rows) {
+int ssh_channel_change_pty_size(ssh_channel channel, int cols, int rows) {
ssh_session session = channel->session;
ssh_buffer buffer = NULL;
int rc = SSH_ERROR;
@@ -1324,7 +1324,7 @@ int channel_change_pty_size(ssh_channel channel, int cols, int rows) {
}
#endif
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
goto error;
}
@@ -1338,7 +1338,7 @@ int channel_change_pty_size(ssh_channel channel, int cols, int rows) {
rc = channel_request(channel, "window-change", buffer, 0);
error:
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
leave_function();
return rc;
@@ -1351,7 +1351,7 @@ error:
*
* @return SSH_SUCCESS on success, SSH_ERROR if an error occured.
*/
-int channel_request_shell(ssh_channel channel) {
+int ssh_channel_request_shell(ssh_channel channel) {
#ifdef WITH_SSH1
if (channel->version == 1) {
return channel_request_shell1(channel);
@@ -1371,17 +1371,17 @@ int channel_request_shell(ssh_channel channel) {
*
* @warning You normally don't have to call it for sftp, see sftp_new().
*/
-int channel_request_subsystem(ssh_channel channel, const char *subsys) {
+int ssh_channel_request_subsystem(ssh_channel channel, const char *subsys) {
ssh_buffer buffer = NULL;
ssh_string subsystem = NULL;
int rc = SSH_ERROR;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
goto error;
}
- subsystem = string_from_char(subsys);
+ subsystem = ssh_string_from_char(subsys);
if (subsystem == NULL) {
goto error;
}
@@ -1392,14 +1392,14 @@ int channel_request_subsystem(ssh_channel channel, const char *subsys) {
rc = channel_request(channel, "subsystem", buffer, 1);
error:
- buffer_free(buffer);
- string_free(subsystem);
+ ssh_buffer_free(buffer);
+ ssh_string_free(subsystem);
return rc;
}
-int channel_request_sftp( ssh_channel channel){
- return channel_request_subsystem(channel, "sftp");
+int ssh_channel_request_sftp( ssh_channel channel){
+ return ssh_channel_request_subsystem(channel, "sftp");
}
static ssh_string generate_cookie(void) {
@@ -1412,7 +1412,7 @@ static ssh_string generate_cookie(void) {
s[i] = hex[rand() % 16];
}
s[32] = '\0';
- return string_from_char(s);
+ return ssh_string_from_char(s);
}
/**
@@ -1437,25 +1437,25 @@ static ssh_string generate_cookie(void) {
*
* @return SSH_SUCCESS on success, SSH_ERROR if an error occured.
*/
-int channel_request_x11(ssh_channel channel, int single_connection, const char *protocol,
+int ssh_channel_request_x11(ssh_channel channel, int single_connection, const char *protocol,
const char *cookie, int screen_number) {
ssh_buffer buffer = NULL;
ssh_string p = NULL;
ssh_string c = NULL;
int rc = SSH_ERROR;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
goto error;
}
- p = string_from_char(protocol ? protocol : "MIT-MAGIC-COOKIE-1");
+ p = ssh_string_from_char(protocol ? protocol : "MIT-MAGIC-COOKIE-1");
if (p == NULL) {
goto error;
}
if (cookie) {
- c = string_from_char(cookie);
+ c = ssh_string_from_char(cookie);
} else {
c = generate_cookie();
}
@@ -1473,9 +1473,9 @@ int channel_request_x11(ssh_channel channel, int single_connection, const char *
rc = channel_request(channel, "x11-req", buffer, 1);
error:
- buffer_free(buffer);
- string_free(p);
- string_free(c);
+ ssh_buffer_free(buffer);
+ ssh_string_free(p);
+ ssh_string_free(c);
return rc;
}
@@ -1530,7 +1530,7 @@ static ssh_channel channel_accept(ssh_session session, int channeltype,
* @return A newly created channel, or NULL if no X11 request from
* the server.
*/
-ssh_channel channel_accept_x11(ssh_channel channel, int timeout_ms) {
+ssh_channel ssh_channel_accept_x11(ssh_channel channel, int timeout_ms) {
return channel_accept(channel->session, SSH_CHANNEL_X11, timeout_ms);
}
@@ -1612,7 +1612,7 @@ static int global_request(ssh_session session, const char *request,
leave_function();
return rc;
}
- req = string_from_char(request);
+ req = ssh_string_from_char(request);
if (req == NULL) {
goto error;
}
@@ -1622,12 +1622,12 @@ static int global_request(ssh_session session, const char *request,
buffer_add_u8(session->out_buffer, reply == 0 ? 0 : 1) < 0) {
goto error;
}
- string_free(req);
+ ssh_string_free(req);
req=NULL;
if (buffer != NULL) {
- if (buffer_add_data(session->out_buffer, buffer_get(buffer),
- buffer_get_len(buffer)) < 0) {
+ if (buffer_add_data(session->out_buffer, ssh_buffer_get_begin(buffer),
+ ssh_buffer_get_len(buffer)) < 0) {
goto error;
}
}
@@ -1674,7 +1674,7 @@ static int global_request(ssh_session session, const char *request,
leave_function();
return rc;
error:
- string_free(req);
+ ssh_string_free(req);
leave_function();
return rc;
}
@@ -1698,18 +1698,18 @@ error:
*
* @return SSH_SUCCESS on success, SSH_ERROR if an error occured.
*/
-int channel_forward_listen(ssh_session session, const char *address, int port, int *bound_port) {
+int ssh_channel_forward_listen(ssh_session session, const char *address, int port, int *bound_port) {
ssh_buffer buffer = NULL;
ssh_string addr = NULL;
int rc = SSH_ERROR;
uint32_t tmp;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
goto error;
}
- addr = string_from_char(address ? address : "");
+ addr = ssh_string_from_char(address ? address : "");
if (addr == NULL) {
goto error;
}
@@ -1727,8 +1727,8 @@ int channel_forward_listen(ssh_session session, const char *address, int port, i
}
error:
- buffer_free(buffer);
- string_free(addr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(addr);
return rc;
}
@@ -1742,7 +1742,7 @@ error:
* @return Newly created channel, or NULL if no incoming channel request from
* the server
*/
-ssh_channel channel_forward_accept(ssh_session session, int timeout_ms) {
+ssh_channel ssh_channel_forward_accept(ssh_session session, int timeout_ms) {
return channel_accept(session, SSH_CHANNEL_FORWARDED_TCPIP, timeout_ms);
}
@@ -1758,17 +1758,17 @@ ssh_channel channel_forward_accept(ssh_session session, int timeout_ms) {
*
* @return SSH_SUCCESS on success, SSH_ERROR if an error occured.
*/
-int channel_forward_cancel(ssh_session session, const char *address, int port) {
+int ssh_channel_forward_cancel(ssh_session session, const char *address, int port) {
ssh_buffer buffer = NULL;
ssh_string addr = NULL;
int rc = SSH_ERROR;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
goto error;
}
- addr = string_from_char(address ? address : "");
+ addr = ssh_string_from_char(address ? address : "");
if (addr == NULL) {
goto error;
}
@@ -1781,8 +1781,8 @@ int channel_forward_cancel(ssh_session session, const char *address, int port) {
rc = global_request(session, "cancel-tcpip-forward", buffer, 1);
error:
- buffer_free(buffer);
- string_free(addr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(addr);
return rc;
}
@@ -1799,17 +1799,17 @@ error:
*
* @warning Some environment variables may be refused by security reasons.
*/
-int channel_request_env(ssh_channel channel, const char *name, const char *value) {
+int ssh_channel_request_env(ssh_channel channel, const char *name, const char *value) {
ssh_buffer buffer = NULL;
ssh_string str = NULL;
int rc = SSH_ERROR;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
goto error;
}
- str = string_from_char(name);
+ str = ssh_string_from_char(name);
if (str == NULL) {
goto error;
}
@@ -1818,8 +1818,8 @@ int channel_request_env(ssh_channel channel, const char *name, const char *value
goto error;
}
- string_free(str);
- str = string_from_char(value);
+ ssh_string_free(str);
+ str = ssh_string_from_char(value);
if (str == NULL) {
goto error;
}
@@ -1830,8 +1830,8 @@ int channel_request_env(ssh_channel channel, const char *name, const char *value
rc = channel_request(channel, "env", buffer,1);
error:
- buffer_free(buffer);
- string_free(str);
+ ssh_buffer_free(buffer);
+ ssh_string_free(str);
return rc;
}
@@ -1863,7 +1863,7 @@ error:
*
* @see channel_request_shell()
*/
-int channel_request_exec(ssh_channel channel, const char *cmd) {
+int ssh_channel_request_exec(ssh_channel channel, const char *cmd) {
ssh_buffer buffer = NULL;
ssh_string command = NULL;
int rc = SSH_ERROR;
@@ -1874,12 +1874,12 @@ int channel_request_exec(ssh_channel channel, const char *cmd) {
}
#endif
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
goto error;
}
- command = string_from_char(cmd);
+ command = ssh_string_from_char(cmd);
if (command == NULL) {
goto error;
}
@@ -1890,8 +1890,8 @@ int channel_request_exec(ssh_channel channel, const char *cmd) {
rc = channel_request(channel, "exec", buffer, 1);
error:
- buffer_free(buffer);
- string_free(command);
+ ssh_buffer_free(buffer);
+ ssh_string_free(command);
return rc;
}
@@ -1912,7 +1912,7 @@ error:
* @return SSH_SUCCESS on success, SSH_ERROR if an error occured
* (including attempts to send signal via SSH-v1 session).
*/
-int channel_request_send_signal(ssh_channel channel, const char *sig) {
+int ssh_channel_request_send_signal(ssh_channel channel, const char *sig) {
ssh_buffer buffer = NULL;
ssh_string encoded_signal = NULL;
int rc = SSH_ERROR;
@@ -1923,12 +1923,12 @@ int channel_request_send_signal(ssh_channel channel, const char *sig) {
}
#endif
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
goto error;
}
- encoded_signal = string_from_char(sig);
+ encoded_signal = ssh_string_from_char(sig);
if (encoded_signal == NULL) {
goto error;
}
@@ -1939,8 +1939,8 @@ int channel_request_send_signal(ssh_channel channel, const char *sig) {
rc = channel_request(channel, "signal", buffer, 0);
error:
- buffer_free(buffer);
- string_free(encoded_signal);
+ ssh_buffer_free(buffer);
+ ssh_string_free(encoded_signal);
return rc;
}
@@ -2046,7 +2046,7 @@ int channel_read_buffer(ssh_channel channel, ssh_buffer buffer, uint32_t count,
}
leave_function();
- return buffer_get_len(buffer);
+ return ssh_buffer_get_len(buffer);
}
/* TODO FIXME Fix the delayed close thing */
@@ -2071,7 +2071,7 @@ int channel_read_buffer(ssh_channel channel, ssh_buffer buffer, uint32_t count,
* @warning The read function using a buffer has been renamed to
* channel_read_buffer().
*/
-int channel_read(ssh_channel channel, void *dest, uint32_t count, int is_stderr) {
+int ssh_channel_read(ssh_channel channel, void *dest, uint32_t count, int is_stderr) {
ssh_session session = channel->session;
ssh_buffer stdbuf = channel->stdout_buffer;
uint32_t len;
@@ -2165,7 +2165,7 @@ int channel_read(ssh_channel channel, void *dest, uint32_t count, int is_stderr)
*
* @see channel_is_eof()
*/
-int channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
+int ssh_channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
int is_stderr) {
ssh_session session = channel->session;
uint32_t to_read;
@@ -2173,7 +2173,7 @@ int channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
enter_function();
- to_read = channel_poll(channel, is_stderr);
+ to_read = ssh_channel_poll(channel, is_stderr);
if (to_read <= 0) {
leave_function();
@@ -2183,7 +2183,7 @@ int channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
if (to_read > count) {
to_read = count;
}
- rc = channel_read(channel, dest, to_read, is_stderr);
+ rc = ssh_channel_read(channel, dest, to_read, is_stderr);
leave_function();
return rc;
@@ -2203,7 +2203,7 @@ int channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
*
* @see channel_is_eof()
*/
-int channel_poll(ssh_channel channel, int is_stderr){
+int ssh_channel_poll(ssh_channel channel, int is_stderr){
ssh_session session = channel->session;
ssh_buffer stdbuf = channel->stdout_buffer;
@@ -2241,7 +2241,7 @@ int channel_poll(ssh_channel channel, int is_stderr){
*
* @return The session pointer.
*/
-ssh_session channel_get_session(ssh_channel channel) {
+ssh_session ssh_channel_get_session(ssh_channel channel) {
return channel->session;
}
@@ -2254,7 +2254,7 @@ ssh_session channel_get_session(ssh_channel channel) {
* @returns The exit status, -1 if no exit status has been returned
* or eof not sent.
*/
-int channel_get_exit_status(ssh_channel channel) {
+int ssh_channel_get_exit_status(ssh_channel channel) {
if (channel->local_eof == 0) {
return -1;
}
@@ -2295,12 +2295,12 @@ static int channel_protocol_select(ssh_channel *rchans, ssh_channel *wchans,
for (i = 0; rchans[i] != NULL; i++) {
chan = rchans[i];
- while (channel_is_open(chan) && ssh_socket_data_available(chan->session->socket)) {
+ while (ssh_channel_is_open(chan) && ssh_socket_data_available(chan->session->socket)) {
ssh_handle_packets(chan->session,-1);
}
- if ((chan->stdout_buffer && buffer_get_len(chan->stdout_buffer) > 0) ||
- (chan->stderr_buffer && buffer_get_len(chan->stderr_buffer) > 0) ||
+ if ((chan->stdout_buffer && ssh_buffer_get_len(chan->stdout_buffer) > 0) ||
+ (chan->stderr_buffer && ssh_buffer_get_len(chan->stderr_buffer) > 0) ||
chan->remote_eof) {
rout[j] = chan;
j++;
@@ -2313,7 +2313,7 @@ static int channel_protocol_select(ssh_channel *rchans, ssh_channel *wchans,
chan = wchans[i];
/* It's not our business to seek if the file descriptor is writable */
if (ssh_socket_data_writable(chan->session->socket) &&
- channel_is_open(chan) && (chan->remote_window > 0)) {
+ ssh_channel_is_open(chan) && (chan->remote_window > 0)) {
wout[j] = chan;
j++;
}
@@ -2324,7 +2324,7 @@ static int channel_protocol_select(ssh_channel *rchans, ssh_channel *wchans,
for (i = 0; echans[i] != NULL; i++) {
chan = echans[i];
- if (!ssh_socket_is_open(chan->session->socket) || channel_is_closed(chan)) {
+ if (!ssh_socket_is_open(chan->session->socket) || ssh_channel_is_closed(chan)) {
eout[j] = chan;
j++;
}
@@ -2365,7 +2365,7 @@ static int count_ptrs(ssh_channel *ptrs) {
* select(2) syscall was interrupted, then relaunch the
* function.
*/
-int channel_select(ssh_channel *readchans, ssh_channel *writechans,
+int ssh_channel_select(ssh_channel *readchans, ssh_channel *writechans,
ssh_channel *exceptchans, struct timeval * timeout) {
ssh_channel *rchans, *wchans, *echans;
ssh_channel dummy = NULL;
diff --git a/libssh/channels1.c b/libssh/channels1.c
index fee1475b..293e5fde 100644
--- a/libssh/channels1.c
+++ b/libssh/channels1.c
@@ -88,7 +88,7 @@ int channel_request_pty_size1(ssh_channel channel, const char *terminal, int col
ssh_set_error(session,SSH_REQUEST_DENIED,"Wrong request state");
return SSH_ERROR;
}
- str = string_from_char(terminal);
+ str = ssh_string_from_char(terminal);
if (str == NULL) {
ssh_set_error_oom(session);
return -1;
@@ -96,10 +96,10 @@ int channel_request_pty_size1(ssh_channel channel, const char *terminal, int col
if (buffer_add_u8(session->out_buffer, SSH_CMSG_REQUEST_PTY) < 0 ||
buffer_add_ssh_string(session->out_buffer, str) < 0) {
- string_free(str);
+ ssh_string_free(str);
return -1;
}
- string_free(str);
+ ssh_string_free(str);
if (buffer_add_u32(session->out_buffer, ntohl(row)) < 0 ||
buffer_add_u32(session->out_buffer, ntohl(col)) < 0 ||
@@ -198,17 +198,17 @@ int channel_request_exec1(ssh_channel channel, const char *cmd) {
ssh_session session = channel->session;
ssh_string command = NULL;
- command = string_from_char(cmd);
+ command = ssh_string_from_char(cmd);
if (command == NULL) {
return -1;
}
if (buffer_add_u8(session->out_buffer, SSH_CMSG_EXEC_CMD) < 0 ||
buffer_add_ssh_string(session->out_buffer, command) < 0) {
- string_free(command);
+ ssh_string_free(command);
return -1;
}
- string_free(command);
+ ssh_string_free(command);
if(packet_send(session) != SSH_OK) {
return -1;
@@ -232,14 +232,14 @@ SSH_PACKET_CALLBACK(ssh_packet_data1){
ssh_log(session, SSH_LOG_PROTOCOL,
"Adding %zu bytes data in %d",
- string_len(str), is_stderr);
+ ssh_string_len(str), is_stderr);
- if (channel_default_bufferize(channel, string_data(str), string_len(str),
+ if (channel_default_bufferize(channel, ssh_string_data(str), ssh_string_len(str),
is_stderr) < 0) {
- string_free(str);
+ ssh_string_free(str);
return SSH_PACKET_USED;
}
- string_free(str);
+ ssh_string_free(str);
return SSH_PACKET_USED;
}
diff --git a/libssh/client.c b/libssh/client.c
index 4fdb9956..45b3df00 100644
--- a/libssh/client.c
+++ b/libssh/client.c
@@ -278,8 +278,8 @@ SSH_PACKET_CALLBACK(ssh_packet_dh_reply){
ssh_set_error(session, SSH_FATAL, "Cannot import f number");
goto error;
}
- string_burn(f);
- string_free(f);
+ ssh_string_burn(f);
+ ssh_string_free(f);
f=NULL;
signature = buffer_get_ssh_string(packet);
if (signature == NULL) {
@@ -351,8 +351,8 @@ SSH_PACKET_CALLBACK(ssh_packet_newkeys){
}
/* forget it for now ... */
- string_burn(signature);
- string_free(signature);
+ ssh_string_burn(signature);
+ ssh_string_free(signature);
signature=NULL;
/*
* Once we got SSH2_MSG_NEWKEYS we can switch next_crypto and
@@ -416,8 +416,8 @@ static int dh_handshake(ssh_session session) {
if (buffer_add_ssh_string(session->out_buffer, e) < 0) {
goto error;
}
- string_burn(e);
- string_free(e);
+ ssh_string_burn(e);
+ ssh_string_free(e);
e=NULL;
rc = packet_send(session);
@@ -446,16 +446,16 @@ static int dh_handshake(ssh_session session) {
return SSH_AGAIN;
error:
if(e != NULL){
- string_burn(e);
- string_free(e);
+ ssh_string_burn(e);
+ ssh_string_free(e);
}
if(f != NULL){
- string_burn(f);
- string_free(f);
+ ssh_string_burn(f);
+ ssh_string_free(f);
}
if(signature != NULL){
- string_burn(signature);
- string_free(signature);
+ ssh_string_burn(signature);
+ ssh_string_free(signature);
}
leave_function();
@@ -503,16 +503,16 @@ int ssh_service_request(ssh_session session, const char *service) {
if (buffer_add_u8(session->out_buffer, SSH2_MSG_SERVICE_REQUEST) < 0) {
break;
}
- service_s = string_from_char(service);
+ service_s = ssh_string_from_char(service);
if (service_s == NULL) {
break;
}
if (buffer_add_ssh_string(session->out_buffer,service_s) < 0) {
- string_free(service_s);
+ ssh_string_free(service_s);
break;
}
- string_free(service_s);
+ ssh_string_free(service_s);
if (packet_send(session) != SSH_OK) {
ssh_set_error(session, SSH_FATAL,
@@ -754,7 +754,7 @@ char *ssh_get_issue_banner(ssh_session session) {
return NULL;
}
- return string_to_char(session->banner);
+ return ssh_string_to_char(session->banner);
}
/**
@@ -799,16 +799,16 @@ void ssh_disconnect(ssh_session session) {
goto error;
}
- str = string_from_char("Bye Bye");
+ str = ssh_string_from_char("Bye Bye");
if (str == NULL) {
goto error;
}
if (buffer_add_ssh_string(session->out_buffer,str) < 0) {
- string_free(str);
+ ssh_string_free(str);
goto error;
}
- string_free(str);
+ ssh_string_free(str);
packet_send(session);
ssh_socket_close(session->socket);
diff --git a/libssh/connect.c b/libssh/connect.c
index 57085d16..4b5752a9 100644
--- a/libssh/connect.c
+++ b/libssh/connect.c
@@ -506,11 +506,11 @@ int ssh_select(ssh_channel *channels, ssh_channel *outchannels, socket_t maxfd,
j = 0;
for (i = 0; channels[i]; i++) {
if (channels[i]->session->alive) {
- if(channel_poll(channels[i], 0) > 0) {
+ if(ssh_channel_poll(channels[i], 0) > 0) {
outchannels[j] = channels[i];
j++;
} else {
- if(channel_poll(channels[i], 1) > 0) {
+ if(ssh_channel_poll(channels[i], 1) > 0) {
outchannels[j] = channels[i];
j++;
}
@@ -574,8 +574,8 @@ int ssh_select(ssh_channel *channels, ssh_channel *outchannels, socket_t maxfd,
for (i = 0; channels[i]; i++) {
if (channels[i]->session->alive &&
ssh_socket_fd_isset(channels[i]->session->socket,&localset)) {
- if ((channel_poll(channels[i],0) > 0) ||
- (channel_poll(channels[i], 1) > 0)) {
+ if ((ssh_channel_poll(channels[i],0) > 0) ||
+ (ssh_channel_poll(channels[i], 1) > 0)) {
outchannels[j] = channels[i];
j++;
}
diff --git a/libssh/crypt.c b/libssh/crypt.c
index c42cd359..1085c4aa 100644
--- a/libssh/crypt.c
+++ b/libssh/crypt.c
@@ -40,6 +40,8 @@
#include "libssh/session.h"
#include "libssh/wrapper.h"
#include "libssh/crypto.h"
+#include "libssh/buffer.h"
+
uint32_t packet_decrypt_len(ssh_session session, char *crypted){
uint32_t decrypted;
@@ -196,7 +198,7 @@ int packet_hmac_verify(ssh_session session, ssh_buffer buffer,
seq = htonl(session->recv_seq);
hmac_update(ctx, (unsigned char *) &seq, sizeof(uint32_t));
- hmac_update(ctx, buffer_get(buffer), buffer_get_len(buffer));
+ hmac_update(ctx, ssh_buffer_get_begin(buffer), ssh_buffer_get_len(buffer));
hmac_final(ctx, hmacbuf, &len);
#ifdef DEBUG_CRYPTO
diff --git a/libssh/dh.c b/libssh/dh.c
index 9b9e129f..e70c9491 100644
--- a/libssh/dh.c
+++ b/libssh/dh.c
@@ -368,7 +368,7 @@ ssh_string make_bignum_string(bignum num) {
bignum make_string_bn(ssh_string string){
bignum bn = NULL;
- unsigned int len = string_len(string);
+ unsigned int len = ssh_string_len(string);
#ifdef DEBUG_CRYPTO
fprintf(stderr, "Importing a %d bits, %d bytes object ...\n",
@@ -498,12 +498,12 @@ int make_sessionid(ssh_session session) {
return rc;
}
- buf = buffer_new();
+ buf = ssh_buffer_new();
if (buf == NULL) {
return rc;
}
- str = string_from_char(session->clientbanner);
+ str = ssh_string_from_char(session->clientbanner);
if (str == NULL) {
goto error;
}
@@ -511,9 +511,9 @@ int make_sessionid(ssh_session session) {
if (buffer_add_ssh_string(buf, str) < 0) {
goto error;
}
- string_free(str);
+ ssh_string_free(str);
- str = string_from_char(session->serverbanner);
+ str = ssh_string_from_char(session->serverbanner);
if (str == NULL) {
goto error;
}
@@ -543,25 +543,25 @@ int make_sessionid(ssh_session session) {
goto error;
}
- len = ntohl(buffer_get_len(client_hash));
+ len = ntohl(ssh_buffer_get_len(client_hash));
if (buffer_add_u32(buf,len) < 0) {
goto error;
}
- if (buffer_add_data(buf, buffer_get(client_hash),
- buffer_get_len(client_hash)) < 0) {
+ if (buffer_add_data(buf, ssh_buffer_get_begin(client_hash),
+ ssh_buffer_get_len(client_hash)) < 0) {
goto error;
}
- len = ntohl(buffer_get_len(server_hash));
+ len = ntohl(ssh_buffer_get_len(server_hash));
if (buffer_add_u32(buf, len) < 0) {
goto error;
}
- if (buffer_add_data(buf, buffer_get(server_hash),
- buffer_get_len(server_hash)) < 0) {
+ if (buffer_add_data(buf, ssh_buffer_get_begin(server_hash),
+ ssh_buffer_get_len(server_hash)) < 0) {
goto error;
}
- len = string_len(session->next_crypto->server_pubkey) + 4;
+ len = ssh_string_len(session->next_crypto->server_pubkey) + 4;
if (buffer_add_data(buf, session->next_crypto->server_pubkey, len) < 0) {
goto error;
}
@@ -571,38 +571,38 @@ int make_sessionid(ssh_session session) {
goto error;
}
- len = string_len(num) + 4;
+ len = ssh_string_len(num) + 4;
if (buffer_add_data(buf, num, len) < 0) {
goto error;
}
- string_free(num);
+ ssh_string_free(num);
num = make_bignum_string(session->next_crypto->f);
if (num == NULL) {
goto error;
}
- len = string_len(num) + 4;
+ len = ssh_string_len(num) + 4;
if (buffer_add_data(buf, num, len) < 0) {
goto error;
}
- string_free(num);
+ ssh_string_free(num);
num = make_bignum_string(session->next_crypto->k);
if (num == NULL) {
goto error;
}
- len = string_len(num) + 4;
+ len = ssh_string_len(num) + 4;
if (buffer_add_data(buf, num, len) < 0) {
goto error;
}
#ifdef DEBUG_CRYPTO
- ssh_print_hexa("hash buffer", buffer_get(buf), buffer_get_len(buf));
+ ssh_print_hexa("hash buffer", ssh_buffer_get_begin(buf), ssh_buffer_get_len(buf));
#endif
- sha1_update(ctx, buffer_get(buf), buffer_get_len(buf));
+ sha1_update(ctx, ssh_buffer_get_begin(buf), ssh_buffer_get_len(buf));
sha1_final(session->next_crypto->session_id, ctx);
#ifdef DEBUG_CRYPTO
@@ -612,15 +612,15 @@ int make_sessionid(ssh_session session) {
rc = SSH_OK;
error:
- buffer_free(buf);
- buffer_free(client_hash);
- buffer_free(server_hash);
+ ssh_buffer_free(buf);
+ ssh_buffer_free(client_hash);
+ ssh_buffer_free(server_hash);
session->in_hashbuf = NULL;
session->out_hashbuf = NULL;
- string_free(str);
- string_free(num);
+ ssh_string_free(str);
+ ssh_string_free(num);
leave_function();
@@ -628,7 +628,7 @@ error:
}
int hashbufout_add_cookie(ssh_session session) {
- session->out_hashbuf = buffer_new();
+ session->out_hashbuf = ssh_buffer_new();
if (session->out_hashbuf == NULL) {
return -1;
}
@@ -656,7 +656,7 @@ int hashbufout_add_cookie(ssh_session session) {
}
int hashbufin_add_cookie(ssh_session session, unsigned char *cookie) {
- session->in_hashbuf = buffer_new();
+ session->in_hashbuf = ssh_buffer_new();
if (session->in_hashbuf == NULL) {
return -1;
}
@@ -684,7 +684,7 @@ static int generate_one_key(ssh_string k,
return -1;
}
- sha1_update(ctx, k, string_len(k) + 4);
+ sha1_update(ctx, k, ssh_string_len(k) + 4);
sha1_update(ctx, session_id, SHA_DIGEST_LEN);
sha1_update(ctx, &letter, 1);
sha1_update(ctx, session_id, SHA_DIGEST_LEN);
@@ -752,7 +752,7 @@ int generate_session_keys(ssh_session session) {
if (ctx == NULL) {
goto error;
}
- sha1_update(ctx, k_string, string_len(k_string) + 4);
+ sha1_update(ctx, k_string, ssh_string_len(k_string) + 4);
sha1_update(ctx, session->next_crypto->session_id, SHA_DIGEST_LEN);
sha1_update(ctx, session->next_crypto->encryptkey, SHA_DIGEST_LEN);
sha1_final(session->next_crypto->encryptkey + SHA_DIGEST_LEN, ctx);
@@ -760,7 +760,7 @@ int generate_session_keys(ssh_session session) {
if (session->next_crypto->in_cipher->keysize > SHA_DIGEST_LEN * 8) {
ctx = sha1_init();
- sha1_update(ctx, k_string, string_len(k_string) + 4);
+ sha1_update(ctx, k_string, ssh_string_len(k_string) + 4);
sha1_update(ctx, session->next_crypto->session_id, SHA_DIGEST_LEN);
sha1_update(ctx, session->next_crypto->decryptkey, SHA_DIGEST_LEN);
sha1_final(session->next_crypto->decryptkey + SHA_DIGEST_LEN, ctx);
@@ -798,7 +798,7 @@ int generate_session_keys(ssh_session session) {
rc = 0;
error:
- string_free(k_string);
+ ssh_string_free(k_string);
leave_function();
return rc;
@@ -851,7 +851,7 @@ int ssh_get_pubkey_hash(ssh_session session, unsigned char **hash) {
pubkey = session->current_crypto->server_pubkey;
- md5_update(ctx, pubkey->string, string_len(pubkey));
+ md5_update(ctx, pubkey->string, ssh_string_len(pubkey));
md5_final(h, ctx);
*hash = h;
@@ -875,7 +875,7 @@ void ssh_clean_pubkey_hash(unsigned char **hash) {
}
ssh_string ssh_get_pubkey(ssh_session session){
- return string_copy(session->current_crypto->server_pubkey);
+ return ssh_string_copy(session->current_crypto->server_pubkey);
}
static int match(const char *group, const char *object){
@@ -976,7 +976,7 @@ int sig_verify(ssh_session session, ssh_public_key pubkey,
}
#elif defined HAVE_LIBCRYPTO
valid = RSA_verify(NID_sha1, hash + 1, SHA_DIGEST_LEN,
- signature->rsa_sign->string, string_len(signature->rsa_sign),
+ signature->rsa_sign->string, ssh_string_len(signature->rsa_sign),
pubkey->rsa_pub);
if (valid == 1) {
return 0;
diff --git a/libssh/gzip.c b/libssh/gzip.c
index c9b0545c..41c198ec 100644
--- a/libssh/gzip.c
+++ b/libssh/gzip.c
@@ -58,8 +58,8 @@ static z_stream *initcompress(ssh_session session, int level) {
static ssh_buffer gzip_compress(ssh_session session,ssh_buffer source,int level){
z_stream *zout = session->current_crypto->compress_out_ctx;
- void *in_ptr = buffer_get(source);
- unsigned long in_size = buffer_get_len(source);
+ void *in_ptr = ssh_buffer_get_begin(source);
+ unsigned long in_size = ssh_buffer_get_len(source);
ssh_buffer dest = NULL;
static unsigned char out_buf[BLOCKSIZE] = {0};
unsigned long len;
@@ -72,7 +72,7 @@ static ssh_buffer gzip_compress(ssh_session session,ssh_buffer source,int level)
}
}
- dest = buffer_new();
+ dest = ssh_buffer_new();
if (dest == NULL) {
return NULL;
}
@@ -84,14 +84,14 @@ static ssh_buffer gzip_compress(ssh_session session,ssh_buffer source,int level)
zout->avail_out = BLOCKSIZE;
status = deflate(zout, Z_PARTIAL_FLUSH);
if (status != Z_OK) {
- buffer_free(dest);
+ ssh_buffer_free(dest);
ssh_set_error(session, SSH_FATAL,
"status %d deflating zlib packet", status);
return NULL;
}
len = BLOCKSIZE - zout->avail_out;
if (buffer_add_data(dest, out_buf, len) < 0) {
- buffer_free(dest);
+ ssh_buffer_free(dest);
return NULL;
}
zout->next_out = out_buf;
@@ -109,16 +109,16 @@ int compress_buffer(ssh_session session, ssh_buffer buf) {
}
if (buffer_reinit(buf) < 0) {
- buffer_free(dest);
+ ssh_buffer_free(dest);
return -1;
}
- if (buffer_add_data(buf, buffer_get(dest), buffer_get_len(dest)) < 0) {
- buffer_free(dest);
+ if (buffer_add_data(buf, ssh_buffer_get_begin(dest), ssh_buffer_get_len(dest)) < 0) {
+ ssh_buffer_free(dest);
return -1;
}
- buffer_free(dest);
+ ssh_buffer_free(dest);
return 0;
}
@@ -161,7 +161,7 @@ static ssh_buffer gzip_decompress(ssh_session session, ssh_buffer source, size_t
}
}
- dest = buffer_new();
+ dest = ssh_buffer_new();
if (dest == NULL) {
return NULL;
}
@@ -176,18 +176,18 @@ static ssh_buffer gzip_decompress(ssh_session session, ssh_buffer source, size_t
if (status != Z_OK) {
ssh_set_error(session, SSH_FATAL,
"status %d inflating zlib packet", status);
- buffer_free(dest);
+ ssh_buffer_free(dest);
return NULL;
}
len = BLOCKSIZE - zin->avail_out;
if (buffer_add_data(dest,out_buf,len) < 0) {
- buffer_free(dest);
+ ssh_buffer_free(dest);
return NULL;
}
- if (buffer_get_len(dest) > maxlen){
+ if (ssh_buffer_get_len(dest) > maxlen){
/* Size of packet exceded, avoid a denial of service attack */
- buffer_free(dest);
+ ssh_buffer_free(dest);
return NULL;
}
zin->next_out = out_buf;
@@ -205,16 +205,16 @@ int decompress_buffer(ssh_session session,ssh_buffer buf, size_t maxlen){
}
if (buffer_reinit(buf) < 0) {
- buffer_free(dest);
+ ssh_buffer_free(dest);
return -1;
}
- if (buffer_add_data(buf, buffer_get(dest), buffer_get_len(dest)) < 0) {
- buffer_free(dest);
+ if (buffer_add_data(buf, ssh_buffer_get_begin(dest), ssh_buffer_get_len(dest)) < 0) {
+ ssh_buffer_free(dest);
return -1;
}
- buffer_free(dest);
+ ssh_buffer_free(dest);
return 0;
}
diff --git a/libssh/kex.c b/libssh/kex.c
index 9d3b1701..a137a594 100644
--- a/libssh/kex.c
+++ b/libssh/kex.c
@@ -282,11 +282,11 @@ SSH_PACKET_CALLBACK(ssh_packet_kexinit){
goto error;
}
- strings[i] = string_to_char(str);
+ strings[i] = ssh_string_to_char(str);
if (strings[i] == NULL) {
goto error;
}
- string_free(str);
+ ssh_string_free(str);
str = NULL;
}
@@ -318,7 +318,7 @@ SSH_PACKET_CALLBACK(ssh_packet_kexinit){
ssh_connection_callback(session);
return SSH_PACKET_USED;
error:
- string_free(str);
+ ssh_string_free(str);
for (i = 0; i < 10; i++) {
SAFE_FREE(strings[i]);
}
@@ -407,7 +407,7 @@ int ssh_send_kex(ssh_session session, int server_kex) {
ssh_list_kex(session, kex);
for (i = 0; i < 10; i++) {
- str = string_from_char(kex->methods[i]);
+ str = ssh_string_from_char(kex->methods[i]);
if (str == NULL) {
goto error;
}
@@ -418,7 +418,7 @@ int ssh_send_kex(ssh_session session, int server_kex) {
if (buffer_add_ssh_string(session->out_buffer, str) < 0) {
goto error;
}
- string_free(str);
+ ssh_string_free(str);
}
if (buffer_add_u8(session->out_buffer, 0) < 0) {
@@ -438,7 +438,7 @@ int ssh_send_kex(ssh_session session, int server_kex) {
error:
buffer_reinit(session->out_buffer);
buffer_reinit(session->out_hashbuf);
- string_free(str);
+ ssh_string_free(str);
leave_function();
return -1;
@@ -466,8 +466,8 @@ static ssh_string make_rsa1_string(ssh_string e, ssh_string n){
ssh_string rsa = NULL;
ssh_string ret = NULL;
- buffer = buffer_new();
- rsa = string_from_char("ssh-rsa1");
+ buffer = ssh_buffer_new();
+ rsa = ssh_string_from_char("ssh-rsa1");
if (buffer_add_ssh_string(buffer, rsa) < 0) {
goto error;
@@ -479,15 +479,15 @@ static ssh_string make_rsa1_string(ssh_string e, ssh_string n){
goto error;
}
- ret = string_new(buffer_get_len(buffer));
+ ret = ssh_string_new(ssh_buffer_get_len(buffer));
if (ret == NULL) {
goto error;
}
- string_fill(ret, buffer_get(buffer), buffer_get_len(buffer));
+ ssh_string_fill(ret, ssh_buffer_get_begin(buffer), ssh_buffer_get_len(buffer));
error:
- buffer_free(buffer);
- string_free(rsa);
+ ssh_buffer_free(buffer);
+ ssh_string_free(rsa);
return ret;
}
@@ -502,11 +502,11 @@ static int build_session_id1(ssh_session session, ssh_string servern,
}
#ifdef DEBUG_CRYPTO
- ssh_print_hexa("host modulus",string_data(hostn),string_len(hostn));
- ssh_print_hexa("server modulus",string_data(servern),string_len(servern));
+ ssh_print_hexa("host modulus",ssh_string_data(hostn),ssh_string_len(hostn));
+ ssh_print_hexa("server modulus",ssh_string_data(servern),ssh_string_len(servern));
#endif
- md5_update(md5,string_data(hostn),string_len(hostn));
- md5_update(md5,string_data(servern),string_len(servern));
+ md5_update(md5,ssh_string_data(hostn),ssh_string_len(hostn));
+ md5_update(md5,ssh_string_data(servern),ssh_string_len(servern));
md5_update(md5,session->server_kex.cookie,8);
md5_final(session->next_crypto->session_id,md5);
#ifdef DEBUG_CRYPTO
@@ -566,11 +566,11 @@ static ssh_string encrypt_session_key(ssh_session session, ssh_public_key srvkey
for (i = 0; i < 16; i++) {
buffer[i] ^= session->next_crypto->session_id[i];
}
- data1 = string_new(32);
+ data1 = ssh_string_new(32);
if (data1 == NULL) {
return NULL;
}
- string_fill(data1, buffer, 32);
+ ssh_string_fill(data1, buffer, 32);
if (ABS(hlen - slen) < 128){
ssh_log(session, SSH_LOG_FUNCTIONS,
"Difference between server modulus and host modulus is only %d. "
@@ -580,25 +580,25 @@ static ssh_string encrypt_session_key(ssh_session session, ssh_public_key srvkey
if (modulus_smaller(srvkey, hostkey)) {
data2 = ssh_encrypt_rsa1(session, data1, srvkey);
- string_free(data1);
+ ssh_string_free(data1);
data1 = NULL;
if (data2 == NULL) {
return NULL;
}
data1 = ssh_encrypt_rsa1(session, data2, hostkey);
- string_free(data2);
+ ssh_string_free(data2);
if (data1 == NULL) {
return NULL;
}
} else {
data2 = ssh_encrypt_rsa1(session, data1, hostkey);
- string_free(data1);
+ ssh_string_free(data1);
data1 = NULL;
if (data2 == NULL) {
return NULL;
}
data1 = ssh_encrypt_rsa1(session, data2, srvkey);
- string_free(data2);
+ ssh_string_free(data2);
if (data1 == NULL) {
return NULL;
}
@@ -718,7 +718,7 @@ SSH_PACKET_CALLBACK(ssh_packet_publickey1){
goto error;
}
- session->next_crypto->server_pubkey = string_copy(hostkey);
+ session->next_crypto->server_pubkey = ssh_string_copy(hostkey);
if (session->next_crypto->server_pubkey == NULL) {
goto error;
}
@@ -747,16 +747,16 @@ SSH_PACKET_CALLBACK(ssh_packet_publickey1){
goto error;
}
- bits = string_len(enc_session) * 8 - 7;
+ bits = ssh_string_len(enc_session) * 8 - 7;
ssh_log(session, SSH_LOG_PROTOCOL, "%d bits, %zu bytes encrypted session",
- bits, string_len(enc_session));
+ bits, ssh_string_len(enc_session));
bits = htons(bits);
/* the encrypted mpint */
if (buffer_add_data(session->out_buffer, &bits, sizeof(uint16_t)) < 0) {
goto error;
}
- if (buffer_add_data(session->out_buffer, string_data(enc_session),
- string_len(enc_session)) < 0) {
+ if (buffer_add_data(session->out_buffer, ssh_string_data(enc_session),
+ ssh_string_len(enc_session)) < 0) {
goto error;
}
/* the protocol flags */
@@ -780,13 +780,13 @@ error:
session->session_state=SSH_SESSION_STATE_ERROR;
end:
- string_free(host_mod);
- string_free(host_exp);
- string_free(server_mod);
- string_free(server_exp);
- string_free(serverkey);
- string_free(hostkey);
- string_free(enc_session);
+ ssh_string_free(host_mod);
+ ssh_string_free(host_exp);
+ ssh_string_free(server_mod);
+ ssh_string_free(server_exp);
+ ssh_string_free(serverkey);
+ ssh_string_free(hostkey);
+ ssh_string_free(enc_session);
publickey_free(srv);
publickey_free(host);
diff --git a/libssh/keyfiles.c b/libssh/keyfiles.c
index ba9a0519..f4c03e5e 100644
--- a/libssh/keyfiles.c
+++ b/libssh/keyfiles.c
@@ -155,13 +155,13 @@ static ssh_string asn1_get_int(ssh_buffer buffer) {
return NULL;
}
- str = string_new(size);
+ str = ssh_string_new(size);
if (str == NULL) {
return NULL;
}
if (buffer_get_data(buffer, str->string, size) == 0) {
- string_free(str);
+ ssh_string_free(str);
return NULL;
}
@@ -180,9 +180,9 @@ static int asn1_check_sequence(ssh_buffer buffer) {
}
size = asn1_get_len(buffer);
- if ((padding = buffer_get_len(buffer) - buffer->pos - size) > 0) {
- for (i = buffer_get_len(buffer) - buffer->pos - size,
- j = (unsigned char*)buffer_get(buffer) + size + buffer->pos;
+ if ((padding = ssh_buffer_get_len(buffer) - buffer->pos - size) > 0) {
+ for (i = ssh_buffer_get_len(buffer) - buffer->pos - size,
+ j = (unsigned char*)ssh_buffer_get_begin(buffer) + size + buffer->pos;
i;
i--, j++)
{
@@ -280,14 +280,14 @@ static int privatekey_decrypt(int algo, int mode, unsigned int key_len,
if (gcry_cipher_open(&cipher, algo, mode, 0)
|| gcry_cipher_setkey(cipher, key, key_len)
|| gcry_cipher_setiv(cipher, iv, iv_len)
- || (tmp = malloc(buffer_get_len(data) * sizeof (char))) == NULL
- || gcry_cipher_decrypt(cipher, tmp, buffer_get_len(data),
- buffer_get(data), buffer_get_len(data))) {
+ || (tmp = malloc(ssh_buffer_get_len(data) * sizeof (char))) == NULL
+ || gcry_cipher_decrypt(cipher, tmp, ssh_buffer_get_len(data),
+ ssh_buffer_get_begin(data), ssh_buffer_get_len(data))) {
gcry_cipher_close(cipher);
return -1;
}
- memcpy(buffer_get(data), tmp, buffer_get_len(data));
+ memcpy(ssh_buffer_get_begin(data), tmp, ssh_buffer_get_len(data));
SAFE_FREE(tmp);
gcry_cipher_close(cipher);
@@ -367,7 +367,7 @@ static ssh_buffer privatekey_file_to_buffer(FILE *fp, int type,
int mode = 0;
int len;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
return NULL;
}
@@ -382,7 +382,7 @@ static ssh_buffer privatekey_file_to_buffer(FILE *fp, int type,
header_end = RSA_HEADER_END;
break;
default:
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
@@ -400,18 +400,18 @@ static ssh_buffer privatekey_file_to_buffer(FILE *fp, int type,
if ((privatekey_dek_header(buf + 10, len - 10, &algo, &mode, &key_len,
&iv, &iv_len) < 0)
|| read_line(buf, MAXLINESIZE, fp)) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
SAFE_FREE(iv);
return NULL;
}
} else {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
SAFE_FREE(iv);
return NULL;
}
} else {
if (buffer_add_data(buffer, buf, len) < 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
SAFE_FREE(iv);
return NULL;
}
@@ -420,31 +420,31 @@ static ssh_buffer privatekey_file_to_buffer(FILE *fp, int type,
while ((len = read_line(buf,MAXLINESIZE,fp)) &&
strncmp(buf, header_end, header_end_size) != 0) {
if (len == -1) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
SAFE_FREE(iv);
return NULL;
}
if (buffer_add_data(buffer, buf, len) < 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
SAFE_FREE(iv);
return NULL;
}
}
if (strncmp(buf,header_end,header_end_size) != 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
SAFE_FREE(iv);
return NULL;
}
if (buffer_add_data(buffer, "\0", 1) < 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
SAFE_FREE(iv);
return NULL;
}
- out = base64_to_bin(buffer_get(buffer));
- buffer_free(buffer);
+ out = base64_to_bin(ssh_buffer_get_begin(buffer));
+ ssh_buffer_free(buffer);
if (out == NULL) {
SAFE_FREE(iv);
return NULL;
@@ -453,7 +453,7 @@ static ssh_buffer privatekey_file_to_buffer(FILE *fp, int type,
if (algo) {
if (privatekey_decrypt(algo, mode, key_len, iv, iv_len, out,
cb, userdata, desc) < 0) {
- buffer_free(out);
+ ssh_buffer_free(out);
SAFE_FREE(iv);
return NULL;
}
@@ -483,13 +483,13 @@ static int read_rsa_privatekey(FILE *fp, gcry_sexp_t *r,
}
if (!asn1_check_sequence(buffer)) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return 0;
}
v = asn1_get_int(buffer);
if (ntohl(v->size) != 1 || v->string[0] != 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return 0;
}
@@ -502,7 +502,7 @@ static int read_rsa_privatekey(FILE *fp, gcry_sexp_t *r,
unused2 = asn1_get_int(buffer);
u = asn1_get_int(buffer);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
if (n == NULL || e == NULL || d == NULL || p == NULL || q == NULL ||
unused1 == NULL || unused2 == NULL|| u == NULL) {
@@ -522,15 +522,15 @@ static int read_rsa_privatekey(FILE *fp, gcry_sexp_t *r,
}
error:
- string_free(n);
- string_free(e);
- string_free(d);
- string_free(p);
- string_free(q);
- string_free(unused1);
- string_free(unused2);
- string_free(u);
- string_free(v);
+ ssh_string_free(n);
+ ssh_string_free(e);
+ ssh_string_free(d);
+ ssh_string_free(p);
+ ssh_string_free(q);
+ ssh_string_free(unused1);
+ ssh_string_free(unused2);
+ ssh_string_free(u);
+ ssh_string_free(v);
return rc;
}
@@ -552,13 +552,13 @@ static int read_dsa_privatekey(FILE *fp, gcry_sexp_t *r, ssh_auth_callback cb,
}
if (!asn1_check_sequence(buffer)) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return 0;
}
v = asn1_get_int(buffer);
if (ntohl(v->size) != 1 || v->string[0] != 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return 0;
}
@@ -567,7 +567,7 @@ static int read_dsa_privatekey(FILE *fp, gcry_sexp_t *r, ssh_auth_callback cb,
g = asn1_get_int(buffer);
y = asn1_get_int(buffer);
x = asn1_get_int(buffer);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
if (p == NULL || q == NULL || g == NULL || y == NULL || x == NULL) {
rc = 0;
@@ -585,12 +585,12 @@ static int read_dsa_privatekey(FILE *fp, gcry_sexp_t *r, ssh_auth_callback cb,
}
error:
- string_free(p);
- string_free(q);
- string_free(g);
- string_free(y);
- string_free(x);
- string_free(v);
+ ssh_string_free(p);
+ ssh_string_free(q);
+ ssh_string_free(g);
+ ssh_string_free(y);
+ ssh_string_free(x);
+ ssh_string_free(v);
return rc;
}
@@ -952,7 +952,7 @@ int ssh_publickey_to_file(ssh_session session, const char *file,
size_t len;
int rc;
- pubkey_64 = bin_to_base64(pubkey->string, string_len(pubkey));
+ pubkey_64 = bin_to_base64(pubkey->string, ssh_string_len(pubkey));
if (pubkey_64 == NULL) {
return -1;
}
@@ -1070,15 +1070,15 @@ ssh_string publickey_from_file(ssh_session session, const char *filename,
return NULL;
}
- str = string_new(buffer_get_len(buffer));
+ str = ssh_string_new(ssh_buffer_get_len(buffer));
if (str == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
- string_fill(str, buffer_get(buffer), buffer_get_len(buffer));
- buffer_free(buffer);
+ ssh_string_fill(str, ssh_buffer_get_begin(buffer), ssh_buffer_get_len(buffer));
+ ssh_buffer_free(buffer);
if (type) {
*type = key_type;
@@ -1215,7 +1215,7 @@ ssh_string try_publickey_from_file(ssh_session session, struct ssh_keys_struct k
new = realloc(*privkeyfile, strlen(priv) + 1);
if (new == NULL) {
- string_free(pubkey);
+ ssh_string_free(pubkey);
goto error;
}
@@ -1380,29 +1380,29 @@ static int check_public_key(ssh_session session, char **tokens) {
unsigned int len;
int i;
- pubkey_buffer = buffer_new();
+ pubkey_buffer = ssh_buffer_new();
if (pubkey_buffer == NULL) {
return -1;
}
- tmpstring = string_from_char("ssh-rsa1");
+ tmpstring = ssh_string_from_char("ssh-rsa1");
if (tmpstring == NULL) {
- buffer_free(pubkey_buffer);
+ ssh_buffer_free(pubkey_buffer);
return -1;
}
if (buffer_add_ssh_string(pubkey_buffer, tmpstring) < 0) {
- buffer_free(pubkey_buffer);
- string_free(tmpstring);
+ ssh_buffer_free(pubkey_buffer);
+ ssh_string_free(tmpstring);
return -1;
}
- string_free(tmpstring);
+ ssh_string_free(tmpstring);
for (i = 2; i < 4; i++) { /* e, then n */
tmpbn = NULL;
bignum_dec2bn(tokens[i], &tmpbn);
if (tmpbn == NULL) {
- buffer_free(pubkey_buffer);
+ ssh_buffer_free(pubkey_buffer);
return -1;
}
/* for some reason, make_bignum_string does not work
@@ -1412,7 +1412,7 @@ static int check_public_key(ssh_session session, char **tokens) {
len = bignum_num_bytes(tmpbn);
tmpstring = malloc(4 + len);
if (tmpstring == NULL) {
- buffer_free(pubkey_buffer);
+ ssh_buffer_free(pubkey_buffer);
bignum_free(tmpbn);
return -1;
}
@@ -1425,12 +1425,12 @@ static int check_public_key(ssh_session session, char **tokens) {
#endif
bignum_free(tmpbn);
if (buffer_add_ssh_string(pubkey_buffer, tmpstring) < 0) {
- buffer_free(pubkey_buffer);
- string_free(tmpstring);
+ ssh_buffer_free(pubkey_buffer);
+ ssh_string_free(tmpstring);
bignum_free(tmpbn);
return -1;
}
- string_free(tmpstring);
+ ssh_string_free(tmpstring);
}
} else {
/* ssh-dss or ssh-rsa */
@@ -1444,19 +1444,19 @@ static int check_public_key(ssh_session session, char **tokens) {
return -1;
}
- if (buffer_get_len(pubkey_buffer) != string_len(pubkey)) {
- buffer_free(pubkey_buffer);
+ if (ssh_buffer_get_len(pubkey_buffer) != ssh_string_len(pubkey)) {
+ ssh_buffer_free(pubkey_buffer);
return 0;
}
/* now test that they are identical */
- if (memcmp(buffer_get(pubkey_buffer), pubkey->string,
- buffer_get_len(pubkey_buffer)) != 0) {
- buffer_free(pubkey_buffer);
+ if (memcmp(ssh_buffer_get_begin(pubkey_buffer), pubkey->string,
+ ssh_buffer_get_len(pubkey_buffer)) != 0) {
+ ssh_buffer_free(pubkey_buffer);
return 0;
}
- buffer_free(pubkey_buffer);
+ ssh_buffer_free(pubkey_buffer);
return 1;
}
@@ -1519,15 +1519,15 @@ static int match_hashed_host(ssh_session session, const char *host,
hash = base64_to_bin(b64hash);
SAFE_FREE(source);
if (hash == NULL) {
- buffer_free(salt);
+ ssh_buffer_free(salt);
leave_function();
return 0;
}
- mac = hmac_init(buffer_get(salt), buffer_get_len(salt), HMAC_SHA1);
+ mac = hmac_init(ssh_buffer_get_begin(salt), ssh_buffer_get_len(salt), HMAC_SHA1);
if (mac == NULL) {
- buffer_free(salt);
- buffer_free(hash);
+ ssh_buffer_free(salt);
+ ssh_buffer_free(hash);
leave_function();
return 0;
}
@@ -1535,15 +1535,15 @@ static int match_hashed_host(ssh_session session, const char *host,
hmac_update(mac, host, strlen(host));
hmac_final(mac, buffer, &size);
- if (size == buffer_get_len(hash) &&
- memcmp(buffer, buffer_get(hash), size) == 0) {
+ if (size == ssh_buffer_get_len(hash) &&
+ memcmp(buffer, ssh_buffer_get_begin(hash), size) == 0) {
match = 1;
} else {
match = 0;
}
- buffer_free(salt);
- buffer_free(hash);
+ ssh_buffer_free(salt);
+ ssh_buffer_free(hash);
ssh_log(session, SSH_LOG_PACKET,
"Matching a hashed host: %s match=%d", host, match);
@@ -1855,7 +1855,7 @@ int ssh_write_knownhost(ssh_session session) {
publickey_free(key);
} else {
- pubkey_64 = bin_to_base64(pubkey->string, string_len(pubkey));
+ pubkey_64 = bin_to_base64(pubkey->string, ssh_string_len(pubkey));
if (pubkey_64 == NULL) {
fclose(file);
SAFE_FREE(host);
diff --git a/libssh/keys.c b/libssh/keys.c
index 535c3783..244e4199 100644
--- a/libssh/keys.c
+++ b/libssh/keys.c
@@ -85,7 +85,7 @@ ssh_public_key publickey_make_dss(ssh_session session, ssh_buffer buffer) {
key = malloc(sizeof(struct ssh_public_key_struct));
if (key == NULL) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
@@ -97,7 +97,7 @@ ssh_public_key publickey_make_dss(ssh_session session, ssh_buffer buffer) {
g = buffer_get_ssh_string(buffer);
pubkey = buffer_get_ssh_string(buffer);
- buffer_free(buffer); /* we don't need it anymore */
+ ssh_buffer_free(buffer); /* we don't need it anymore */
if (p == NULL || q == NULL || g == NULL || pubkey == NULL) {
ssh_set_error(session, SSH_FATAL, "Invalid DSA public key");
@@ -107,10 +107,10 @@ ssh_public_key publickey_make_dss(ssh_session session, ssh_buffer buffer) {
#ifdef HAVE_LIBGCRYPT
gcry_sexp_build(&key->dsa_pub, NULL,
"(public-key(dsa(p %b)(q %b)(g %b)(y %b)))",
- string_len(p), string_data(p),
- string_len(q), string_data(q),
- string_len(g), string_data(g),
- string_len(pubkey), string_data(pubkey));
+ ssh_string_len(p), ssh_string_data(p),
+ ssh_string_len(q), ssh_string_data(q),
+ ssh_string_len(g), ssh_string_data(g),
+ ssh_string_len(pubkey), ssh_string_data(pubkey));
if (key->dsa_pub == NULL) {
goto error;
}
@@ -133,30 +133,30 @@ ssh_public_key publickey_make_dss(ssh_session session, ssh_buffer buffer) {
#endif /* HAVE_LIBCRYPTO */
#ifdef DEBUG_CRYPTO
- ssh_print_hexa("p", string_data(p), string_len(p));
- ssh_print_hexa("q", string_data(q), string_len(q));
- ssh_print_hexa("g", string_data(g), string_len(g));
+ ssh_print_hexa("p", ssh_string_data(p), ssh_string_len(p));
+ ssh_print_hexa("q", ssh_string_data(q), ssh_string_len(q));
+ ssh_print_hexa("g", ssh_string_data(g), ssh_string_len(g));
#endif
- string_burn(p);
- string_free(p);
- string_burn(q);
- string_free(q);
- string_burn(g);
- string_free(g);
- string_burn(pubkey);
- string_free(pubkey);
+ ssh_string_burn(p);
+ ssh_string_free(p);
+ ssh_string_burn(q);
+ ssh_string_free(q);
+ ssh_string_burn(g);
+ ssh_string_free(g);
+ ssh_string_burn(pubkey);
+ ssh_string_free(pubkey);
return key;
error:
- string_burn(p);
- string_free(p);
- string_burn(q);
- string_free(q);
- string_burn(g);
- string_free(g);
- string_burn(pubkey);
- string_free(pubkey);
+ ssh_string_burn(p);
+ ssh_string_free(p);
+ ssh_string_burn(q);
+ ssh_string_free(q);
+ ssh_string_burn(g);
+ ssh_string_free(g);
+ ssh_string_burn(pubkey);
+ ssh_string_free(pubkey);
publickey_free(key);
return NULL;
@@ -170,7 +170,7 @@ ssh_public_key publickey_make_rsa(ssh_session session, ssh_buffer buffer,
key = malloc(sizeof(struct ssh_public_key_struct));
if (key == NULL) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
@@ -180,7 +180,7 @@ ssh_public_key publickey_make_rsa(ssh_session session, ssh_buffer buffer,
e = buffer_get_ssh_string(buffer);
n = buffer_get_ssh_string(buffer);
- buffer_free(buffer); /* we don't need it anymore */
+ ssh_buffer_free(buffer); /* we don't need it anymore */
if(e == NULL || n == NULL) {
ssh_set_error(session, SSH_FATAL, "Invalid RSA public key");
@@ -189,8 +189,8 @@ ssh_public_key publickey_make_rsa(ssh_session session, ssh_buffer buffer,
#ifdef HAVE_LIBGCRYPT
gcry_sexp_build(&key->rsa_pub, NULL,
"(public-key(rsa(n %b)(e %b)))",
- string_len(n), string_data(n),
- string_len(e),string_data(e));
+ ssh_string_len(n), ssh_string_data(n),
+ ssh_string_len(e),ssh_string_data(e));
if (key->rsa_pub == NULL) {
goto error;
}
@@ -209,21 +209,21 @@ ssh_public_key publickey_make_rsa(ssh_session session, ssh_buffer buffer,
#endif
#ifdef DEBUG_CRYPTO
- ssh_print_hexa("e", string_data(e), string_len(e));
- ssh_print_hexa("n", string_data(n), string_len(n));
+ ssh_print_hexa("e", ssh_string_data(e), ssh_string_len(e));
+ ssh_print_hexa("n", ssh_string_data(n), ssh_string_len(n));
#endif
- string_burn(e);
- string_free(e);
- string_burn(n);
- string_free(n);
+ ssh_string_burn(e);
+ ssh_string_free(e);
+ ssh_string_burn(n);
+ ssh_string_free(n);
return key;
error:
- string_burn(e);
- string_free(e);
- string_burn(n);
- string_free(n);
+ ssh_string_burn(e);
+ ssh_string_free(e);
+ ssh_string_burn(n);
+ ssh_string_free(n);
publickey_free(key);
return NULL;
@@ -262,12 +262,12 @@ ssh_public_key publickey_from_string(ssh_session session, ssh_string pubkey_s) {
char *type_c = NULL;
int type;
- tmpbuf = buffer_new();
+ tmpbuf = ssh_buffer_new();
if (tmpbuf == NULL) {
return NULL;
}
- if (buffer_add_data(tmpbuf, string_data(pubkey_s), string_len(pubkey_s)) < 0) {
+ if (buffer_add_data(tmpbuf, ssh_string_data(pubkey_s), ssh_string_len(pubkey_s)) < 0) {
goto error;
}
@@ -277,8 +277,8 @@ ssh_public_key publickey_from_string(ssh_session session, ssh_string pubkey_s) {
goto error;
}
- type_c = string_to_char(type_s);
- string_free(type_s);
+ type_c = ssh_string_to_char(type_s);
+ ssh_string_free(type_s);
if (type_c == NULL) {
goto error;
}
@@ -298,7 +298,7 @@ ssh_public_key publickey_from_string(ssh_session session, ssh_string pubkey_s) {
ssh_type_to_char(type));
error:
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
@@ -339,11 +339,11 @@ ssh_public_key publickey_from_privatekey(ssh_private_key prv) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp, 1, &size);
- p = string_new(size);
+ p = ssh_string_new(size);
if (p == NULL) {
goto error;
}
- string_fill(p,(char *) tmp, size);
+ ssh_string_fill(p,(char *) tmp, size);
gcry_sexp_release(sexp);
sexp = gcry_sexp_find_token(prv->dsa_priv,"q",0);
@@ -351,11 +351,11 @@ ssh_public_key publickey_from_privatekey(ssh_private_key prv) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp,1,&size);
- q = string_new(size);
+ q = ssh_string_new(size);
if (q == NULL) {
goto error;
}
- string_fill(q,(char *) tmp,size);
+ ssh_string_fill(q,(char *) tmp,size);
gcry_sexp_release(sexp);
sexp = gcry_sexp_find_token(prv->dsa_priv, "g", 0);
@@ -363,11 +363,11 @@ ssh_public_key publickey_from_privatekey(ssh_private_key prv) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp,1,&size);
- g = string_new(size);
+ g = ssh_string_new(size);
if (g == NULL) {
goto error;
}
- string_fill(g,(char *) tmp,size);
+ ssh_string_fill(g,(char *) tmp,size);
gcry_sexp_release(sexp);
sexp = gcry_sexp_find_token(prv->dsa_priv,"y",0);
@@ -375,28 +375,28 @@ ssh_public_key publickey_from_privatekey(ssh_private_key prv) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp,1,&size);
- y = string_new(size);
+ y = ssh_string_new(size);
if (y == NULL) {
goto error;
}
- string_fill(y,(char *) tmp,size);
+ ssh_string_fill(y,(char *) tmp,size);
gcry_sexp_release(sexp);
gcry_sexp_build(&key->dsa_pub, NULL,
"(public-key(dsa(p %b)(q %b)(g %b)(y %b)))",
- string_len(p), string_data(p),
- string_len(q), string_data(q),
- string_len(g), string_data(g),
- string_len(y), string_data(y));
-
- string_burn(p);
- string_free(p);
- string_burn(q);
- string_free(q);
- string_burn(g);
- string_free(g);
- string_burn(y);
- string_free(y);
+ ssh_string_len(p), ssh_string_data(p),
+ ssh_string_len(q), ssh_string_data(q),
+ ssh_string_len(g), ssh_string_data(g),
+ ssh_string_len(y), ssh_string_data(y));
+
+ ssh_string_burn(p);
+ ssh_string_free(p);
+ ssh_string_burn(q);
+ ssh_string_free(q);
+ ssh_string_burn(g);
+ ssh_string_free(g);
+ ssh_string_burn(y);
+ ssh_string_free(y);
#elif defined HAVE_LIBCRYPTO
key->dsa_pub = DSA_new();
if (key->dsa_pub == NULL) {
@@ -422,11 +422,11 @@ ssh_public_key publickey_from_privatekey(ssh_private_key prv) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp, 1, &size);
- n = string_new(size);
+ n = ssh_string_new(size);
if (n == NULL) {
goto error;
}
- string_fill(n, (char *) tmp, size);
+ ssh_string_fill(n, (char *) tmp, size);
gcry_sexp_release(sexp);
sexp = gcry_sexp_find_token(prv->rsa_priv, "e", 0);
@@ -434,25 +434,25 @@ ssh_public_key publickey_from_privatekey(ssh_private_key prv) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp, 1, &size);
- e = string_new(size);
+ e = ssh_string_new(size);
if (e == NULL) {
goto error;
}
- string_fill(e, (char *) tmp, size);
+ ssh_string_fill(e, (char *) tmp, size);
gcry_sexp_release(sexp);
gcry_sexp_build(&key->rsa_pub, NULL,
"(public-key(rsa(n %b)(e %b)))",
- string_len(n), string_data(n),
- string_len(e), string_data(e));
+ ssh_string_len(n), ssh_string_data(n),
+ ssh_string_len(e), ssh_string_data(e));
if (key->rsa_pub == NULL) {
goto error;
}
- string_burn(e);
- string_free(e);
- string_burn(n);
- string_free(n);
+ ssh_string_burn(e);
+ ssh_string_free(e);
+ ssh_string_burn(n);
+ ssh_string_free(n);
#elif defined HAVE_LIBCRYPTO
key->rsa_pub = RSA_new();
if (key->rsa_pub == NULL) {
@@ -473,19 +473,19 @@ ssh_public_key publickey_from_privatekey(ssh_private_key prv) {
error:
#ifdef HAVE_LIBGCRYPT
gcry_sexp_release(sexp);
- string_burn(p);
- string_free(p);
- string_burn(q);
- string_free(q);
- string_burn(g);
- string_free(g);
- string_burn(y);
- string_free(y);
-
- string_burn(e);
- string_free(e);
- string_burn(n);
- string_free(n);
+ ssh_string_burn(p);
+ ssh_string_free(p);
+ ssh_string_burn(q);
+ ssh_string_free(q);
+ ssh_string_burn(g);
+ ssh_string_free(g);
+ ssh_string_burn(y);
+ ssh_string_free(y);
+
+ ssh_string_burn(e);
+ ssh_string_free(e);
+ ssh_string_burn(n);
+ ssh_string_free(n);
#endif
publickey_free(key);
@@ -514,11 +514,11 @@ static int dsa_public_to_string(DSA *key, ssh_buffer buffer) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp, 1, &size);
- p = string_new(size);
+ p = ssh_string_new(size);
if (p == NULL) {
goto error;
}
- string_fill(p, (char *) tmp, size);
+ ssh_string_fill(p, (char *) tmp, size);
gcry_sexp_release(sexp);
sexp = gcry_sexp_find_token(key, "q", 0);
@@ -526,11 +526,11 @@ static int dsa_public_to_string(DSA *key, ssh_buffer buffer) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp, 1, &size);
- q = string_new(size);
+ q = ssh_string_new(size);
if (q == NULL) {
goto error;
}
- string_fill(q, (char *) tmp, size);
+ ssh_string_fill(q, (char *) tmp, size);
gcry_sexp_release(sexp);
sexp = gcry_sexp_find_token(key, "g", 0);
@@ -538,11 +538,11 @@ static int dsa_public_to_string(DSA *key, ssh_buffer buffer) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp, 1, &size);
- g = string_new(size);
+ g = ssh_string_new(size);
if (g == NULL) {
goto error;
}
- string_fill(g, (char *) tmp, size);
+ ssh_string_fill(g, (char *) tmp, size);
gcry_sexp_release(sexp);
sexp = gcry_sexp_find_token(key, "y", 0);
@@ -550,11 +550,11 @@ static int dsa_public_to_string(DSA *key, ssh_buffer buffer) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp, 1, &size);
- n = string_new(size);
+ n = ssh_string_new(size);
if (n == NULL) {
goto error;
}
- string_fill(n, (char *) tmp, size);
+ ssh_string_fill(n, (char *) tmp, size);
#elif defined HAVE_LIBCRYPTO
p = make_bignum_string(key->p);
@@ -584,14 +584,14 @@ error:
gcry_sexp_release(sexp);
#endif
- string_burn(p);
- string_free(p);
- string_burn(q);
- string_free(q);
- string_burn(g);
- string_free(g);
- string_burn(n);
- string_free(n);
+ ssh_string_burn(p);
+ ssh_string_free(p);
+ ssh_string_burn(q);
+ ssh_string_free(q);
+ ssh_string_burn(g);
+ ssh_string_free(g);
+ ssh_string_burn(n);
+ ssh_string_free(n);
return rc;
}
@@ -617,11 +617,11 @@ static int rsa_public_to_string(RSA *key, ssh_buffer buffer) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp, 1, &size);
- n = string_new(size);
+ n = ssh_string_new(size);
if (n == NULL) {
goto error;
}
- string_fill(n, (char *) tmp, size);
+ ssh_string_fill(n, (char *) tmp, size);
gcry_sexp_release(sexp);
sexp = gcry_sexp_find_token(key, "e", 0);
@@ -629,11 +629,11 @@ static int rsa_public_to_string(RSA *key, ssh_buffer buffer) {
goto error;
}
tmp = gcry_sexp_nth_data(sexp, 1, &size);
- e = string_new(size);
+ e = ssh_string_new(size);
if (e == NULL) {
goto error;
}
- string_fill(e, (char *) tmp, size);
+ ssh_string_fill(e, (char *) tmp, size);
#elif defined HAVE_LIBCRYPTO
e = make_bignum_string(key->e);
@@ -656,10 +656,10 @@ error:
gcry_sexp_release(sexp);
#endif
- string_burn(e);
- string_free(e);
- string_burn(n);
- string_free(n);
+ ssh_string_burn(e);
+ ssh_string_free(e);
+ ssh_string_burn(n);
+ ssh_string_free(n);
return rc;
}
@@ -679,12 +679,12 @@ ssh_string publickey_to_string(ssh_public_key key) {
ssh_string ret = NULL;
ssh_buffer buf = NULL;
- buf = buffer_new();
+ buf = ssh_buffer_new();
if (buf == NULL) {
return NULL;
}
- type = string_from_char(key->type_c);
+ type = ssh_string_from_char(key->type_c);
if (type == NULL) {
goto error;
}
@@ -707,15 +707,15 @@ ssh_string publickey_to_string(ssh_public_key key) {
break;
}
- ret = string_new(buffer_get_len(buf));
+ ret = ssh_string_new(ssh_buffer_get_len(buf));
if (ret == NULL) {
goto error;
}
- string_fill(ret, buffer_get(buf), buffer_get_len(buf));
+ ssh_string_fill(ret, ssh_buffer_get_begin(buf), ssh_buffer_get_len(buf));
error:
- buffer_free(buf);
- string_free(type);
+ ssh_buffer_free(buf);
+ ssh_string_free(type);
return ret;
}
@@ -738,29 +738,29 @@ static ssh_string signature_to_string(SIGNATURE *sign) {
ssh_string s = NULL;
#endif
- tmpbuf = buffer_new();
+ tmpbuf = ssh_buffer_new();
if (tmpbuf == NULL) {
return NULL;
}
- tmp = string_from_char(ssh_type_to_char(sign->type));
+ tmp = ssh_string_from_char(ssh_type_to_char(sign->type));
if (tmp == NULL) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
if (buffer_add_ssh_string(tmpbuf, tmp) < 0) {
- buffer_free(tmpbuf);
- string_free(tmp);
+ ssh_buffer_free(tmpbuf);
+ ssh_string_free(tmp);
return NULL;
}
- string_free(tmp);
+ ssh_string_free(tmp);
switch(sign->type) {
case SSH_KEYTYPE_DSS:
#ifdef HAVE_LIBGCRYPT
sexp = gcry_sexp_find_token(sign->dsa_sign, "r", 0);
if (sexp == NULL) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
r = gcry_sexp_nth_data(sexp, 1, &size);
@@ -773,7 +773,7 @@ static ssh_string signature_to_string(SIGNATURE *sign) {
sexp = gcry_sexp_find_token(sign->dsa_sign, "s", 0);
if (sexp == NULL) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
s = gcry_sexp_nth_data(sexp,1,&size);
@@ -786,33 +786,33 @@ static ssh_string signature_to_string(SIGNATURE *sign) {
#elif defined HAVE_LIBCRYPTO
r = make_bignum_string(sign->dsa_sign->r);
if (r == NULL) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
s = make_bignum_string(sign->dsa_sign->s);
if (s == NULL) {
- buffer_free(tmpbuf);
- string_free(r);
+ ssh_buffer_free(tmpbuf);
+ ssh_string_free(r);
return NULL;
}
- memcpy(buffer, (char *)string_data(r) + string_len(r) - 20, 20);
- memcpy(buffer + 20, (char *)string_data(s) + string_len(s) - 20, 20);
+ memcpy(buffer, (char *)ssh_string_data(r) + ssh_string_len(r) - 20, 20);
+ memcpy(buffer + 20, (char *)ssh_string_data(s) + ssh_string_len(s) - 20, 20);
- string_free(r);
- string_free(s);
+ ssh_string_free(r);
+ ssh_string_free(s);
#endif /* HAVE_LIBCRYPTO */
- rs = string_new(40);
+ rs = ssh_string_new(40);
if (rs == NULL) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
- string_fill(rs, buffer, 40);
+ ssh_string_fill(rs, buffer, 40);
rc = buffer_add_ssh_string(tmpbuf, rs);
- string_free(rs);
+ ssh_string_free(rs);
if (rc < 0) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
@@ -822,7 +822,7 @@ static ssh_string signature_to_string(SIGNATURE *sign) {
#ifdef HAVE_LIBGCRYPT
sexp = gcry_sexp_find_token(sign->rsa_sign, "s", 0);
if (sexp == NULL) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
s = gcry_sexp_nth_data(sexp,1,&size);
@@ -830,36 +830,36 @@ static ssh_string signature_to_string(SIGNATURE *sign) {
size--;
s++;
}
- rs = string_new(size);
+ rs = ssh_string_new(size);
if (rs == NULL) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
- string_fill(rs, (char *) s, size);
+ ssh_string_fill(rs, (char *) s, size);
rc = buffer_add_ssh_string(tmpbuf, rs);
gcry_sexp_release(sexp);
- string_free(rs);
+ ssh_string_free(rs);
if (rc < 0) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
#elif defined HAVE_LIBCRYPTO
if (buffer_add_ssh_string(tmpbuf,sign->rsa_sign) < 0) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
#endif
break;
}
- str = string_new(buffer_get_len(tmpbuf));
+ str = ssh_string_new(ssh_buffer_get_len(tmpbuf));
if (str == NULL) {
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
- string_fill(str, buffer_get(tmpbuf), buffer_get_len(tmpbuf));
- buffer_free(tmpbuf);
+ ssh_string_fill(str, ssh_buffer_get_begin(tmpbuf), ssh_buffer_get_len(tmpbuf));
+ ssh_buffer_free(tmpbuf);
return str;
}
@@ -890,16 +890,16 @@ SIGNATURE *signature_from_string(ssh_session session, ssh_string signature,
return NULL;
}
- tmpbuf = buffer_new();
+ tmpbuf = ssh_buffer_new();
if (tmpbuf == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
signature_free(sign);
return NULL;
}
- if (buffer_add_data(tmpbuf, string_data(signature), string_len(signature)) < 0) {
+ if (buffer_add_data(tmpbuf, ssh_string_data(signature), ssh_string_len(signature)) < 0) {
signature_free(sign);
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
@@ -907,15 +907,15 @@ SIGNATURE *signature_from_string(ssh_session session, ssh_string signature,
if (type_s == NULL) {
ssh_set_error(session, SSH_FATAL, "Invalid signature packet");
signature_free(sign);
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
- type_c = string_to_char(type_s);
- string_free(type_s);
+ type_c = ssh_string_to_char(type_s);
+ ssh_string_free(type_s);
if (type_c == NULL) {
signature_free(sign);
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
type = ssh_type_from_name(type_c);
@@ -925,18 +925,18 @@ SIGNATURE *signature_from_string(ssh_session session, ssh_string signature,
ssh_set_error(session, SSH_FATAL, "Invalid signature type: %s",
ssh_type_to_char(type));
signature_free(sign);
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
return NULL;
}
switch(needed_type) {
case SSH_KEYTYPE_DSS:
rs = buffer_get_ssh_string(tmpbuf);
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
/* 40 is the dual signature blob len. */
- if (rs == NULL || string_len(rs) != 40) {
- string_free(rs);
+ if (rs == NULL || ssh_string_len(rs) != 40) {
+ ssh_string_free(rs);
signature_free(sign);
return NULL;
}
@@ -945,40 +945,40 @@ SIGNATURE *signature_from_string(ssh_session session, ssh_string signature,
* them to bignums (ou pas ;) */
#ifdef HAVE_LIBGCRYPT
if (gcry_sexp_build(&sig, NULL, "(sig-val(dsa(r %b)(s %b)))",
- 20 ,string_data(rs), 20,(unsigned char *)string_data(rs) + 20)) {
- string_free(rs);
+ 20 ,ssh_string_data(rs), 20,(unsigned char *)ssh_string_data(rs) + 20)) {
+ ssh_string_free(rs);
signature_free(sign);
return NULL;
}
#elif defined HAVE_LIBCRYPTO
- r = string_new(20);
- s = string_new(20);
+ r = ssh_string_new(20);
+ s = ssh_string_new(20);
if (r == NULL || s == NULL) {
- string_free(r);
- string_free(s);
- string_free(rs);
+ ssh_string_free(r);
+ ssh_string_free(s);
+ ssh_string_free(rs);
signature_free(sign);
return NULL;
}
- string_fill(r, string_data(rs), 20);
- string_fill(s, (char *)string_data(rs) + 20, 20);
+ ssh_string_fill(r, ssh_string_data(rs), 20);
+ ssh_string_fill(s, (char *)ssh_string_data(rs) + 20, 20);
sig = DSA_SIG_new();
if (sig == NULL) {
- string_free(r);
- string_free(s);
- string_free(rs);
+ ssh_string_free(r);
+ ssh_string_free(s);
+ ssh_string_free(rs);
signature_free(sign);
return NULL;
}
sig->r = make_string_bn(r); /* is that really portable ? Openssh's hack isn't better */
sig->s = make_string_bn(s);
- string_free(r);
- string_free(s);
+ ssh_string_free(r);
+ ssh_string_free(s);
if (sig->r == NULL || sig->s == NULL) {
- string_free(rs);
+ ssh_string_free(rs);
DSA_SIG_free(sig);
signature_free(sign);
return NULL;
@@ -986,10 +986,10 @@ SIGNATURE *signature_from_string(ssh_session session, ssh_string signature,
#endif
#ifdef DEBUG_CRYPTO
- ssh_print_hexa("r", string_data(rs), 20);
- ssh_print_hexa("s", (const unsigned char *)string_data(rs) + 20, 20);
+ ssh_print_hexa("r", ssh_string_data(rs), 20);
+ ssh_print_hexa("s", (const unsigned char *)ssh_string_data(rs) + 20, 20);
#endif
- string_free(rs);
+ ssh_string_free(rs);
sign->type = SSH_KEYTYPE_DSS;
sign->dsa_sign = sig;
@@ -997,19 +997,19 @@ SIGNATURE *signature_from_string(ssh_session session, ssh_string signature,
return sign;
case SSH_KEYTYPE_RSA:
e = buffer_get_ssh_string(tmpbuf);
- buffer_free(tmpbuf);
+ ssh_buffer_free(tmpbuf);
if (e == NULL) {
signature_free(sign);
return NULL;
}
- len = string_len(e);
+ len = ssh_string_len(e);
#ifdef HAVE_LIBGCRYPT
rsalen = (gcry_pk_get_nbits(pubkey->rsa_pub) + 7) / 8;
#elif defined HAVE_LIBCRYPTO
rsalen = RSA_size(pubkey->rsa_pub);
#endif
if (len > rsalen) {
- string_free(e);
+ ssh_string_free(e);
signature_free(sign);
ssh_set_error(session, SSH_FATAL, "Signature too big! %d instead of %d",
len, rsalen);
@@ -1023,9 +1023,9 @@ SIGNATURE *signature_from_string(ssh_session session, ssh_string signature,
sign->type = SSH_KEYTYPE_RSA;
#ifdef HAVE_LIBGCRYPT
if (gcry_sexp_build(&sig, NULL, "(sig-val(rsa(s %b)))",
- string_len(e), string_data(e))) {
+ ssh_string_len(e), ssh_string_data(e))) {
signature_free(sign);
- string_free(e);
+ ssh_string_free(e);
return NULL;
}
@@ -1036,11 +1036,11 @@ SIGNATURE *signature_from_string(ssh_session session, ssh_string signature,
#ifdef DEBUG_CRYPTO
ssh_log(session, SSH_LOG_FUNCTIONS, "len e: %d", len);
- ssh_print_hexa("RSA signature", string_data(e), len);
+ ssh_print_hexa("RSA signature", ssh_string_data(e), len);
#endif
#ifdef HAVE_LIBGCRYPT
- string_free(e);
+ ssh_string_free(e);
#endif
return sign;
@@ -1104,13 +1104,13 @@ static ssh_string RSA_do_sign(const unsigned char *payload, int len, RSA *privke
return NULL;
}
- sign = string_new(size);
+ sign = ssh_string_new(size);
if (sign == NULL) {
SAFE_FREE(buffer);
return NULL;
}
- string_fill(sign, buffer, size);
+ ssh_string_fill(sign, buffer, size);
SAFE_FREE(buffer);
return sign;
@@ -1132,35 +1132,35 @@ ssh_string ssh_do_sign_with_agent(ssh_session session,
}
/* prepend session identifier */
- session_id = string_new(SHA_DIGEST_LEN);
+ session_id = ssh_string_new(SHA_DIGEST_LEN);
if (session_id == NULL) {
return NULL;
}
- string_fill(session_id, crypto->session_id, SHA_DIGEST_LEN);
+ ssh_string_fill(session_id, crypto->session_id, SHA_DIGEST_LEN);
- sigbuf = buffer_new();
+ sigbuf = ssh_buffer_new();
if (sigbuf == NULL) {
- string_free(session_id);
+ ssh_string_free(session_id);
return NULL;
}
if (buffer_add_ssh_string(sigbuf, session_id) < 0) {
- buffer_free(sigbuf);
- string_free(session_id);
+ ssh_buffer_free(sigbuf);
+ ssh_string_free(session_id);
return NULL;
}
- string_free(session_id);
+ ssh_string_free(session_id);
/* append out buffer */
if (buffer_add_buffer(sigbuf, buf) < 0) {
- buffer_free(sigbuf);
+ ssh_buffer_free(sigbuf);
return NULL;
}
/* create signature */
signature = agent_sign_data(session, sigbuf, publickey);
- buffer_free(sigbuf);
+ ssh_buffer_free(sigbuf);
return signature;
}
@@ -1188,24 +1188,24 @@ ssh_buffer ssh_userauth_build_digest(ssh_session session, ssh_message msg, char
ssh_buffer buffer = NULL;
ssh_string session_id = NULL;
uint8_t type = SSH2_MSG_USERAUTH_REQUEST;
- ssh_string username = string_from_char(msg->auth_request.username);
- ssh_string servicename = string_from_char(service);
- ssh_string method = string_from_char("publickey");
+ ssh_string username = ssh_string_from_char(msg->auth_request.username);
+ ssh_string servicename = ssh_string_from_char(service);
+ ssh_string method = ssh_string_from_char("publickey");
uint8_t has_sign = 1;
- ssh_string algo = string_from_char(msg->auth_request.public_key->type_c);
+ ssh_string algo = ssh_string_from_char(msg->auth_request.public_key->type_c);
ssh_string publickey = publickey_to_string(msg->auth_request.public_key);
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
goto error;
}
- session_id = string_new(SHA_DIGEST_LEN);
+ session_id = ssh_string_new(SHA_DIGEST_LEN);
if (session_id == NULL) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
buffer = NULL;
goto error;
}
- string_fill(session_id, crypto->session_id, SHA_DIGEST_LEN);
+ ssh_string_fill(session_id, crypto->session_id, SHA_DIGEST_LEN);
if(buffer_add_ssh_string(buffer, session_id) < 0 ||
buffer_add_u8(buffer, type) < 0 ||
@@ -1215,18 +1215,18 @@ ssh_buffer ssh_userauth_build_digest(ssh_session session, ssh_message msg, char
buffer_add_u8(buffer, has_sign) < 0 ||
buffer_add_ssh_string(buffer, algo) < 0 ||
buffer_add_ssh_string(buffer, publickey) < 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
buffer = NULL;
goto error;
}
error:
- if(session_id) string_free(session_id);
- if(username) string_free(username);
- if(servicename) string_free(servicename);
- if(method) string_free(method);
- if(algo) string_free(algo);
- if(publickey) string_free(publickey);
+ if(session_id) ssh_string_free(session_id);
+ if(username) ssh_string_free(username);
+ if(servicename) ssh_string_free(servicename);
+ if(method) ssh_string_free(method);
+ if(algo) ssh_string_free(algo);
+ if(publickey) ssh_string_free(publickey);
return buffer;
}
@@ -1246,21 +1246,21 @@ ssh_string ssh_do_sign(ssh_session session, ssh_buffer sigbuf,
gcry_sexp_t gcryhash;
#endif
- session_str = string_new(SHA_DIGEST_LEN);
+ session_str = ssh_string_new(SHA_DIGEST_LEN);
if (session_str == NULL) {
return NULL;
}
- string_fill(session_str, crypto->session_id, SHA_DIGEST_LEN);
+ ssh_string_fill(session_str, crypto->session_id, SHA_DIGEST_LEN);
ctx = sha1_init();
if (ctx == NULL) {
- string_free(session_str);
+ ssh_string_free(session_str);
return NULL;
}
- sha1_update(ctx, session_str, string_len(session_str) + 4);
- string_free(session_str);
- sha1_update(ctx, buffer_get(sigbuf), buffer_get_len(sigbuf));
+ sha1_update(ctx, session_str, ssh_string_len(session_str) + 4);
+ ssh_string_free(session_str);
+ sha1_update(ctx, ssh_buffer_get_begin(sigbuf), ssh_buffer_get_len(sigbuf));
sha1_final(hash + 1,ctx);
hash[0] = 0;
@@ -1336,7 +1336,7 @@ ssh_string ssh_do_sign(ssh_session session, ssh_buffer sigbuf,
ssh_string ssh_encrypt_rsa1(ssh_session session, ssh_string data, ssh_public_key key) {
ssh_string str = NULL;
- size_t len = string_len(data);
+ size_t len = ssh_string_len(data);
size_t size = 0;
#ifdef HAVE_LIBGCRYPT
const char *tmp = NULL;
@@ -1344,7 +1344,7 @@ ssh_string ssh_encrypt_rsa1(ssh_session session, ssh_string data, ssh_public_key
gcry_sexp_t data_sexp;
if (gcry_sexp_build(&data_sexp, NULL, "(data(flags pkcs1)(value %b))",
- len, string_data(data))) {
+ len, ssh_string_data(data))) {
ssh_set_error(session, SSH_FATAL, "RSA1 encrypt: libgcrypt error");
return NULL;
}
@@ -1368,29 +1368,29 @@ ssh_string ssh_encrypt_rsa1(ssh_session session, ssh_string data, ssh_public_key
tmp++;
}
- str = string_new(size);
+ str = ssh_string_new(size);
if (str == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
gcry_sexp_release(data_sexp);
gcry_sexp_release(ret_sexp);
return NULL;
}
- string_fill(str, tmp, size);
+ ssh_string_fill(str, tmp, size);
gcry_sexp_release(data_sexp);
gcry_sexp_release(ret_sexp);
#elif defined HAVE_LIBCRYPTO
size = RSA_size(key->rsa_pub);
- str = string_new(size);
+ str = ssh_string_new(size);
if (str == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
return NULL;
}
- if (RSA_public_encrypt(len, string_data(data), string_data(str), key->rsa_pub,
+ if (RSA_public_encrypt(len, ssh_string_data(data), ssh_string_data(str), key->rsa_pub,
RSA_PKCS1_PADDING) < 0) {
- string_free(str);
+ ssh_string_free(str);
return NULL;
}
#endif
diff --git a/libssh/legacy.c b/libssh/legacy.c
new file mode 100644
index 00000000..5147d046
--- /dev/null
+++ b/libssh/legacy.c
@@ -0,0 +1,233 @@
+/*
+ * This file is part of the SSH Library
+ *
+ * Copyright (c) 2010 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.
+ */
+
+/** functions in that file are wrappers to the newly named functions. All
+ * of them are depreciated, but these wrapper will avoid breaking backward
+ * compatibility
+ */
+
+#include <libssh/libssh.h>
+#include <libssh/buffer.h>
+
+void buffer_free(ssh_buffer buffer){
+ ssh_buffer_free(buffer);
+}
+void *buffer_get(ssh_buffer buffer){
+ return ssh_buffer_get_begin(buffer);
+}
+uint32_t buffer_get_len(ssh_buffer buffer){
+ return ssh_buffer_get_len(buffer);
+}
+ssh_buffer buffer_new(void){
+ return ssh_buffer_new();
+}
+
+ssh_channel channel_accept_x11(ssh_channel channel, int timeout_ms){
+ return ssh_channel_accept_x11(channel, timeout_ms);
+}
+
+int channel_change_pty_size(ssh_channel channel,int cols,int rows){
+ return ssh_channel_change_pty_size(channel,cols,rows);
+}
+
+ssh_channel channel_forward_accept(ssh_session session, int timeout_ms){
+ return ssh_channel_forward_accept(session,timeout_ms);
+}
+
+int channel_close(ssh_channel channel){
+ return ssh_channel_close(channel);
+}
+
+int channel_forward_cancel(ssh_session session, const char *address, int port){
+ return ssh_channel_forward_cancel(session, address, port);
+}
+
+int channel_forward_listen(ssh_session session, const char *address,
+ int port, int *bound_port){
+ return ssh_channel_forward_listen(session, address, port, bound_port);
+}
+
+void channel_free(ssh_channel channel){
+ ssh_channel_free(channel);
+}
+
+int channel_get_exit_status(ssh_channel channel){
+ return ssh_channel_get_exit_status(channel);
+}
+
+ssh_session channel_get_session(ssh_channel channel){
+ return ssh_channel_get_session(channel);
+}
+
+int channel_is_closed(ssh_channel channel){
+ return ssh_channel_is_closed(channel);
+}
+
+int channel_is_eof(ssh_channel channel){
+ return ssh_channel_is_eof(channel);
+}
+
+int channel_is_open(ssh_channel channel){
+ return ssh_channel_is_open(channel);
+}
+
+ssh_channel channel_new(ssh_session session){
+ return ssh_channel_new(session);
+}
+
+int channel_open_forward(ssh_channel channel, const char *remotehost,
+ int remoteport, const char *sourcehost, int localport){
+ return ssh_channel_open_forward(channel, remotehost, remoteport,
+ sourcehost,localport);
+}
+
+int channel_open_session(ssh_channel channel){
+ return ssh_channel_open_session(channel);
+}
+
+int channel_poll(ssh_channel channel, int is_stderr){
+ return ssh_channel_poll(channel, is_stderr);
+}
+
+int channel_read(ssh_channel channel, void *dest, uint32_t count, int is_stderr){
+ return ssh_channel_read(channel, dest, count, is_stderr);
+}
+
+/*
+ * This function will completely be depreciated. The old implementation was not
+ * renamed.
+ * int channel_read_buffer(ssh_channel channel, ssh_buffer buffer, uint32_t count,
+ * int is_stderr);
+ */
+
+int channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count,
+ int is_stderr){
+ return ssh_channel_read_nonblocking(channel, dest, count, is_stderr);
+}
+
+int channel_request_env(ssh_channel channel, const char *name, const char *value){
+ return ssh_channel_request_env(channel, name, value);
+}
+
+int channel_request_exec(ssh_channel channel, const char *cmd){
+ return ssh_channel_request_exec(channel, cmd);
+}
+
+int channel_request_pty(ssh_channel channel){
+ return ssh_channel_request_pty(channel);
+}
+
+int channel_request_pty_size(ssh_channel channel, const char *term,
+ int cols, int rows){
+ return ssh_channel_request_pty_size(channel, term, cols, rows);
+}
+
+int channel_request_shell(ssh_channel channel){
+ return ssh_channel_request_shell(channel);
+}
+
+int channel_request_send_signal(ssh_channel channel, const char *signum){
+ return ssh_channel_request_send_signal(channel, signum);
+}
+
+int channel_request_sftp(ssh_channel channel){
+ return ssh_channel_request_sftp(channel);
+}
+
+int channel_request_subsystem(ssh_channel channel, const char *subsystem){
+ return ssh_channel_request_subsystem(channel, subsystem);
+}
+
+int channel_request_x11(ssh_channel channel, int single_connection, const char *protocol,
+ const char *cookie, int screen_number){
+ return ssh_channel_request_x11(channel, single_connection, protocol, cookie,
+ screen_number);
+}
+
+int channel_send_eof(ssh_channel channel){
+ return ssh_channel_send_eof(channel);
+}
+
+int channel_select(ssh_channel *readchans, ssh_channel *writechans, ssh_channel *exceptchans, struct
+ timeval * timeout){
+ return ssh_channel_select(readchans, writechans, exceptchans, timeout);
+}
+
+void channel_set_blocking(ssh_channel channel, int blocking){
+ ssh_channel_set_blocking(channel, blocking);
+}
+
+int channel_write(ssh_channel channel, const void *data, uint32_t len){
+ return ssh_channel_write(channel, data, len);
+}
+
+/*
+ * These functions have to be wrapped around the pki.c functions.
+
+void privatekey_free(ssh_private_key prv);
+ssh_private_key privatekey_from_file(ssh_session session, const char *filename,
+ int type, const char *passphrase);
+void publickey_free(ssh_public_key key);
+int ssh_publickey_to_file(ssh_session session, const char *file,
+ ssh_string pubkey, int type);
+ssh_string publickey_from_file(ssh_session session, const char *filename,
+ int *type);
+ssh_public_key publickey_from_privatekey(ssh_private_key prv);
+ssh_string publickey_to_string(ssh_public_key key);
+ *
+ */
+
+void string_burn(ssh_string str){
+ ssh_string_burn(str);
+}
+
+ssh_string string_copy(ssh_string str){
+ return ssh_string_copy(str);
+}
+
+void *string_data(ssh_string str){
+ return ssh_string_data(str);
+}
+
+int string_fill(ssh_string str, const void *data, size_t len){
+ return ssh_string_fill(str,data,len);
+}
+
+void string_free(ssh_string str){
+ ssh_string_free(str);
+}
+
+ssh_string string_from_char(const char *what){
+ return ssh_string_from_char(what);
+}
+
+size_t string_len(ssh_string str){
+ return ssh_string_len(str);
+}
+
+ssh_string string_new(size_t size){
+ return ssh_string_new(size);
+}
+
+char *string_to_char(ssh_string str){
+ return ssh_string_to_char(str);
+}
+
diff --git a/libssh/messages.c b/libssh/messages.c
index 99ec103e..0964c9dc 100644
--- a/libssh/messages.c
+++ b/libssh/messages.c
@@ -78,7 +78,7 @@ SSH_PACKET_CALLBACK(ssh_packet_service_request){
goto error;
}
- service_c = string_to_char(service);
+ service_c = ssh_string_to_char(service);
if (service_c == NULL) {
goto error;
}
@@ -92,7 +92,7 @@ SSH_PACKET_CALLBACK(ssh_packet_service_request){
msg->type=SSH_REQUEST_SERVICE;
msg->service_request.service=service_c;
error:
- string_free(service);
+ ssh_string_free(service);
if(msg != NULL)
ssh_message_queue(session,msg);
leave_function();
@@ -138,26 +138,26 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
}
msg->type = SSH_REQUEST_AUTH;
- msg->auth_request.username = string_to_char(user_s);
+ msg->auth_request.username = ssh_string_to_char(user_s);
if (msg->auth_request.username == NULL) {
goto error;
}
- string_free(user_s);
+ ssh_string_free(user_s);
user_s = NULL;
- service_c = string_to_char(service);
+ service_c = ssh_string_to_char(service);
if (service_c == NULL) {
goto error;
}
- method_c = string_to_char(method);
+ method_c = ssh_string_to_char(method);
if (method_c == NULL) {
goto error;
}
- method_size = string_len(method);
+ method_size = ssh_string_len(method);
- string_free(service);
+ ssh_string_free(service);
service = NULL;
- string_free(method);
+ ssh_string_free(method);
method = NULL;
ssh_log(session, SSH_LOG_PACKET,
@@ -185,9 +185,9 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
if (pass == NULL) {
goto error;
}
- msg->auth_request.password = string_to_char(pass);
- string_burn(pass);
- string_free(pass);
+ msg->auth_request.password = ssh_string_to_char(pass);
+ ssh_string_burn(pass);
+ ssh_string_free(pass);
pass = NULL;
if (msg->auth_request.password == NULL) {
goto error;
@@ -209,14 +209,14 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
}
publickey = buffer_get_ssh_string(packet);
if (publickey == NULL) {
- string_free(algo);
+ ssh_string_free(algo);
algo = NULL;
goto error;
}
msg->auth_request.public_key = publickey_from_string(session, publickey);
- string_free(algo);
+ ssh_string_free(algo);
algo = NULL;
- string_free(publickey);
+ ssh_string_free(publickey);
publickey = NULL;
if (msg->auth_request.public_key == NULL) {
goto error;
@@ -241,12 +241,12 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
if ((digest == NULL || signature == NULL) ||
(digest != NULL && signature != NULL &&
sig_verify(session, public_key, signature,
- buffer_get(digest), buffer_get_len(digest)) < 0)) {
+ ssh_buffer_get_begin(digest), ssh_buffer_get_len(digest)) < 0)) {
ssh_log(session, SSH_LOG_PACKET, "Wrong signature from peer");
- string_free(sign);
+ ssh_string_free(sign);
sign = NULL;
- buffer_free(digest);
+ ssh_buffer_free(digest);
digest = NULL;
signature_free(signature);
signature = NULL;
@@ -257,9 +257,9 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
else
ssh_log(session, SSH_LOG_PACKET, "Valid signature received");
- buffer_free(digest);
+ ssh_buffer_free(digest);
digest = NULL;
- string_free(sign);
+ ssh_string_free(sign);
sign = NULL;
signature_free(signature);
signature = NULL;
@@ -274,9 +274,9 @@ SSH_PACKET_CALLBACK(ssh_packet_userauth_request){
SAFE_FREE(method_c);
goto end;
error:
- string_free(user_s);
- string_free(service);
- string_free(method);
+ ssh_string_free(user_s);
+ ssh_string_free(service);
+ ssh_string_free(method);
SAFE_FREE(method_c);
SAFE_FREE(service_c);
@@ -313,7 +313,7 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open){
ssh_set_error_oom(session);
goto error;
}
- type_c = string_to_char(type_s);
+ type_c = ssh_string_to_char(type_s);
if (type_c == NULL) {
ssh_set_error_oom(session);
goto error;
@@ -321,7 +321,7 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open){
ssh_log(session, SSH_LOG_PACKET,
"Clients wants to open a %s channel", type_c);
- string_free(type_s);
+ ssh_string_free(type_s);
type_s=NULL;
buffer_get_u32(packet, &sender);
@@ -344,13 +344,13 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open){
ssh_set_error_oom(session);
goto error;
}
- msg->channel_request_open.destination = string_to_char(type_s);
+ msg->channel_request_open.destination = ssh_string_to_char(type_s);
if (msg->channel_request_open.destination == NULL) {
ssh_set_error_oom(session);
- string_free(destination);
+ ssh_string_free(destination);
goto error;
}
- string_free(destination);
+ ssh_string_free(destination);
buffer_get_u32(packet, &destination_port);
msg->channel_request_open.destination_port = ntohl(destination_port);
@@ -360,13 +360,13 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open){
ssh_set_error_oom(session);
goto error;
}
- msg->channel_request_open.originator = string_to_char(type_s);
+ msg->channel_request_open.originator = ssh_string_to_char(type_s);
if (msg->channel_request_open.originator == NULL) {
ssh_set_error_oom(session);
- string_free(originator);
+ ssh_string_free(originator);
goto error;
}
- string_free(originator);
+ ssh_string_free(originator);
buffer_get_u32(packet, &originator_port);
msg->channel_request_open.originator_port = ntohl(originator_port);
@@ -381,13 +381,13 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open){
ssh_set_error_oom(session);
goto error;
}
- msg->channel_request_open.destination = string_to_char(type_s);
+ msg->channel_request_open.destination = ssh_string_to_char(type_s);
if (msg->channel_request_open.destination == NULL) {
ssh_set_error_oom(session);
- string_free(destination);
+ ssh_string_free(destination);
goto error;
}
- string_free(destination);
+ ssh_string_free(destination);
buffer_get_u32(packet, &destination_port);
msg->channel_request_open.destination_port = ntohl(destination_port);
@@ -397,13 +397,13 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open){
ssh_set_error_oom(session);
goto error;
}
- msg->channel_request_open.originator = string_to_char(type_s);
+ msg->channel_request_open.originator = ssh_string_to_char(type_s);
if (msg->channel_request_open.originator == NULL) {
ssh_set_error_oom(session);
- string_free(originator);
+ ssh_string_free(originator);
goto error;
}
- string_free(originator);
+ ssh_string_free(originator);
buffer_get_u32(packet, &originator_port);
msg->channel_request_open.originator_port = ntohl(originator_port);
@@ -418,13 +418,13 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open){
ssh_set_error_oom(session);
goto error;
}
- msg->channel_request_open.originator = string_to_char(type_s);
+ msg->channel_request_open.originator = ssh_string_to_char(type_s);
if (msg->channel_request_open.originator == NULL) {
ssh_set_error_oom(session);
- string_free(originator);
+ ssh_string_free(originator);
goto error;
}
- string_free(originator);
+ ssh_string_free(originator);
buffer_get_u32(packet, &originator_port);
msg->channel_request_open.originator_port = ntohl(originator_port);
@@ -441,7 +441,7 @@ error:
msg=NULL;
end:
if(type_s != NULL)
- string_free(type_s);
+ ssh_string_free(type_s);
SAFE_FREE(type_c);
if(msg != NULL)
ssh_message_queue(session,msg);
@@ -461,7 +461,7 @@ ssh_channel ssh_message_channel_request_open_reply_accept(ssh_message msg) {
return NULL;
}
- chan = channel_new(session);
+ chan = ssh_channel_new(session);
if (chan == NULL) {
leave_function();
return NULL;
@@ -501,7 +501,7 @@ ssh_channel ssh_message_channel_request_open_reply_accept(ssh_message msg) {
leave_function();
return chan;
error:
- channel_free(chan);
+ ssh_channel_free(chan);
leave_function();
return NULL;
@@ -552,13 +552,13 @@ int ssh_message_handle_channel_request(ssh_session session, ssh_channel channel,
ssh_set_error_oom(session);
goto error;
}
- term_c = string_to_char(term);
+ term_c = ssh_string_to_char(term);
if (term_c == NULL) {
ssh_set_error_oom(session);
- string_free(term);
+ ssh_string_free(term);
goto error;
}
- string_free(term);
+ ssh_string_free(term);
msg->channel_request.type = SSH_CHANNEL_REQUEST_PTY;
msg->channel_request.TERM = term_c;
@@ -604,13 +604,13 @@ int ssh_message_handle_channel_request(ssh_session session, ssh_channel channel,
ssh_set_error_oom(session);
goto error;
}
- subsys_c = string_to_char(subsys);
+ subsys_c = ssh_string_to_char(subsys);
if (subsys_c == NULL) {
ssh_set_error_oom(session);
- string_free(subsys);
+ ssh_string_free(subsys);
goto error;
}
- string_free(subsys);
+ ssh_string_free(subsys);
msg->channel_request.type = SSH_CHANNEL_REQUEST_SUBSYSTEM;
msg->channel_request.subsystem = subsys_c;
@@ -631,8 +631,8 @@ int ssh_message_handle_channel_request(ssh_session session, ssh_channel channel,
goto error;
}
msg->channel_request.type = SSH_CHANNEL_REQUEST_EXEC;
- msg->channel_request.command = string_to_char(cmd);
- string_free(cmd);
+ msg->channel_request.command = ssh_string_to_char(cmd);
+ ssh_string_free(cmd);
if (msg->channel_request.command == NULL) {
goto error;
}
@@ -650,21 +650,21 @@ int ssh_message_handle_channel_request(ssh_session session, ssh_channel channel,
value = buffer_get_ssh_string(packet);
if (value == NULL) {
ssh_set_error_oom(session);
- string_free(name);
+ ssh_string_free(name);
goto error;
}
msg->channel_request.type = SSH_CHANNEL_REQUEST_ENV;
- msg->channel_request.var_name = string_to_char(name);
- msg->channel_request.var_value = string_to_char(value);
+ msg->channel_request.var_name = ssh_string_to_char(name);
+ msg->channel_request.var_value = ssh_string_to_char(value);
if (msg->channel_request.var_name == NULL ||
msg->channel_request.var_value == NULL) {
- string_free(name);
- string_free(value);
+ ssh_string_free(name);
+ ssh_string_free(value);
goto error;
}
- string_free(name);
- string_free(value);
+ ssh_string_free(name);
+ ssh_string_free(value);
goto end;
}
diff --git a/libssh/packet.c b/libssh/packet.c
index f0f7b919..b0ae1458 100644
--- a/libssh/packet.c
+++ b/libssh/packet.c
@@ -147,7 +147,7 @@ int ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user)
goto error;
}
} else {
- session->in_buffer = buffer_new();
+ session->in_buffer = ssh_buffer_new();
if (session->in_buffer == NULL) {
goto error;
}
@@ -206,8 +206,8 @@ int ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user)
* have been decrypted)
*/
if (packet_decrypt(session,
- ((uint8_t*)buffer_get(session->in_buffer) + blocksize),
- buffer_get_len(session->in_buffer) - blocksize) < 0) {
+ ((uint8_t*)ssh_buffer_get_begin(session->in_buffer) + blocksize),
+ ssh_buffer_get_len(session->in_buffer) - blocksize) < 0) {
ssh_set_error(session, SSH_FATAL, "Decrypt error");
goto error;
}
@@ -240,8 +240,8 @@ int ssh_packet_socket_callback(const void *data, size_t receivedlen, void *user)
buffer_get_rest_len(session->in_buffer));
#ifdef DEBUG_CRYPTO
ssh_print_hexa("incrimined packet",
- buffer_get(session->in_buffer),
- buffer_get_len(session->in_buffer));
+ ssh_buffer_get_begin(session->in_buffer),
+ ssh_buffer_get_len(session->in_buffer));
#endif
goto error;
}
@@ -413,8 +413,8 @@ static int ssh_packet_write(ssh_session session) {
enter_function();
ssh_socket_write(session->socket,
- buffer_get(session->out_buffer),
- buffer_get_len(session->out_buffer));
+ ssh_buffer_get_begin(session->out_buffer),
+ ssh_buffer_get_len(session->out_buffer));
rc = packet_flush(session, 0);
@@ -425,7 +425,7 @@ static int ssh_packet_write(ssh_session session) {
static int packet_send2(ssh_session session) {
unsigned int blocksize = (session->current_crypto ?
session->current_crypto->out_cipher->blocksize : 8);
- uint32_t currentlen = buffer_get_len(session->out_buffer);
+ uint32_t currentlen = ssh_buffer_get_len(session->out_buffer);
unsigned char *hmac = NULL;
char padstring[32] = {0};
int rc = SSH_ERROR;
@@ -443,7 +443,7 @@ static int packet_send2(ssh_session session) {
if (compress_buffer(session,session->out_buffer) < 0) {
goto error;
}
- currentlen = buffer_get_len(session->out_buffer);
+ currentlen = ssh_buffer_get_len(session->out_buffer);
}
#endif
padding = (blocksize - ((currentlen +5) % blocksize));
@@ -474,12 +474,12 @@ static int packet_send2(ssh_session session) {
#ifdef WITH_PCAP
if(session->pcap_ctx){
ssh_pcap_context_write(session->pcap_ctx,SSH_PCAP_DIR_OUT,
- buffer_get(session->out_buffer),buffer_get_len(session->out_buffer)
- ,buffer_get_len(session->out_buffer));
+ ssh_buffer_get_begin(session->out_buffer),ssh_buffer_get_len(session->out_buffer)
+ ,ssh_buffer_get_len(session->out_buffer));
}
#endif
- hmac = packet_encrypt(session, buffer_get(session->out_buffer),
- buffer_get_len(session->out_buffer));
+ hmac = packet_encrypt(session, ssh_buffer_get_begin(session->out_buffer),
+ ssh_buffer_get_len(session->out_buffer));
if (hmac) {
if (buffer_add_data(session->out_buffer, hmac, 20) < 0) {
goto error;
diff --git a/libssh/packet1.c b/libssh/packet1.c
index 7a68c121..67aae4a9 100644
--- a/libssh/packet1.c
+++ b/libssh/packet1.c
@@ -110,7 +110,7 @@ int ssh_packet_socket_callback1(const void *data, size_t receivedlen, void *user
goto error;
}
} else {
- session->in_buffer = buffer_new();
+ session->in_buffer = ssh_buffer_new();
if (session->in_buffer == NULL) {
goto error;
}
@@ -156,8 +156,8 @@ int ssh_packet_socket_callback1(const void *data, size_t receivedlen, void *user
}
processed += to_be_read;
#ifdef DEBUG_CRYPTO
- ssh_print_hexa("read packet:", buffer_get(session->in_buffer),
- buffer_get_len(session->in_buffer));
+ ssh_print_hexa("read packet:", ssh_buffer_get_begin(session->in_buffer),
+ ssh_buffer_get_len(session->in_buffer));
#endif
if (session->current_crypto) {
/*
@@ -165,15 +165,15 @@ int ssh_packet_socket_callback1(const void *data, size_t receivedlen, void *user
* previously read, unencrypted, and is not part of the buffer
*/
if (packet_decrypt(session,
- buffer_get(session->in_buffer),
- buffer_get_len(session->in_buffer)) < 0) {
+ ssh_buffer_get_begin(session->in_buffer),
+ ssh_buffer_get_len(session->in_buffer)) < 0) {
ssh_set_error(session, SSH_FATAL, "Packet decrypt error");
goto error;
}
}
#ifdef DEBUG_CRYPTO
- ssh_print_hexa("read packet decrypted:", buffer_get(session->in_buffer),
- buffer_get_len(session->in_buffer));
+ ssh_print_hexa("read packet decrypted:", ssh_buffer_get_begin(session->in_buffer),
+ ssh_buffer_get_len(session->in_buffer));
#endif
ssh_log(session, SSH_LOG_PACKET, "%d bytes padding", padding);
if(((len + padding) != buffer_get_rest_len(session->in_buffer)) ||
@@ -245,7 +245,7 @@ error:
int packet_send1(ssh_session session) {
unsigned int blocksize = (session->current_crypto ?
session->current_crypto->out_cipher->blocksize : 8);
- uint32_t currentlen = buffer_get_len(session->out_buffer) + sizeof(uint32_t);
+ uint32_t currentlen = ssh_buffer_get_len(session->out_buffer) + sizeof(uint32_t);
char padstring[32] = {0};
int rc = SSH_ERROR;
uint32_t finallen;
@@ -284,27 +284,27 @@ int packet_send1(ssh_session session) {
goto error;
}
- crc = ssh_crc32((char *)buffer_get(session->out_buffer) + sizeof(uint32_t),
- buffer_get_len(session->out_buffer) - sizeof(uint32_t));
+ crc = ssh_crc32((char *)ssh_buffer_get_begin(session->out_buffer) + sizeof(uint32_t),
+ ssh_buffer_get_len(session->out_buffer) - sizeof(uint32_t));
if (buffer_add_u32(session->out_buffer, ntohl(crc)) < 0) {
goto error;
}
#ifdef DEBUG_CRYPTO
- ssh_print_hexa("Clear packet", buffer_get(session->out_buffer),
- buffer_get_len(session->out_buffer));
+ ssh_print_hexa("Clear packet", ssh_buffer_get_begin(session->out_buffer),
+ ssh_buffer_get_len(session->out_buffer));
#endif
- packet_encrypt(session, (unsigned char *)buffer_get(session->out_buffer) + sizeof(uint32_t),
- buffer_get_len(session->out_buffer) - sizeof(uint32_t));
+ packet_encrypt(session, (unsigned char *)ssh_buffer_get_begin(session->out_buffer) + sizeof(uint32_t),
+ ssh_buffer_get_len(session->out_buffer) - sizeof(uint32_t));
#ifdef DEBUG_CRYPTO
- ssh_print_hexa("encrypted packet",buffer_get(session->out_buffer),
- buffer_get_len(session->out_buffer));
+ ssh_print_hexa("encrypted packet",ssh_buffer_get_begin(session->out_buffer),
+ ssh_buffer_get_len(session->out_buffer));
#endif
- if (ssh_socket_write(session->socket, buffer_get(session->out_buffer),
- buffer_get_len(session->out_buffer)) == SSH_ERROR) {
+ if (ssh_socket_write(session->socket, ssh_buffer_get_begin(session->out_buffer),
+ ssh_buffer_get_len(session->out_buffer)) == SSH_ERROR) {
goto error;
}
diff --git a/libssh/pcap.c b/libssh/pcap.c
index 6020506c..4781f5aa 100644
--- a/libssh/pcap.c
+++ b/libssh/pcap.c
@@ -133,8 +133,8 @@ static int ssh_pcap_file_write(ssh_pcap_file pcap, ssh_buffer packet){
uint32_t len;
if(pcap == NULL || pcap->output==NULL)
return SSH_ERROR;
- len=buffer_get_len(packet);
- err=fwrite(buffer_get(packet),len,1,pcap->output);
+ len=ssh_buffer_get_len(packet);
+ err=fwrite(ssh_buffer_get_begin(packet),len,1,pcap->output);
if(err<0)
return SSH_ERROR;
else
@@ -146,7 +146,7 @@ static int ssh_pcap_file_write(ssh_pcap_file pcap, ssh_buffer packet){
* on file
*/
int ssh_pcap_file_write_packet(ssh_pcap_file pcap, ssh_buffer packet, uint32_t original_len){
- ssh_buffer header=buffer_new();
+ ssh_buffer header=ssh_buffer_new();
struct timeval now;
int err;
if(header == NULL)
@@ -154,11 +154,11 @@ int ssh_pcap_file_write_packet(ssh_pcap_file pcap, ssh_buffer packet, uint32_t o
gettimeofday(&now,NULL);
buffer_add_u32(header,htonl(now.tv_sec));
buffer_add_u32(header,htonl(now.tv_usec));
- buffer_add_u32(header,htonl(buffer_get_len(packet)));
+ buffer_add_u32(header,htonl(ssh_buffer_get_len(packet)));
buffer_add_u32(header,htonl(original_len));
buffer_add_buffer(header,packet);
err=ssh_pcap_file_write(pcap,header);
- buffer_free(header);
+ ssh_buffer_free(header);
return err;
}
@@ -177,7 +177,7 @@ int ssh_pcap_file_open(ssh_pcap_file pcap, const char *filename){
pcap->output=fopen(filename,"wb");
if(pcap->output==NULL)
return SSH_ERROR;
- header=buffer_new();
+ header=ssh_buffer_new();
if(header==NULL)
return SSH_ERROR;
buffer_add_u32(header,htonl(PCAP_MAGIC));
@@ -192,7 +192,7 @@ int ssh_pcap_file_open(ssh_pcap_file pcap, const char *filename){
/* we will write sort-of IP */
buffer_add_u32(header,htonl(DLT_RAW));
err=ssh_pcap_file_write(pcap,header);
- buffer_free(header);
+ ssh_buffer_free(header);
return err;
}
@@ -299,7 +299,7 @@ int ssh_pcap_context_write(ssh_pcap_context ctx,enum ssh_pcap_direction directio
if(ctx->connected==0)
if(ssh_pcap_context_connect(ctx)==SSH_ERROR)
return SSH_ERROR;
- ip=buffer_new();
+ ip=ssh_buffer_new();
if(ip==NULL){
ssh_set_error_oom(ctx->session);
return SSH_ERROR;
@@ -364,7 +364,7 @@ int ssh_pcap_context_write(ssh_pcap_context ctx,enum ssh_pcap_direction directio
/* actual data */
buffer_add_data(ip,data,len);
err=ssh_pcap_file_write_packet(ctx->file,ip,origlen + TCPIPHDR_LEN);
- buffer_free(ip);
+ ssh_buffer_free(ip);
return err;
}
diff --git a/libssh/scp.c b/libssh/scp.c
index 9590e2d2..4a6f6f14 100644
--- a/libssh/scp.c
+++ b/libssh/scp.c
@@ -90,12 +90,12 @@ int ssh_scp_init(ssh_scp scp){
scp->mode==SSH_SCP_WRITE?"write":"read",
scp->recursive?"recursive ":"",
scp->location);
- scp->channel=channel_new(scp->session);
+ scp->channel=ssh_channel_new(scp->session);
if(scp->channel == NULL){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
- r= channel_open_session(scp->channel);
+ r= ssh_channel_open_session(scp->channel);
if(r==SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
@@ -106,12 +106,12 @@ int ssh_scp_init(ssh_scp scp){
else
snprintf(execbuffer,sizeof(execbuffer),"scp -f %s %s",
scp->recursive ? "-r":"", scp->location);
- if(channel_request_exec(scp->channel,execbuffer) == SSH_ERROR){
+ if(ssh_channel_request_exec(scp->channel,execbuffer) == SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
if(scp->mode == SSH_SCP_WRITE){
- r=channel_read(scp->channel,&code,1,0);
+ r=ssh_channel_read(scp->channel,&code,1,0);
if(r<=0){
ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session));
scp->state=SSH_SCP_ERROR;
@@ -123,7 +123,7 @@ int ssh_scp_init(ssh_scp scp){
return SSH_ERROR;
}
} else {
- channel_write(scp->channel,"",1);
+ ssh_channel_write(scp->channel,"",1);
}
if(scp->mode == SSH_SCP_WRITE)
scp->state=SSH_SCP_WRITE_INITED;
@@ -138,7 +138,7 @@ int ssh_scp_close(ssh_scp scp){
if(scp==NULL)
return SSH_ERROR;
if(scp->channel != NULL){
- if(channel_send_eof(scp->channel) == SSH_ERROR){
+ if(ssh_channel_send_eof(scp->channel) == SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
@@ -146,16 +146,16 @@ int ssh_scp_close(ssh_scp scp){
* not yet stored on disk. This can happen if the close is sent
* before we got the EOF back
*/
- while(!channel_is_eof(scp->channel)){
- err=channel_read(scp->channel,buffer,sizeof(buffer),0);
+ while(!ssh_channel_is_eof(scp->channel)){
+ err=ssh_channel_read(scp->channel,buffer,sizeof(buffer),0);
if(err==SSH_ERROR)
break;
}
- if(channel_close(scp->channel) == SSH_ERROR){
+ if(ssh_channel_close(scp->channel) == SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
- channel_free(scp->channel);
+ ssh_channel_free(scp->channel);
scp->channel=NULL;
}
scp->state=SSH_SCP_NEW;
@@ -168,7 +168,7 @@ void ssh_scp_free(ssh_scp scp){
if(scp->state != SSH_SCP_NEW)
ssh_scp_close(scp);
if(scp->channel)
- channel_free(scp->channel);
+ ssh_channel_free(scp->channel);
SAFE_FREE(scp->location);
SAFE_FREE(scp->request_name);
SAFE_FREE(scp->warning);
@@ -206,12 +206,12 @@ int ssh_scp_push_directory(ssh_scp scp, const char *dirname, int mode){
snprintf(buffer, sizeof(buffer), "D%s 0 %s\n", perms, dir);
SAFE_FREE(dir);
SAFE_FREE(perms);
- r=channel_write(scp->channel,buffer,strlen(buffer));
+ r=ssh_channel_write(scp->channel,buffer,strlen(buffer));
if(r==SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
- r=channel_read(scp->channel,&code,1,0);
+ r=ssh_channel_read(scp->channel,&code,1,0);
if(r<=0){
ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session));
scp->state=SSH_SCP_ERROR;
@@ -243,12 +243,12 @@ int ssh_scp_push_directory(ssh_scp scp, const char *dirname, int mode){
ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_leave_directory called under invalid state");
return SSH_ERROR;
}
- r=channel_write(scp->channel,buffer,strlen(buffer));
+ r=ssh_channel_write(scp->channel,buffer,strlen(buffer));
if(r==SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
- r=channel_read(scp->channel,&code,1,0);
+ r=ssh_channel_read(scp->channel,&code,1,0);
if(r<=0){
ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session));
scp->state=SSH_SCP_ERROR;
@@ -295,12 +295,12 @@ int ssh_scp_push_file(ssh_scp scp, const char *filename, size_t size, int mode){
snprintf(buffer, sizeof(buffer), "C%s %" PRIdS " %s\n", perms, size, file);
SAFE_FREE(file);
SAFE_FREE(perms);
- r=channel_write(scp->channel,buffer,strlen(buffer));
+ r=ssh_channel_write(scp->channel,buffer,strlen(buffer));
if(r==SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
- r=channel_read(scp->channel,&code,1,0);
+ r=ssh_channel_read(scp->channel,&code,1,0);
if(r<=0){
ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session));
scp->state=SSH_SCP_ERROR;
@@ -335,7 +335,7 @@ int ssh_scp_response(ssh_scp scp, char **response){
char msg[128];
if(scp==NULL)
return SSH_ERROR;
- r=channel_read(scp->channel,&code,1,0);
+ r=ssh_channel_read(scp->channel,&code,1,0);
if(r == SSH_ERROR)
return SSH_ERROR;
if(code == 0)
@@ -391,8 +391,8 @@ int ssh_scp_write(ssh_scp scp, const void *buffer, size_t len){
if(scp->processed + len > scp->filelen)
len = scp->filelen - scp->processed;
/* hack to avoid waiting for window change */
- channel_poll(scp->channel,0);
- w=channel_write(scp->channel,buffer,len);
+ ssh_channel_poll(scp->channel,0);
+ w=ssh_channel_write(scp->channel,buffer,len);
if(w != SSH_ERROR)
scp->processed += w;
else {
@@ -439,7 +439,7 @@ int ssh_scp_read_string(ssh_scp scp, char *buffer, size_t len){
if(scp==NULL)
return SSH_ERROR;
while(r<len-1){
- err=channel_read(scp->channel,&buffer[r],1,0);
+ err=ssh_channel_read(scp->channel,&buffer[r],1,0);
if(err==SSH_ERROR){
break;
}
@@ -487,7 +487,7 @@ int ssh_scp_pull_request(ssh_scp scp){
}
err=ssh_scp_read_string(scp,buffer,sizeof(buffer));
if(err==SSH_ERROR){
- if(channel_is_eof(scp->channel)){
+ if(ssh_channel_is_eof(scp->channel)){
scp->state=SSH_SCP_TERMINATED;
return SSH_SCP_REQUEST_EOF;
}
@@ -532,7 +532,7 @@ int ssh_scp_pull_request(ssh_scp scp){
break;
case 'E':
scp->request_type=SSH_SCP_REQUEST_ENDDIR;
- channel_write(scp->channel,"",1);
+ ssh_channel_write(scp->channel,"",1);
return scp->request_type;
case 0x1:
ssh_set_error(scp->session,SSH_REQUEST_DENIED,"SCP: Warning: %s",&buffer[1]);
@@ -579,7 +579,7 @@ int ssh_scp_deny_request(ssh_scp scp, const char *reason){
return SSH_ERROR;
}
snprintf(buffer,sizeof(buffer),"%c%s\n",2,reason);
- err=channel_write(scp->channel,buffer,strlen(buffer));
+ err=ssh_channel_write(scp->channel,buffer,strlen(buffer));
if(err==SSH_ERROR) {
return SSH_ERROR;
}
@@ -607,7 +607,7 @@ int ssh_scp_accept_request(ssh_scp scp){
ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_deny_request called under invalid state");
return SSH_ERROR;
}
- err=channel_write(scp->channel,buffer,1);
+ err=ssh_channel_write(scp->channel,buffer,1);
if(err==SSH_ERROR) {
return SSH_ERROR;
}
@@ -646,7 +646,7 @@ int ssh_scp_read(ssh_scp scp, void *buffer, size_t size){
size = scp->filelen - scp->processed;
if(size > 65536)
size=65536; /* avoid too large reads */
- r=channel_read(scp->channel,buffer,size,0);
+ r=ssh_channel_read(scp->channel,buffer,size,0);
if(r != SSH_ERROR)
scp->processed += r;
else {
@@ -656,7 +656,7 @@ int ssh_scp_read(ssh_scp scp, void *buffer, size_t size){
/* Check if we arrived at end of file */
if(scp->processed == scp->filelen) {
scp->processed=scp->filelen=0;
- channel_write(scp->channel,"",1);
+ ssh_channel_write(scp->channel,"",1);
code=ssh_scp_response(scp,NULL);
if(code == 0){
scp->state=SSH_SCP_READ_INITED;
diff --git a/libssh/server.c b/libssh/server.c
index 17ecd6e7..3fe19d20 100644
--- a/libssh/server.c
+++ b/libssh/server.c
@@ -375,7 +375,7 @@ SSH_PACKET_CALLBACK(ssh_packet_kexdh_init){
} else {
session->dh_handshake_state=DH_STATE_INIT_SENT;
}
- string_free(e);
+ ssh_string_free(e);
error:
leave_function();
@@ -424,34 +424,34 @@ static int dh_handshake_server(ssh_session session) {
if (pub == NULL) {
ssh_set_error(session, SSH_FATAL,
"Could not get the public key from the private key");
- string_free(f);
+ ssh_string_free(f);
return -1;
}
pubkey = publickey_to_string(pub);
publickey_free(pub);
if (pubkey == NULL) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
- string_free(f);
+ ssh_string_free(f);
return -1;
}
dh_import_pubkey(session, pubkey);
if (dh_build_k(session) < 0) {
ssh_set_error(session, SSH_FATAL, "Could not import the public key");
- string_free(f);
+ ssh_string_free(f);
return -1;
}
if (make_sessionid(session) != SSH_OK) {
ssh_set_error(session, SSH_FATAL, "Could not create a session id");
- string_free(f);
+ ssh_string_free(f);
return -1;
}
sign = ssh_sign_session_id(session, prv);
if (sign == NULL) {
ssh_set_error(session, SSH_FATAL, "Could not sign the session id");
- string_free(f);
+ ssh_string_free(f);
return -1;
}
@@ -471,12 +471,12 @@ static int dh_handshake_server(ssh_session session) {
buffer_add_ssh_string(session->out_buffer, sign) < 0) {
ssh_set_error(session, SSH_FATAL, "Not enough space");
buffer_reinit(session->out_buffer);
- string_free(f);
- string_free(sign);
+ ssh_string_free(f);
+ ssh_string_free(sign);
return -1;
}
- string_free(f);
- string_free(sign);
+ ssh_string_free(f);
+ ssh_string_free(sign);
session->dh_handshake_state=DH_STATE_NEWKEYS_SENT;
if (packet_send(session) != SSH_OK) {
return -1;
@@ -615,7 +615,7 @@ static int ssh_message_auth_reply_default(ssh_message msg,int partial) {
ssh_log(session, SSH_LOG_PACKET,
"Sending a auth failure. methods that can continue: %s", methods_c);
- methods = string_from_char(methods_c);
+ methods = ssh_string_from_char(methods_c);
if (methods == NULL) {
goto error;
}
@@ -636,7 +636,7 @@ static int ssh_message_auth_reply_default(ssh_message msg,int partial) {
rc = packet_send(msg->session);
error:
- string_free(methods);
+ ssh_string_free(methods);
leave_function();
return rc;
@@ -712,12 +712,12 @@ int ssh_message_service_reply_success(ssh_message msg) {
if (buffer_add_u8(session->out_buffer, SSH2_MSG_SERVICE_ACCEPT) < 0) {
return -1;
}
- service=string_from_char(msg->service_request.service);
+ service=ssh_string_from_char(msg->service_request.service);
if (buffer_add_ssh_string(session->out_buffer, service) < 0) {
- string_free(service);
+ ssh_string_free(service);
return -1;
}
- string_free(service);
+ ssh_string_free(service);
return packet_send(msg->session);
}
@@ -829,11 +829,11 @@ int ssh_message_auth_reply_pk_ok_simple(ssh_message msg) {
ssh_string algo;
ssh_string pubkey;
int ret;
- algo=string_from_char(msg->auth_request.public_key->type_c);
+ algo=ssh_string_from_char(msg->auth_request.public_key->type_c);
pubkey=publickey_to_string(msg->auth_request.public_key);
ret=ssh_message_auth_reply_pk_ok(msg,algo,pubkey);
- string_free(algo);
- string_free(pubkey);
+ ssh_string_free(algo);
+ ssh_string_free(pubkey);
return ret;
}
diff --git a/libssh/session.c b/libssh/session.c
index 56061378..8bc97404 100644
--- a/libssh/session.c
+++ b/libssh/session.c
@@ -73,12 +73,12 @@ ssh_session ssh_new(void) {
goto err;
}
- session->out_buffer = buffer_new();
+ session->out_buffer = ssh_buffer_new();
if (session->out_buffer == NULL) {
goto err;
}
- session->in_buffer=buffer_new();
+ session->in_buffer=ssh_buffer_new();
if (session->in_buffer == NULL) {
goto err;
}
@@ -171,15 +171,15 @@ void ssh_free(ssh_session session) {
session->pcap_ctx=NULL;
}
#endif
- buffer_free(session->in_buffer);
- buffer_free(session->out_buffer);
+ ssh_buffer_free(session->in_buffer);
+ ssh_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);
+ ssh_channel_free(session->channels);
}
#ifndef _WIN32
agent_free(session->agent);
@@ -469,8 +469,8 @@ SSH_PACKET_CALLBACK(ssh_packet_disconnect_callback){
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);
+ error = ssh_string_to_char(error_s);
+ ssh_string_free(error_s);
}
ssh_log(session, SSH_LOG_PACKET, "Received SSH_MSG_DISCONNECT %d:%s",code,
error != NULL ? error : "no error");
diff --git a/libssh/sftp.c b/libssh/sftp.c
index ca6d64e2..a3b0a198 100644
--- a/libssh/sftp.c
+++ b/libssh/sftp.c
@@ -126,21 +126,21 @@ sftp_session sftp_new(ssh_session session){
}
sftp->session = session;
- sftp->channel = channel_new(session);
+ sftp->channel = ssh_channel_new(session);
if (sftp->channel == NULL) {
SAFE_FREE(sftp);
leave_function();
return NULL;
}
- if (channel_open_session(sftp->channel)) {
- channel_free(sftp->channel);
+ if (ssh_channel_open_session(sftp->channel)) {
+ ssh_channel_free(sftp->channel);
SAFE_FREE(sftp);
leave_function();
return NULL;
}
- if (channel_request_sftp(sftp->channel)) {
+ if (ssh_channel_request_sftp(sftp->channel)) {
sftp_free(sftp);
leave_function();
return NULL;
@@ -200,7 +200,7 @@ int sftp_server_init(sftp_session sftp){
sftp_packet_free(packet);
- reply = buffer_new();
+ reply = ssh_buffer_new();
if (reply == NULL) {
ssh_set_error_oom(session);
sftp_leave_function();
@@ -209,17 +209,17 @@ int sftp_server_init(sftp_session sftp){
if (buffer_add_u32(reply, ntohl(LIBSFTP_VERSION)) < 0) {
ssh_set_error_oom(session);
- buffer_free(reply);
+ ssh_buffer_free(reply);
sftp_leave_function();
return -1;
}
if (sftp_packet_write(sftp, SSH_FXP_VERSION, reply) < 0) {
- buffer_free(reply);
+ ssh_buffer_free(reply);
sftp_leave_function();
return -1;
}
- buffer_free(reply);
+ ssh_buffer_free(reply);
ssh_log(session, SSH_LOG_RARE, "Server version sent");
@@ -241,7 +241,7 @@ void sftp_free(sftp_session sftp){
return;
}
- channel_send_eof(sftp->channel);
+ ssh_channel_send_eof(sftp->channel);
ptr = sftp->queue;
while(ptr) {
sftp_request_queue old;
@@ -251,7 +251,7 @@ void sftp_free(sftp_session sftp){
ptr = old;
}
- channel_free(sftp->channel);
+ ssh_channel_free(sftp->channel);
sftp_ext_free(sftp->ext);
ZERO_STRUCTP(sftp);
@@ -266,20 +266,20 @@ int sftp_packet_write(sftp_session sftp, uint8_t type, ssh_buffer payload){
return -1;
}
- size = htonl(buffer_get_len(payload));
+ size = htonl(ssh_buffer_get_len(payload));
if (buffer_prepend_data(payload, &size, sizeof(uint32_t)) < 0) {
ssh_set_error_oom(sftp->session);
return -1;
}
- size = channel_write(sftp->channel, buffer_get(payload),
- buffer_get_len(payload));
+ size = ssh_channel_write(sftp->channel, ssh_buffer_get_begin(payload),
+ ssh_buffer_get_len(payload));
if (size < 0) {
return -1;
- } else if((uint32_t) size != buffer_get_len(payload)) {
+ } else if((uint32_t) size != ssh_buffer_get_len(payload)) {
ssh_log(sftp->session, SSH_LOG_PACKET,
"Had to write %d bytes, wrote only %d",
- buffer_get_len(payload),
+ ssh_buffer_get_len(payload),
size);
}
@@ -298,7 +298,7 @@ sftp_packet sftp_packet_read(sftp_session sftp) {
return NULL;
}
packet->sftp = sftp;
- packet->payload = buffer_new();
+ packet->payload = ssh_buffer_new();
if (packet->payload == NULL) {
ssh_set_error_oom(sftp->session);
SAFE_FREE(packet);
@@ -306,7 +306,7 @@ sftp_packet sftp_packet_read(sftp_session sftp) {
}
if (channel_read_buffer(sftp->channel, packet->payload, 4, 0) <= 0) {
- buffer_free(packet->payload);
+ ssh_buffer_free(packet->payload);
SAFE_FREE(packet);
sftp_leave_function();
return NULL;
@@ -314,7 +314,7 @@ sftp_packet sftp_packet_read(sftp_session sftp) {
if (buffer_get_u32(packet->payload, &size) != sizeof(uint32_t)) {
ssh_set_error(sftp->session, SSH_FATAL, "Short sftp packet!");
- buffer_free(packet->payload);
+ ssh_buffer_free(packet->payload);
SAFE_FREE(packet);
sftp_leave_function();
return NULL;
@@ -323,7 +323,7 @@ sftp_packet sftp_packet_read(sftp_session sftp) {
size = ntohl(size);
if (channel_read_buffer(sftp->channel, packet->payload, 1, 0) <= 0) {
/* TODO: check if there are cases where an error needs to be set here */
- buffer_free(packet->payload);
+ ssh_buffer_free(packet->payload);
SAFE_FREE(packet);
sftp_leave_function();
return NULL;
@@ -333,7 +333,7 @@ sftp_packet sftp_packet_read(sftp_session sftp) {
if (size > 1) {
if (channel_read_buffer(sftp->channel, packet->payload, size - 1, 0) <= 0) {
/* TODO: check if there are cases where an error needs to be set here */
- buffer_free(packet->payload);
+ ssh_buffer_free(packet->payload);
SAFE_FREE(packet);
sftp_leave_function();
return NULL;
@@ -371,7 +371,7 @@ static sftp_message sftp_message_new(sftp_session sftp){
}
ZERO_STRUCTP(msg);
- msg->payload = buffer_new();
+ msg->payload = ssh_buffer_new();
if (msg->payload == NULL) {
ssh_set_error_oom(sftp->session);
SAFE_FREE(msg);
@@ -393,7 +393,7 @@ static void sftp_message_free(sftp_message msg) {
sftp = msg->sftp;
sftp_enter_function();
- buffer_free(msg->payload);
+ ssh_buffer_free(msg->payload);
SAFE_FREE(msg);
sftp_leave_function();
@@ -483,7 +483,7 @@ void sftp_packet_free(sftp_packet packet) {
return;
}
- buffer_free(packet->payload);
+ ssh_buffer_free(packet->payload);
free(packet);
}
@@ -499,7 +499,7 @@ int sftp_init(sftp_session sftp) {
sftp_enter_function();
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
sftp_leave_function();
@@ -508,16 +508,16 @@ int sftp_init(sftp_session sftp) {
if (buffer_add_u32(buffer, version) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
sftp_leave_function();
return -1;
}
if (sftp_packet_write(sftp, SSH_FXP_INIT, buffer) < 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
sftp_leave_function();
return -1;
}
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
packet = sftp_packet_read(sftp);
if (packet == NULL) {
@@ -547,18 +547,18 @@ int sftp_init(sftp_session sftp) {
ext_data_s = buffer_get_ssh_string(packet->payload);
if (ext_data_s == NULL) {
- string_free(ext_name_s);
+ ssh_string_free(ext_name_s);
break;
}
- ext_name = string_to_char(ext_name_s);
- ext_data = string_to_char(ext_data_s);
+ ext_name = ssh_string_to_char(ext_name_s);
+ ext_data = ssh_string_to_char(ext_data_s);
if (ext_name == NULL || ext_data == NULL) {
ssh_set_error_oom(sftp->session);
SAFE_FREE(ext_name);
SAFE_FREE(ext_data);
- string_free(ext_name_s);
- string_free(ext_data_s);
+ ssh_string_free(ext_name_s);
+ ssh_string_free(ext_data_s);
return -1;
}
ssh_log(sftp->session, SSH_LOG_RARE,
@@ -571,8 +571,8 @@ int sftp_init(sftp_session sftp) {
ssh_set_error_oom(sftp->session);
SAFE_FREE(ext_name);
SAFE_FREE(ext_data);
- string_free(ext_name_s);
- string_free(ext_data_s);
+ ssh_string_free(ext_name_s);
+ ssh_string_free(ext_data_s);
return -1;
}
tmp[count - 1] = ext_name;
@@ -583,8 +583,8 @@ int sftp_init(sftp_session sftp) {
ssh_set_error_oom(sftp->session);
SAFE_FREE(ext_name);
SAFE_FREE(ext_data);
- string_free(ext_name_s);
- string_free(ext_data_s);
+ ssh_string_free(ext_name_s);
+ ssh_string_free(ext_data_s);
return -1;
}
tmp[count - 1] = ext_data;
@@ -592,8 +592,8 @@ int sftp_init(sftp_session sftp) {
sftp->ext->count = count;
- string_free(ext_name_s);
- string_free(ext_data_s);
+ ssh_string_free(ext_name_s);
+ ssh_string_free(ext_data_s);
ext_name_s = buffer_get_ssh_string(packet->payload);
}
@@ -786,7 +786,7 @@ static sftp_status_message parse_status_msg(sftp_message msg){
if(status->error == NULL || status->lang == NULL){
if(msg->sftp->version >=3){
/* These are mandatory from version 3 */
- string_free(status->error);
+ ssh_string_free(status->error);
/* status->lang never get allocated if something failed */
SAFE_FREE(status);
ssh_set_error(msg->sftp->session, SSH_FATAL,
@@ -797,11 +797,11 @@ static sftp_status_message parse_status_msg(sftp_message msg){
status->status = ntohl(status->status);
if(status->error)
- status->errormsg = string_to_char(status->error);
+ status->errormsg = ssh_string_to_char(status->error);
else
status->errormsg = strdup("No error message in packet");
if(status->lang)
- status->langmsg = string_to_char(status->lang);
+ status->langmsg = ssh_string_to_char(status->lang);
else
status->langmsg = strdup("");
if (status->errormsg == NULL || status->langmsg == NULL) {
@@ -818,8 +818,8 @@ static void status_msg_free(sftp_status_message status){
return;
}
- string_free(status->error);
- string_free(status->lang);
+ ssh_string_free(status->error);
+ ssh_string_free(status->lang);
SAFE_FREE(status->errormsg);
SAFE_FREE(status->langmsg);
SAFE_FREE(status);
@@ -866,16 +866,16 @@ sftp_dir sftp_opendir(sftp_session sftp, const char *path){
ssh_buffer payload;
uint32_t id;
- payload = buffer_new();
+ payload = ssh_buffer_new();
if (payload == NULL) {
ssh_set_error_oom(sftp->session);
return NULL;
}
- path_s = string_from_char(path);
+ path_s = ssh_string_from_char(path);
if (path_s == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(payload);
+ ssh_buffer_free(payload);
return NULL;
}
@@ -883,17 +883,17 @@ sftp_dir sftp_opendir(sftp_session sftp, const char *path){
if (buffer_add_u32(payload, id) < 0 ||
buffer_add_ssh_string(payload, path_s) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(payload);
- string_free(path_s);
+ ssh_buffer_free(payload);
+ ssh_string_free(path_s);
return NULL;
}
- string_free(path_s);
+ ssh_string_free(path_s);
if (sftp_packet_write(sftp, SSH_FXP_OPENDIR, payload) < 0) {
- buffer_free(payload);
+ ssh_buffer_free(payload);
return NULL;
}
- buffer_free(payload);
+ ssh_buffer_free(payload);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -987,11 +987,11 @@ static sftp_attributes sftp_parse_attr_4(sftp_session sftp, ssh_buffer buf,
if (flags & SSH_FILEXFER_ATTR_OWNERGROUP) {
if((owner = buffer_get_ssh_string(buf)) == NULL ||
- (attr->owner = string_to_char(owner)) == NULL) {
+ (attr->owner = ssh_string_to_char(owner)) == NULL) {
break;
}
if ((group = buffer_get_ssh_string(buf)) == NULL ||
- (attr->group = string_to_char(group)) == NULL) {
+ (attr->group = ssh_string_to_char(group)) == NULL) {
break;
}
}
@@ -1094,11 +1094,11 @@ static sftp_attributes sftp_parse_attr_4(sftp_session sftp, ssh_buffer buf,
if (ok == 0) {
/* break issued somewhere */
- string_free(owner);
- string_free(group);
- string_free(attr->acl);
- string_free(attr->extended_type);
- string_free(attr->extended_data);
+ ssh_string_free(owner);
+ ssh_string_free(group);
+ ssh_string_free(attr->acl);
+ ssh_string_free(attr->extended_type);
+ ssh_string_free(attr->extended_data);
SAFE_FREE(attr->owner);
SAFE_FREE(attr->group);
SAFE_FREE(attr);
@@ -1193,18 +1193,18 @@ static sftp_attributes sftp_parse_attr_3(sftp_session sftp, ssh_buffer buf,
do {
if (expectname) {
if ((name = buffer_get_ssh_string(buf)) == NULL ||
- (attr->name = string_to_char(name)) == NULL) {
+ (attr->name = ssh_string_to_char(name)) == NULL) {
break;
}
- string_free(name);
+ ssh_string_free(name);
ssh_log(sftp->session, SSH_LOG_RARE, "Name: %s", attr->name);
if ((longname=buffer_get_ssh_string(buf)) == NULL ||
- (attr->longname=string_to_char(longname)) == NULL) {
+ (attr->longname=ssh_string_to_char(longname)) == NULL) {
break;
}
- string_free(longname);
+ ssh_string_free(longname);
/* Set owner and group if we talk to openssh and have the longname */
if (ssh_get_openssh_version(sftp->session)) {
@@ -1309,10 +1309,10 @@ static sftp_attributes sftp_parse_attr_3(sftp_session sftp, ssh_buffer buf,
if (!ok) {
/* break issued somewhere */
- string_free(name);
- string_free(longname);
- string_free(attr->extended_type);
- string_free(attr->extended_data);
+ ssh_string_free(name);
+ ssh_string_free(longname);
+ ssh_string_free(attr->extended_type);
+ ssh_string_free(attr->extended_data);
SAFE_FREE(attr->name);
SAFE_FREE(attr->longname);
SAFE_FREE(attr->owner);
@@ -1404,7 +1404,7 @@ sftp_attributes sftp_readdir(sftp_session sftp, sftp_dir dir) {
uint32_t id;
if (dir->buffer == NULL) {
- payload = buffer_new();
+ payload = ssh_buffer_new();
if (payload == NULL) {
ssh_set_error_oom(sftp->session);
return NULL;
@@ -1414,15 +1414,15 @@ sftp_attributes sftp_readdir(sftp_session sftp, sftp_dir dir) {
if (buffer_add_u32(payload, id) < 0 ||
buffer_add_ssh_string(payload, dir->handle) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(payload);
+ ssh_buffer_free(payload);
return NULL;
}
if (sftp_packet_write(sftp, SSH_FXP_READDIR, payload) < 0) {
- buffer_free(payload);
+ ssh_buffer_free(payload);
return NULL;
}
- buffer_free(payload);
+ ssh_buffer_free(payload);
ssh_log(sftp->session, SSH_LOG_PACKET,
"Sent a ssh_fxp_readdir with id %d", id);
@@ -1492,7 +1492,7 @@ sftp_attributes sftp_readdir(sftp_session sftp, sftp_dir dir) {
dir->count--;
if (dir->count == 0) {
- buffer_free(dir->buffer);
+ ssh_buffer_free(dir->buffer);
dir->buffer = NULL;
}
@@ -1510,9 +1510,9 @@ void sftp_attributes_free(sftp_attributes file){
return;
}
- string_free(file->acl);
- string_free(file->extended_data);
- string_free(file->extended_type);
+ ssh_string_free(file->acl);
+ ssh_string_free(file->extended_data);
+ ssh_string_free(file->extended_type);
SAFE_FREE(file->name);
SAFE_FREE(file->longname);
@@ -1528,7 +1528,7 @@ static int sftp_handle_close(sftp_session sftp, ssh_string handle) {
ssh_buffer buffer = NULL;
uint32_t id;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return -1;
@@ -1538,14 +1538,14 @@ static int sftp_handle_close(sftp_session sftp, ssh_string handle) {
if (buffer_add_u32(buffer, id) < 0 ||
buffer_add_ssh_string(buffer, handle) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
if (sftp_packet_write(sftp, SSH_FXP_CLOSE ,buffer) < 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -1591,7 +1591,7 @@ int sftp_close(sftp_file file){
SAFE_FREE(file->name);
if (file->handle){
err = sftp_handle_close(file->sftp,file->handle);
- string_free(file->handle);
+ ssh_string_free(file->handle);
}
/* FIXME: check server response and implement errno */
SAFE_FREE(file);
@@ -1606,10 +1606,10 @@ int sftp_closedir(sftp_dir dir){
SAFE_FREE(dir->name);
if (dir->handle) {
err = sftp_handle_close(dir->sftp, dir->handle);
- string_free(dir->handle);
+ ssh_string_free(dir->handle);
}
/* FIXME: check server response and implement errno */
- buffer_free(dir->buffer);
+ ssh_buffer_free(dir->buffer);
SAFE_FREE(dir);
return err;
@@ -1627,16 +1627,16 @@ sftp_file sftp_open(sftp_session sftp, const char *file, int flags,
uint32_t sftp_flags = 0;
uint32_t id;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return NULL;
}
- filename = string_from_char(file);
+ filename = ssh_string_from_char(file);
if (filename == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
@@ -1662,23 +1662,23 @@ sftp_file sftp_open(sftp_session sftp, const char *file, int flags,
if (buffer_add_u32(buffer, id) < 0 ||
buffer_add_ssh_string(buffer, filename) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(filename);
+ ssh_buffer_free(buffer);
+ ssh_string_free(filename);
return NULL;
}
- string_free(filename);
+ ssh_string_free(filename);
if (buffer_add_u32(buffer, htonl(sftp_flags)) < 0 ||
buffer_add_attributes(buffer, &attr) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
if (sftp_packet_write(sftp, SSH_FXP_OPEN, buffer) < 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -1734,7 +1734,7 @@ ssize_t sftp_read(sftp_file handle, void *buf, size_t count) {
return 0;
}
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return -1;
@@ -1745,18 +1745,18 @@ ssize_t sftp_read(sftp_file handle, void *buf, size_t count) {
buffer_add_u64(buffer, htonll(handle->offset)) < 0 ||
buffer_add_u32(buffer,htonl(count)) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
if (sftp_packet_write(handle->sftp, SSH_FXP_READ, buffer) < 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
while (msg == NULL) {
if (handle->nonblocking) {
- if (channel_poll(handle->sftp->channel, 0) == 0) {
+ if (ssh_channel_poll(handle->sftp->channel, 0) == 0) {
/* we cannot block */
return 0;
}
@@ -1797,18 +1797,18 @@ ssize_t sftp_read(sftp_file handle, void *buf, size_t count) {
return -1;
}
- if (string_len(datastring) > count) {
+ if (ssh_string_len(datastring) > count) {
ssh_set_error(sftp->session, SSH_FATAL,
"Received a too big DATA packet from sftp server: "
"%zu and asked for %zu",
- string_len(datastring), count);
- string_free(datastring);
+ ssh_string_len(datastring), count);
+ ssh_string_free(datastring);
return -1;
}
- count = string_len(datastring);
+ count = ssh_string_len(datastring);
handle->offset += count;
- memcpy(buf, string_data(datastring), count);
- string_free(datastring);
+ memcpy(buf, ssh_string_data(datastring), count);
+ ssh_string_free(datastring);
return count;
default:
ssh_set_error(sftp->session, SSH_FATAL,
@@ -1828,7 +1828,7 @@ int sftp_async_read_begin(sftp_file file, uint32_t len){
sftp_enter_function();
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return -1;
@@ -1840,14 +1840,14 @@ int sftp_async_read_begin(sftp_file file, uint32_t len){
buffer_add_u64(buffer, htonll(file->offset)) < 0 ||
buffer_add_u32(buffer, htonl(len)) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
if (sftp_packet_write(sftp, SSH_FXP_READ, buffer) < 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
file->offset += len; /* assume we'll read len bytes */
@@ -1874,7 +1874,7 @@ int sftp_async_read(sftp_file file, void *data, uint32_t size, uint32_t id){
/* handle an existing request */
while (msg == NULL) {
if (file->nonblocking){
- if (channel_poll(sftp->channel, 0) == 0) {
+ if (ssh_channel_poll(sftp->channel, 0) == 0) {
/* we cannot block */
return SSH_AGAIN;
}
@@ -1918,21 +1918,21 @@ int sftp_async_read(sftp_file file, void *data, uint32_t size, uint32_t id){
sftp_leave_function();
return SSH_ERROR;
}
- if (string_len(datastring) > size) {
+ if (ssh_string_len(datastring) > size) {
ssh_set_error(sftp->session, SSH_FATAL,
"Received a too big DATA packet from sftp server: "
"%zu and asked for %u",
- string_len(datastring), size);
- string_free(datastring);
+ ssh_string_len(datastring), size);
+ ssh_string_free(datastring);
sftp_leave_function();
return SSH_ERROR;
}
- len = string_len(datastring);
+ len = ssh_string_len(datastring);
//handle->offset+=len;
/* We already have set the offset previously. All we can do is warn that the expected len
* and effective lengths are different */
- memcpy(data, string_data(datastring), len);
- string_free(datastring);
+ memcpy(data, ssh_string_data(datastring), len);
+ ssh_string_free(datastring);
sftp_leave_function();
return len;
default:
@@ -1956,19 +1956,19 @@ ssize_t sftp_write(sftp_file file, const void *buf, size_t count) {
int len;
int packetlen;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return -1;
}
- datastring = string_new(count);
+ datastring = ssh_string_new(count);
if (datastring == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
- string_fill(datastring, buf, count);
+ ssh_string_fill(datastring, buf, count);
id = sftp_get_new_id(file->sftp);
if (buffer_add_u32(buffer, id) < 0 ||
@@ -1976,14 +1976,14 @@ ssize_t sftp_write(sftp_file file, const void *buf, size_t count) {
buffer_add_u64(buffer, htonll(file->offset)) < 0 ||
buffer_add_ssh_string(buffer, datastring) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(datastring);
+ ssh_buffer_free(buffer);
+ ssh_string_free(datastring);
return -1;
}
- string_free(datastring);
+ ssh_string_free(datastring);
len = sftp_packet_write(file->sftp, SSH_FXP_WRITE, buffer);
- packetlen=buffer_get_len(buffer);
- buffer_free(buffer);
+ packetlen=ssh_buffer_get_len(buffer);
+ ssh_buffer_free(buffer);
if (len < 0) {
return -1;
} else if (len != packetlen) {
@@ -2073,16 +2073,16 @@ int sftp_unlink(sftp_session sftp, const char *file) {
ssh_buffer buffer;
uint32_t id;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return -1;
}
- filename = string_from_char(file);
+ filename = ssh_string_from_char(file);
if (filename == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
@@ -2090,15 +2090,15 @@ int sftp_unlink(sftp_session sftp, const char *file) {
if (buffer_add_u32(buffer, id) < 0 ||
buffer_add_ssh_string(buffer, filename) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(filename);
+ ssh_buffer_free(buffer);
+ ssh_string_free(filename);
}
if (sftp_packet_write(sftp, SSH_FXP_REMOVE, buffer) < 0) {
- buffer_free(buffer);
- string_free(filename);
+ ssh_buffer_free(buffer);
+ ssh_string_free(filename);
}
- string_free(filename);
- buffer_free(buffer);
+ ssh_string_free(filename);
+ ssh_buffer_free(buffer);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp)) {
@@ -2148,16 +2148,16 @@ int sftp_rmdir(sftp_session sftp, const char *directory) {
ssh_buffer buffer;
uint32_t id;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return -1;
}
- filename = string_from_char(directory);
+ filename = ssh_string_from_char(directory);
if (filename == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
@@ -2165,17 +2165,17 @@ int sftp_rmdir(sftp_session sftp, const char *directory) {
if (buffer_add_u32(buffer, id) < 0 ||
buffer_add_ssh_string(buffer, filename) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(filename);
+ ssh_buffer_free(buffer);
+ ssh_string_free(filename);
return -1;
}
if (sftp_packet_write(sftp, SSH_FXP_RMDIR, buffer) < 0) {
- buffer_free(buffer);
- string_free(filename);
+ ssh_buffer_free(buffer);
+ ssh_string_free(filename);
return -1;
}
- buffer_free(buffer);
- string_free(filename);
+ ssh_buffer_free(buffer);
+ ssh_string_free(filename);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -2224,16 +2224,16 @@ int sftp_mkdir(sftp_session sftp, const char *directory, mode_t mode) {
ssh_string path;
uint32_t id;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return -1;
}
- path = string_from_char(directory);
+ path = ssh_string_from_char(directory);
if (path == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
@@ -2246,11 +2246,11 @@ int sftp_mkdir(sftp_session sftp, const char *directory, mode_t mode) {
buffer_add_ssh_string(buffer, path) < 0 ||
buffer_add_attributes(buffer, &attr) < 0 ||
sftp_packet_write(sftp, SSH_FXP_MKDIR, buffer) < 0) {
- buffer_free(buffer);
- string_free(path);
+ ssh_buffer_free(buffer);
+ ssh_string_free(path);
}
- buffer_free(buffer);
- string_free(path);
+ ssh_buffer_free(buffer);
+ ssh_string_free(path);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -2314,24 +2314,24 @@ int sftp_rename(sftp_session sftp, const char *original, const char *newname) {
ssh_string newpath;
uint32_t id;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return -1;
}
- oldpath = string_from_char(original);
+ oldpath = ssh_string_from_char(original);
if (oldpath == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
- newpath = string_from_char(newname);
+ newpath = ssh_string_from_char(newname);
if (newpath == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(oldpath);
+ ssh_buffer_free(buffer);
+ ssh_string_free(oldpath);
return -1;
}
@@ -2342,20 +2342,20 @@ int sftp_rename(sftp_session sftp, const char *original, const char *newname) {
/* POSIX rename atomically replaces newpath, we should do the same */
buffer_add_u32(buffer, SSH_FXF_RENAME_OVERWRITE) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(oldpath);
- string_free(newpath);
+ ssh_buffer_free(buffer);
+ ssh_string_free(oldpath);
+ ssh_string_free(newpath);
return -1;
}
if (sftp_packet_write(sftp, SSH_FXP_RENAME, buffer) < 0) {
- buffer_free(buffer);
- string_free(oldpath);
- string_free(newpath);
+ ssh_buffer_free(buffer);
+ ssh_string_free(oldpath);
+ ssh_string_free(newpath);
return -1;
}
- buffer_free(buffer);
- string_free(oldpath);
- string_free(newpath);
+ ssh_buffer_free(buffer);
+ ssh_string_free(oldpath);
+ ssh_string_free(newpath);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -2406,16 +2406,16 @@ int sftp_setstat(sftp_session sftp, const char *file, sftp_attributes attr) {
sftp_message msg = NULL;
sftp_status_message status = NULL;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return -1;
}
- path = string_from_char(file);
+ path = ssh_string_from_char(file);
if (path == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
@@ -2424,17 +2424,17 @@ int sftp_setstat(sftp_session sftp, const char *file, sftp_attributes attr) {
buffer_add_ssh_string(buffer, path) < 0 ||
buffer_add_attributes(buffer, attr) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(path);
+ ssh_buffer_free(buffer);
+ ssh_string_free(path);
return -1;
}
if (sftp_packet_write(sftp, SSH_FXP_SETSTAT, buffer) < 0) {
- buffer_free(buffer);
- string_free(path);
+ ssh_buffer_free(buffer);
+ ssh_string_free(path);
return -1;
}
- buffer_free(buffer);
- string_free(path);
+ ssh_buffer_free(buffer);
+ ssh_string_free(path);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -2530,33 +2530,33 @@ int sftp_symlink(sftp_session sftp, const char *target, const char *dest) {
return -1;
}
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return -1;
}
- target_s = string_from_char(target);
+ target_s = ssh_string_from_char(target);
if (target_s == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return -1;
}
- dest_s = string_from_char(dest);
+ dest_s = ssh_string_from_char(dest);
if (dest_s == NULL) {
ssh_set_error_oom(sftp->session);
- string_free(target_s);
- buffer_free(buffer);
+ ssh_string_free(target_s);
+ ssh_buffer_free(buffer);
return -1;
}
id = sftp_get_new_id(sftp);
if (buffer_add_u32(buffer, id) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(dest_s);
- string_free(target_s);
+ ssh_buffer_free(buffer);
+ ssh_string_free(dest_s);
+ ssh_string_free(target_s);
return -1;
}
if (ssh_get_openssh_version(sftp->session)) {
@@ -2564,31 +2564,31 @@ int sftp_symlink(sftp_session sftp, const char *target, const char *dest) {
if (buffer_add_ssh_string(buffer, target_s) < 0 ||
buffer_add_ssh_string(buffer, dest_s) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(dest_s);
- string_free(target_s);
+ ssh_buffer_free(buffer);
+ ssh_string_free(dest_s);
+ ssh_string_free(target_s);
return -1;
}
} else {
if (buffer_add_ssh_string(buffer, dest_s) < 0 ||
buffer_add_ssh_string(buffer, target_s) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(dest_s);
- string_free(target_s);
+ ssh_buffer_free(buffer);
+ ssh_string_free(dest_s);
+ ssh_string_free(target_s);
return -1;
}
}
if (sftp_packet_write(sftp, SSH_FXP_SYMLINK, buffer) < 0) {
- buffer_free(buffer);
- string_free(dest_s);
- string_free(target_s);
+ ssh_buffer_free(buffer);
+ ssh_string_free(dest_s);
+ ssh_string_free(target_s);
return -1;
}
- buffer_free(buffer);
- string_free(dest_s);
- string_free(target_s);
+ ssh_buffer_free(buffer);
+ ssh_string_free(dest_s);
+ ssh_string_free(target_s);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -2649,16 +2649,16 @@ char *sftp_readlink(sftp_session sftp, const char *path) {
ssh_set_error(sftp,SSH_REQUEST_DENIED,"sftp version %d does not support sftp_readlink",sftp->version);
return NULL;
}
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return NULL;
}
- path_s = string_from_char(path);
+ path_s = ssh_string_from_char(path);
if (path_s == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
@@ -2666,17 +2666,17 @@ char *sftp_readlink(sftp_session sftp, const char *path) {
if (buffer_add_u32(buffer, id) < 0 ||
buffer_add_ssh_string(buffer, path_s) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(path_s);
+ ssh_buffer_free(buffer);
+ ssh_string_free(path_s);
return NULL;
}
if (sftp_packet_write(sftp, SSH_FXP_READLINK, buffer) < 0) {
- buffer_free(buffer);
- string_free(path_s);
+ ssh_buffer_free(buffer);
+ ssh_string_free(path_s);
return NULL;
}
- buffer_free(buffer);
- string_free(path_s);
+ ssh_buffer_free(buffer);
+ ssh_string_free(path_s);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -2695,8 +2695,8 @@ char *sftp_readlink(sftp_session sftp, const char *path) {
/* TODO: what error to set here? */
return NULL;
}
- lnk = string_to_char(link_s);
- string_free(link_s);
+ lnk = ssh_string_to_char(link_s);
+ ssh_string_free(link_s);
return lnk;
} else if (msg->packet_type == SSH_FXP_STATUS) { /* bad response (error) */
@@ -2828,24 +2828,24 @@ sftp_statvfs_t sftp_statvfs(sftp_session sftp, const char *path) {
return NULL;
}
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return NULL;
}
- ext = string_from_char("statvfs@openssh.com");
+ ext = ssh_string_from_char("statvfs@openssh.com");
if (ext == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
- pathstr = string_from_char(path);
+ pathstr = ssh_string_from_char(path);
if (pathstr == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(ext);
+ ssh_buffer_free(buffer);
+ ssh_string_free(ext);
return NULL;
}
@@ -2854,20 +2854,20 @@ sftp_statvfs_t sftp_statvfs(sftp_session sftp, const char *path) {
buffer_add_ssh_string(buffer, ext) < 0 ||
buffer_add_ssh_string(buffer, pathstr) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(ext);
- string_free(pathstr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(ext);
+ ssh_string_free(pathstr);
return NULL;
}
if (sftp_packet_write(sftp, SSH_FXP_EXTENDED, buffer) < 0) {
- buffer_free(buffer);
- string_free(ext);
- string_free(pathstr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(ext);
+ ssh_string_free(pathstr);
return NULL;
}
- buffer_free(buffer);
- string_free(ext);
- string_free(pathstr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(ext);
+ ssh_string_free(pathstr);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -2915,16 +2915,16 @@ sftp_statvfs_t sftp_fstatvfs(sftp_file file) {
}
sftp = file->sftp;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return NULL;
}
- ext = string_from_char("fstatvfs@openssh.com");
+ ext = ssh_string_from_char("fstatvfs@openssh.com");
if (ext == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
@@ -2933,17 +2933,17 @@ sftp_statvfs_t sftp_fstatvfs(sftp_file file) {
buffer_add_ssh_string(buffer, ext) < 0 ||
buffer_add_ssh_string(buffer, file->handle) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(ext);
+ ssh_buffer_free(buffer);
+ ssh_string_free(ext);
return NULL;
}
if (sftp_packet_write(sftp, SSH_FXP_EXTENDED, buffer) < 0) {
- buffer_free(buffer);
- string_free(ext);
+ ssh_buffer_free(buffer);
+ ssh_string_free(ext);
return NULL;
}
- buffer_free(buffer);
- string_free(ext);
+ ssh_buffer_free(buffer);
+ ssh_string_free(ext);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -3004,16 +3004,16 @@ char *sftp_canonicalize_path(sftp_session sftp, const char *path) {
return NULL;
}
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return NULL;
}
- pathstr = string_from_char(path);
+ pathstr = ssh_string_from_char(path);
if (pathstr == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
@@ -3021,17 +3021,17 @@ char *sftp_canonicalize_path(sftp_session sftp, const char *path) {
if (buffer_add_u32(buffer, id) < 0 ||
buffer_add_ssh_string(buffer, pathstr) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(pathstr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(pathstr);
return NULL;
}
if (sftp_packet_write(sftp, SSH_FXP_REALPATH, buffer) < 0) {
- buffer_free(buffer);
- string_free(pathstr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(pathstr);
return NULL;
}
- buffer_free(buffer);
- string_free(pathstr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(pathstr);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -3050,8 +3050,8 @@ char *sftp_canonicalize_path(sftp_session sftp, const char *path) {
/* TODO: error message? */
return NULL;
}
- cname = string_to_char(name);
- string_free(name);
+ cname = ssh_string_to_char(name);
+ ssh_string_free(name);
if (cname == NULL) {
ssh_set_error_oom(sftp->session);
}
@@ -3082,16 +3082,16 @@ static sftp_attributes sftp_xstat(sftp_session sftp, const char *path,
ssh_buffer buffer;
uint32_t id;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(sftp->session);
return NULL;
}
- pathstr = string_from_char(path);
+ pathstr = ssh_string_from_char(path);
if (pathstr == NULL) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
@@ -3099,17 +3099,17 @@ static sftp_attributes sftp_xstat(sftp_session sftp, const char *path,
if (buffer_add_u32(buffer, id) < 0 ||
buffer_add_ssh_string(buffer, pathstr) < 0) {
ssh_set_error_oom(sftp->session);
- buffer_free(buffer);
- string_free(pathstr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(pathstr);
return NULL;
}
if (sftp_packet_write(sftp, param, buffer) < 0) {
- buffer_free(buffer);
- string_free(pathstr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(pathstr);
return NULL;
}
- buffer_free(buffer);
- string_free(pathstr);
+ ssh_buffer_free(buffer);
+ ssh_string_free(pathstr);
while (msg == NULL) {
if (sftp_read_and_dispatch(sftp) < 0) {
@@ -3153,7 +3153,7 @@ sftp_attributes sftp_fstat(sftp_file file) {
ssh_buffer buffer;
uint32_t id;
- buffer = buffer_new();
+ buffer = ssh_buffer_new();
if (buffer == NULL) {
ssh_set_error_oom(file->sftp->session);
return NULL;
@@ -3163,14 +3163,14 @@ sftp_attributes sftp_fstat(sftp_file file) {
if (buffer_add_u32(buffer, id) < 0 ||
buffer_add_ssh_string(buffer, file->handle) < 0) {
ssh_set_error_oom(file->sftp->session);
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
if (sftp_packet_write(file->sftp, SSH_FXP_FSTAT, buffer) < 0) {
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
return NULL;
}
- buffer_free(buffer);
+ ssh_buffer_free(buffer);
while (msg == NULL) {
if (sftp_read_and_dispatch(file->sftp) < 0) {
diff --git a/libssh/sftpserver.c b/libssh/sftpserver.c
index bc72f579..77f64198 100644
--- a/libssh/sftpserver.c
+++ b/libssh/sftpserver.c
@@ -101,8 +101,8 @@ sftp_client_message sftp_get_client_message(sftp_session sftp) {
sftp_client_message_free(msg);
return NULL;
}
- msg->filename = string_to_char(tmp);
- string_free(tmp);
+ msg->filename = ssh_string_to_char(tmp);
+ ssh_string_free(tmp);
if (msg->filename == NULL) {
sftp_client_message_free(msg);
return NULL;
@@ -115,8 +115,8 @@ sftp_client_message sftp_get_client_message(sftp_session sftp) {
sftp_client_message_free(msg);
return NULL;
}
- msg->filename = string_to_char(tmp);
- string_free(tmp);
+ msg->filename = ssh_string_to_char(tmp);
+ ssh_string_free(tmp);
if (msg->filename == NULL) {
sftp_client_message_free(msg);
return NULL;
@@ -134,8 +134,8 @@ sftp_client_message sftp_get_client_message(sftp_session sftp) {
sftp_client_message_free(msg);
return NULL;
}
- msg->filename=string_to_char(tmp);
- string_free(tmp);
+ msg->filename=ssh_string_to_char(tmp);
+ ssh_string_free(tmp);
if (msg->filename == NULL) {
sftp_client_message_free(msg);
return NULL;
@@ -165,8 +165,8 @@ sftp_client_message sftp_get_client_message(sftp_session sftp) {
sftp_client_message_free(msg);
return NULL;
}
- msg->filename = string_to_char(tmp);
- string_free(tmp);
+ msg->filename = ssh_string_to_char(tmp);
+ ssh_string_free(tmp);
if (msg->filename == NULL) {
sftp_client_message_free(msg);
return NULL;
@@ -181,8 +181,8 @@ sftp_client_message sftp_get_client_message(sftp_session sftp) {
sftp_client_message_free(msg);
return NULL;
}
- msg->filename = string_to_char(tmp);
- string_free(tmp);
+ msg->filename = ssh_string_to_char(tmp);
+ ssh_string_free(tmp);
if (msg->filename == NULL) {
sftp_client_message_free(msg);
return NULL;
@@ -219,8 +219,8 @@ void sftp_client_message_free(sftp_client_message msg) {
}
SAFE_FREE(msg->filename);
- string_free(msg->data);
- string_free(msg->handle);
+ ssh_string_free(msg->data);
+ ssh_string_free(msg->handle);
sftp_attributes_free(msg->attr);
ZERO_STRUCTP(msg);
@@ -232,14 +232,14 @@ int sftp_reply_name(sftp_client_message msg, const char *name,
ssh_buffer out;
ssh_string file;
- out = buffer_new();
+ out = ssh_buffer_new();
if (out == NULL) {
return -1;
}
- file = string_from_char(name);
+ file = ssh_string_from_char(name);
if (file == NULL) {
- buffer_free(out);
+ ssh_buffer_free(out);
return -1;
}
@@ -249,12 +249,12 @@ int sftp_reply_name(sftp_client_message msg, const char *name,
buffer_add_ssh_string(out, file) < 0 || /* The protocol is broken here between 3 & 4 */
buffer_add_attributes(out, attr) < 0 ||
sftp_packet_write(msg->sftp, SSH_FXP_NAME, out) < 0) {
- buffer_free(out);
- string_free(file);
+ ssh_buffer_free(out);
+ ssh_string_free(file);
return -1;
}
- buffer_free(out);
- string_free(file);
+ ssh_buffer_free(out);
+ ssh_string_free(file);
return 0;
}
@@ -262,7 +262,7 @@ int sftp_reply_name(sftp_client_message msg, const char *name,
int sftp_reply_handle(sftp_client_message msg, ssh_string handle){
ssh_buffer out;
- out = buffer_new();
+ out = ssh_buffer_new();
if (out == NULL) {
return -1;
}
@@ -270,10 +270,10 @@ int sftp_reply_handle(sftp_client_message msg, ssh_string handle){
if (buffer_add_u32(out, msg->id) < 0 ||
buffer_add_ssh_string(out, handle) < 0 ||
sftp_packet_write(msg->sftp, SSH_FXP_HANDLE, out) < 0) {
- buffer_free(out);
+ ssh_buffer_free(out);
return -1;
}
- buffer_free(out);
+ ssh_buffer_free(out);
return 0;
}
@@ -281,7 +281,7 @@ int sftp_reply_handle(sftp_client_message msg, ssh_string handle){
int sftp_reply_attr(sftp_client_message msg, sftp_attributes attr) {
ssh_buffer out;
- out = buffer_new();
+ out = ssh_buffer_new();
if (out == NULL) {
return -1;
}
@@ -289,10 +289,10 @@ int sftp_reply_attr(sftp_client_message msg, sftp_attributes attr) {
if (buffer_add_u32(out, msg->id) < 0 ||
buffer_add_attributes(out, attr) < 0 ||
sftp_packet_write(msg->sftp, SSH_FXP_ATTRS, out) < 0) {
- buffer_free(out);
+ ssh_buffer_free(out);
return -1;
}
- buffer_free(out);
+ ssh_buffer_free(out);
return 0;
}
@@ -301,35 +301,35 @@ int sftp_reply_names_add(sftp_client_message msg, const char *file,
const char *longname, sftp_attributes attr) {
ssh_string name;
- name = string_from_char(file);
+ name = ssh_string_from_char(file);
if (name == NULL) {
return -1;
}
if (msg->attrbuf == NULL) {
- msg->attrbuf = buffer_new();
+ msg->attrbuf = ssh_buffer_new();
if (msg->attrbuf == NULL) {
- string_free(name);
+ ssh_string_free(name);
return -1;
}
}
if (buffer_add_ssh_string(msg->attrbuf, name) < 0) {
- string_free(name);
+ ssh_string_free(name);
return -1;
}
- string_free(name);
- name = string_from_char(longname);
+ ssh_string_free(name);
+ name = ssh_string_from_char(longname);
if (name == NULL) {
return -1;
}
if (buffer_add_ssh_string(msg->attrbuf,name) < 0 ||
buffer_add_attributes(msg->attrbuf,attr) < 0) {
- string_free(name);
+ ssh_string_free(name);
return -1;
}
- string_free(name);
+ ssh_string_free(name);
msg->attr_num++;
return 0;
@@ -338,24 +338,24 @@ int sftp_reply_names_add(sftp_client_message msg, const char *file,
int sftp_reply_names(sftp_client_message msg) {
ssh_buffer out;
- out = buffer_new();
+ out = ssh_buffer_new();
if (out == NULL) {
- buffer_free(msg->attrbuf);
+ ssh_buffer_free(msg->attrbuf);
return -1;
}
if (buffer_add_u32(out, msg->id) < 0 ||
buffer_add_u32(out, htonl(msg->attr_num)) < 0 ||
- buffer_add_data(out, buffer_get(msg->attrbuf),
- buffer_get_len(msg->attrbuf)) < 0 ||
+ buffer_add_data(out, ssh_buffer_get_begin(msg->attrbuf),
+ ssh_buffer_get_len(msg->attrbuf)) < 0 ||
sftp_packet_write(msg->sftp, SSH_FXP_NAME, out) < 0) {
- buffer_free(out);
- buffer_free(msg->attrbuf);
+ ssh_buffer_free(out);
+ ssh_buffer_free(msg->attrbuf);
return -1;
}
- buffer_free(out);
- buffer_free(msg->attrbuf);
+ ssh_buffer_free(out);
+ ssh_buffer_free(msg->attrbuf);
msg->attr_num = 0;
msg->attrbuf = NULL;
@@ -368,14 +368,14 @@ int sftp_reply_status(sftp_client_message msg, uint32_t status,
ssh_buffer out;
ssh_string s;
- out = buffer_new();
+ out = ssh_buffer_new();
if (out == NULL) {
return -1;
}
- s = string_from_char(message ? message : "");
+ s = ssh_string_from_char(message ? message : "");
if (s == NULL) {
- buffer_free(out);
+ ssh_buffer_free(out);
return -1;
}
@@ -384,13 +384,13 @@ int sftp_reply_status(sftp_client_message msg, uint32_t status,
buffer_add_ssh_string(out, s) < 0 ||
buffer_add_u32(out, 0) < 0 || /* language string */
sftp_packet_write(msg->sftp, SSH_FXP_STATUS, out) < 0) {
- buffer_free(out);
- string_free(s);
+ ssh_buffer_free(out);
+ ssh_string_free(s);
return -1;
}
- buffer_free(out);
- string_free(s);
+ ssh_buffer_free(out);
+ ssh_string_free(s);
return 0;
}
@@ -398,7 +398,7 @@ int sftp_reply_status(sftp_client_message msg, uint32_t status,
int sftp_reply_data(sftp_client_message msg, const void *data, int len) {
ssh_buffer out;
- out = buffer_new();
+ out = ssh_buffer_new();
if (out == NULL) {
return -1;
}
@@ -407,10 +407,10 @@ int sftp_reply_data(sftp_client_message msg, const void *data, int len) {
buffer_add_u32(out, ntohl(len)) < 0 ||
buffer_add_data(out, data, len) < 0 ||
sftp_packet_write(msg->sftp, SSH_FXP_DATA, out) < 0) {
- buffer_free(out);
+ ssh_buffer_free(out);
return -1;
}
- buffer_free(out);
+ ssh_buffer_free(out);
return 0;
}
@@ -445,12 +445,12 @@ ssh_string sftp_handle_alloc(sftp_session sftp, void *info) {
}
val = i;
- ret = string_new(4);
+ ret = ssh_string_new(4);
if (ret == NULL) {
return NULL;
}
- memcpy(string_data(ret), &val, sizeof(uint32_t));
+ memcpy(ssh_string_data(ret), &val, sizeof(uint32_t));
sftp->handles[i] = info;
return ret;
@@ -463,11 +463,11 @@ void *sftp_handle(sftp_session sftp, ssh_string handle){
return NULL;
}
- if (string_len(handle) != sizeof(uint32_t)) {
+ if (ssh_string_len(handle) != sizeof(uint32_t)) {
return NULL;
}
- memcpy(&val, string_data(handle), sizeof(uint32_t));
+ memcpy(&val, ssh_string_data(handle), sizeof(uint32_t));
if (val > SFTP_HANDLES) {
return NULL;
diff --git a/libssh/socket.c b/libssh/socket.c
index 33789230..7c5a83f0 100644
--- a/libssh/socket.c
+++ b/libssh/socket.c
@@ -131,14 +131,14 @@ ssh_socket ssh_socket_new(ssh_session session) {
s->last_errno = -1;
s->fd_is_socket = 1;
s->session = session;
- s->in_buffer = buffer_new();
+ s->in_buffer = ssh_buffer_new();
if (s->in_buffer == NULL) {
SAFE_FREE(s);
return NULL;
}
- s->out_buffer=buffer_new();
+ s->out_buffer=ssh_buffer_new();
if (s->out_buffer == NULL) {
- buffer_free(s->in_buffer);
+ ssh_buffer_free(s->in_buffer);
SAFE_FREE(s);
return NULL;
}
@@ -289,8 +289,8 @@ void ssh_socket_free(ssh_socket s){
return;
}
ssh_socket_close(s);
- buffer_free(s->in_buffer);
- buffer_free(s->out_buffer);
+ ssh_buffer_free(s->in_buffer);
+ ssh_buffer_free(s->out_buffer);
SAFE_FREE(s);
}
diff --git a/libssh/string.c b/libssh/string.c
index e56fdcee..0a036adf 100644
--- a/libssh/string.c
+++ b/libssh/string.c
@@ -47,7 +47,7 @@
*
* @return The newly allocated string, NULL on error.
*/
-struct ssh_string_struct *string_new(size_t size) {
+struct ssh_string_struct *ssh_string_new(size_t size) {
struct ssh_string_struct *str = NULL;
str = malloc(size + 4);
@@ -70,7 +70,7 @@ struct ssh_string_struct *string_new(size_t size) {
*
* @return 0 on success, < 0 on error.
*/
-int string_fill(struct ssh_string_struct *s, const void *data, size_t len) {
+int ssh_string_fill(struct ssh_string_struct *s, const void *data, size_t len) {
if ((s == NULL) || (data == NULL) ||
(len == 0) || (len > s->size)) {
return -1;
@@ -90,7 +90,7 @@ int string_fill(struct ssh_string_struct *s, const void *data, size_t len) {
*
* @note The nul byte is not copied nor counted in the ouput string.
*/
-struct ssh_string_struct *string_from_char(const char *what) {
+struct ssh_string_struct *ssh_string_from_char(const char *what) {
struct ssh_string_struct *ptr = NULL;
size_t len = strlen(what);
@@ -111,7 +111,7 @@ struct ssh_string_struct *string_from_char(const char *what) {
*
* @return The size of the content of the string, 0 on error.
*/
-size_t string_len(struct ssh_string_struct *s) {
+size_t ssh_string_len(struct ssh_string_struct *s) {
if (s == NULL) {
return ntohl(0);
}
@@ -130,7 +130,7 @@ size_t string_len(struct ssh_string_struct *s) {
* @note If the input SSH string contains zeroes, some parts of the output
* string may not be readable with regular libc functions.
*/
-char *string_to_char(struct ssh_string_struct *s) {
+char *ssh_string_to_char(struct ssh_string_struct *s) {
size_t len = ntohl(s->size) + 1;
char *new = malloc(len);
@@ -150,7 +150,7 @@ char *string_to_char(struct ssh_string_struct *s) {
*
* @return Newly allocated copy of the string, NULL on error.
*/
-struct ssh_string_struct *string_copy(struct ssh_string_struct *s) {
+struct ssh_string_struct *ssh_string_copy(struct ssh_string_struct *s) {
struct ssh_string_struct *new = malloc(ntohl(s->size) + 4);
if (new == NULL) {
@@ -167,11 +167,11 @@ struct ssh_string_struct *string_copy(struct ssh_string_struct *s) {
*
* @param[in] s The string to burn.
*/
-void string_burn(struct ssh_string_struct *s) {
+void ssh_string_burn(struct ssh_string_struct *s) {
if (s == NULL) {
return;
}
- memset(s->string, 'X', string_len(s));
+ memset(s->string, 'X', ssh_string_len(s));
}
/**
@@ -181,7 +181,7 @@ void string_burn(struct ssh_string_struct *s) {
*
* @return Return the data of the string or NULL on error.
*/
-void *string_data(struct ssh_string_struct *s) {
+void *ssh_string_data(struct ssh_string_struct *s) {
if (s == NULL) {
return NULL;
}
@@ -194,7 +194,7 @@ void *string_data(struct ssh_string_struct *s) {
*
* \param[in] s The SSH string to delete.
*/
-void string_free(struct ssh_string_struct *s) {
+void ssh_string_free(struct ssh_string_struct *s) {
SAFE_FREE(s);
}
diff --git a/tests/test_exec.c b/tests/test_exec.c
index 1b2081d0..9f10520c 100644
--- a/tests/test_exec.c
+++ b/tests/test_exec.c
@@ -26,26 +26,26 @@ void do_connect(SSH_SESSION *session) {
return;
}
printf("Authenticated\n");
- channel = channel_new(session);
- channel_open_session(channel);
+ channel = ssh_channel_new(session);
+ ssh_channel_open_session(channel);
printf("Execute 'ls' on the channel\n");
- error = channel_request_exec(channel, "ls");
+ error = ssh_channel_request_exec(channel, "ls");
if(error != SSH_OK){
fprintf(stderr, "Error executing command: %s\n", ssh_get_error(session));
return;
}
printf("--------------------output----------------------\n");
- while (channel_read(channel, buf, sizeof(buf), 0)) {
+ while (ssh_channel_read(channel, buf, sizeof(buf), 0)) {
printf("%s", buf);
}
printf("\n");
printf("---------------------end------------------------\n");
- channel_send_eof(channel);
- fprintf(stderr, "Exit status: %d\n", channel_get_exit_status(channel));
+ ssh_channel_send_eof(channel);
+ fprintf(stderr, "Exit status: %d\n", ssh_channel_get_exit_status(channel));
printf("\nChannel test finished\n");
- channel_close(channel);
- channel_free(channel);
+ ssh_channel_close(channel);
+ ssh_channel_free(channel);
}
int main(int argc, char **argv){
diff --git a/tests/test_pcap.c b/tests/test_pcap.c
index 994ae4bf..01aa714a 100644
--- a/tests/test_pcap.c
+++ b/tests/test_pcap.c
@@ -32,7 +32,7 @@
int main(int argc, char **argv){
ssh_pcap_file pcap;
ssh_pcap_context ctx;
- ssh_buffer buffer=buffer_new();
+ ssh_buffer buffer=ssh_buffer_new();
char *str="Hello, this is a test string to test the capabilities of the"
"pcap file writer.";
printf("Simple pcap tester\n");
diff --git a/tests/test_tunnel.c b/tests/test_tunnel.c
index 5d1e7534..27f667b7 100644
--- a/tests/test_tunnel.c
+++ b/tests/test_tunnel.c
@@ -22,8 +22,8 @@ void do_connect(SSH_SESSION *session){
return;
}
printf("Authenticated\n");
- CHANNEL *channel=channel_new(session);
- error=channel_open_forward(channel,"localhost",ECHO_PORT,"localhost",42);
+ CHANNEL *channel=ssh_channel_new(session);
+ error=ssh_channel_open_forward(channel,"localhost",ECHO_PORT,"localhost",42);
if(error!=SSH_OK){
fprintf(stderr,"Error when opening forward:%s\n",ssh_get_error(session));
return;
@@ -34,14 +34,14 @@ void do_connect(SSH_SESSION *session){
char buffer[20];
for(i=0;i<2000;++i){
sprintf(string,"%d\n",i);
- channel_write(channel,string,strlen(string));
+ ssh_channel_write(channel,string,strlen(string));
do {
- error=channel_poll(channel,0);
+ error=ssh_channel_poll(channel,0);
//if(error < strlen(string))
//usleep(10);
} while(error < strlen(string) && error >= 0);
if(error>0){
- error=channel_read_nonblocking(channel,buffer,strlen(string),0);
+ error=ssh_channel_read_nonblocking(channel,buffer,strlen(string),0);
if(error>=0){
if(memcmp(buffer,string,strlen(string))!=0){
fprintf(stderr,"Problem with answer: wanted %s got %s\n",string,buffer);
@@ -58,8 +58,8 @@ void do_connect(SSH_SESSION *session){
}
}
printf("\nChannel test finished\n");
- channel_close(channel);
- channel_free(channel);
+ ssh_channel_close(channel);
+ ssh_channel_free(channel);
}
int main(int argc, char **argv){
diff --git a/tests/unittests/torture_keyfiles.c b/tests/unittests/torture_keyfiles.c
index 653bebab..7f57b5bf 100644
--- a/tests/unittests/torture_keyfiles.c
+++ b/tests/unittests/torture_keyfiles.c
@@ -64,7 +64,7 @@ START_TEST (torture_pubkey_from_file)
ck_assert_msg(rc == 0,ssh_get_error(session));
- string_free(pubkey);
+ ssh_string_free(pubkey);
/* test if it returns 1 if pubkey doesn't exist */
unlink(LIBSSH_RSA_TESTKEY ".pub");
@@ -138,9 +138,9 @@ START_TEST (torture_pubkey_generate_from_privkey)
ck_assert_msg(pubkey_new != NULL,ssh_get_error(session));
- ck_assert(string_len(pubkey_orig) == string_len(pubkey_new));
- ck_assert(memcmp(string_data(pubkey_orig), string_data(pubkey_new),
- string_len(pubkey_orig)) == 0);
+ ck_assert(ssh_string_len(pubkey_orig) == ssh_string_len(pubkey_new));
+ ck_assert(memcmp(ssh_string_data(pubkey_orig), ssh_string_data(pubkey_new),
+ ssh_string_len(pubkey_orig)) == 0);
rc = ssh_publickey_to_file(session, LIBSSH_RSA_TESTKEY ".pub", pubkey_new, type_new);
ck_assert_msg(rc == 0,ssh_get_error(session));
@@ -150,8 +150,8 @@ START_TEST (torture_pubkey_generate_from_privkey)
ck_assert_str_eq(pubkey_line_orig, pubkey_line_new);
- string_free(pubkey_orig);
- string_free(pubkey_new);
+ ssh_string_free(pubkey_orig);
+ ssh_string_free(pubkey_new);
}
END_TEST