ssh.h

   1 /*
   2
   3 ssh.h
   4
   5 Author: Tatu Ylonen <ylo@cs.hut.fi>
   6
   7 Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   8                    All rights reserved
   9
  10 Created: Fri Mar 17 17:09:37 1995 ylo
  11
  12 Generic header file for ssh.
  13
  14 */
  15
  16 /* RCSID("$Id$"); */
  17
  18 #ifndef SSH_H
  19 #define SSH_H
  20
  21 /* Added by Dan */
  22 #ifndef SHUT_RDWR
  23 enum
  24 {
  25   SHUT_RD = 0,    /* No more receptions.  */
  26 #define SHUT_RD   SHUT_RD
  27   SHUT_WR,    /* No more transmissions.  */
  28 #define SHUT_WR   SHUT_WR
  29   SHUT_RDWR   /* No more receptions or transmissions.  */
  30 #define SHUT_RDWR SHUT_RDWR
  31 };
  32 #endif
  33
  34
  35 #include "rsa.h"
  36 #include "cipher.h"
  37
  38 /* The default cipher used if IDEA is not supported by the remote host.
  39    It is recommended that this be one of the mandatory ciphers (DES, 3DES),
  40    though that is not required. */
  41 #define SSH_FALLBACK_CIPHER     SSH_CIPHER_3DES
  42
  43 /* Cipher used for encrypting authentication files. */
  44 #define SSH_AUTHFILE_CIPHER     SSH_CIPHER_3DES
  45
  46 /* Default port number. */
  47 #define SSH_DEFAULT_PORT        22
  48
  49 /* Maximum number of TCP/IP ports forwarded per direction. */
  50 #define SSH_MAX_FORWARDS_PER_DIRECTION  100
  51
  52 /* Maximum number of RSA authentication identity files that can be specified
  53    in configuration files or on the command line. */
  54 #define SSH_MAX_IDENTITY_FILES          100
  55
  56 /* Major protocol version.  Different version indicates major incompatiblity
  57    that prevents communication.  */
  58 #define PROTOCOL_MAJOR          1
  59
  60 /* Minor protocol version.  Different version indicates minor incompatibility
  61    that does not prevent interoperation. */
  62 #define PROTOCOL_MINOR          5
  63
  64 /* Name for the service.  The port named by this service overrides the default
  65    port if present. */
  66 #define SSH_SERVICE_NAME        "ssh"
  67
  68 #ifndef ETCDIR
  69 #define ETCDIR                  "/etc"
  70 #endif /* ETCDIR */
  71
  72 #define PIDDIR                  "/var/run"
  73
  74 /* System-wide file containing host keys of known hosts.  This file should be
  75    world-readable. */
  76 #define SSH_SYSTEM_HOSTFILE     ETCDIR "/ssh_known_hosts"
  77
  78 /*  HOST_KEY_FILE               /etc/ssh_host_key,
  79     SERVER_CONFIG_FILE          /etc/sshd_config,
  80 and HOST_CONFIG_FILE            /etc/ssh_config
  81 are all defined in Makefile.in.  Of these, ssh_host_key should be readable
  82 only by root, whereas ssh_config should be world-readable. */
  83
  84 #define HOST_KEY_FILE           ETCDIR "/ssh_host_key"
  85 #define SERVER_CONFIG_FILE      ETCDIR "/sshd_config"
  86 #define HOST_CONFIG_FILE        ETCDIR "/ssh_config"
  87
  88 #ifndef SSH_PROGRAM
  89 #define SSH_PROGRAM             "/usr/bin/ssh"
  90 #endif /* SSH_PROGRAM */
  91
  92 #ifndef LOGIN_PROGRAM
  93 #define LOGIN_PROGRAM   "/usr/bin/login"
  94 #endif /* LOGIN_PROGRAM */
  95
  96 #ifndef ASKPASS_PROGRAM
  97 #define ASKPASS_PROGRAM "/usr/lib/ssh/ssh-askpass"
  98 #endif /* ASKPASS_PROGRAM */
  99
 100 /* The process id of the daemon listening for connections is saved
 101    here to make it easier to kill the correct daemon when necessary. */
 102 #define SSH_DAEMON_PID_FILE     PIDDIR "/sshd.pid"
 103
 104 /* The directory in user\'s home directory in which the files reside.
 105    The directory should be world-readable (though not all files are). */
 106 #define SSH_USER_DIR            ".ssh"
 107
 108 /* Per-user file containing host keys of known hosts.  This file need
 109    not be readable by anyone except the user him/herself, though this does
 110    not contain anything particularly secret. */
 111 #define SSH_USER_HOSTFILE       "~/.ssh/known_hosts"
 112
 113 /* Name of the default file containing client-side authentication key.
 114    This file should only be readable by the user him/herself. */
 115 #define SSH_CLIENT_IDENTITY     ".ssh/identity"
 116
 117 /* Configuration file in user\'s home directory.  This file need not be
 118    readable by anyone but the user him/herself, but does not contain
 119    anything particularly secret.  If the user\'s home directory resides
 120    on an NFS volume where root is mapped to nobody, this may need to be
 121    world-readable. */
 122 #define SSH_USER_CONFFILE       ".ssh/config"
 123
 124 /* File containing a list of those rsa keys that permit logging in as
 125    this user.  This file need not be
 126    readable by anyone but the user him/herself, but does not contain
 127    anything particularly secret.  If the user\'s home directory resides
 128    on an NFS volume where root is mapped to nobody, this may need to be
 129    world-readable.  (This file is read by the daemon which is running as
 130    root.) */
 131 #define SSH_USER_PERMITTED_KEYS ".ssh/authorized_keys"
 132
 133 /* Per-user and system-wide ssh "rc" files.  These files are executed with
 134    /bin/sh before starting the shell or command if they exist.  They
 135    will be passed "proto cookie" as arguments if X11 forwarding with
 136    spoofing is in use.  xauth will be run if neither of these exists. */
 137 #define SSH_USER_RC             ".ssh/rc"
 138 #define SSH_SYSTEM_RC           ETCDIR "/sshrc"
 139
 140 /* Ssh-only version of /etc/hosts.equiv. */
 141 #define SSH_HOSTS_EQUIV         ETCDIR "/shosts.equiv"
 142
 143 /* Additionally, the daemon may use ~/.rhosts and /etc/hosts.equiv if
 144    rhosts authentication is enabled. */
 145
 146 /* Name of the environment variable containing the pathname of the
 147    authentication socket. */
 148 #define SSH_AUTHSOCKET_ENV_NAME "SSH_AUTH_SOCK"
 149
 150 /* Name of the environment variable containing the pathname of the
 151         authentication socket. */
 152 #define SSH_AGENTPID_ENV_NAME  "SSH_AGENT_PID"
 153
 154 /* Force host key length and server key length to differ by at least this
 155    many bits.  This is to make double encryption with rsaref work. */
 156 #define SSH_KEY_BITS_RESERVED           128
 157
 158 /* Length of the session key in bytes.  (Specified as 256 bits in the
 159    protocol.)  */
 160 #define SSH_SESSION_KEY_LENGTH          32
 161
 162 /* Name of Kerberos service for SSH to use. */
 163 #define KRB4_SERVICE_NAME               "rcmd"
 164
 165 /* Authentication methods.  New types can be added, but old types should not
 166    be removed for compatibility.  The maximum allowed value is 31. */
 167 #define SSH_AUTH_RHOSTS         1
 168 #define SSH_AUTH_RSA            2
 169 #define SSH_AUTH_PASSWORD       3
 170 #define SSH_AUTH_RHOSTS_RSA     4
 171                                 /* 5 is TIS */
 172 #define SSH_AUTH_KERBEROS       6
 173 #define SSH_PASS_KERBEROS_TGT   7
 174                                 /* 8 to 15 are reserved */
 175 #define SSH_PASS_AFS_TOKEN      21
 176
 177 /* Protocol flags.  These are bit masks. */
 178 #define SSH_PROTOFLAG_SCREEN_NUMBER     1 /* X11 forwarding includes screen */
 179 #define SSH_PROTOFLAG_HOST_IN_FWD_OPEN  2 /* forwarding opens contain host */
 180
 181 /* Definition of message types.  New values can be added, but old values
 182    should not be removed or without careful consideration of the consequences
 183    for compatibility.  The maximum value is 254; value 255 is reserved
 184    for future extension. */
 185 /* Message name */                      /* msg code */  /* arguments */
 186 #define SSH_MSG_NONE                            0       /* no message */
 187 #define SSH_MSG_DISCONNECT                      1       /* cause (string) */
 188 #define SSH_SMSG_PUBLIC_KEY                     2       /* ck,msk,srvk,hostk */
 189 #define SSH_CMSG_SESSION_KEY                    3       /* key (BIGNUM) */
 190 #define SSH_CMSG_USER                           4       /* user (string) */
 191 #define SSH_CMSG_AUTH_RHOSTS                    5       /* user (string) */
 192 #define SSH_CMSG_AUTH_RSA                       6       /* modulus (BIGNUM) */
 193 #define SSH_SMSG_AUTH_RSA_CHALLENGE             7       /* int (BIGNUM) */
 194 #define SSH_CMSG_AUTH_RSA_RESPONSE              8       /* int (BIGNUM) */
 195 #define SSH_CMSG_AUTH_PASSWORD                  9       /* pass (string) */
 196 #define SSH_CMSG_REQUEST_PTY                    10      /* TERM, tty modes */
 197 #define SSH_CMSG_WINDOW_SIZE                    11      /* row,col,xpix,ypix */
 198 #define SSH_CMSG_EXEC_SHELL                     12      /* */
 199 #define SSH_CMSG_EXEC_CMD                       13      /* cmd (string) */
 200 #define SSH_SMSG_SUCCESS                        14      /* */
 201 #define SSH_SMSG_FAILURE                        15      /* */
 202 #define SSH_CMSG_STDIN_DATA                     16      /* data (string) */
 203 #define SSH_SMSG_STDOUT_DATA                    17      /* data (string) */
 204 #define SSH_SMSG_STDERR_DATA                    18      /* data (string) */
 205 #define SSH_CMSG_EOF                            19      /* */
 206 #define SSH_SMSG_EXITSTATUS                     20      /* status (int) */
 207 #define SSH_MSG_CHANNEL_OPEN_CONFIRMATION       21      /* channel (int) */
 208 #define SSH_MSG_CHANNEL_OPEN_FAILURE            22      /* channel (int) */
 209 #define SSH_MSG_CHANNEL_DATA                    23      /* ch,data (int,str) */
 210 #define SSH_MSG_CHANNEL_CLOSE                   24      /* channel (int) */
 211 #define SSH_MSG_CHANNEL_CLOSE_CONFIRMATION      25      /* channel (int) */
 212 /*      SSH_CMSG_X11_REQUEST_FORWARDING         26         OBSOLETE */
 213 #define SSH_SMSG_X11_OPEN                       27      /* channel (int) */
 214 #define SSH_CMSG_PORT_FORWARD_REQUEST           28      /* p,host,hp (i,s,i) */
 215 #define SSH_MSG_PORT_OPEN                       29      /* ch,h,p (i,s,i) */
 216 #define SSH_CMSG_AGENT_REQUEST_FORWARDING       30      /* */
 217 #define SSH_SMSG_AGENT_OPEN                     31      /* port (int) */
 218 #define SSH_MSG_IGNORE                          32      /* string */
 219 #define SSH_CMSG_EXIT_CONFIRMATION              33      /* */
 220 #define SSH_CMSG_X11_REQUEST_FORWARDING         34      /* proto,data (s,s) */
 221 #define SSH_CMSG_AUTH_RHOSTS_RSA                35      /* user,mod (s,mpi) */
 222 #define SSH_MSG_DEBUG                           36      /* string */
 223 #define SSH_CMSG_REQUEST_COMPRESSION            37      /* level 1-9 (int) */
 224 #define SSH_CMSG_MAX_PACKET_SIZE                38      /* size 4k-1024k (int) */
 225 #define SSH_CMSG_AUTH_TIS                       39      /* this is proto-1.5, but we ignore TIS */
 226 #define SSH_SMSG_AUTH_TIS_CHALLENGE             40
 227 #define SSH_CMSG_AUTH_TIS_RESPONSE              41
 228
 229 #define SSH_CMSG_AUTH_KERBEROS                  42      /* (KTEXT) */
 230 #define SSH_SMSG_AUTH_KERBEROS_RESPONSE         43      /* (KTEXT) */
 231 #define SSH_CMSG_HAVE_KERBEROS_TGT              44      /* credentials (s) */
 232 #define SSH_CMSG_HAVE_AFS_TOKEN                 65      /* token (s) */
 233
 234
 235 /* Includes that need definitions above. */
 236
 237 #include "readconf.h"
 238
 239 /*------------ definitions for login.c -------------*/
 240
 241 /* Returns the time when the user last logged in.  Returns 0 if the
 242    information is not available.  This must be called before record_login.
 243    The host from which the user logged in is stored in buf. */
 244 unsigned long get_last_login_time(uid_t uid, const char *logname,
 245                                   char *buf, unsigned int bufsize);
 246
 247 /* Records that the user has logged in.  This does many things normally
 248    done by login(1). */
 249 void record_login(int pid, const char *ttyname, const char *user, uid_t uid,
 250                   const char *host, struct sockaddr_in *addr);
 251
 252 /* Records that the user has logged out.  This does many thigs normally
 253    done by login(1) or init. */
 254 void record_logout(int pid, const char *ttyname);
 255
 256 /*------------ definitions for sshconnect.c ----------*/
 257
 258 /* Opens a TCP/IP connection to the remote server on the given host.  If
 259    port is 0, the default port will be used.  If anonymous is zero,
 260    a privileged port will be allocated to make the connection.
 261    This requires super-user privileges if anonymous is false.
 262    Connection_attempts specifies the maximum number of tries, one per
 263    second.  This returns true on success, and zero on failure.  If the
 264    connection is successful, this calls packet_set_connection for the
 265    connection. */
 266 int ssh_connect(const char *host, struct sockaddr_in *hostaddr,
 267                 int port, int connection_attempts,
 268                 int anonymous, uid_t original_real_uid,
 269                 const char *proxy_command);
 270
 271 /* Starts a dialog with the server, and authenticates the current user on the
 272    server.  This does not need any extra privileges.  The basic connection
 273    to the server must already have been established before this is called.
 274    If login fails, this function prints an error and never returns.
 275    This initializes the random state, and leaves it initialized (it will also
 276    have references from the packet module). */
 277 void ssh_login(int host_key_valid, RSA *host_key, const char *host,
 278                struct sockaddr_in *hostaddr, Options *options,
 279                uid_t original_real_uid);
 280
 281 /*------------ Definitions for various authentication methods. -------*/
 282
 283 /* Tries to authenticate the user using the .rhosts file.  Returns true if
 284    authentication succeeds.  If ignore_rhosts is non-zero, this will not
 285    consider .rhosts and .shosts (/etc/hosts.equiv will still be used).
 286    If strict_modes is true, checks ownership and modes of .rhosts/.shosts. */
 287 int auth_rhosts(struct passwd *pw, const char *client_user,
 288                 int ignore_rhosts, int strict_modes);
 289
 290 /* Tries to authenticate the user using the .rhosts file and the host using
 291    its host key.  Returns true if authentication succeeds. */
 292 int auth_rhosts_rsa(struct passwd *pw, const char *client_user,
 293                     unsigned int bits, BIGNUM *client_host_key_e,
 294                     BIGNUM *client_host_key_n, int ignore_rhosts,
 295                     int strict_modes);
 296
 297 /* Tries to authenticate the user using password.  Returns true if
 298    authentication succeeds. */
 299 int auth_password(struct passwd *pw, const char *password);
 300
 301 /* Performs the RSA authentication dialog with the client.  This returns
 302    0 if the client could not be authenticated, and 1 if authentication was
 303    successful.  This may exit if there is a serious protocol violation. */
 304 int auth_rsa(struct passwd *pw, BIGNUM *client_n, int strict_modes);
 305
 306 /* Parses an RSA key (number of bits, e, n) from a string.  Moves the pointer
 307    over the key.  Skips any whitespace at the beginning and at end. */
 308 int auth_rsa_read_key(char **cpp, unsigned int *bitsp, BIGNUM *e, BIGNUM *n);
 309
 310 /* Returns the name of the machine at the other end of the socket.  The
 311    returned string should be freed by the caller. */
 312 char *get_remote_hostname(int socket);
 313
 314 /* Return the canonical name of the host in the other side of the current
 315    connection (as returned by packet_get_connection).  The host name is
 316    cached, so it is efficient to call this several times. */
 317 const char *get_canonical_hostname(void);
 318
 319 /* Returns the remote IP address as an ascii string.  The value need not be
 320    freed by the caller. */
 321 const char *get_remote_ipaddr(void);
 322
 323 /* Returns the port number of the peer of the socket. */
 324 int get_peer_port(int sock);
 325
 326 /* Returns the port number of the remote host. */
 327 int get_remote_port(void);
 328
 329 /* Tries to match the host name (which must be in all lowercase) against the
 330    comma-separated sequence of subpatterns (each possibly preceded by ! to
 331    indicate negation).  Returns true if there is a positive match; zero
 332    otherwise. */
 333 int match_hostname(const char *host, const char *pattern, unsigned int len);
 334
 335 /* Checks whether the given host is already in the list of our known hosts.
 336    Returns HOST_OK if the host is known and has the specified key,
 337    HOST_NEW if the host is not known, and HOST_CHANGED if the host is known
 338    but used to have a different host key.  The host must be in all lowercase. */
 339 typedef enum { HOST_OK, HOST_NEW, HOST_CHANGED } HostStatus;
 340 HostStatus check_host_in_hostfile(const char *filename,
 341                                   const char *host, unsigned int bits,
 342                                   BIGNUM *e, BIGNUM *n,
 343                                   BIGNUM *ke, BIGNUM *kn);
 344
 345 /* Appends an entry to the host file.  Returns false if the entry
 346    could not be appended. */
 347 int add_host_to_hostfile(const char *filename, const char *host,
 348                          unsigned int bits, BIGNUM *e, BIGNUM *n);
 349
 350 /* Performs the RSA authentication challenge-response dialog with the client,
 351    and returns true (non-zero) if the client gave the correct answer to
 352    our challenge; returns zero if the client gives a wrong answer. */
 353 int auth_rsa_challenge_dialog(unsigned int bits, BIGNUM *e, BIGNUM *n);
 354
 355 /* Reads a passphrase from /dev/tty with echo turned off.  Returns the
 356    passphrase (allocated with xmalloc).  Exits if EOF is encountered.
 357    If from_stdin is true, the passphrase will be read from stdin instead. */
 358 char *read_passphrase(const char *prompt, int from_stdin);
 359
 360 /* Saves the authentication (private) key in a file, encrypting it with
 361    passphrase.  The identification of the file (lowest 64 bits of n)
 362    will precede the key to provide identification of the key without
 363    needing a passphrase. */
 364 int save_private_key(const char *filename, const char *passphrase,
 365                      RSA *private_key, const char *comment);
 366
 367 /* Loads the public part of the key file (public key and comment).
 368    Returns 0 if an error occurred; zero if the public key was successfully
 369    read.  The comment of the key is returned in comment_return if it is
 370    non-NULL; the caller must free the value with xfree. */
 371 int load_public_key(const char *filename, RSA *pub,
 372                     char **comment_return);
 373
 374 /* Loads the private key from the file.  Returns 0 if an error is encountered
 375    (file does not exist or is not readable, or passphrase is bad).
 376    This initializes the private key.  The comment of the key is returned
 377    in comment_return if it is non-NULL; the caller must free the value
 378    with xfree. */
 379 int load_private_key(const char *filename, const char *passphrase,
 380                      RSA *private_key, char **comment_return);
 381
 382 /*------------ Definitions for logging. -----------------------*/
 383
 384 /* Supported syslog facilities. */
 385 typedef enum
 386 {
 387   SYSLOG_FACILITY_DAEMON,
 388   SYSLOG_FACILITY_USER,
 389   SYSLOG_FACILITY_AUTH,
 390   SYSLOG_FACILITY_LOCAL0,
 391   SYSLOG_FACILITY_LOCAL1,
 392   SYSLOG_FACILITY_LOCAL2,
 393   SYSLOG_FACILITY_LOCAL3,
 394   SYSLOG_FACILITY_LOCAL4,
 395   SYSLOG_FACILITY_LOCAL5,
 396   SYSLOG_FACILITY_LOCAL6,
 397   SYSLOG_FACILITY_LOCAL7
 398 } SyslogFacility;
 399
 400 /* Initializes logging.  If debug is non-zero, debug() will output something.
 401    If quiet is non-zero, none of these will log send anything to syslog
 402    (but maybe to stderr). */
 403 void log_init(char *av0, int on_stderr, int debug, int quiet,
 404               SyslogFacility facility);
 405
 406 /* Outputs a message to syslog or stderr, depending on the implementation.
 407    The format must guarantee that the final message does not exceed 1024
 408    characters.  The message should not contain newline. */
 409 void log(const char *fmt, ...);
 410
 411 /* Outputs a message to syslog or stderr, depending on the implementation.
 412    The format must guarantee that the final message does not exceed 1024
 413    characters.  The message should not contain newline. */
 414 void debug(const char *fmt, ...);
 415
 416 /* Outputs a message to syslog or stderr, depending on the implementation.
 417    The format must guarantee that the final message does not exceed 1024
 418    characters.  The message should not contain newline. */
 419 void error(const char *fmt, ...);
 420
 421 /* Outputs a message to syslog or stderr, depending on the implementation.
 422    The format must guarantee that the final message does not exceed 1024
 423    characters.  The message should not contain newline.
 424    This call never returns. */
 425 void fatal(const char *fmt, ...);
 426
 427 /* Registers a cleanup function to be called by fatal() before exiting.
 428    It is permissible to call fatal_remove_cleanup for the function itself
 429    from the function. */
 430 void fatal_add_cleanup(void (*proc)(void *context), void *context);
 431
 432 /* Removes a cleanup frunction to be called at fatal(). */
 433 void fatal_remove_cleanup(void (*proc)(void *context), void *context);
 434
 435 /*---------------- definitions for channels ------------------*/
 436
 437 /* Sets specific protocol options. */
 438 void channel_set_options(int hostname_in_open);
 439
 440 /* Allocate a new channel object and set its type and socket.  Remote_name
 441    must have been allocated with xmalloc; this will free it when the channel
 442    is freed. */
 443 int channel_allocate(int type, int sock, char *remote_name);
 444
 445 /* Free the channel and close its socket. */
 446 void channel_free(int channel);
 447
 448 /* Add any bits relevant to channels in select bitmasks. */
 449 void channel_prepare_select(fd_set *readset, fd_set *writeset);
 450
 451 /* After select, perform any appropriate operations for channels which
 452    have events pending. */
 453 void channel_after_select(fd_set *readset, fd_set *writeset);
 454
 455 /* If there is data to send to the connection, send some of it now. */
 456 void channel_output_poll(void);
 457
 458 /* This is called when a packet of type CHANNEL_DATA has just been received.
 459    The message type has already been consumed, but channel number and data
 460    is still there. */
 461 void channel_input_data(int payload_len);
 462
 463 /* Returns true if no channel has too much buffered data. */
 464 int channel_not_very_much_buffered_data(void);
 465
 466 /* This is called after receiving CHANNEL_CLOSE. */
 467 void channel_input_close(void);
 468
 469 /* This is called after receiving CHANNEL_CLOSE_CONFIRMATION. */
 470 void channel_input_close_confirmation(void);
 471
 472 /* This is called after receiving CHANNEL_OPEN_CONFIRMATION. */
 473 void channel_input_open_confirmation(void);
 474
 475 /* This is called after receiving CHANNEL_OPEN_FAILURE from the other side. */
 476 void channel_input_open_failure(void);
 477
 478 /* This closes any sockets that are listening for connections; this removes
 479    any unix domain sockets. */
 480 void channel_stop_listening(void);
 481
 482 /* Closes the sockets of all channels.  This is used to close extra file
 483    descriptors after a fork. */
 484 void channel_close_all(void);
 485
 486 /* Returns the maximum file descriptor number used by the channels. */
 487 int channel_max_fd(void);
 488
 489 /* Returns true if there is still an open channel over the connection. */
 490 int channel_still_open(void);
 491
 492 /* Returns a string containing a list of all open channels.  The list is
 493    suitable for displaying to the user.  It uses crlf instead of newlines.
 494    The caller should free the string with xfree. */
 495 char *channel_open_message(void);
 496
 497 /* Initiate forwarding of connections to local port "port" through the secure
 498    channel to host:port from remote side.  This never returns if there
 499    was an error. */
 500 void channel_request_local_forwarding(int port, const char *host,
 501                                       int remote_port);
 502
 503 /* Initiate forwarding of connections to port "port" on remote host through
 504    the secure channel to host:port from local side.  This never returns
 505    if there was an error.  This registers that open requests for that
 506    port are permitted. */
 507 void channel_request_remote_forwarding(int port, const char *host,
 508                                        int remote_port);
 509
 510 /* Permits opening to any host/port in SSH_MSG_PORT_OPEN.  This is usually
 511    called by the server, because the user could connect to any port anyway,
 512    and the server has no way to know but to trust the client anyway. */
 513 void channel_permit_all_opens(void);
 514
 515 /* This is called after receiving CHANNEL_FORWARDING_REQUEST.  This initates
 516    listening for the port, and sends back a success reply (or disconnect
 517    message if there was an error).  This never returns if there was an
 518    error. */
 519 void channel_input_port_forward_request(int is_root);
 520
 521 /* This is called after receiving PORT_OPEN message.  This attempts to connect
 522    to the given host:port, and sends back CHANNEL_OPEN_CONFIRMATION or
 523    CHANNEL_OPEN_FAILURE. */
 524 void channel_input_port_open(int payload_len);
 525
 526 /* Creates a port for X11 connections, and starts listening for it.
 527    Returns the display name, or NULL if an error was encountered. */
 528 char *x11_create_display(int screen);
 529
 530 /* Creates an internet domain socket for listening for X11 connections.
 531    Returns a suitable value for the DISPLAY variable, or NULL if an error
 532    occurs. */
 533 char *x11_create_display_inet(int screen);
 534
 535 /* This is called when SSH_SMSG_X11_OPEN is received.  The packet contains
 536    the remote channel number.  We should do whatever we want, and respond
 537    with either SSH_MSG_OPEN_CONFIRMATION or SSH_MSG_OPEN_FAILURE. */
 538 void x11_input_open(int payload_len);
 539
 540 /* Requests forwarding of X11 connections.  This should be called on the
 541    client only. */
 542 void x11_request_forwarding(void);
 543
 544 /* Requests forwarding for X11 connections, with authentication spoofing.
 545    This should be called in the client only.  */
 546 void x11_request_forwarding_with_spoofing(const char *proto, const char *data);
 547
 548 /* Local Xauthority file (server only). */
 549 extern char *xauthfile;
 550
 551 /* Sends a message to the server to request authentication fd forwarding. */
 552 void auth_request_forwarding(void);
 553
 554 /* Returns the name of the forwarded authentication socket.  Returns NULL
 555    if there is no forwarded authentication socket.  The returned value points
 556    to a static buffer. */
 557 char *auth_get_socket_name(void);
 558
 559 /* This if called to process SSH_CMSG_AGENT_REQUEST_FORWARDING on the server.
 560    This starts forwarding authentication requests. */
 561 void auth_input_request_forwarding(struct passwd *pw);
 562
 563 /* This is called to process an SSH_SMSG_AGENT_OPEN message. */
 564 void auth_input_open_request(void);
 565
 566 /* Returns true if the given string matches the pattern (which may contain
 567    ? and * as wildcards), and zero if it does not match. */
 568 int match_pattern(const char *s, const char *pattern);
 569
 570 /* Expands tildes in the file name.  Returns data allocated by xmalloc.
 571    Warning: this calls getpw*. */
 572 char *tilde_expand_filename(const char *filename, uid_t my_uid);
 573
 574 /* Performs the interactive session.  This handles data transmission between
 575    the client and the program.  Note that the notion of stdin, stdout, and
 576    stderr in this function is sort of reversed: this function writes to
 577    stdin (of the child program), and reads from stdout and stderr (of the
 578    child program). */
 579 void server_loop(int pid, int fdin, int fdout, int fderr);
 580
 581 /* Client side main loop for the interactive session. */
 582 int client_loop(int have_pty, int escape_char);
 583
 584 /* Linked list of custom environment strings (see auth-rsa.c). */
 585 struct envstring {
 586   struct envstring *next;
 587   char *s;
 588 };
 589
 590 #ifdef KRB4
 591 #include <krb.h>
 592
 593 /* Performs Kerberos v4 mutual authentication with the client. This returns
 594    0 if the client could not be authenticated, and 1 if authentication was
 595    successful.  This may exit if there is a serious protocol violation. */
 596 int auth_krb4(const char *server_user, KTEXT auth, char **client);
 597 int ssh_tf_init(uid_t uid);
 598
 599 #ifdef AFS
 600 #include <kafs.h>
 601
 602 /* Accept passed Kerberos v4 ticket-granting ticket and AFS tokens. */
 603 int auth_kerberos_tgt(struct passwd *pw, const char *string);
 604 int auth_afs_token(struct passwd *pw, const char *token_string);
 605
 606 int creds_to_radix(CREDENTIALS *creds, unsigned char *buf);
 607 int radix_to_creds(const char *buf, CREDENTIALS *creds);
 608 #endif /* AFS */
 609
 610 #endif /* KRB4 */
 611
 612 #ifdef SKEY
 613 #include <skey.h>
 614 char *skey_fake_keyinfo(char *username);
 615 #endif /* SKEY */
 616
 617 #endif /* SSH_H */