lib/util.c

   1 /*
   2  * $Id$
   3  *
   4  * DEBUG:
   5  * AUTHOR: Harvest Derived
   6  *
   7  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   8  * ----------------------------------------------------------
   9  *
  10  *  Squid is the result of efforts by numerous individuals from
  11  *  the Internet community; see the CONTRIBUTORS file for full
  12  *  details.   Many organizations have provided support for Squid's
  13  *  development; see the SPONSORS file for full details.  Squid is
  14  *  Copyrighted (C) 2001 by the Regents of the University of
  15  *  California; see the COPYRIGHT file for full details.  Squid
  16  *  incorporates software developed and/or copyrighted by other
  17  *  sources; see the CREDITS file for full details.
  18  *
  19  *  This program is free software; you can redistribute it and/or modify
  20  *  it under the terms of the GNU General Public License as published by
  21  *  the Free Software Foundation; either version 2 of the License, or
  22  *  (at your option) any later version.
  23  *
  24  *  This program is distributed in the hope that it will be useful,
  25  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27  *  GNU General Public License for more details.
  28  *
  29  *  You should have received a copy of the GNU General Public License
  30  *  along with this program; if not, write to the Free Software
  31  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  32  *
  33  */
  34
  35 #define _etext etext
  36
  37 #include "squid.h"
  38 #include "profiler/Profiler.h"
  39 #include "util.h"
  40
  41 #if HAVE_STDIO_H
  42 #include <stdio.h>
  43 #endif
  44 #if HAVE_STRING_H
  45 #include <string.h>
  46 #endif
  47 #if HAVE_CTYPE_H
  48 #include <ctype.h>
  49 #endif
  50 #if HAVE_UNISTD_H
  51 #include <unistd.h>
  52 #endif
  53 #if HAVE_MATH_H
  54 #include <math.h>
  55 #endif
  56
  57 void
  58 Tolower(char *q)
  59 {
  60     char *s = q;
  61
  62     while (*s) {
  63         *s = xtolower(*s);
  64         s++;
  65     }
  66 }
  67
  68 int
  69 tvSubUsec(struct timeval t1, struct timeval t2)
  70 {
  71     return (t2.tv_sec - t1.tv_sec) * 1000000 +
  72            (t2.tv_usec - t1.tv_usec);
  73 }
  74
  75 double
  76 tvSubDsec(struct timeval t1, struct timeval t2)
  77 {
  78     return (double) (t2.tv_sec - t1.tv_sec) +
  79            (double) (t2.tv_usec - t1.tv_usec) / 1000000.0;
  80 }
  81
  82 /* returns the number of leading white spaces in str; handy in skipping ws */
  83 size_t
  84 xcountws(const char *str)
  85 {
  86     size_t count = 0;
  87     PROF_start(xcountws);
  88
  89     if (str) {
  90         while (xisspace(*str)) {
  91             str++;
  92             count++;
  93         }
  94     }
  95
  96     PROF_stop(xcountws);
  97     return count;
  98 }
  99
 100 /* somewhat safer calculation of %s */
 101 double
 102 xpercent(double part, double whole)
 103 {
 104     return xdiv(100 * part, whole);
 105 }
 106
 107 int
 108 xpercentInt(double part, double whole)
 109 {
 110 #if HAVE_RINT
 111     return (int) rint(xpercent(part, whole));
 112 #else
 113     /* SCO 3.2v4.2 doesn't have rint() -- mauri@mbp.ee */
 114     return (int) floor(xpercent(part, whole) + 0.5);
 115 #endif
 116 }
 117
 118 /* somewhat safer division */
 119 double
 120 xdiv(double nom, double denom)
 121 {
 122     return (denom != 0.0) ? nom / denom : -1.0;
 123 }
 124
 125 /* integer to string */
 126 const char *
 127 xitoa(int num)
 128 {
 129     static char buf[24];        /* 2^64 = 18446744073709551616 */
 130     snprintf(buf, sizeof(buf), "%d", num);
 131     return buf;
 132 }
 133
 134 /* int64_t to string */
 135 const char *
 136 xint64toa(int64_t num)
 137 {
 138     static char buf[24];        /* 2^64 = 18446744073709551616 */
 139     snprintf(buf, sizeof(buf), "%" PRId64, num);
 140     return buf;
 141 }
 142
 143 void
 144 gb_flush(gb_t * g)
 145 {
 146     g->gb += (g->bytes >> 30);
 147     g->bytes &= (1 << 30) - 1;
 148 }
 149
 150 double
 151 gb_to_double(const gb_t * g)
 152 {
 153     return ((double) g->gb) * ((double) (1 << 30)) + ((double) g->bytes);
 154 }
 155
 156 const char *
 157 double_to_str(char *buf, int buf_size, double value)
 158 {
 159     /* select format */
 160
 161     if (value < 1e9)
 162         snprintf(buf, buf_size, "%.2f MB", value / 1e6);
 163     else if (value < 1e12)
 164         snprintf(buf, buf_size, "%.3f GB", value / 1e9);
 165     else
 166         snprintf(buf, buf_size, "%.4f TB", value / 1e12);
 167
 168     return buf;
 169 }
 170
 171 const char *
 172 gb_to_str(const gb_t * g)
 173 {
 174     /*
 175      * it is often convenient to call gb_to_str several times for _one_ printf
 176      */
 177 #define max_cc_calls 5
 178     typedef char GbBuf[32];
 179     static GbBuf bufs[max_cc_calls];
 180     static int call_id = 0;
 181     double value = gb_to_double(g);
 182     char *buf = bufs[call_id++];
 183
 184     if (call_id >= max_cc_calls)
 185         call_id = 0;
 186
 187     /* select format */
 188     if (value < 1e9)
 189         snprintf(buf, sizeof(GbBuf), "%.2f MB", value / 1e6);
 190     else if (value < 1e12)
 191         snprintf(buf, sizeof(GbBuf), "%.2f GB", value / 1e9);
 192     else
 193         snprintf(buf, sizeof(GbBuf), "%.2f TB", value / 1e12);
 194
 195     return buf;
 196 }
 197
 198 /**
 199  * rounds num to the next upper integer multiple of what
 200  */
 201 unsigned int RoundTo(const unsigned int num, const unsigned int what)
 202 {
 203     return what * ((num + what -1)/what);
 204 }