work on shelly input (not tested)

include/aos/shelly_client.h

@@ -21,6 +21,7 @@ enum shelly_msg_type {
 struct shelly_header {
     enum shelly_msg_type type;
     char character;
+    errval_t err;
 };
 
 struct shelly_client_state {

lib/aos/shelly_client.c

@@ -39,6 +39,7 @@ errval_t shelly_client_init(void) {
 }
 
 static void handle_payload(void *arg, size_t payload_size, void *payload) {
+    state.current_request = NULL;
     state.request_ongoing = false;
 }
 
@@ -68,15 +69,15 @@ errval_t shelly_client_getchar(struct aos_rpc * rpc, char * ret) {
     errval_t err;
     SHELLY_CLIENT_DEBUG("[shelly_client_getchar]\n");
 
-    state.request_ongoing = true;
-    state.buf = ret;
-
     struct shelly_header * header = malloc(sizeof(struct shelly_header));
     if (header == NULL) return LIB_ERR_MALLOC_FAIL;
-    state.current_request = header;
     struct ump_send_queue_entry *entry = malloc(sizeof(struct ump_send_queue_entry));
     if (entry == NULL) return LIB_ERR_MALLOC_FAIL;
 
+    state.request_ongoing = true;
+    state.buf = ret;
+    state.current_request = header;
+
     header->type = SHELLY_MSG_GETCHAR;
     header->character = 0;
 
@@ -102,14 +103,15 @@ errval_t shelly_client_putchar(struct aos_rpc * rpc, char input) {
     errval_t err;
     SHELLY_CLIENT_DEBUG("[shelly_client_putchar]\n");
 
-    state.request_ongoing = true;
-
     struct shelly_header * header = malloc(sizeof(struct shelly_header));
     if (header == NULL) return LIB_ERR_MALLOC_FAIL;
-    state.current_request = header;
     struct ump_send_queue_entry *entry = malloc(sizeof(struct ump_send_queue_entry));
     if (entry == NULL) return LIB_ERR_MALLOC_FAIL;
 
+    state.request_ongoing = true;
+    state.current_request = header;
+    state.buf = NULL;
+
     header->type = SHELLY_MSG_PUTCHAR;
     header->character = input;
 

usr/hello/hello.c

@@ -26,6 +26,7 @@
 #define HELLO_CMD_SPAWN "spawn"
 #define HELLO_CMD_SPAWN_REMOTE "spawn_remote"
 #define HELLO_CMD_ECHOCLIENT "echoclient"
+#define HELLO_CMD_IO "io"
 
 #define HELLO_CMDLINE_READ_LEN 100
 
@@ -183,5 +184,16 @@ int main(int argc, char *argv[])
         ump_recv_header(recv_chan, handle_header_recv, recv_chan);
     }
 
+    if (argc > 1 && !strncmp(argv[1], HELLO_CMD_IO, sizeof(HELLO_CMD_IO))) {
+        int testInteger;
+        printf("Hi! Please enter an integer: ");
+        scanf("%d", &testInteger);  
+        printf("number = %d",testInteger);
+        char name_input[20];
+        printf("Please enter your name: ");
+        scanf("%s", name_input);
+        printf("why hello there, %s", name_input);
+    }
+
     return EXIT_SUCCESS;
 }

usr/shelly/shelly.c

@@ -78,7 +78,21 @@ static void handle_lpuart_interrupt(void * arg) {
         if (is_newline(input_char)) {
             err = lpuart_putchar(global_state->uart_s, ASCII_CR);
             if (err_is_fail(err)) USER_PANIC_ERR(err, "while trying to put character");
+        }
 
+        if (global_state->current_getchar_request != NULL) {
+            // a client is waiting for a getchar request, forward it.
+            if (is_newline(input_char)) {
+                input_char = '\0';
+            }
+            send_response(global_state->current_getchar_request, SYS_ERR_OK, input_char, 0, NULL);
+            global_state->current_getchar_request = NULL;
+            continue;
+        }
+
+        assert(global_state->current_getchar_request == NULL);
+        //handle as shell input
+        if (is_newline(input_char)) {
             global_state->buf[global_state->buffer_i] = '\0';
             global_state->buffer_i += 1;
 
@@ -108,13 +122,15 @@ static void handle_send_completed(void *arg, struct ump_send_queue_entry *entry)
     free(entry);
 }
 
-static void send_response(struct shelly_st_local * local_state, errval_t err, size_t payload_size, void *payload) {
+static void send_response(struct shelly_st_local * local_state, errval_t err, char c, size_t payload_size, void *payload) {
     assert(local_state);
 
     // SHELLY_DEBUG("[send_response]\n");
     struct shelly_header * header = malloc(sizeof(struct shelly_header));
     assert(header);
     header->type = SHELLY_MSG_RESPONSE;
+    header->err = err;
+    header->character = c;
 
     struct ump_send_queue_entry *entry = malloc(sizeof(struct ump_send_queue_entry));
     if (entry == NULL) USER_PANIC("Ran out of memory");
@@ -132,7 +148,6 @@ static void send_response(struct shelly_st_local * local_state, errval_t err, si
     // SHELLY_DEBUG("[send_response] done\n");
 }
 
-static void handle_client_request(void *arg, size_t header_size, void *header_buf, size_t payload_size);
 static void handle_payload(void *arg, size_t payload_size, void *payload) {
     struct shelly_st_local * local_state = arg;
     assert(local_state);
@@ -153,9 +168,7 @@ static void handle_client_request(void *arg, size_t header_size, void *header_bu
     struct shelly_header * header = (struct shelly_header *) header_buf;
 
     if (header->type == SHELLY_MSG_GETCHAR) {
-        char input_char = '\0';
+        global_state->current_getchar_request = local_state;
-        err = lpuart_getchar(global_state->uart_s, &input_char);
-        if (err_is_fail(err)) USER_PANIC_ERR(err, "while trying to get character");
     } else if (header->type == SHELLY_MSG_PUTCHAR) {
         err = lpuart_putchar(global_state->uart_s, header->character);
         if (err_is_fail(err)) USER_PANIC_ERR(err, "while trying to put character");
@@ -163,10 +176,9 @@ static void handle_client_request(void *arg, size_t header_size, void *header_bu
             err = lpuart_putchar(global_state->uart_s, ASCII_CR);
             if (err_is_fail(err)) USER_PANIC_ERR(err, "while trying to put character");
         }
+        send_response(local_state, SYS_ERR_OK, '\0', 0, NULL);
     }
 
-    send_response(local_state, SYS_ERR_OK, 0, NULL);
-
     // skip payload
     ump_recv_payload(local_state->recv_chan, NULL, handle_payload, local_state);
 }
@@ -209,6 +221,7 @@ int main(int argc, char *argv[])
     global_state->num_clients = 0;
     global_state->buffer_i = 0;
     global_state->ws = get_default_waitset();
+    global_state->current_getchar_request = NULL;
 
     //afeer: map lpuart registers
     struct capref cap_arg0 = {

usr/shelly/shelly.h

@@ -28,6 +28,15 @@
 #define ASCII_EOT 3 // < end of text
 
 #define SHELLY_BUF_SIZE 2048
+
+//state that different for each client
+struct shelly_st_local {
+    uint32_t client_id;
+    struct ump_recv_chan * recv_chan;
+    struct ump_send_chan * send_chan;
+
+};
+
 //state that is shared for all clients
 struct shelly_st_global {
     struct waitset * ws;
@@ -41,18 +50,15 @@ struct shelly_st_global {
     u_int32_t num_clients;
     char buf[SHELLY_BUF_SIZE];
     size_t buffer_i;
-};
 
-//state that different for each client
+    struct shelly_st_local * current_getchar_request; // < the getchar request that is currently being served, NULL if there is none.
-struct shelly_st_local {
-    uint32_t client_id;
-    struct ump_recv_chan * recv_chan;
-    struct ump_send_chan * send_chan;
 };
 
 bool is_newline(char c);
 errval_t shelly_write_str(char * str);
 void shelly_reset_buffer(void);
 errval_t shelly_buffer_append(char c);
+static void handle_client_request(void *arg, size_t header_size, void *header_buf, size_t payload_size);
+static void send_response(struct shelly_st_local * local_state, errval_t err, char c, size_t payload_size, void *payload);
 
 #endif // ndef SHELLY_H_