Implemented X11 server side

src/channels.c

@@ -2928,6 +2928,69 @@ error:
   return rc;
 }
 
+/**
+ * @brief Open a X11 channel.
+ *
+ * @param[in]  channel      An allocated channel.
+ *
+ * @param[in]  orig_addr    The source host (the local server).
+ *
+ * @param[in]  orig_port    The source port (the local server).
+ *
+ * @return              SSH_OK on success, SSH_ERROR if an error occured.
+ *
+ * @warning This function does not bind the local port and does not automatically
+ *          forward the content of a socket to the channel. You still have to
+ *          use channel_read and channel_write for this.
+ */
+int ssh_channel_open_x11(ssh_channel channel, 
+                                        const char *orig_addr, int orig_port) {
+  ssh_session session;
+  ssh_buffer payload = NULL;
+  ssh_string str = NULL;
+  int rc = SSH_ERROR;
+
+  if(channel == NULL) {
+      return rc;
+  }
+  if(orig_addr == NULL) {
+      ssh_set_error_invalid(channel->session, __FUNCTION__);
+      return rc;
+  }
+
+
+  session = channel->session;
+
+  enter_function();
+
+  payload = ssh_buffer_new();
+  if (payload == NULL) {
+    ssh_set_error_oom(session);
+    goto error;
+  }
+
+  str = ssh_string_from_char(orig_addr);
+  if (str == NULL) {
+    ssh_set_error_oom(session);
+    goto error;
+  }
+
+  if (buffer_add_ssh_string(payload, str) < 0 ||
+      buffer_add_u32(payload,htonl(orig_port)) < 0) {
+    ssh_set_error_oom(session);
+    goto error;
+  }
+
+  rc = channel_open(channel, "x11", 64000, 32000, payload);
+
+error:
+  ssh_buffer_free(payload);
+  ssh_string_free(str);
+
+  leave_function();
+  return rc;
+}
+
 /**
  * @brief Send the exit status to the remote process (as described in RFC 4254, section 6.10).
  *

src/messages.c

@@ -988,6 +988,41 @@ int ssh_message_handle_channel_request(ssh_session session, ssh_channel channel,
     goto end;
   }
 
+  if (strcmp(request, "x11-req") == 0) {
+    ssh_string auth_protocol = NULL;
+    ssh_string auth_cookie = NULL;
+
+    buffer_get_u8(packet, &msg->channel_request.x11_single_connection);
+
+    auth_protocol = buffer_get_ssh_string(packet);
+    if (auth_protocol == NULL) {
+      ssh_set_error_oom(session);
+      goto error;
+    }
+    auth_cookie = buffer_get_ssh_string(packet);
+    if (auth_cookie == NULL) {
+      ssh_set_error_oom(session);
+      ssh_string_free(auth_protocol);
+      goto error;
+    }
+
+    msg->channel_request.type = SSH_CHANNEL_REQUEST_X11;
+    msg->channel_request.x11_auth_protocol = ssh_string_to_char(auth_protocol);
+    msg->channel_request.x11_auth_cookie = ssh_string_to_char(auth_cookie);
+    if (msg->channel_request.x11_auth_protocol == NULL ||
+        msg->channel_request.x11_auth_cookie == NULL) {
+      ssh_string_free(auth_protocol);
+      ssh_string_free(auth_cookie);
+      goto error;
+    }
+    ssh_string_free(auth_protocol);
+    ssh_string_free(auth_cookie);
+
+    buffer_get_u32(packet, &msg->channel_request.x11_screen_number);
+
+    goto end;
+  }
+
   msg->channel_request.type = SSH_CHANNEL_UNKNOWN;
 end:
   ssh_message_queue(session,msg);

src/server.c

@@ -1009,6 +1009,22 @@ const char *ssh_message_channel_request_subsystem(ssh_message msg){
     return msg->channel_request.subsystem;
 }
 
+int ssh_message_channel_request_x11_single_connection(ssh_message msg){
+    return msg->channel_request.x11_single_connection ? 1 : 0;
+}
+
+const char *ssh_message_channel_request_x11_auth_protocol(ssh_message msg){
+    return msg->channel_request.x11_auth_protocol;
+}
+
+const char *ssh_message_channel_request_x11_auth_cookie(ssh_message msg){
+    return msg->channel_request.x11_auth_cookie;
+}
+
+int ssh_message_channel_request_x11_screen_number(ssh_message msg){
+    return msg->channel_request.x11_screen_number;
+}
+
 const char *ssh_message_global_request_address(ssh_message msg){
     return msg->global_request.bind_address;
 }