[BACK]Return to session.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/session.c between version 1.183 and 1.184

version 1.183, 2005/07/16 01:35:24 version 1.184, 2005/07/17 06:49:04
Line 1277 
Line 1277 
                         s->ttyfd = -1;                          s->ttyfd = -1;
                         s->used = 1;                          s->used = 1;
                         s->self = i;                          s->self = i;
                           s->x11_chanids = NULL;
                         debug("session_new: session %d", i);                          debug("session_new: session %d", i);
                         return s;                          return s;
                 }                  }
Line 1350 
Line 1351 
 }  }
   
 static Session *  static Session *
   session_by_x11_channel(int id)
   {
           int i, j;
   
           for (i = 0; i < MAX_SESSIONS; i++) {
                   Session *s = &sessions[i];
   
                   if (s->x11_chanids == NULL || !s->used)
                           continue;
                   for (j = 0; s->x11_chanids[j] != -1; j++) {
                           if (s->x11_chanids[j] == id) {
                                   debug("session_by_x11_channel: session %d "
                                       "channel %d", s->self, id);
                                   return s;
                           }
                   }
           }
           debug("session_by_x11_channel: unknown channel %d", id);
           session_dump();
           return NULL;
   }
   
   static Session *
 session_by_pid(pid_t pid)  session_by_pid(pid_t pid)
 {  {
         int i;          int i;
Line 1478 
Line 1502 
 {  {
         int success;          int success;
   
           if (s->auth_proto != NULL || s->auth_data != NULL) {
                   error("session_x11_req: session %d: "
                       "x11 fowarding already active", s->self);
                   return 0;
           }
         s->single_connection = packet_get_char();          s->single_connection = packet_get_char();
         s->auth_proto = packet_get_string(NULL);          s->auth_proto = packet_get_string(NULL);
         s->auth_data = packet_get_string(NULL);          s->auth_data = packet_get_string(NULL);
Line 1703 
Line 1732 
 }  }
   
 static void  static void
   session_close_x11(int id)
   {
           Channel *c;
   
           if ((c = channel_lookup(id)) == NULL) {
                   debug("session_close_x11: x11 channel %d missing", id);
           } else {
                   /* Detach X11 listener */
                   debug("session_close_x11: detach x11 channel %d", id);
                   channel_cancel_cleanup(id);
                   if (c->ostate != CHAN_OUTPUT_CLOSED)
                           chan_mark_dead(c);
           }
   }
   
   static void
   session_close_single_x11(int id, void *arg)
   {
           Session *s;
           u_int i;
   
           debug3("session_close_single_x11: channel %d", id);
           channel_cancel_cleanup(id);
           if ((s  = session_by_x11_channel(id)) == NULL)
                   fatal("session_close_single_x11: no x11 channel %d", id);
           for (i = 0; s->x11_chanids[i] != -1; i++) {
                   debug("session_close_single_x11: session %d: "
                       "closing channel %d", s->self, s->x11_chanids[i]);
                   /*
                    * The channel "id" is already closing, but make sure we
                    * close all of its siblings.
                    */
                   if (s->x11_chanids[i] != id)
                           session_close_x11(s->x11_chanids[i]);
           }
           xfree(s->x11_chanids);
           s->x11_chanids = NULL;
           if (s->display) {
                   xfree(s->display);
                   s->display = NULL;
           }
           if (s->auth_proto) {
                   xfree(s->auth_proto);
                   s->auth_proto = NULL;
           }
           if (s->auth_data) {
                   xfree(s->auth_data);
                   s->auth_data = NULL;
           }
           if (s->auth_display) {
                   xfree(s->auth_display);
                   s->auth_display = NULL;
           }
   }
   
   static void
 session_exit_message(Session *s, int status)  session_exit_message(Session *s, int status)
 {  {
         Channel *c;          Channel *c;
           u_int i;
   
         if ((c = channel_lookup(s->chanid)) == NULL)          if ((c = channel_lookup(s->chanid)) == NULL)
                 fatal("session_exit_message: session %d: no channel %d",                  fatal("session_exit_message: session %d: no channel %d",
Line 1741 
Line 1827 
         if (c->ostate != CHAN_OUTPUT_CLOSED)          if (c->ostate != CHAN_OUTPUT_CLOSED)
                 chan_write_failed(c);                  chan_write_failed(c);
         s->chanid = -1;          s->chanid = -1;
   
           /* Close any X11 listeners associated with this session */
           if (s->x11_chanids != NULL) {
                   for (i = 0; s->x11_chanids[i] != -1; i++) {
                           session_close_x11(s->x11_chanids[i]);
                           s->x11_chanids[i] = -1;
                   }
           }
 }  }
   
 void  void
Line 1755 
Line 1849 
                 xfree(s->term);                  xfree(s->term);
         if (s->display)          if (s->display)
                 xfree(s->display);                  xfree(s->display);
           if (s->x11_chanids)
                   xfree(s->x11_chanids);
         if (s->auth_display)          if (s->auth_display)
                 xfree(s->auth_display);                  xfree(s->auth_display);
         if (s->auth_data)          if (s->auth_data)
Line 1793 
Line 1889 
 session_close_by_channel(int id, void *arg)  session_close_by_channel(int id, void *arg)
 {  {
         Session *s = session_by_channel(id);          Session *s = session_by_channel(id);
   
         if (s == NULL) {          if (s == NULL) {
                 debug("session_close_by_channel: no session for id %d", id);                  debug("session_close_by_channel: no session for id %d", id);
                 return;                  return;
Line 1864 
Line 1961 
         struct stat st;          struct stat st;
         char display[512], auth_display[512];          char display[512], auth_display[512];
         char hostname[MAXHOSTNAMELEN];          char hostname[MAXHOSTNAMELEN];
           u_int i;
   
         if (no_x11_forwarding_flag) {          if (no_x11_forwarding_flag) {
                 packet_send_debug("X11 forwarding disabled in user configuration file.");                  packet_send_debug("X11 forwarding disabled in user configuration file.");
Line 1889 
Line 1987 
         }          }
         if (x11_create_display_inet(options.x11_display_offset,          if (x11_create_display_inet(options.x11_display_offset,
             options.x11_use_localhost, s->single_connection,              options.x11_use_localhost, s->single_connection,
             &s->display_number) == -1) {              &s->display_number, &s->x11_chanids) == -1) {
                 debug("x11_create_display_inet failed.");                  debug("x11_create_display_inet failed.");
                 return 0;                  return 0;
           }
           for (i = 0; s->x11_chanids[i] != -1; i++) {
                   channel_register_cleanup(s->x11_chanids[i],
                       session_close_single_x11);
         }          }
   
         /* Set up a suitable value for the DISPLAY variable. */          /* Set up a suitable value for the DISPLAY variable. */
Legend:
Removed from v.1.183  
changed lines
  Added in v.1.184