home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 July & August / Pcwk78a98.iso / Wtestowe / Clico / UNIX / SAMBA / SOURCE / SAMBA.TAR / samba-1.9.17 / source / predict.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-08  |  3.7 KB  |  146 lines
  1. /* 
  2.    Unix SMB/Netbios implementation.
  3.    Version 1.9.
  4.    file read prediction routines
  5.    Copyright (C) Andrew Tridgell 1992-1997
  6.    
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2 of the License, or
  10.    (at your option) any later version.
  11.    
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.    
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. #include "includes.h"
  23.  
  24. extern int DEBUGLEVEL;
  25.  
  26.  
  27. /* variables used by the read prediction module */
  28. static int rp_fd = -1;
  29. static int rp_offset = 0;
  30. static int rp_length = 0;
  31. static int rp_alloced = 0;
  32. static int rp_predict_fd = -1;
  33. static int rp_predict_offset = 0;
  34. static int rp_predict_length = 0;
  35. static int rp_timeout = 5;
  36. static time_t rp_time = 0;
  37. static char *rp_buffer = NULL;
  38. static BOOL predict_skip=False;
  39. time_t smb_last_time=(time_t)0;
  40.  
  41. /****************************************************************************
  42. handle read prediction on a file
  43. ****************************************************************************/
  44. int read_predict(int fd,int offset,char *buf,char **ptr,int num)
  45. {
  46.   int ret = 0;
  47.   int possible = rp_length - (offset - rp_offset);
  48.  
  49.   possible = MIN(possible,num);
  50.  
  51.   /* give data if possible */
  52.   if (fd == rp_fd && 
  53.       offset >= rp_offset && 
  54.       possible>0 &&
  55.       smb_last_time-rp_time < rp_timeout)
  56.     {
  57.       ret = possible;
  58.       if (buf)
  59.     memcpy(buf,rp_buffer + (offset-rp_offset),possible);
  60.       else
  61.     *ptr = rp_buffer + (offset-rp_offset);
  62.       DEBUG(5,("read-prediction gave %d bytes of %d\n",ret,num));
  63.     }
  64.  
  65.   if (ret == num) {
  66.     predict_skip = True;
  67.   } else {
  68.     predict_skip = False;
  69.  
  70.     /* prepare the next prediction */
  71.     rp_predict_fd = fd;
  72.     rp_predict_offset = offset + num;
  73.     rp_predict_length = num;
  74.   }
  75.  
  76.   if (ret < 0) ret = 0;
  77.  
  78.   return(ret);
  79. }
  80.  
  81. /****************************************************************************
  82. pre-read some data
  83. ****************************************************************************/
  84. void do_read_prediction()
  85. {
  86.   static int readsize = 0;
  87.  
  88.   if (predict_skip) return;
  89.  
  90.   if (rp_predict_fd == -1) 
  91.     return;
  92.  
  93.   rp_fd = rp_predict_fd;
  94.   rp_offset = rp_predict_offset;
  95.   rp_length = 0;
  96.  
  97.   rp_predict_fd = -1;
  98.  
  99.   if (readsize == 0) {
  100.     readsize = lp_readsize();
  101.     readsize = MAX(readsize,1024);
  102.   }
  103.  
  104.   rp_predict_length = MIN(rp_predict_length,2*readsize);
  105.   rp_predict_length = MAX(rp_predict_length,1024);
  106.   rp_offset = (rp_offset/1024)*1024;
  107.   rp_predict_length = (rp_predict_length/1024)*1024;
  108.  
  109.   if (rp_predict_length > rp_alloced)
  110.     {
  111.       rp_buffer = Realloc(rp_buffer,rp_predict_length);
  112.       rp_alloced = rp_predict_length;
  113.       if (!rp_buffer)
  114.     {
  115.       DEBUG(0,("can't allocate read-prediction buffer\n"));
  116.       rp_predict_fd = -1;
  117.       rp_fd = -1;
  118.       rp_alloced = 0;
  119.       return;
  120.     }
  121.     }
  122.  
  123.   if (lseek(rp_fd,rp_offset,SEEK_SET) != rp_offset) {
  124.     rp_fd = -1;
  125.     rp_predict_fd = -1;
  126.     return;
  127.   }
  128.  
  129.   rp_length = read(rp_fd,rp_buffer,rp_predict_length);
  130.   rp_time = time(NULL);
  131.   if (rp_length < 0)
  132.     rp_length = 0;
  133. }
  134.  
  135. /****************************************************************************
  136. invalidate read-prediction on a fd
  137. ****************************************************************************/
  138. void invalidate_read_prediction(int fd)
  139. {
  140.  if (rp_fd == fd) 
  141.    rp_fd = -1;
  142.  if (rp_predict_fd == fd)
  143.    rp_predict_fd = -1;
  144. }
  145.  
  146.