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

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

代理服务器

开发平台：

Unix_Linux

delay_pools.c：源码内容
  2. /*
  3.  * $Id: delay_pools.c,v 1.7.2.1 1999/02/14 08:35:01 wessels Exp $
  4.  *
  5.  * DEBUG: section 77    Delay Pools
  6.  * AUTHOR: David Luyer <luyer@ucs.uwa.edu.au>
  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 "config.h"
  38. #if DELAY_POOLS
  39. #include "squid.h"
  41. struct _class1DelayPool {
  42.     int aggregate;
  43. };
  45. struct _class2DelayPool {
  46.     int aggregate;
  47.     /* OK: -1 is terminator.  individual[255] is always host 255. */
  48.     /* 255 entries + 1 terminator byte */
  49.     unsigned char individual_map[256];
  50.     unsigned char individual_255_used;
  51.     /* 256 entries */
  52.     int individual[256];
  53. };
  55. struct _class3DelayPool {
  56.     int aggregate;
  57.     /* OK: -1 is terminator.  network[255] is always host 255. */
  58.     /* 255 entries + 1 terminator byte */
  59.     unsigned char network_map[256];
  60.     unsigned char network_255_used;
  61.     /* 256 entries */
  62.     int network[256];
  63.     /* 256 sets of (255 entries + 1 terminator byte) */
  64.     unsigned char individual_map[256][256];
  65.     /* Pack this into one bit per net */
  66.     unsigned char individual_255_used[32];
  67.     /* largest entry = (255<<8)+255 = 65535 */
  68.     int individual[65536];
  69. };
  71. typedef struct _class1DelayPool class1DelayPool;
  72. typedef struct _class2DelayPool class2DelayPool;
  73. typedef struct _class3DelayPool class3DelayPool;
  75. union _delayPool {
  76.     class1DelayPool *class1;
  77.     class2DelayPool *class2;
  78.     class3DelayPool *class3;
  79. };
  81. typedef union _delayPool delayPool;
  83. static delayPool *delay_data = NULL;
  84. static fd_set delay_no_delay;
  85. static time_t delay_pools_last_update = 0;
  87. static OBJH delayPoolStats;
  89. void
  90. delayPoolsInit(void)
  91. {
  92.     delay_pools_last_update = getCurrentTime();
  93.     FD_ZERO(&delay_no_delay);
  94.     cachemgrRegister("delay", "Delay Pool Levels", delayPoolStats, 0, 1);
  95. }
  97. void
  98. delayInitDelayData(unsigned short pools)
  99. {
  100.     if (pools) {
  101. delay_data = xcalloc(pools, sizeof(delayPool));
  102. eventAdd("delayPoolsUpdate", delayPoolsUpdate, NULL, 1.0, 1);
  103.     }
  104. }
  106. void
  107. delayFreeDelayData()
  108. {
  109.     safe_free(delay_data);
  110. }
  112. void
  113. delayCreateDelayPool(unsigned short pool, u_char class)
  114. {
  115.     switch (class) {
  116.     case 1:
  117. delay_data[pool].class1 = xmalloc(sizeof(class1DelayPool));
  118. break;
  119.     case 2:
  120. delay_data[pool].class2 = xmalloc(sizeof(class2DelayPool));
  121. break;
  122.     case 3:
  123. delay_data[pool].class3 = xmalloc(sizeof(class3DelayPool));
  124. break;
  125.     default:
  126. assert(0);
  127.     }
  128. }
  130. void
  131. delayInitDelayPool(unsigned short pool, u_char class, delaySpecSet * rates)
  132. {
  133.     /* delaySetSpec may be pointer to partial structure so MUST pass by
  134.      * reference.
  135.      */
  136.     switch (class) {
  137.     case 1:
  138. delay_data[pool].class1->aggregate = (rates->aggregate.max_bytes *
  139.     Config.Delay.initial) / 100;
  140. break;
  141.     case 2:
  142. delay_data[pool].class2->aggregate = (rates->aggregate.max_bytes *
  143.     Config.Delay.initial) / 100;
  144. delay_data[pool].class2->individual_map[0] = 255;
  145. delay_data[pool].class2->individual_255_used = 0;
  146. break;
  147.     case 3:
  148. delay_data[pool].class3->aggregate = (rates->aggregate.max_bytes *
  149.     Config.Delay.initial) / 100;
  150. delay_data[pool].class3->network_map[0] = 255;
  151. delay_data[pool].class3->network_255_used = 0;
  152. memset(&delay_data[pool].class3->individual_255_used, '',
  153.     sizeof(delay_data[pool].class3->individual_255_used));
  154. break;
  155.     default:
  156. assert(0);
  157.     }
  158. }
  160. void
  161. delayFreeDelayPool(unsigned short pool)
  162. {
  163.     /* this is a union - and all free() cares about is the pointer location */
  164.     safe_free(delay_data[pool].class1);
  165. }
  167. void
  168. delaySetNoDelay(int fd)
  169. {
  170.     FD_SET(fd, &delay_no_delay);
  171. }
  173. void
  174. delayClearNoDelay(int fd)
  175. {
  176.     FD_CLR(fd, &delay_no_delay);
  177. }
  179. int
  180. delayIsNoDelay(int fd)
  181. {
  182.     return FD_ISSET(fd, &delay_no_delay);
  183. }
  185. static delay_id
  186. delayId(unsigned short pool, unsigned short position)
  187. {
  188.     return (pool << 16) | position;
  189. }
  191. delay_id
  192. delayClient(request_t * r)
  193. {
  194.     aclCheck_t ch;
  195.     int i;
  196.     int j;
  197.     unsigned int host;
  198.     unsigned short pool, position;
  199.     unsigned char class, net;
  201.     memset(&ch, '', sizeof(ch));
  202.     ch.src_addr = r->client_addr;
  203.     ch.my_addr = r->my_addr;
  204.     ch.request = r;
  205.     for (pool = 0; pool < Config.Delay.pools; pool++) {
  206. if (aclCheckFast(Config.Delay.access[pool], &ch))
  207.     break;
  208.     }
  209.     if (pool == Config.Delay.pools)
  210. return delayId(0, 0);
  211.     class = Config.Delay.class[pool];
  212.     if (class == 0)
  213. return delayId(0, 0);
  214.     if (class == 1)
  215. return delayId(pool + 1, 0);
  216.     if (class == 2) {
  217. host = ntohl(ch.src_addr.s_addr) & 0xff;
  218. if (host == 255) {
  219.     if (!delay_data[pool].class2->individual_255_used) {
  220. delay_data[pool].class2->individual_255_used = 1;
  221. delay_data[pool].class2->individual[255] =
  222.     (Config.Delay.rates[pool]->individual.max_bytes *
  223.     Config.Delay.initial) / 100;
  224.     }
  225.     return delayId(pool + 1, 255);
  226. }
  227. for (i = 0;; i++) {
  228.     if (delay_data[pool].class2->individual_map[i] == host)
  229. break;
  230.     if (delay_data[pool].class2->individual_map[i] == 255) {
  231. delay_data[pool].class2->individual_map[i] = host;
  232. delay_data[pool].class2->individual_map[i + 1] = 255;
  233. delay_data[pool].class2->individual[i] =
  234.     (Config.Delay.rates[pool]->individual.max_bytes *
  235.     Config.Delay.initial) / 100;
  236. break;
  237.     }
  238. }
  239. return delayId(pool + 1, i);
  240.     }
  241.     /* class == 3 */
  242.     host = ntohl(ch.src_addr.s_addr) & 0xffff;
  243.     net = host >> 8;
  244.     host &= 0xff;
  245.     if (net == 255) {
  246. i = 255;
  247. if (!delay_data[pool].class3->network_255_used) {
  248.     delay_data[pool].class3->network_255_used = 1;
  249.     delay_data[pool].class3->network[255] =
  250. (Config.Delay.rates[pool]->network.max_bytes *
  251. Config.Delay.initial) / 100;
  252. }
  253.     } else {
  254. for (i = 0;; i++) {
  255.     if (delay_data[pool].class3->network_map[i] == net)
  256. break;
  257.     if (delay_data[pool].class3->network_map[i] == 255) {
  258. delay_data[pool].class3->network_map[i] = net;
  259. delay_data[pool].class3->individual_map[i][0] = 255;
  260. delay_data[pool].class3->network_map[i + 1] = 255;
  261. delay_data[pool].class3->network[i] =
  262.     (Config.Delay.rates[pool]->network.max_bytes *
  263.     Config.Delay.initial) / 100;
  264. break;
  265.     }
  266. }
  267.     }
  268.     position = i << 8;
  269.     if (host == 255) {
  270. position |= 255;
  271. if (!(delay_data[pool].class3->individual_255_used[i / 8] & (1 << (i % 8)))) {
  272.     delay_data[pool].class3->individual_255_used[i / 8] |= (1 << (i % 8));
  273.     delay_data[pool].class3->individual[position] =
  274. (Config.Delay.rates[pool]->individual.max_bytes *
  275. Config.Delay.initial) / 100;
  276. }
  277. return delayId(pool + 1, position);
  278.     }
  279.     for (j = 0;; j++) {
  280. if (delay_data[pool].class3->individual_map[i][j] == host) {
  281.     position |= j;
  282.     break;
  283. }
  284. if (delay_data[pool].class3->individual_map[i][j] == 255) {
  285.     delay_data[pool].class3->individual_map[i][j] = host;
  286.     delay_data[pool].class3->individual_map[i][j + 1] = 255;
  287.     delay_data[pool].class3->individual[position |= j] =
  288. (Config.Delay.rates[pool]->individual.max_bytes *
  289. Config.Delay.initial) / 100;
  290.     break;
  291. }
  292.     }
  293.     return delayId(pool + 1, position);
  294. }
  296. static void
  297. delayUpdateClass1(class1DelayPool * class1, delaySpecSet * rates, int incr)
  298. {
  299.     /* delaySetSpec may be pointer to partial structure so MUST pass by
  300.      * reference.
  301.      */
  302.     if (rates->aggregate.restore_bps != -1 &&
  303. (class1->aggregate += rates->aggregate.restore_bps * incr) >
  304. rates->aggregate.max_bytes)
  305. class1->aggregate = rates->aggregate.max_bytes;
  306. }
  308. static void
  309. delayUpdateClass2(class2DelayPool * class2, delaySpecSet * rates, int incr)
  310. {
  311.     int restore_bytes;
  312.     unsigned char i;
  313.     /* delaySetSpec may be pointer to partial structure so MUST pass by
  314.      * reference.
  315.      */
  316.     if (rates->aggregate.restore_bps != -1 &&
  317. (class2->aggregate += rates->aggregate.restore_bps * incr) >
  318. rates->aggregate.max_bytes)
  319. class2->aggregate = rates->aggregate.max_bytes;
  320.     if ((restore_bytes = rates->individual.restore_bps) == -1)
  321. return;
  322.     restore_bytes *= incr;
  323.     if (class2->individual_255_used)
  324. i = 255;
  325.     else
  326. i = 0;
  327.     for (;;) {
  328. if (i != 255 && class2->individual_map[i] == 255)
  329.     return;
  330. if (class2->individual[i] != rates->individual.max_bytes &&
  331.     (class2->individual[i] += restore_bytes) > rates->individual.max_bytes)
  332.     class2->individual[i] = rates->individual.max_bytes;
  333. if (++i == 255)
  334.     return;
  335.     }
  336. }
  338. static void
  339. delayUpdateClass3(class3DelayPool * class3, delaySpecSet * rates, int incr)
  340. {
  341.     int individual_restore_bytes, network_restore_bytes;
  342.     int mpos;
  343.     unsigned char i, j;
  344.     /* delaySetSpec may be pointer to partial structure so MUST pass by
  345.      * reference.
  346.      */
  347.     if (rates->aggregate.restore_bps != -1 &&
  348. (class3->aggregate += rates->aggregate.restore_bps * incr) >
  349. rates->aggregate.max_bytes)
  350. class3->aggregate = rates->aggregate.max_bytes;
  351.     /* the following line deliberately uses &, not &&, in an if statement
  352.      * to avoid conditional execution
  353.      */
  354.     if (((network_restore_bytes = rates->network.restore_bps) == -1) &
  355. ((individual_restore_bytes = rates->individual.restore_bps) == -1))
  356. return;
  357.     individual_restore_bytes *= incr;
  358.     network_restore_bytes *= incr;
  359.     if (class3->network_255_used)
  360. i = 255;
  361.     else
  362. i = 0;
  363.     for (;;) {
  364. if (i != 255 && class3->network_map[i] == 255)
  365.     return;
  366. if (individual_restore_bytes != -incr) {
  367.     mpos = i << 8;
  368.     if (class3->individual_255_used[i / 8] & (1 << (i % 8)))
  369. j = 255;
  370.     else
  371. j = 0;
  372.     for (;;) {
  373. if (j != 255 && class3->individual_map[i][j] == 255)
  374.     break;
  375. if (class3->individual[mpos] != rates->individual.max_bytes &&
  376.     (class3->individual[mpos] += individual_restore_bytes) >
  377.     rates->individual.max_bytes)
  378.     class3->individual[mpos] = rates->individual.max_bytes;
  379. mpos++;
  380. if (j == 255)
  381.     mpos -= 256;
  382. if (++j == 255)
  383.     break;
  384.     }
  385. }
  386. if (network_restore_bytes != -incr &&
  387.     class3->network[i] != rates->network.max_bytes &&
  388.     (class3->network[i] += network_restore_bytes) >
  389.     rates->network.max_bytes)
  390.     class3->network[i] = rates->network.max_bytes;
  391. if (++i == 255)
  392.     return;
  393.     }
  394. }
  396. void
  397. delayPoolsUpdate(void *unused)
  398. {
  399.     int incr = squid_curtime - delay_pools_last_update;
  400.     unsigned short i;
  401.     unsigned char class;
  402.     if (!Config.Delay.pools)
  403. return;
  404.     eventAdd("delayPoolsUpdate", delayPoolsUpdate, NULL, 1.0, 1);
  405.     if (incr < 1)
  406. return;
  407.     delay_pools_last_update = squid_curtime;
  408.     for (i = 0; i < Config.Delay.pools; i++) {
  409. class = Config.Delay.class[i];
  410. if (!class)
  411.     continue;
  412. switch (class) {
  413. case 1:
  414.     delayUpdateClass1(delay_data[i].class1, Config.Delay.rates[i], incr);
  415.     break;
  416. case 2:
  417.     delayUpdateClass2(delay_data[i].class2, Config.Delay.rates[i], incr);
  418.     break;
  419. case 3:
  420.     delayUpdateClass3(delay_data[i].class3, Config.Delay.rates[i], incr);
  421.     break;
  422. default:
  423.     assert(0);
  424. }
  425.     }
  426. }
  428. /*
  429.  * this returns the number of bytes the client is permitted. it does not take
  430.  * into account bytes already buffered - that is up to the caller.
  431.  */
  432. int
  433. delayBytesWanted(delay_id d, int min, int max)
  434. {
  435.     unsigned short position = d & 0xFFFF;
  436.     unsigned short pool = (d >> 16) - 1;
  437.     unsigned char class = (pool == 0xFFFF) ? 0 : Config.Delay.class[pool];
  438.     int nbytes = max;
  440.     switch (class) {
  441.     case 0:
  442. break;
  444.     case 1:
  445. if (Config.Delay.rates[pool]->aggregate.restore_bps != -1)
  446.     nbytes = XMIN(nbytes, delay_data[pool].class1->aggregate);
  447. break;
  449.     case 2:
  450. if (Config.Delay.rates[pool]->aggregate.restore_bps != -1)
  451.     nbytes = XMIN(nbytes, delay_data[pool].class2->aggregate);
  452. if (Config.Delay.rates[pool]->individual.restore_bps != -1)
  453.     nbytes = XMIN(nbytes, delay_data[pool].class2->individual[position]);
  454. break;
  456.     case 3:
  457. if (Config.Delay.rates[pool]->aggregate.restore_bps != -1)
  458.     nbytes = XMIN(nbytes, delay_data[pool].class3->aggregate);
  459. if (Config.Delay.rates[pool]->individual.restore_bps != -1)
  460.     nbytes = XMIN(nbytes, delay_data[pool].class3->individual[position]);
  461. if (Config.Delay.rates[pool]->network.restore_bps != -1)
  462.     nbytes = XMIN(nbytes, delay_data[pool].class3->network[position >> 8]);
  463. break;
  465.     default:
  466. fatalf("delayBytesWanted: Invalid class %dn", class);
  467. break;
  468.     }
  469.     nbytes = XMAX(min, nbytes);
  470.     return nbytes;
  471. }
  473. /*
  474.  * this records actual bytes recieved.  always recorded, even if the
  475.  * class is disabled - it's more efficient to just do it than to do all
  476.  * the checks.
  477.  */
  478. void
  479. delayBytesIn(delay_id d, int qty)
  480. {
  481.     unsigned short position = d & 0xFFFF;
  482.     unsigned short pool = (d >> 16) - 1;
  483.     unsigned char class;
  485.     if (pool == 0xFFFF)
  486. return;
  487.     class = Config.Delay.class[pool];
  488.     switch (class) {
  489.     case 1:
  490. delay_data[pool].class1->aggregate -= qty;
  491. return;
  492.     case 2:
  493. delay_data[pool].class2->aggregate -= qty;
  494. delay_data[pool].class2->individual[position] -= qty;
  495. return;
  496.     case 3:
  497. delay_data[pool].class3->aggregate -= qty;
  498. delay_data[pool].class3->network[position >> 8] -= qty;
  499. delay_data[pool].class3->individual[position] -= qty;
  500. return;
  501.     }
  502.     fatalf("delayBytesWanted: Invalid class %dn", class);
  503.     assert(0);
  504. }
  506. int
  507. delayMostBytesWanted(const MemObject * mem, int max)
  508. {
  509.     int i = 0;
  510.     int found = 0;
  511.     store_client *sc;
  512.     for (sc = mem->clients; sc; sc = sc->next) {
  513. if (sc->callback_data == NULL) /* open slot */
  514.     continue;
  515. if (sc->type != STORE_MEM_CLIENT)
  516.     continue;
  517. i = delayBytesWanted(sc->delay_id, i, max);
  518. found = 1;
  519.     }
  520.     return found ? i : max;
  521. }
  523. delay_id
  524. delayMostBytesAllowed(const MemObject * mem)
  525. {
  526.     int j;
  527.     int jmax = -1;
  528.     store_client *sc;
  529.     delay_id d = 0;
  530.     for (sc = mem->clients; sc; sc = sc->next) {
  531. if (sc->callback_data == NULL) /* open slot */
  532.     continue;
  533. if (sc->type != STORE_MEM_CLIENT)
  534.     continue;
  535. j = delayBytesWanted(sc->delay_id, 0, SQUID_TCP_SO_RCVBUF);
  536. if (j > jmax) {
  537.     jmax = j;
  538.     d = sc->delay_id;
  539. }
  540.     }
  541.     return d;
  542. }
  544. void
  545. delaySetStoreClient(StoreEntry * e, void *data, delay_id delay_id)
  546. {
  547.     store_client *sc = storeClientListSearch(e->mem_obj, data);
  548.     assert(sc != NULL);
  549.     sc->delay_id = delay_id;
  550. }
  552. static void
  553. delayPoolStatsAg(StoreEntry * sentry, delaySpecSet * rate, int ag)
  554. {
  555.     /* note - always pass delaySpecSet's by reference as may be incomplete */
  556.     if (rate->aggregate.restore_bps == -1) {
  557. storeAppendPrintf(sentry, "tAggregate:nttDisabled.nn");
  558. return;
  559.     }
  560.     storeAppendPrintf(sentry, "tAggregate:n");
  561.     storeAppendPrintf(sentry, "ttMax: %dn", rate->aggregate.max_bytes);
  562.     storeAppendPrintf(sentry, "ttRestore: %dn", rate->aggregate.restore_bps);
  563.     storeAppendPrintf(sentry, "ttCurrent: %dnn", ag);
  564. }
  566. static void
  567. delayPoolStats1(StoreEntry * sentry, unsigned short pool)
  568. {
  569.     /* must be a reference only - partially malloc()d struct */
  570.     delaySpecSet *rate = Config.Delay.rates[pool];
  572.     storeAppendPrintf(sentry, "Pool: %dntClass: 1nn", pool + 1);
  573.     delayPoolStatsAg(sentry, rate, delay_data[pool].class1->aggregate);
  574. }
  576. static void
  577. delayPoolStats2(StoreEntry * sentry, unsigned short pool)
  578. {
  579.     /* must be a reference only - partially malloc()d struct */
  580.     delaySpecSet *rate = Config.Delay.rates[pool];
  581.     class2DelayPool *class2 = delay_data[pool].class2;
  582.     unsigned char shown = 0, i;
  584.     storeAppendPrintf(sentry, "Pool: %dntClass: 2nn", pool + 1);
  585.     delayPoolStatsAg(sentry, rate, class2->aggregate);
  586.     if (rate->individual.restore_bps == -1) {
  587. storeAppendPrintf(sentry, "tIndividual:nttDisabled.nn");
  588. return;
  589.     }
  590.     storeAppendPrintf(sentry, "tIndividual:n");
  591.     storeAppendPrintf(sentry, "ttMax: %dn", rate->individual.max_bytes);
  592.     storeAppendPrintf(sentry, "ttRate: %dn", rate->individual.restore_bps);
  593.     storeAppendPrintf(sentry, "ttCurrent: ");
  594.     for (i = 0;; i++) {
  595. if (class2->individual_map[i] == 255)
  596.     break;
  597. storeAppendPrintf(sentry, "%d:%d ", class2->individual_map[i],
  598.     class2->individual[i]);
  599. shown = 1;
  600.     }
  601.     if (class2->individual_255_used) {
  602. storeAppendPrintf(sentry, "%d:%d ", 255, class2->individual[255]);
  603. shown = 1;
  604.     }
  605.     if (!shown)
  606. storeAppendPrintf(sentry, "Not used yet.");
  607.     storeAppendPrintf(sentry, "nn");
  608. }
  610. static void
  611. delayPoolStats3(StoreEntry * sentry, unsigned short pool)
  612. {
  613.     /* fully malloc()d struct in this case only */
  614.     delaySpecSet *rate = Config.Delay.rates[pool];
  615.     class3DelayPool *class3 = delay_data[pool].class3;
  616.     unsigned char shown = 0, i, j;
  618.     storeAppendPrintf(sentry, "Pool: %dntClass: 3nn", pool + 1);
  619.     delayPoolStatsAg(sentry, rate, class3->aggregate);
  620.     if (rate->network.restore_bps == -1) {
  621. storeAppendPrintf(sentry, "tNetwork:nttDisabled.");
  622.     } else {
  623. storeAppendPrintf(sentry, "tNetwork:n");
  624. storeAppendPrintf(sentry, "ttMax: %dn", rate->network.max_bytes);
  625. storeAppendPrintf(sentry, "ttRate: %dn", rate->network.restore_bps);
  626. storeAppendPrintf(sentry, "ttCurrent: ");
  627. for (i = 0;; i++) {
  628.     if (class3->network_map[i] == 255)
  629. break;
  630.     storeAppendPrintf(sentry, "%d:%d ", class3->network_map[i],
  631. class3->network[i]);
  632.     shown = 1;
  633. }
  634. if (class3->network_255_used) {
  635.     storeAppendPrintf(sentry, "%d:%d ", 255, class3->network[255]);
  636.     shown = 1;
  637. }
  638. if (!shown)
  639.     storeAppendPrintf(sentry, "Not used yet.");
  640.     }
  641.     storeAppendPrintf(sentry, "nn");
  642.     shown = 0;
  643.     if (rate->individual.restore_bps == -1) {
  644. storeAppendPrintf(sentry, "tIndividual:nttDisabled.nn");
  645. return;
  646.     }
  647.     storeAppendPrintf(sentry, "tIndividual:n");
  648.     storeAppendPrintf(sentry, "ttMax: %dn", rate->individual.max_bytes);
  649.     storeAppendPrintf(sentry, "ttRate: %dn", rate->individual.restore_bps);
  650.     for (i = 0;; i++) {
  651. if (class3->network_map[i] == 255)
  652.     break;
  653. storeAppendPrintf(sentry, "ttCurrent [Network %d]: ", class3->network_map[i]);
  654. shown = 1;
  655. for (j = 0;; j++) {
  656.     if (class3->individual_map[i][j] == 255)
  657. break;
  658.     storeAppendPrintf(sentry, "%d:%d ", class3->individual_map[i][j],
  659. class3->individual[(i << 8) | j]);
  660. }
  661. if (class3->individual_255_used[i / 8] & (1 << (i % 8))) {
  662.     storeAppendPrintf(sentry, "%d:%d ", 255, class3->individual[(i << 8) | 255]);
  663. }
  664. storeAppendPrintf(sentry, "n");
  665.     }
  666.     if (class3->network_255_used) {
  667. storeAppendPrintf(sentry, "ttCurrent [Network 255]: ");
  668. shown = 1;
  669. for (j = 0;; j++) {
  670.     if (class3->individual_map[255][j] == 255)
  671. break;
  672.     storeAppendPrintf(sentry, "%d:%d ", class3->individual_map[255][j],
  673. class3->individual[(255 << 8) | j]);
  674. }
  675. if (class3->individual_255_used[255 / 8] & (1 << (255 % 8))) {
  676.     storeAppendPrintf(sentry, "%d:%d ", 255, class3->individual[(255 << 8) | 255]);
  677. }
  678. storeAppendPrintf(sentry, "n");
  679.     }
  680.     if (!shown)
  681. storeAppendPrintf(sentry, "ttCurrent [All networks]: Not used yet.n");
  682.     storeAppendPrintf(sentry, "n");
  683. }
  685. static void
  686. delayPoolStats(StoreEntry * sentry)
  687. {
  688.     unsigned short i;
  690.     storeAppendPrintf(sentry, "Delay pools configured: %dnn", Config.Delay.pools);
  691.     for (i = 0; i < Config.Delay.pools; i++) {
  692. switch (Config.Delay.class[i]) {
  693. case 0:
  694.     storeAppendPrintf(sentry, "Pool: %dntClass: 0nn", i + 1);
  695.     storeAppendPrintf(sentry, "tMisconfigured pool.nn");
  696.     break;
  697. case 1:
  698.     delayPoolStats1(sentry, i);
  699.     break;
  700. case 2:
  701.     delayPoolStats2(sentry, i);
  702.     break;
  703. case 3:
  704.     delayPoolStats3(sentry, i);
  705.     break;
  706. default:
  707.     assert(0);
  708. }
  709.     }
  710. }
  712. #endif