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 "util.h"
  39
  40 #if HAVE_STDIO_H
  41 #include <stdio.h>
  42 #endif
  43 #if HAVE_STRING_H
  44 #include <string.h>
  45 #endif
  46 #if HAVE_CTYPE_H
  47 #include <ctype.h>
  48 #endif
  49 #if HAVE_UNISTD_H
  50 #include <unistd.h>
  51 #endif
  52 #if HAVE_MATH_H
  53 #include <math.h>
  54 #endif
  55
  56 void
  57 Tolower(char *q)
  58 {
  59     char *s = q;
  60
  61     while (*s) {
  62         *s = xtolower(*s);
  63         s++;
  64     }
  65 }
  66
  67 int
  68 tvSubUsec(struct timeval t1, struct timeval t2)
  69 {
  70     return (t2.tv_sec - t1.tv_sec) * 1000000 +
  71            (t2.tv_usec - t1.tv_usec);
  72 }
  73
  74 double
  75 tvSubDsec(struct timeval t1, struct timeval t2)
  76 {
  77     return (double) (t2.tv_sec - t1.tv_sec) +
  78            (double) (t2.tv_usec - t1.tv_usec) / 1000000.0;
  79 }
  80
  81 /* somewhat safer calculation of %s */
  82 double
  83 xpercent(double part, double whole)
  84 {
  85     return xdiv(100 * part, whole);
  86 }
  87
  88 int
  89 xpercentInt(double part, double whole)
  90 {
  91 #if HAVE_RINT
  92     return (int) rint(xpercent(part, whole));
  93 #else
  94     /* SCO 3.2v4.2 doesn't have rint() -- mauri@mbp.ee */
  95     return (int) floor(xpercent(part, whole) + 0.5);
  96 #endif
  97 }
  98
  99 /* somewhat safer division */
 100 double
 101 xdiv(double nom, double denom)
 102 {
 103     return (denom != 0.0) ? nom / denom : -1.0;
 104 }
 105
 106 /* integer to string */
 107 const char *
 108 xitoa(int num)
 109 {
 110     static char buf[24];        /* 2^64 = 18446744073709551616 */
 111     snprintf(buf, sizeof(buf), "%d", num);
 112     return buf;
 113 }
 114
 115 /* int64_t to string */
 116 const char *
 117 xint64toa(int64_t num)
 118 {
 119     static char buf[24];        /* 2^64 = 18446744073709551616 */
 120     snprintf(buf, sizeof(buf), "%" PRId64, num);
 121     return buf;
 122 }
 123
 124 void
 125 gb_flush(gb_t * g)
 126 {
 127     g->gb += (g->bytes >> 30);
 128     g->bytes &= (1 << 30) - 1;
 129 }
 130
 131 double
 132 gb_to_double(const gb_t * g)
 133 {
 134     return ((double) g->gb) * ((double) (1 << 30)) + ((double) g->bytes);
 135 }
 136
 137 const char *
 138 double_to_str(char *buf, int buf_size, double value)
 139 {
 140     /* select format */
 141
 142     if (value < 1e9)
 143         snprintf(buf, buf_size, "%.2f MB", value / 1e6);
 144     else if (value < 1e12)
 145         snprintf(buf, buf_size, "%.3f GB", value / 1e9);
 146     else
 147         snprintf(buf, buf_size, "%.4f TB", value / 1e12);
 148
 149     return buf;
 150 }
 151
 152 const char *
 153 gb_to_str(const gb_t * g)
 154 {
 155     /*
 156      * it is often convenient to call gb_to_str several times for _one_ printf
 157      */
 158 #define max_cc_calls 5
 159     typedef char GbBuf[32];
 160     static GbBuf bufs[max_cc_calls];
 161     static int call_id = 0;
 162     double value = gb_to_double(g);
 163     char *buf = bufs[call_id++];
 164
 165     if (call_id >= max_cc_calls)
 166         call_id = 0;
 167
 168     /* select format */
 169     if (value < 1e9)
 170         snprintf(buf, sizeof(GbBuf), "%.2f MB", value / 1e6);
 171     else if (value < 1e12)
 172         snprintf(buf, sizeof(GbBuf), "%.2f GB", value / 1e9);
 173     else
 174         snprintf(buf, sizeof(GbBuf), "%.2f TB", value / 1e12);
 175
 176     return buf;
 177 }
 178
 179 /**
 180  * rounds num to the next upper integer multiple of what
 181  */
 182 unsigned int RoundTo(const unsigned int num, const unsigned int what)
 183 {
 184     return what * ((num + what -1)/what);
 185 }