Changeset 8 for trunk/src


Ignore:
Timestamp:
Dec 31, 2005, 2:02:03 PM (19 years ago)
Author:
rainer
Message:

minor optimisations for speed

Location:
trunk/src
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/sh_files.c

    r5 r8  
    229229              tmp = sh_util_safe_name (ptr->name);
    230230#endif
    231               sh_error_handle ((-1),  FIL__, __LINE__, 0, MSG_FI_CHK,
    232                                tmp);
     231              sh_error_handle ((-1),  FIL__, __LINE__, 0, MSG_FI_CHK, tmp);
    233232            }
    234233
    … …  
    14571456    }
    14581457
    1459   sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_CHK,
    1460                    tmpname);
    1461  
     1458  if (flag_err_info == SL_TRUE)
     1459    {
     1460      sh_error_handle ((-1), FIL__, __LINE__, 0, MSG_FI_CHK, tmpname);
     1461    }
     1462
    14621463  /* ---- check input ----
    14631464   */

  • trunk/src/sh_hash.c

    r3 r8  
    7171static char * unquote_string (char * str)
    7272{
    73   int    i = 0, j, k = 0, len;
    74   char * tmp;
     73  int    i = 0, j, k = 0, len, t1, t2, l2;
     74  char * tmp = NULL;
    7575
    7676  SL_ENTER(_("unquote_string"));
    7777
    78   if (str == NULL)
    79     {
    80       SL_RETURN(NULL, _("unquote_string"));
    81     }
    82 
    83   len = sl_strlen(str);
    84 
    85   tmp = SH_ALLOC(len + 1);
    86   for (j = 0; j <= len; ++j)
    87     {
    88       if (str[j] == QUOTE_CHAR && j < (len-2))
    89         {
    90           if (sh_util_hexchar(str[j+1]) >= 0 && sh_util_hexchar(str[j+2]) >= 0)
    91             {
    92               i = 16 * sh_util_hexchar(str[j+1]) + sh_util_hexchar(str[j+2]);
    93               tmp[k] = i; j += 2;
    94             }
    95           else
     78  if (str != NULL)
     79    {
     80      len = sl_strlen(str);
     81      l2  = len - 2;
     82      tmp = SH_ALLOC(len + 1);
     83
     84      for (j = 0; j <= len; ++j)
     85        {
     86          if (str[j] != QUOTE_CHAR)
    9687            {
    9788              tmp[k] = str[j];
    9889            }
    99         }
    100       else
    101         tmp[k] = str[j];
    102       ++k;
     90          else if (str[j] == QUOTE_CHAR && j < l2)
     91            {
     92              t1 = sh_util_hexchar(str[j+1]);
     93              t2 = sh_util_hexchar(str[j+2]);
     94              if ((t1|t2) >= 0)
     95                {
     96                  i = 16 * t1 + t2;
     97                  tmp[k] = i;
     98                  j += 2;
     99                }
     100              else
     101                {
     102                  tmp[k] = str[j];
     103                }
     104            }
     105          else
     106            tmp[k] = str[j];
     107          ++k;
     108        }
    103109    }
    104110  SL_RETURN(tmp, _("unquote_string"));
    … …  
    306312
    307313/* must fit an int              */
    308 #define TABSIZE 2048 
     314/* #define TABSIZE 2048         */
     315#define TABSIZE 65536
    309316
    310317/* must fit an unsigned short   */
    … …  
    386393 *
    387394 **************************************************************/
     395
    388396static int hashfunc(char *s)
    389397{
    … …  
    392400  for ( ; *s; s++)
    393401    n = 31 * n + *s;
    394   return n % TABSIZE;
     402  return n & 0xFFFF;/* % TABSIZE*/;
    395403}
     404
    396405
    397406int hashreport_missing( char *fullpath, int level)
    … …  
    635644  SL_ENTER(_("hashsearch"));
    636645
    637   if (!s)
    638     SL_RETURN( NULL, _("hashsearch"));
    639 
    640   for (p = tab[hashfunc(s)]; p; p = p->next)
    641     if ((p->fullpath != NULL) && (0 == strcmp(s, p->fullpath)))
    642       SL_RETURN( p, _("hashsearch"));
     646  if (s)
     647    {
     648      for (p = tab[hashfunc(s)]; p; p = p->next)
     649        if ((p->fullpath != NULL) && (0 == strcmp(s, p->fullpath)))
     650          SL_RETURN( p, _("hashsearch"));
     651    }
    643652  SL_RETURN( NULL, _("hashsearch"));
    644653}
    … …  
    672681        {
    673682          if (p && p->fullpath &&
    674               0 == strcmp(s->fullpath, p->fullpath) &&
    675               strlen(s->fullpath) == strlen(p->fullpath))
     683              0 == strcmp(s->fullpath, p->fullpath))
    676684            {
    677685              q = p->next;
    … …  
    30643072int hash_remove_tree (char * s)
    30653073{
    3066   sh_file_t * p;
    3067   int         len;
    3068   int        i;
     3074  sh_file_t *  p;
     3075  size_t       len;
     3076  unsigned int i;
    30693077
    30703078  SL_ENTER(_("hash_remove_tree"));
    30713079
    3072   if (!s)
     3080  if (!s || *s == '\0')
    30733081    SL_RETURN ((-1), _("hash_remove_tree"));
    3074   else
    3075     len = sl_strlen(s);
     3082
     3083  len = sl_strlen(s);
    30763084
    30773085  if (IsInit != 1)
    … …  
    30823090      for (p = tab[i]; p; p = p->next)
    30833091        {
    3084           if (sl_strncmp(s, p->fullpath, len) == 0)
     3092          if (p->fullpath && 0 == strncmp(s, p->fullpath, len))
    30853093            {
    30863094              p->allignore  = S_TRUE;

  • trunk/src/sh_prelink.c

    r1 r8  
    7474int sh_prelink_iself (SL_TICKET fd, off_t size, int alert_timeout)
    7575{
    76    long status;
    77    char magic[4];
    78    if (size < 42)
    79         return S_FALSE;
    80    status = sl_read_timeout (fd, magic, 4, alert_timeout);
    81    (void) sl_rewind(fd);
    82    if (status == 4)
    83      {
    84        /*@-usedef@*/
    85        if (magic[0] == (char) 0x7f &&
    86            magic[1] == 'E'  &&
    87            magic[2] == 'L'  &&
    88            magic[3] == 'F')
    89          return S_TRUE;
    90        /*@+usedef@*/
    91      }
    92    return S_FALSE;
     76  long status;
     77  char magic[4];
     78  if (size < 42)
     79    return S_FALSE;
     80  status = sl_read_timeout (fd, magic, 4, alert_timeout);
     81  (void) sl_rewind(fd);
     82  if (status == 4)
     83    {
     84      /*@-usedef@*/
     85      if (magic[0] == (char) 0x7f &&
     86          magic[1] == 'E'  &&
     87          magic[2] == 'L'  &&
     88          magic[3] == 'F')
     89        return S_TRUE;
     90      /*@+usedef@*/
     91    }
     92  return S_FALSE;
    9393}
    9494
    … …  
    242242   */
    243243  tiger_fd = task.pipeTI;
     244
     245  sl_read_timeout_prep (task.pipeTI);
     246
    244247  strcpy(file_hash,                        /* known to fit */
    245248         sh_tiger_generic_hash (path, TIGER_FD, 0, alert_timeout));

  • trunk/src/sh_tiger0.c

    r1 r8  
    9595SL_TICKET tiger_fd = (-1);
    9696
     97static sh_byte buffer[PRIV_MAX + 72];
    9798
    9899#if defined(HAVE_LONG_64) || defined(HAVE_LONG_LONG_64)
    … …  
    108109{
    109110  SL_TICKET  fd;
    110   int  i, j;
     111  int  i, j, tt;
    111112  int  count = 0;
    112113  int  blk;
    113114  char    * tmp;
    114115  sh_byte * bptr;
    115   sh_byte buffer[PRIV_MAX + 72];
     116  /* sh_byte buffer[PRIV_MAX + 72]; */
    116117  sh_byte bbuf[64];
     118
     119  static int lockflag = SL_FALSE;
    117120
    118121  unsigned long pages_read;
    … …  
    148151  SL_ENTER(_("sh_tiger_hash_val"));
    149152
    150   if (what == TIGER_FILE || what == TIGER_FD)
    151     {
    152       if (what == TIGER_FILE)
     153  if (what == TIGER_FD || what == TIGER_FILE)
     154    {
     155      if (what == TIGER_FD)
     156        {
     157          fd = tiger_fd;
     158          TPT((0,FIL__, __LINE__, _("msg=<TIGER_FD>, fd=<%ld>\n"), tiger_fd));
     159        }
     160      else
    153161        {
    154162          TPT((0,FIL__, __LINE__, _("msg=<TIGER_FILE>, path=<%s>\n"),
    155163               (filename == NULL ? _("(null)") : filename) ));
    156164          fd = sl_open_read (filename, SL_YESPRIV);
    157         }
    158       else
    159         {
    160           fd = tiger_fd;
    161           TPT((0,FIL__, __LINE__, _("msg=<TIGER_FD>, fd=<%ld>\n"), tiger_fd));
    162165        }
    163166
    … …  
    174177     
    175178#if defined(HAVE_MLOCK) && !defined(HAVE_BROKEN_MLOCK)
    176     if (skey->mlock_failed == SL_FALSE)
     179    if (lockflag == SL_FALSE && skey->mlock_failed == SL_FALSE)
    177180      {
    178181        if ( (-1) == sh_unix_mlock((char *)buffer,(PRIV_MAX)*sizeof(sh_byte)))
    179182          skey->mlock_failed = SL_TRUE;
     183        lockflag = SL_TRUE;
    180184      }
    181185#else
    182     if (skey->mlock_failed == SL_FALSE)
    183       skey->mlock_failed = SL_TRUE;
     186    if (lockflag == SL_FALSE && skey->mlock_failed == SL_FALSE)
     187      {
     188        skey->mlock_failed = SL_TRUE;
     189        lockflag = SL_TRUE;
     190      }
    184191#endif
    185192
    … …  
    190197    pages_read = 0;
    191198
    192     while (1 == 1)
     199    while (1)
    193200      {
    194201        if (timeout > 0)
    … …  
    217224                               count, MSG_E_READ, tmp);
    218225            SH_FREE(tmp);
    219             (void) sh_unix_munlock((char*)buffer, (PRIV_MAX)*sizeof(sh_byte));
     226            memset (bbuf,   0, 64);
     227            memset (buffer, 0, PRIV_MAX);
     228
    220229            SL_RETURN( NULL, _("sh_tiger_hash_val"));
    221230          }
    222 
    223         /* TPT((0, FIL__, __LINE__ , _("msg=<Read %ld bytes>\n"), count)); */
    224231
    225232        blk      = (count / 64); /* number of 64-byte words */
    … …  
    228235         * count cannot be negative here, see 'if (SL_ISERROR (count))'
    229236         */
    230         ncount = (unsigned long) (count - ((count/64)*64));
     237        tt = blk*64;
     238
     239        ncount = (unsigned long) (count - tt);
     240
     241        nblocks += blk;
     242        sh.statistics.bytes_hashed += tt;
    231243       
    232         bptr = buffer;
     244        bptr = buffer; tt = 0;
    233245        for (i = 0; i < blk; ++i)
    234246          {
    235             bptr = &buffer[64 * i];
     247            bptr = &buffer[tt]; tt += 64;
    236248           
    237249            tiger_t(TIGER_CAST bptr, 64, res);
    238             ++nblocks;
    239             sh.statistics.bytes_hashed += 64;
    240250           
    241251#ifdef TIGER_DBG
    … …  
    252262            memset (bbuf,   0, 64);
    253263            memset (buffer, 0, PRIV_MAX);
    254             (void) sh_unix_munlock( (char *) buffer,
    255                                     (PRIV_MAX) * sizeof(sh_byte));
     264
    256265            SL_RETURN( NULL, _("sh_tiger_hash_val"));
    257266          }
    … …  
    268277    /* copy incomplete block
    269278     */
    270     j = 0; for (i = 0; i < 64; ++i)
    271       bbuf[i] = (sh_byte) '\0';
     279    j = 0;
     280    for (i = 0; i < 64; i += 4)
     281      {
     282        bbuf[i]   = (sh_byte) '\0';
     283        bbuf[i+1] = (sh_byte) '\0';
     284        bbuf[i+2] = (sh_byte) '\0';
     285        bbuf[i+3] = (sh_byte) '\0';
     286      }
    272287    for (i = (count/64) * 64; i < count; ++i)
    273288      /*@-usedef@*/bbuf[j++] = buffer[i];/*@+usedef@*/
    … …  
    304319        sh.statistics.bytes_hashed += 64;
    305320        ++nblocks; ncount = 0;
    306         memset(bbuf, 0, 56 );
     321        for (i = 0; i < 56; i += 4)
     322          {
     323            bbuf[i]   = (sh_byte) '\0';
     324            bbuf[i+1] = (sh_byte) '\0';
     325            bbuf[i+2] = (sh_byte) '\0';
     326            bbuf[i+3] = (sh_byte) '\0';
     327          }
     328        /* memset(bbuf, 0, 56 ); */
    307329      }
    308330
    … …  
    327349#endif
    328350
    329     memset (bbuf,   0, 64);
    330     memset (buffer, 0, PRIV_MAX);
    331 
    332     (void) sh_unix_munlock( (char *) buffer, (PRIV_MAX) * sizeof(sh_byte));
     351    for (i = 0; i < 64; i += 4)
     352      {
     353        bbuf[i]   = (sh_byte) '\0';
     354        bbuf[i+1] = (sh_byte) '\0';
     355        bbuf[i+2] = (sh_byte) '\0';
     356        bbuf[i+3] = (sh_byte) '\0';
     357      }
     358
     359    bptr = buffer;
     360
     361    memcpy(bptr, bbuf,    64); bptr +=   64;
     362    memcpy(bptr, bbuf,    64); bptr +=   64;
     363    memcpy(bptr, buffer, 128); bptr +=  128;
     364    memcpy(bptr, buffer, 256); bptr +=  256;
     365    memcpy(bptr, buffer, 512); bptr +=  512;
     366    memcpy(bptr, buffer,1024); bptr += 1024;
     367    memcpy(bptr, buffer,2048);
    333368
    334369    if (what == TIGER_FILE)
    … …  
    343378  if (what == TIGER_DATA && filename != NULL)
    344379    {
    345       /* TPT((0, FIL__, __LINE__, _("msg=<TIGER_DATA>\n"))); */
    346380      tiger(TIGER_CAST filename,  (sh_word32) Length, res);
    347381      SL_RETURN(res, _("sh_tiger_hash_val"));
    … …  
    11581192  SL_TICKET  fd;
    11591193  char * tmp;
    1160   uid_t   euid;
     1194  uid_t  euid;
    11611195
    11621196  unsigned long pages_read;

  • trunk/src/sh_unix.c

    r1 r8  
    11941194  setrlimit (RLIMIT_NPROC,   &limits);
    11951195#endif
     1196#ifdef RLIMIT_MEMLOCK
     1197  setrlimit (RLIMIT_MEMLOCK, &limits);
     1198#endif
     1199
     1200#if !defined(SL_DEBUG)
     1201  /* no core dumps
     1202   */
     1203  limits.rlim_cur = 0;
     1204  limits.rlim_max = 0;
     1205#ifdef RLIMIT_CORE
     1206  setrlimit (RLIMIT_CORE,    &limits);
     1207#endif
     1208#else
     1209#ifdef RLIMIT_CORE
     1210  setrlimit (RLIMIT_CORE,    &limits);
     1211#endif
     1212#endif
     1213
     1214  limits.rlim_cur = 1024;
     1215  limits.rlim_max = 1024;
     1216
    11961217#if defined(RLIMIT_NOFILE)
    11971218  setrlimit (RLIMIT_NOFILE,  &limits);
    … …  
    11991220  setrlimit (RLIMIT_OFILE,   &limits);
    12001221#endif
    1201 #ifdef RLIMIT_MEMLOCK
    1202   setrlimit (RLIMIT_MEMLOCK, &limits);
    1203 #endif
    1204 
    1205 #if !defined(SL_DEBUG)
    1206   /* no core dumps
    1207    */
    1208   limits.rlim_cur = 0;
    1209   limits.rlim_max = 0;
    1210 #ifdef RLIMIT_CORE
    1211   setrlimit (RLIMIT_CORE,    &limits);
    1212 #endif
    1213 #else
    1214 #ifdef RLIMIT_CORE
    1215   setrlimit (RLIMIT_CORE,    &limits);
    1216 #endif
    1217 #endif
    1218 
    12191222
    12201223  SL_RET0(_("sh_unix_setlimits"));
    … …  
    26962699  struct stat   fbuf;
    26972700  int           stat_return;
    2698   register int  i;
     2701
    26992702  ShFileType    type;
    27002703  unsigned int  mode;
    … …  
    27022705  char        * tmp;
    27032706  char        * tmp2;
    2704   /* char        * p; */
     2707
    27052708  char        * linknamebuf;
    27062709  int           linksize;
    … …  
    27102713  SL_TICKET     rval_open;
    27112714  int           fd;
    2712 #if defined(__linux__)
    2713   int           fd_2;
    2714 #endif
    27152715  int           fstat_return;
    27162716
    … …  
    27382738   */
    27392739  tstart = time(NULL);
     2740
    27402741  stat_return = retry_lstat (FIL__, __LINE__,
    27412742                             path /* theFile->fullpath */, &buf);
    27422743
     2744  fd           = -1;
     2745  fstat_return = -1;
     2746  rval_open    = -1;
     2747
    27432748  if (stat_return == 0 && S_ISREG(buf.st_mode))
    27442749    {
    … …  
    27472752      alert_timeout = 120; /* this is per 8K block now ! */
    27482753
    2749       if (path[0] == '/' && path[1] == 'p' && path[2] == 'r' &&
    2750           path[3] == 'o' && path[4] == 'c' && path[5] == '/')
     2754      if (path[1] == 'p' && path[5] == '/' && path[2] == 'r' &&
     2755          path[3] == 'o' && path[4] == 'c' && path[0] == '/')
    27512756        {
    27522757          /* seven is magic */
    27532758          alert_timeout = 7;
    27542759        }
    2755     }
    2756   else
    2757     rval_open = -1;
    2758 
    2759   if (SL_ISERROR(rval_open))
    2760     fd = -1;
    2761   else
    2762     fd = get_the_fd(rval_open);
     2760
     2761      fd = get_the_fd(rval_open);
     2762    }
    27632763
    27642764  tend = time(NULL);
    … …  
    27742774      SH_FREE(tmp2);
    27752775    }
     2776
     2777  if (fd >= 0)
     2778    fstat_return = retry_fstat (FIL__, __LINE__, fd, &fbuf);
     2779  else
     2780    fd = -1;
    27762781     
    2777   if (fd >= 0)
    2778     {
    2779       fstat_return = retry_fstat (FIL__, __LINE__, fd, &fbuf);
    2780     }
    2781   else
    2782     {
    2783       fstat_return = -1;
    2784       fd           = -1;
    2785     }
    2786 #if defined(__linux__)
    2787   fd_2 = fd;
    2788 #endif
    27892782
    27902783  /* ---  case 1: lstat failed  ---
    … …  
    28092802    }
    28102803
    2811   /* ---  case 2: not a regular file, or [IgnoreAll]  ---
     2804  /* ---  case 2: not a regular file  ---
    28122805   */
    28132806  else if (! S_ISREG(buf.st_mode))
    … …  
    29062899  /* --- Determine file type. ---
    29072900   */
    2908   for (i = 0; i < 10; ++i) theFile->c_mode[i] = '-';
     2901  memset (theFile->c_mode, '-', 10);
    29092902  theFile->c_mode[10] = '\0';
    2910   for (i = 0; i < 11; ++i) theFile->link_c_mode[i] = '-';
     2903
     2904  memset (theFile->link_c_mode, '-', 10);
    29112905  theFile->link_c_mode[10] = '\0';
    29122906
    … …  
    29182912  /* --- Determine file attributes. ---
    29192913   */
    2920   for (i = 0; i < 12; ++i) theFile->c_attributes[i] = '-';
     2914  memset (theFile->c_attributes, '-', 12);
    29212915  theFile->c_attributes[12] = '\0';
    29222916  theFile->attributes      =    0;
    … …  
    29252919      theFile->c_mode[0] != 'l' )
    29262920    sh_unix_getinfo_attr(theFile->fullpath,
    2927                          &theFile->attributes, theFile->c_attributes, fd_2);
     2921                         &theFile->attributes, theFile->c_attributes, fd);
    29282922
    29292923#endif

  • trunk/src/slib.c

    r5 r8  
    566566void *sl_memset(void *s, int c, size_t n)
    567567{
    568   size_t i;
    569   volatile char *p = s;
    570 
    571   if (s == NULL || n <= 0)
    572     return s;
    573  
    574   for (i = 0; i < n; ++i)
    575     p[i] = (char) c;
     568  volatile char *p = (char *) s;
     569
     570  if (s != NULL)
     571    {
     572      while (n--)
     573        *p++ = c;
     574    }
    576575  return s;
    577576}
    … …  
    16731672      fd = aud_open_noatime (FIL__, __LINE__, priv, filename,
    16741673                             O_RDONLY|O_NONBLOCK, 0, &o_noatime);
     1674      /*
    16751675      if (fd >= 0) {
    16761676        sflags = retry_fcntl(FIL__, __LINE__, fd, F_GETFL, 0);
    16771677        retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags & ~O_NONBLOCK);
    16781678      }
     1679      */
    16791680      if (fd < 0)
    16801681        SL_IRETURN(SL_EBADFILE, _("sl_open_file"));
    … …  
    20812082}
    20822083
     2084int sl_read_timeout_prep (SL_TICKET ticket)
     2085{
     2086  int fd;
     2087  int sflags;
     2088
     2089  SL_ENTER(_("sl_read_timeout_prep"));
     2090
     2091  if (SL_ISERROR(fd = get_the_fd(ticket)))
     2092    {
     2093      TPT(( 0, FIL__, __LINE__, _("msg=<ticket error> errno=<%d>"), fd));
     2094      SL_IRETURN(fd, _("sl_read_timeout_prep"));
     2095    }
     2096
     2097  /* set to non-blocking mode
     2098   */
     2099  sflags = retry_fcntl(FIL__, __LINE__, fd, F_GETFL, 0);
     2100  retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags | O_NONBLOCK);
     2101
     2102  SL_IRETURN(SL_ENONE, _("sl_read_timeout_prep"));
     2103}
     2104 
    20832105
    20842106int sl_read_timeout (SL_TICKET ticket, void * buf_in, size_t count,
    … …  
    20872109  fd_set readfds;
    20882110  struct timeval tv;
    2089   int sflags;
     2111  /* int sflags; */
    20902112  int retval;
    20912113
    … …  
    21002122  extern volatile int sig_termfast;
    21012123 
    2102   if (count < 1)
    2103     {
    2104       TPT(( 0, FIL__, __LINE__, _("msg=<range error>")));
    2105       return(SL_ERANGE);
    2106     }
    2107   if (buf_in == NULL)
    2108     {
    2109       TPT(( 0, FIL__, __LINE__, _("msg=<null buffer>")));
    2110       return (SL_ENULL);
    2111     }
    2112 
    2113   if (SL_ISERROR(fd = get_the_fd(ticket)))
    2114     {
    2115       TPT(( 0, FIL__, __LINE__, _("msg=<ticket error> errno=<%d>"), fd));
    2116       return (fd);
     2124  if (buf_in == NULL || SL_ISERROR(fd = get_the_fd(ticket)))
     2125    {
     2126      if (buf_in == NULL)
     2127        {
     2128          TPT(( 0, FIL__, __LINE__, _("msg=<null buffer>")));
     2129          return (SL_ENULL);
     2130        }
     2131      if (SL_ISERROR(fd = get_the_fd(ticket)))
     2132        {
     2133          TPT(( 0, FIL__, __LINE__, _("msg=<ticket error> errno=<%d>"), fd));
     2134          return (fd);
     2135        }
    21172136    }
    21182137
    21192138  buf = (char *) buf_in;
    2120 
    2121   /* set to non-blocking mode
    2122    */
    2123   sflags = retry_fcntl(FIL__, __LINE__, fd, F_GETFL, 0);
    2124   retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags | O_NONBLOCK);
    21252139
    21262140  tstart = time(NULL);
    … …  
    21292143  while (count > 0)
    21302144    {
    2131 
    2132       if (sig_termfast == 1)
    2133         {
    2134           retry_fcntl(FIL__, __LINE__, fd, F_SETFL,
    2135                       sflags & ~O_NONBLOCK);
    2136           return (SL_EREAD);
    2137         }
    2138          
    21392145      FD_ZERO(&readfds);
    21402146      FD_SET(fd, &readfds);
    2141 
    2142       if (tdiff >= timeout)
    2143         {
    2144           retry_fcntl(FIL__, __LINE__, fd, F_SETFL,
    2145                       sflags & ~O_NONBLOCK);
    2146           return (SL_TIMEOUT);
    2147         }
    2148 
    2149       /*
    2150       tnow  = time(NULL);
    2151       tdiff = tnow - tstart;
    2152       */
    21532147
    21542148      tv.tv_sec  = timeout - tdiff;
    … …  
    21602154        {
    21612155          byteread = read (fd, buf, count);
    2162           if (byteread != -1 && byteread != 0)
     2156
     2157          if (byteread > 0)
    21632158            {
    21642159              bytes += byteread; count -= byteread;
    … …  
    21822177              else
    21832178                {
    2184                   retry_fcntl(FIL__, __LINE__, fd, F_SETFL,
    2185                               sflags & ~O_NONBLOCK);
    21862179                  return (SL_EREAD);
    21872180                }
    … …  
    21972190      else if (retval == 0)
    21982191        {
    2199           retry_fcntl(FIL__, __LINE__, fd, F_SETFL,
    2200                       sflags & ~O_NONBLOCK);
    22012192          return (SL_TIMEOUT);
    22022193        }
    22032194      else
    22042195        {
    2205           retry_fcntl(FIL__, __LINE__, fd, F_SETFL,
    2206                       sflags & ~O_NONBLOCK);
    22072196          return (SL_EREAD);
    22082197        }
     2198
     2199      if (sig_termfast == 1)
     2200        {
     2201          return (SL_EREAD);
     2202        }
     2203         
    22092204      tnow  = time(NULL);
    22102205      tdiff = tnow - tstart;
    2211     }
    2212 
    2213   retry_fcntl(FIL__, __LINE__, fd, F_SETFL, sflags & ~O_NONBLOCK);
     2206
     2207      if (tdiff > timeout)
     2208        {
     2209          return (SL_TIMEOUT);
     2210        }
     2211    }
     2212
    22142213  return ((int) bytes);
    22152214}
Note: See TracChangeset for help on using the changeset viewer.