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

Diff for /src/usr.bin/ssh/Attic/roaming_common.c between version 1.4 and 1.5

version 1.4, 2009/06/21 09:04:03 version 1.5, 2009/06/27 09:32:43
Line 22 
Line 22 
 #include <errno.h>  #include <errno.h>
 #include <inttypes.h>  #include <inttypes.h>
 #include <stdarg.h>  #include <stdarg.h>
   #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
 #include "atomicio.h"  #include "atomicio.h"
Line 32 
Line 33 
 #include "buffer.h"  #include "buffer.h"
 #include "roaming.h"  #include "roaming.h"
   
   static size_t out_buf_size = 0;
   static char *out_buf = NULL;
   static size_t out_start;
   static size_t out_last;
   
 static u_int64_t write_bytes = 0;  static u_int64_t write_bytes = 0;
 static u_int64_t read_bytes = 0;  static u_int64_t read_bytes = 0;
   
   int roaming_enabled = 0;
 int resume_in_progress = 0;  int resume_in_progress = 0;
   
   int
   get_snd_buf_size()
   {
           int fd = packet_get_connection_out();
           int optval, optvallen;
   
           optvallen = sizeof(optval);
           if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optval, &optvallen) != 0)
                   optval = DEFAULT_ROAMBUF;
           return optval;
   }
   
   int
   get_recv_buf_size()
   {
           int fd = packet_get_connection_in();
           int optval, optvallen;
   
           optvallen = sizeof(optval);
           if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &optval, &optvallen) != 0)
                   optval = DEFAULT_ROAMBUF;
           return optval;
   }
   
   void
   set_out_buffer_size(size_t size)
   {
           /*
            * The buffer size can only be set once and the buffer will live
            * as long as the session lives.
            */
           if (out_buf == NULL) {
                   out_buf_size = size;
                   out_buf = xmalloc(size);
                   out_start = 0;
                   out_last = 0;
           }
   }
   
 u_int64_t  u_int64_t
 get_recv_bytes(void)  get_recv_bytes(void)
 {  {
Line 62 
Line 108 
         write_bytes = sent;          write_bytes = sent;
 }  }
   
   static void
   buf_append(const char *buf, size_t count)
   {
           if (count > out_buf_size) {
                   buf += count - out_buf_size;
                   count = out_buf_size;
           }
           if (count < out_buf_size - out_last) {
                   memcpy(out_buf + out_last, buf, count);
                   if (out_start > out_last)
                           out_start += count;
                   out_last += count;
           } else {
                   /* data will wrap */
                   size_t chunk = out_buf_size - out_last;
                   memcpy(out_buf + out_last, buf, chunk);
                   memcpy(out_buf, buf + chunk, count - chunk);
                   out_last = count - chunk;
                   out_start = out_last + 1;
           }
   }
   
 ssize_t  ssize_t
 roaming_write(int fd, const void *buf, size_t count, int *cont)  roaming_write(int fd, const void *buf, size_t count, int *cont)
 {  {
Line 70 
Line 138 
         ret = write(fd, buf, count);          ret = write(fd, buf, count);
         if (ret > 0 && !resume_in_progress) {          if (ret > 0 && !resume_in_progress) {
                 write_bytes += ret;                  write_bytes += ret;
                   if (out_buf_size > 0)
                           buf_append(buf, ret);
         }          }
         debug3("Wrote %ld bytes for a total of %llu", (long)ret,          debug3("Wrote %ld bytes for a total of %llu", (long)ret,
             (unsigned long long)write_bytes);              (unsigned long long)write_bytes);
Line 100 
Line 170 
                 read_bytes += ret;                  read_bytes += ret;
         }          }
         return ret;          return ret;
   }
   
   void
   resend_bytes(int fd, u_int64_t *offset)
   {
           size_t available, needed;
   
           if (out_start < out_last)
                   available = out_last - out_start;
           else
                   available = out_buf_size;
           needed = write_bytes - *offset;
           debug3("resend_bytes: resend %lu bytes from %llu",
               (unsigned long)needed, (unsigned long long)*offset);
           if (needed > available)
                   fatal("Needed to resend more data than in the cache");
           if (out_last < needed) {
                   int chunkend = needed - out_last;
                   atomicio(vwrite, fd, out_buf + out_buf_size - chunkend,
                       chunkend);
                   atomicio(vwrite, fd, out_buf, out_last);
           } else {
                   atomicio(vwrite, fd, out_buf + (out_last - needed), needed);
           }
 }  }
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5