Skip to content
Snippets Groups Projects
Select Git revision
  • c53b3377eec76b21626ff498df610b1e70e07ae2
  • master default
  • wip-add-ed25519
  • disable-sha1
  • lsh-2.0.4
  • experimental-20050201
  • lsh-1.4.2
  • lsh-1.2
  • lsh_2.1_release_20130626
  • converted-master-branch-to-git
  • nettle_2.4_release_20110903
  • nettle_2.3_release_20110902
  • nettle_2.2_release_20110711
  • nettle_2.1_release_20100725
  • camellia_32bit_20100720
  • nettle_2.0_release_20090608
  • converted-lsh-2.0.4-branch-to-git
  • lsh_2.0.4_release_20070905
  • lsh_2.9_exp_release_20070404
  • nettle_1.15_release_20061128
  • after_experimental_merge_20060516
  • branch_before_experimental_merge_20060516
  • converted-experimental-branch-to-git
  • head_before_experimental_merge_20060516
  • lsh_2.0.3_release_20060509
  • lsh_2.0.2_release_20060127
  • nettle_1.14_release_20051205
  • nettle_1.13_release_20051006
28 results

server.c

Blame
  • Niels Möller's avatar
    Niels Möller authored
    Rev: src/client.c:1.10
    Rev: src/server.c:1.3
    c53b3377
    History
    server.c 3.11 KiB
    /* server.c
     *
     */
    
    #include "server.h"
    
    #include "version.h"
    #include "connection.h"
    #include "abstract_io.h"
    #include "read_line.h"
    #include "read_packet.h"
    #include "debug.h"
    #include "format.h"
    #include "werror.h"
    #include "void.h"
    #include "xalloc.h"
    
    struct read_handler *make_server_read_line();
    struct callback *make_server_close_handler();
    
    static int server_initiate(struct fd_callback **c,
    			   int fd)
    {
      struct server_callback *closure = (struct server_callback *) *c;
      
      /* FIXME: Should pass a key exchange handler, not NULL! */
      struct ssh_connection *connection = make_ssh_connection(NULL);
      struct abstract_write *write =
        io_read_write(closure->backend, fd,
    		  make_server_read_line(),
    		  closure->block_size,
    		  make_server_close_handler());
      
      connection->server_version
        = ssh_format("SSH-%lz-%lz %lz",
    		 PROTOCOL_VERSION,
    		 SOFTWARE_SERVER_VERSION,
    		 closure->id_comment);
    
      return A_WRITE(write, ssh_format("%lS\r\n", connection->server_version));
    }
    
    struct server_line_handler
    {
      struct line_handler super;
      struct ssh_connection *connection;
    };
    
    static struct read_handler *do_line(struct line_handler **h,
    				    UINT32 length,
    				    UINT8 *line)
    {
      struct server_line_handler *closure = (struct server_line_handler *) *h;
      
      if ( (length >= 4) && !memcmp(line, "SSH-", 4))
        {
          /* Parse and remember format string */
          if ((length >= 8) && !memcmp(line + 4, "2.0-", 4))
    	{
    	  struct read_handler *new
    	    = make_read_packet(make_packet_debug(&closure->connection->super,
    						 stderr),
    			       closure->connection->max_packet);
    	  
    	  closure->connection->client_version
    	    = ssh_format("%ls", length, line);
    
    	  verbose("Client version: ");
    	  verbose_safe(closure->connection->client_version->length,
    		       closure->connection->client_version->data);
    	  verbose("\n");
    	  
    	  /* FIXME: Cleanup properly. */
    	  lsh_free(closure);
    
    	  return new;
    	}
          else
    	{
    	  werror("Unsupported protocol version: ");
    	  werror_safe(length, line);
    	  werror("\n");
    
    	  /* FIXME: Clean up properly */
    	  lsh_free(closure);
    	  *h = 0;
    		  
    	  return 0;
    	}
        }
      else
        {
          /* Display line */
          werror_safe(length, line);
    
          /* Read next line */
          return 0;
        }
    }
    
    struct read_handler *make_server_read_line(struct ssh_connection *s)
    {
      struct server_line_handler *closure
        = xalloc(sizeof(struct server_line_handler));
      
      closure->super.handler = do_line;
      closure->connection = s;
      
      return make_read_line(&closure->super);
    }
    
    struct fd_callback *make_server_callback(struct io_backend *b,
    					 char *comment,
    					 UINT32 block_size)
    					 
    {
      struct server_callback *connected = xalloc(sizeof(struct server_callback));
    
      connected->super.f = server_initiate;
      connected->backend = b;
      connected->block_size = block_size;
      connected->id_comment = comment;
      
      return &connected->super;
    }
    
    static int server_die(struct callback *closure)
    {
      werror("Connection died.\n");
      /* FIXME: Cleanup properly. */
      return 0;  /* Ignored */
    }
    
    struct callback *make_server_close_handler()
    {
      struct callback *c = xalloc(sizeof(struct callback));
    
      c->f = server_die;
    
      return c;
    }