开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
tools.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：20k
源码类别：

代理服务器

开发平台：

Unix_Linux

tools.c：源码内容
  2. /*
  3.  * $Id: tools.c,v 1.173 1999/01/11 21:55:44 wessels Exp $
  4.  *
  5.  * DEBUG: section 21    Misc Functions
  6.  * AUTHOR: Harvest Derived
  7.  *
  8.  * SQUID Internet Object Cache  http://squid.nlanr.net/Squid/
  9.  * ----------------------------------------------------------
  10.  *
  11.  *  Squid is the result of efforts by numerous individuals from the
  12.  *  Internet community.  Development is led by Duane Wessels of the
  13.  *  National Laboratory for Applied Network Research and funded by the
  14.  *  National Science Foundation.  Squid is Copyrighted (C) 1998 by
  15.  *  Duane Wessels and the University of California San Diego.  Please
  16.  *  see the COPYRIGHT file for full details.  Squid incorporates
  17.  *  software developed and/or copyrighted by other sources.  Please see
  18.  *  the CREDITS file for full details.
  19.  *
  20.  *  This program is free software; you can redistribute it and/or modify
  21.  *  it under the terms of the GNU General Public License as published by
  22.  *  the Free Software Foundation; either version 2 of the License, or
  23.  *  (at your option) any later version.
  24.  *  
  25.  *  This program is distributed in the hope that it will be useful,
  26.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.  *  GNU General Public License for more details.
  29.  *  
  30.  *  You should have received a copy of the GNU General Public License
  31.  *  along with this program; if not, write to the Free Software
  32.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33.  *
  34.  */
  36. #include "squid.h"
  38. #define DEAD_MSG "
  39. The Squid Cache (version %s) died.n
  40. n
  41. You've encountered a fatal error in the Squid Cache version %s.n
  42. If a core file was created (possibly in the swap directory),n
  43. please execute 'gdb squid core' or 'dbx squid core', then type 'where',n
  44. and report the trace back to squid-bugs@ircache.net.n
  45. n
  46. Thanks!n"
  48. static void fatal_common(const char *);
  49. static void fatalvf(const char *fmt, va_list args);
  50. static void mail_warranty(void);
  51. #if USE_ASYNC_IO
  52. static AIOCB safeunlinkComplete;
  53. #endif
  54. #if MEM_GEN_TRACE
  55. extern void log_trace_done();
  56. extern void log_trace_init(char *);
  57. #endif
  59. void
  60. releaseServerSockets(void)
  61. {
  62.     int i;
  63.     /* Release the main ports as early as possible */
  64.     for (i = 0; i < NHttpSockets; i++) {
  65. if (HttpSockets[i] >= 0)
  66.     close(HttpSockets[i]);
  67.     }
  68.     if (theInIcpConnection >= 0)
  69. close(theInIcpConnection);
  70.     if (theOutIcpConnection >= 0 && theOutIcpConnection != theInIcpConnection)
  71. close(theOutIcpConnection);
  72. }
  74. static char *
  75. dead_msg(void)
  76. {
  77.     LOCAL_ARRAY(char, msg, 1024);
  78.     snprintf(msg, 1024, DEAD_MSG, version_string, version_string);
  79.     return msg;
  80. }
  82. static void
  83. mail_warranty(void)
  84. {
  85.     FILE *fp = NULL;
  86.     char *filename;
  87.     static char command[256];
  88.     if ((filename = tempnam(NULL, appname)) == NULL)
  89. return;
  90.     if ((fp = fopen(filename, "w")) == NULL)
  91. return;
  92.     fprintf(fp, "From: %sn", appname);
  93.     fprintf(fp, "To: %sn", Config.adminEmail);
  94.     fprintf(fp, "Subject: %sn", dead_msg());
  95.     fclose(fp);
  96.     snprintf(command, 256, "mail %s < %s", Config.adminEmail, filename);
  97.     system(command); /* XXX should avoid system(3) */
  98.     unlink(filename);
  99. }
  101. void
  102. dumpMallocStats(void)
  103. {
  104. #if HAVE_MSTATS && HAVE_GNUMALLOC_H
  105.     struct mstats ms = mstats();
  106.     fprintf(debug_log, "ttotal space in arena:  %6d KBn",
  107. (int) (ms.bytes_total >> 10));
  108.     fprintf(debug_log, "tTotal free:            %6d KB %d%%n",
  109. (int) (ms.bytes_free >> 10),
  110. percent(ms.bytes_free, ms.bytes_total));
  111. #elif HAVE_MALLINFO
  112.     struct mallinfo mp;
  113.     int t;
  114.     if (!do_mallinfo)
  115. return;
  116.     mp = mallinfo();
  117.     fprintf(debug_log, "Memory usage for %s via mallinfo():n", appname);
  118.     fprintf(debug_log, "ttotal space in arena:  %6d KBn",
  119. mp.arena >> 10);
  120.     fprintf(debug_log, "tOrdinary blocks:       %6d KB %6d blksn",
  121. mp.uordblks >> 10, mp.ordblks);
  122.     fprintf(debug_log, "tSmall blocks:          %6d KB %6d blksn",
  123. mp.usmblks >> 10, mp.smblks);
  124.     fprintf(debug_log, "tHolding blocks:        %6d KB %6d blksn",
  125. mp.hblkhd >> 10, mp.hblks);
  126.     fprintf(debug_log, "tFree Small blocks:     %6d KBn",
  127. mp.fsmblks >> 10);
  128.     fprintf(debug_log, "tFree Ordinary blocks:  %6d KBn",
  129. mp.fordblks >> 10);
  130.     t = mp.uordblks + mp.usmblks + mp.hblkhd;
  131.     fprintf(debug_log, "tTotal in use:          %6d KB %d%%n",
  132. t >> 10, percent(t, mp.arena));
  133.     t = mp.fsmblks + mp.fordblks;
  134.     fprintf(debug_log, "tTotal free:            %6d KB %d%%n",
  135. t >> 10, percent(t, mp.arena));
  136. #if HAVE_EXT_MALLINFO
  137.     fprintf(debug_log, "tmax size of small blocks:t%dn",
  138. mp.mxfast);
  139.     fprintf(debug_log, "tnumber of small blocks in a holding block:t%dn",
  140. mp.nlblks);
  141.     fprintf(debug_log, "tsmall block rounding factor:t%dn",
  142. mp.grain);
  143.     fprintf(debug_log, "tspace (including overhead) allocated in ord. blks:t%dn",
  144. mp.uordbytes);
  145.     fprintf(debug_log, "tnumber of ordinary blocks allocated:t%dn",
  146. mp.allocated);
  147.     fprintf(debug_log, "tbytes used in maintaining the free tree:t%dn",
  148. mp.treeoverhead);
  149. #endif /* HAVE_EXT_MALLINFO */
  150. #endif /* HAVE_MALLINFO */
  151. }
  153. void
  154. squid_getrusage(struct rusage *r)
  155. {
  156.     memset(r, '', sizeof(struct rusage));
  157. #if HAVE_GETRUSAGE && defined(RUSAGE_SELF)
  158. #ifdef _SQUID_SOLARIS_
  159.     /* Solaris 2.5 has getrusage() permission bug -- Arjan de Vet */
  160.     enter_suid();
  161. #endif
  162.     getrusage(RUSAGE_SELF, r);
  163. #ifdef _SQUID_SOLARIS_
  164.     leave_suid();
  165. #endif
  166. #endif
  167. }
  169. double
  170. rusage_cputime(struct rusage *r)
  171. {
  172.     return (double) r->ru_stime.tv_sec +
  173. (double) r->ru_utime.tv_sec +
  174. (double) r->ru_stime.tv_usec / 1000000.0 +
  175. (double) r->ru_utime.tv_usec / 1000000.0;
  176. }
  178. int
  179. rusage_maxrss(struct rusage *r)
  180. {
  181. #if defined(_SQUID_SGI_) && _ABIAPI
  182.     return r->ru_pad[0];
  183. #elif defined(_SQUID_SGI_)
  184.     return r->ru_maxrss;
  185. #elif defined(_SQUID_OSF_)
  186.     return r->ru_maxrss;
  187. #elif defined(BSD4_4)
  188.     return r->ru_maxrss;
  189. #elif HAVE_GETPAGESIZE
  190.     return (r->ru_maxrss * getpagesize()) >> 10;
  191. #elif defined(PAGESIZE)
  192.     return (r->ru_maxrss * PAGESIZE) >> 10;
  193. #else
  194.     return r->ru_maxrss;
  195. #endif
  196. }
  198. int
  199. rusage_pagefaults(struct rusage *r)
  200. {
  201. #if defined(_SQUID_SGI_) && _ABIAPI
  202.     return r->ru_pad[5];
  203. #else
  204.     return r->ru_majflt;
  205. #endif
  206. }
  209. void
  210. PrintRusage(void)
  211. {
  212.     struct rusage rusage;
  213.     squid_getrusage(&rusage);
  214.     fprintf(debug_log, "CPU Usage: %.3f secondsn", rusage_cputime(&rusage));
  215.     fprintf(debug_log, "Maximum Resident Size: %d KBn",
  216. rusage_maxrss(&rusage));
  217.     fprintf(debug_log, "Page faults with physical i/o: %dn",
  218. rusage_pagefaults(&rusage));
  219. }
  222. void
  223. death(int sig)
  224. {
  225.     if (sig == SIGSEGV)
  226. fprintf(debug_log, "FATAL: Received Segment Violation...dying.n");
  227.     else if (sig == SIGBUS)
  228. fprintf(debug_log, "FATAL: Received Bus Error...dying.n");
  229.     else
  230. fprintf(debug_log, "FATAL: Received signal %d...dying.n", sig);
  232. #ifdef PRINT_STACK_TRACE
  233. #ifdef _SQUID_HPUX_
  234.     {
  235. extern void U_STACK_TRACE(void); /* link with -lcl */
  236. fflush(debug_log);
  237. dup2(fileno(debug_log), 2);
  238. U_STACK_TRACE();
  239.     }
  240. #endif /* _SQUID_HPUX_ */
  241. #ifdef _SQUID_SOLARIS_
  242.     { /* get ftp://opcom.sun.ca/pub/tars/opcom_stack.tar.gz and */
  243. extern void opcom_stack_trace(void); /* link with -lopcom_stack */
  244. fflush(debug_log);
  245. dup2(fileno(debug_log), fileno(stdout));
  246. opcom_stack_trace();
  247. fflush(stdout);
  248.     }
  249. #endif /* _SQUID_SOLARIS_ */
  250. #endif /* PRINT_STACK_TRACE */
  252. #if SA_RESETHAND == 0
  253.     signal(SIGSEGV, SIG_DFL);
  254.     signal(SIGBUS, SIG_DFL);
  255.     signal(sig, SIG_DFL);
  256. #endif
  257.     releaseServerSockets();
  258.     storeDirWriteCleanLogs(0);
  259.     PrintRusage();
  260.     dumpMallocStats();
  261.     if (squid_curtime - SQUID_RELEASE_TIME < 864000) {
  262. /* skip if more than 10 days old */
  263. if (Config.adminEmail)
  264.     mail_warranty();
  265. else
  266.     puts(dead_msg());
  267.     }
  268.     abort();
  269. }
  272. void
  273. sigusr2_handle(int sig)
  274. {
  275.     static int state = 0;
  276.     /* no debug() here; bad things happen if the signal is delivered during _db_print() */
  277.     if (state == 0) {
  278. #ifndef MEM_GEN_TRACE
  279. _db_init(Config.Log.log, "ALL,10");
  280. #else
  281. log_trace_done();
  282. #endif
  283. state = 1;
  284.     } else {
  285. #ifndef MEM_GEN_TRACE
  286. _db_init(Config.Log.log, Config.debugOptions);
  287. #else
  288. log_trace_init("/tmp/squid.alloc");
  289. #endif
  290. state = 0;
  291.     }
  292. #if !HAVE_SIGACTION
  293.     signal(sig, sigusr2_handle); /* reinstall */
  294. #endif
  295. }
  297. static void
  298. fatal_common(const char *message)
  299. {
  300. #if HAVE_SYSLOG
  301.     if (opt_syslog_enable)
  302. syslog(LOG_ALERT, "%s", message);
  303. #endif
  304.     fprintf(debug_log, "FATAL: %sn", message);
  305.     if (opt_debug_stderr && debug_log != stderr)
  306. fprintf(stderr, "FATAL: %sn", message);
  307.     fprintf(debug_log, "Squid Cache (Version %s): Terminated abnormally.n",
  308. version_string);
  309.     fflush(debug_log);
  310.     PrintRusage();
  311.     dumpMallocStats();
  312. }
  314. /* fatal */
  315. void
  316. fatal(const char *message)
  317. {
  318.     releaseServerSockets();
  319.     /* check for store_rebuilding flag because fatal() is often
  320.      * used in early initialization phases, long before we ever
  321.      * get to the store log. */
  322.     if (!store_rebuilding)
  323. storeDirWriteCleanLogs(0);
  324.     fatal_common(message);
  325.     exit(shutting_down ? 0 : 1);
  326. }
  328. /* printf-style interface for fatal */
  329. #if STDC_HEADERS
  330. void
  331. fatalf(const char *fmt,...)
  332. {
  333.     va_list args;
  334.     va_start(args, fmt);
  335. #else
  336. void
  337. fatalf(va_alist)
  338.      va_dcl
  339. {
  340.     va_list args;
  341.     const char *fmt = NULL;
  342.     va_start(args);
  343.     fmt = va_arg(args, char *);
  344. #endif
  345.     fatalvf(fmt, args);
  346.     va_end(args);
  347. }
  350. /* used by fatalf */
  351. static void
  352. fatalvf(const char *fmt, va_list args)
  353. {
  354.     static char fatal_str[BUFSIZ];
  355.     vsnprintf(fatal_str, sizeof(fatal_str), fmt, args);
  356.     fatal(fatal_str);
  357. }
  359. /* fatal with dumping core */
  360. void
  361. fatal_dump(const char *message)
  362. {
  363.     releaseServerSockets();
  364.     if (message)
  365. fatal_common(message);
  366.     if (opt_catch_signals)
  367. storeDirWriteCleanLogs(0);
  368.     abort();
  369. }
  371. void
  372. debug_trap(const char *message)
  373. {
  374.     if (!opt_catch_signals)
  375. fatal_dump(message);
  376.     _db_print("WARNING: %sn", message);
  377. }
  379. void
  380. sig_child(int sig)
  381. {
  382. #ifdef _SQUID_NEXT_
  383.     union wait status;
  384. #else
  385.     int status;
  386. #endif
  387.     pid_t pid;
  389.     do {
  390. #ifdef _SQUID_NEXT_
  391. pid = wait3(&status, WNOHANG, NULL);
  392. #else
  393. pid = waitpid(-1, &status, WNOHANG);
  394. #endif
  395. /* no debug() here; bad things happen if the signal is delivered during _db_print() */
  396. #if HAVE_SIGACTION
  397.     } while (pid > 0);
  398. #else
  399.     } while (pid > 0 || (pid < 0 && errno == EINTR));
  400.     signal(sig, sig_child);
  401. #endif
  402. }
  404. const char *
  405. getMyHostname(void)
  406. {
  407.     LOCAL_ARRAY(char, host, SQUIDHOSTNAMELEN + 1);
  408.     static int present = 0;
  409.     const struct hostent *h = NULL;
  410.     char *t = NULL;
  412.     if ((t = Config.visibleHostname) != NULL)
  413. return t;
  415.     /* Get the host name and store it in host to return */
  416.     if (!present) {
  417. host[0] = '';
  418. if (gethostname(host, SQUIDHOSTNAMELEN) == -1) {
  419.     debug(50, 1) ("getMyHostname: gethostname failed: %sn",
  420. xstrerror());
  421.     return NULL;
  422. } else {
  423.     if ((h = gethostbyname(host)) != NULL) {
  424. /* DNS lookup successful */
  425. /* use the official name from DNS lookup */
  426. strcpy(host, h->h_name);
  427.     }
  428.     present = 1;
  429. }
  430.     }
  431.     return host;
  432. }
  434. const char *
  435. uniqueHostname(void)
  436. {
  437.     return Config.uniqueHostname ? Config.uniqueHostname : getMyHostname();
  438. }
  440. void
  441. safeunlink(const char *s, int quiet)
  442. {
  443. #if USE_ASYNC_IO
  444.     aioUnlink(s,
  445. quiet ? NULL : safeunlinkComplete,
  446. quiet ? NULL : xstrdup(s));
  447. #else
  448.     Counter.syscalls.disk.unlinks++;
  449.     if (unlink(s) < 0 && !quiet)
  450. debug(50, 1) ("safeunlink: Couldn't delete %s: %sn", s, xstrerror());
  451. #endif
  452. }
  454. #if USE_ASYNC_IO
  455. static void
  456. safeunlinkComplete(int fd, void *data, int retcode, int errcode)
  457. {
  458.     char *s = data;
  459.     if (retcode < 0) {
  460. errno = errcode;
  461. debug(50, 1) ("safeunlink: Couldn't delete %s. %sn", s, xstrerror());
  462. errno = 0;
  463.     }
  464.     xfree(s);
  465. }
  466. #endif
  468. /* leave a privilegied section. (Give up any privilegies)
  469.  * Routines that need privilegies can rap themselves in enter_suid()
  470.  * and leave_suid()
  471.  * To give upp all posibilites to gain privilegies use no_suid()
  472.  */
  473. void
  474. leave_suid(void)
  475. {
  476.     struct passwd *pwd = NULL;
  477.     struct group *grp = NULL;
  478.     debug(21, 3) ("leave_suid: PID %d calledn", getpid());
  479.     if (geteuid() != 0)
  480. return;
  481.     /* Started as a root, check suid option */
  482.     if (Config.effectiveUser == NULL)
  483. return;
  484.     if ((pwd = getpwnam(Config.effectiveUser)) == NULL)
  485. return;
  486.     if (Config.effectiveGroup && (grp = getgrnam(Config.effectiveGroup))) {
  487. if (setgid(grp->gr_gid) < 0)
  488.     debug(50, 1) ("leave_suid: setgid: %sn", xstrerror());
  489.     } else {
  490. if (setgid(pwd->pw_gid) < 0)
  491.     debug(50, 1) ("leave_suid: setgid: %sn", xstrerror());
  492.     }
  493.     debug(21, 3) ("leave_suid: PID %d giving up root, becoming '%s'n",
  494. getpid(), pwd->pw_name);
  495. #if HAVE_SETRESUID
  496.     if (setresuid(pwd->pw_uid, pwd->pw_uid, 0) < 0)
  497. debug(50, 1) ("leave_suid: setresuid: %sn", xstrerror());
  498. #elif HAVE_SETEUID
  499.     if (seteuid(pwd->pw_uid) < 0)
  500. debug(50, 1) ("leave_suid: seteuid: %sn", xstrerror());
  501. #else
  502.     if (setuid(pwd->pw_uid) < 0)
  503. debug(50, 1) ("leave_suid: setuid: %sn", xstrerror());
  504. #endif
  505. }
  507. /* Enter a privilegied section */
  508. void
  509. enter_suid(void)
  510. {
  511.     debug(21, 3) ("enter_suid: PID %d taking root privelegesn", getpid());
  512. #if HAVE_SETRESUID
  513.     setresuid(-1, 0, -1);
  514. #else
  515.     setuid(0);
  516. #endif
  517. }
  519. /* Give up the posibility to gain privilegies.
  520.  * this should be used before starting a sub process
  521.  */
  522. void
  523. no_suid(void)
  524. {
  525.     uid_t uid;
  526.     leave_suid();
  527.     uid = geteuid();
  528.     debug(21, 3) ("leave_suid: PID %d giving up root priveleges forevern", getpid());
  529. #if HAVE_SETRESUID
  530.     if (setresuid(uid, uid, uid) < 0)
  531. debug(50, 1) ("no_suid: setresuid: %sn", xstrerror());
  532. #else
  533.     setuid(0);
  534.     if (setuid(uid) < 0)
  535. debug(50, 1) ("no_suid: setuid: %sn", xstrerror());
  536. #endif
  537. }
  539. void
  540. writePidFile(void)
  541. {
  542.     int fd;
  543.     const char *f = NULL;
  544.     mode_t old_umask;
  545.     char buf[32];
  546.     if ((f = Config.pidFilename) == NULL)
  547. return;
  548.     if (!strcmp(Config.pidFilename, "none"))
  549. return;
  550.     enter_suid();
  551.     old_umask = umask(022);
  552.     fd = file_open(f, O_WRONLY | O_CREAT | O_TRUNC, NULL, NULL, NULL);
  553.     umask(old_umask);
  554.     leave_suid();
  555.     if (fd < 0) {
  556. debug(50, 0) ("%s: %sn", f, xstrerror());
  557. debug_trap("Could not write pid file");
  558. return;
  559.     }
  560.     snprintf(buf, 32, "%dn", (int) getpid());
  561.     write(fd, buf, strlen(buf));
  562.     file_close(fd);
  563. }
  566. pid_t
  567. readPidFile(void)
  568. {
  569.     FILE *pid_fp = NULL;
  570.     const char *f = Config.pidFilename;
  571.     pid_t pid = -1;
  572.     int i;
  574.     if (f == NULL || !strcmp(Config.pidFilename, "none")) {
  575. fprintf(stderr, "%s: ERROR: No pid file name definedn", appname);
  576. exit(1);
  577.     }
  578.     pid_fp = fopen(f, "r");
  579.     if (pid_fp != NULL) {
  580. pid = 0;
  581. if (fscanf(pid_fp, "%d", &i) == 1)
  582.     pid = (pid_t) i;
  583. fclose(pid_fp);
  584.     } else {
  585. if (errno != ENOENT) {
  586.     fprintf(stderr, "%s: ERROR: Could not read pid filen", appname);
  587.     fprintf(stderr, "t%s: %sn", f, xstrerror());
  588.     exit(1);
  589. }
  590.     }
  591.     return pid;
  592. }
  595. void
  596. setMaxFD(void)
  597. {
  598. #if HAVE_SETRLIMIT
  599.     /* try to use as many file descriptors as possible */
  600.     /* System V uses RLIMIT_NOFILE and BSD uses RLIMIT_OFILE */
  601.     struct rlimit rl;
  602. #if defined(RLIMIT_NOFILE)
  603.     if (getrlimit(RLIMIT_NOFILE, &rl) < 0) {
  604. debug(50, 0) ("setrlimit: RLIMIT_NOFILE: %sn", xstrerror());
  605.     } else {
  606. rl.rlim_cur = Squid_MaxFD;
  607. if (rl.rlim_cur > rl.rlim_max)
  608.     Squid_MaxFD = rl.rlim_cur = rl.rlim_max;
  609. if (setrlimit(RLIMIT_NOFILE, &rl) < 0) {
  610.     snprintf(tmp_error_buf, ERROR_BUF_SZ,
  611. "setrlimit: RLIMIT_NOFILE: %s", xstrerror());
  612.     fatal_dump(tmp_error_buf);
  613. }
  614.     }
  615. #elif defined(RLIMIT_OFILE)
  616.     if (getrlimit(RLIMIT_OFILE, &rl) < 0) {
  617. debug(50, 0) ("setrlimit: RLIMIT_NOFILE: %sn", xstrerror());
  618.     } else {
  619. rl.rlim_cur = Squid_MaxFD;
  620. if (rl.rlim_cur > rl.rlim_max)
  621.     Squid_MaxFD = rl.rlim_cur = rl.rlim_max;
  622. if (setrlimit(RLIMIT_OFILE, &rl) < 0) {
  623.     snprintf(tmp_error_buf, ERROR_BUF_SZ,
  624. "setrlimit: RLIMIT_OFILE: %s", xstrerror());
  625.     fatal_dump(tmp_error_buf);
  626. }
  627.     }
  628. #endif
  629. #else /* HAVE_SETRLIMIT */
  630.     debug(21, 1) ("setMaxFD: Cannot increase: setrlimit() not supported on this systemn");
  631. #endif /* HAVE_SETRLIMIT */
  633. #if HAVE_SETRLIMIT && defined(RLIMIT_DATA)
  634.     if (getrlimit(RLIMIT_DATA, &rl) < 0) {
  635. debug(50, 0) ("getrlimit: RLIMIT_DATA: %sn", xstrerror());
  636.     } else if (rl.rlim_max > rl.rlim_cur) {
  637. rl.rlim_cur = rl.rlim_max; /* set it to the max */
  638. if (setrlimit(RLIMIT_DATA, &rl) < 0) {
  639.     snprintf(tmp_error_buf, ERROR_BUF_SZ,
  640. "setrlimit: RLIMIT_DATA: %s", xstrerror());
  641.     fatal_dump(tmp_error_buf);
  642. }
  643.     }
  644. #endif /* RLIMIT_DATA */
  645. #if HAVE_SETRLIMIT && defined(RLIMIT_VMEM)
  646.     if (getrlimit(RLIMIT_VMEM, &rl) < 0) {
  647. debug(50, 0) ("getrlimit: RLIMIT_VMEM: %sn", xstrerror());
  648.     } else if (rl.rlim_max > rl.rlim_cur) {
  649. rl.rlim_cur = rl.rlim_max; /* set it to the max */
  650. if (setrlimit(RLIMIT_VMEM, &rl) < 0) {
  651.     snprintf(tmp_error_buf, ERROR_BUF_SZ,
  652. "setrlimit: RLIMIT_VMEM: %s", xstrerror());
  653.     fatal_dump(tmp_error_buf);
  654. }
  655.     }
  656. #endif /* RLIMIT_VMEM */
  657. }
  659. time_t
  660. getCurrentTime(void)
  661. {
  662. #if GETTIMEOFDAY_NO_TZP
  663.     gettimeofday(&current_time);
  664. #else
  665.     gettimeofday(&current_time, NULL);
  666. #endif
  667.     current_dtime = (double) current_time.tv_sec +
  668. (double) current_time.tv_usec / 1000000.0;
  669.     return squid_curtime = current_time.tv_sec;
  670. }
  672. int
  673. percent(int a, int b)
  674. {
  675.     return b ? ((int) (100.0 * a / b + 0.5)) : 0;
  676. }
  678. double
  679. dpercent(double a, double b)
  680. {
  681.     return b ? (100.0 * a / b) : 0.0;
  682. }
  684. void
  685. squid_signal(int sig, SIGHDLR * func, int flags)
  686. {
  687. #if HAVE_SIGACTION
  688.     struct sigaction sa;
  689.     sa.sa_handler = func;
  690.     sa.sa_flags = flags;
  691.     sigemptyset(&sa.sa_mask);
  692.     if (sigaction(sig, &sa, NULL) < 0)
  693. debug(50, 0) ("sigaction: sig=%d func=%p: %sn", sig, func, xstrerror());
  694. #else
  695.     signal(sig, func);
  696. #endif
  697. }
  699. struct in_addr
  700. inaddrFromHostent(const struct hostent *hp)
  701. {
  702.     struct in_addr s;
  703.     xmemcpy(&s.s_addr, hp->h_addr, sizeof(s.s_addr));
  704.     return s;
  705. }
  707. double
  708. doubleAverage(double cur, double new, int N, int max)
  709. {
  710.     if (N > max)
  711. N = max;
  712.     return (cur * (N - 1.0) + new) / N;
  713. }
  715. int
  716. intAverage(int cur, int new, int n, int max)
  717. {
  718.     if (n > max)
  719. n = max;
  720.     return (cur * (n - 1) + new) / n;
  721. }
  723. void
  724. logsFlush(void)
  725. {
  726.     if (debug_log)
  727. fflush(debug_log);
  728.     if (cache_useragent_log)
  729. fflush(cache_useragent_log);
  730. }
  732. char *
  733. checkNullString(char *p)
  734. {
  735.     return p ? p : "(NULL)";
  736. }
  738. void
  739. dlinkAdd(void *data, dlink_node * m, dlink_list * list)
  740. {
  741.     m->data = data;
  742.     m->prev = NULL;
  743.     m->next = list->head;
  744.     if (list->head)
  745. list->head->prev = m;
  746.     list->head = m;
  747.     if (list->tail == NULL)
  748. list->tail = m;
  749. }
  751. void
  752. dlinkAddTail(void *data, dlink_node * m, dlink_list * list)
  753. {
  754.     m->data = data;
  755.     m->next = NULL;
  756.     m->prev = list->tail;
  757.     if (list->tail)
  758. list->tail->next = m;
  759.     list->tail = m;
  760.     if (list->head == NULL)
  761. list->head = m;
  762. }
  764. void
  765. dlinkDelete(dlink_node * m, dlink_list * list)
  766. {
  767.     if (m->next)
  768. m->next->prev = m->prev;
  769.     if (m->prev)
  770. m->prev->next = m->next;
  771.     if (m == list->head)
  772. list->head = m->next;
  773.     if (m == list->tail)
  774. list->tail = m->prev;
  775. }
  777. void
  778. kb_incr(kb_t * k, size_t v)
  779. {
  780.     k->bytes += v;
  781.     k->kb += (k->bytes >> 10);
  782.     k->bytes &= 0x3FF;
  783. }
  785. void
  786. gb_flush(gb_t * g)
  787. {
  788.     g->gb += (g->bytes >> 30);
  789.     g->bytes &= (1 << 30) - 1;
  790. }
  792. double
  793. gb_to_double(const gb_t * g)
  794. {
  795.     return ((double) g->gb) * ((double) (1 << 30)) + ((double) g->bytes);
  796. }
  798. const char *
  799. gb_to_str(const gb_t * g)
  800. {
  801.     /*
  802.      * it is often convenient to call gb_to_str several times for _one_ printf
  803.      */
  804. #define max_cc_calls 5
  805.     typedef char GbBuf[32];
  806.     static GbBuf bufs[max_cc_calls];
  807.     static int call_id = 0;
  808.     double value = gb_to_double(g);
  809.     char *buf = bufs[call_id++];
  810.     /* select format */
  811.     if (value < 1e9)
  812. snprintf(buf, sizeof(GbBuf), "%.2f MB", value / 1e6);
  813.     else if (value < 1e12)
  814. snprintf(buf, sizeof(GbBuf), "%.2f GB", value / 1e9);
  815.     else
  816. snprintf(buf, sizeof(GbBuf), "%.2f TB", value / 1e12);
  817.     return buf;
  818. }
  820. void
  821. debugObj(int section, int level, const char *label, void *obj, ObjPackMethod pm)
  822. {
  823.     MemBuf mb;
  824.     Packer p;
  825.     assert(label && obj && pm);
  826.     memBufDefInit(&mb);
  827.     packerToMemInit(&p, &mb);
  828.     (*pm) (obj, &p);
  829.     debug(section, level) ("%s%s", label, mb.buf);
  830.     packerClean(&p);
  831.     memBufClean(&mb);
  832. }
  834. int
  835. stringHasWhitespace(const char *s)
  836. {
  837.     return (strcspn(s, w_space) != strlen(s));
  838. }