add simple-server

simple-server/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_executable(simple-server main.c)
+
+target_link_libraries(simple-server ssh::ssh)

simple-server/main.c

@@ -0,0 +1,187 @@
+#include "config.h"
+
+#include <libssh/libssh.h>
+#include <libssh/server.h>
+#include <libssh/callbacks.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "priv_key.h"
+
+#define BUF_SIZE 2049
+
+#define USER "odroid"
+#define PASSWORD "odroid"
+
+static int authenticated=0;
+static int tries = 0;
+static int error = 0;
+static ssh_channel chan=NULL;
+
+static int auth_none(ssh_session session,
+                     const char *user,
+                     void *userdata)
+{
+    char buf[100];
+    ssh_string banner = NULL;
+
+    (void)userdata; /* unused */
+
+    ssh_set_auth_methods(session,
+                         SSH_AUTH_METHOD_PASSWORD);
+
+    sprintf(buf, "hello [%s]!\n", user);
+    banner = ssh_string_from_char(buf);
+    if (banner != NULL) {
+        ssh_send_issue_banner(session, banner);
+    }
+    ssh_string_free(banner);
+
+    return SSH_AUTH_DENIED;
+}
+
+static int auth_password(ssh_session session, const char *user,
+        const char *password, void *userdata){
+    (void)userdata;
+    ssh_string banner = NULL;
+    printf("Authenticating user %s pwd %s\n",user, password);
+    if(strcmp(user,USER) == 0 && strcmp(password, PASSWORD) == 0){
+        authenticated = 1;
+        printf("Authenticated\n");
+        banner = ssh_string_from_char("Authenticated\n");
+        ssh_send_issue_banner(session, banner);
+        ssh_string_free(banner);
+        return SSH_AUTH_SUCCESS;
+    }
+    if (tries >= 3){
+        printf("Too many authentication tries\n");
+        ssh_disconnect(session);
+        error = 1;
+        return SSH_AUTH_DENIED;
+    }
+    tries++;
+    return SSH_AUTH_DENIED;
+}
+
+static int pty_request(ssh_session session, ssh_channel channel, const char *term,
+        int x,int y, int px, int py, void *userdata){
+    (void) session;
+    (void) channel;
+    (void) userdata;
+    printf("Allocated terminal\n");
+    printf("trem: %s, x: %d, y: %d, px: %d, py %d\n", term, x, y, px, py);
+    return 0;
+}
+
+static int shell_request(ssh_session session, ssh_channel channel, void *userdata){
+    (void)session;
+    (void)channel;
+    (void)userdata;
+    printf("Allocated shell\n");
+    return 0;
+}
+struct ssh_channel_callbacks_struct channel_cb = {
+    .channel_pty_request_function = pty_request,
+    .channel_shell_request_function = shell_request
+};
+
+static ssh_channel new_session_channel(ssh_session session, void *userdata){
+    (void) session;
+    (void) userdata;
+    if(chan != NULL)
+        return NULL;
+    printf("Allocated session channel\n");
+    chan = ssh_channel_new(session);
+    ssh_callbacks_init(&channel_cb);
+    ssh_set_channel_callbacks(chan, &channel_cb);
+    return chan;
+}
+
+int main(int argc, char **argv)
+{
+    ssh_session session = NULL;
+    ssh_bind sshbind = NULL;
+    ssh_event mainloop = NULL;
+    struct ssh_server_callbacks_struct cb = {
+        .userdata = NULL,
+        .auth_none_function = auth_none,
+        .auth_password_function = auth_password,
+        .channel_open_request_session_function = new_session_channel
+    };
+
+    char buf[BUF_SIZE];
+    int i;
+    int r;
+
+    sshbind=ssh_bind_new();
+    session=ssh_new();
+    ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_BINDPORT_STR, "11422");
+    ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_BINDADDR, "0.0.0.0");
+    ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_IMPORT_KEY_STR, HOST_KEY);
+
+    (void) argc;
+    (void) argv;
+
+    if(ssh_bind_listen(sshbind)<0){
+        printf("Error listening to socket: %s\n",ssh_get_error(sshbind));
+        return 1;
+    }
+    r=ssh_bind_accept(sshbind,session);
+    if(r==SSH_ERROR){
+        printf("error accepting a connection : %s\n",ssh_get_error(sshbind));
+        return 1;
+    }
+    ssh_callbacks_init(&cb);
+    ssh_set_server_callbacks(session, &cb);
+
+    if (ssh_handle_key_exchange(session)) {
+        printf("ssh_handle_key_exchange: %s\n", ssh_get_error(session));
+        return 1;
+    }
+    ssh_set_auth_methods(session,SSH_AUTH_METHOD_PASSWORD);
+    mainloop = ssh_event_new();
+    ssh_event_add_session(mainloop, session);
+
+    while (!(authenticated && chan != NULL)){
+        if(error)
+            break;
+        r = ssh_event_dopoll(mainloop, -1);
+        if (r == SSH_ERROR){
+            printf("Error : %s\n",ssh_get_error(session));
+            ssh_disconnect(session);
+            return 1;
+        }
+    }
+    if(error){
+        printf("Error, exiting loop\n");
+    } else
+        printf("Authenticated and got a channel\n");
+    do{
+        i=ssh_channel_read(chan, buf, sizeof(buf) - 1, 0);
+        if(i>0) {
+            if (ssh_channel_write(chan, buf, i) == SSH_ERROR) {
+                printf("error writing to channel\n");
+                return 1;
+            }
+
+            buf[i] = '\0';
+            printf("%s", buf);
+            fflush(stdout);
+
+            if (buf[0] == '\x0d') {
+                if (ssh_channel_write(chan, "\n", 1) == SSH_ERROR) {
+                    printf("error writing to channel\n");
+                    return 1;
+                }
+
+                printf("\n");
+            }
+        }
+    } while (i>0);
+    ssh_disconnect(session);
+    ssh_bind_free(sshbind);
+    ssh_finalize();
+    return 0;
+}