Asn.cc
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1996-2017 The Squid Software Foundation and contributors
3  *
4  * Squid software is distributed under GPLv2+ license and includes
5  * contributions from numerous individuals and organizations.
6  * Please see the COPYING and CONTRIBUTORS files for details.
7  */
8 
9 /* DEBUG: section 53 AS Number handling */
10 
11 #include "squid.h"
12 #include "acl/Acl.h"
13 #include "acl/Asn.h"
14 #include "acl/Checklist.h"
15 #include "acl/DestinationAsn.h"
16 #include "acl/DestinationIp.h"
17 #include "acl/SourceAsn.h"
18 #include "acl/Strategised.h"
19 #include "FwdState.h"
20 #include "HttpReply.h"
21 #include "HttpRequest.h"
22 #include "ipcache.h"
23 #include "MasterXaction.h"
24 #include "mgr/Registration.h"
25 #include "radix.h"
26 #include "RequestFlags.h"
27 #include "SquidConfig.h"
28 #include "Store.h"
29 #include "StoreClient.h"
30 
31 #define WHOIS_PORT 43
32 #define AS_REQBUF_SZ 4096
33 
34 /* BEGIN of definitions for radix tree entries */
35 
36 /* 32/128 bits address in memory with length */
37 class m_ADDR
38 {
39 public:
40  uint8_t len;
42 
43  m_ADDR() : len(sizeof(Ip::Address)) {};
44 };
45 
46 /* END of definitions for radix tree entries */
47 
48 /* Head for ip to asn radix tree */
49 
51 
52 /* explicit instantiation required for some systems */
53 
57 
63 struct as_info {
65  time_t expires; /* NOTUSED */
66 };
67 
68 class ASState
69 {
71 
72 public:
73  ASState();
74  ~ASState();
75 
79  int as_number;
80  int64_t offset;
81  int reqofs;
82  char reqbuf[AS_REQBUF_SZ];
83  bool dataRead;
84 };
85 
87 
89  entry(NULL),
90  sc(NULL),
91  request(NULL),
92  as_number(0),
93  offset(0),
94  reqofs(0),
95  dataRead(false)
96 {
97  memset(reqbuf, 0, AS_REQBUF_SZ);
98 }
99 
101 {
102  debugs(53, 3, entry->url());
103  storeUnregister(sc, entry, this);
104  entry->unlock("~ASState");
105 }
106 
108 struct rtentry_t {
109  struct squid_radix_node e_nodes[2];
113 };
114 
115 static int asnAddNet(char *, int);
116 
117 static void asnCacheStart(int as);
118 
120 
121 #if defined(__cplusplus)
122 extern "C" {
123 #endif
124 
125 static int destroyRadixNode(struct squid_radix_node *rn, void *w);
126 static int printRadixNode(struct squid_radix_node *rn, void *sentry);
127 
128 #if defined(__cplusplus)
129 }
130 #endif
131 
132 void asnAclInitialize(ACL * acls);
133 
134 static void destroyRadixNodeInfo(as_info *);
135 
136 static OBJH asnStats;
137 
138 /* PUBLIC */
139 
140 int
142 {
143  struct squid_radix_node *rn;
144  as_info *e;
145  m_ADDR m_addr;
147  CbDataList<int> *b = NULL;
148 
149  debugs(53, 3, "asnMatchIp: Called for " << addr );
150 
151  if (AS_tree_head == NULL)
152  return 0;
153 
154  if (addr.isNoAddr())
155  return 0;
156 
157  if (addr.isAnyAddr())
158  return 0;
159 
160  m_addr.addr = addr;
161 
162  rn = squid_rn_match(&m_addr, AS_tree_head);
163 
164  if (rn == NULL) {
165  debugs(53, 3, "asnMatchIp: Address not in as db.");
166  return 0;
167  }
168 
169  debugs(53, 3, "asnMatchIp: Found in db!");
170  e = ((rtentry_t *) rn)->e_info;
171  assert(e);
172 
173  for (a = data; a; a = a->next)
174  for (b = e->as_number; b; b = b->next)
175  if (a->element == b->element) {
176  debugs(53, 5, "asnMatchIp: Found a match!");
177  return 1;
178  }
179 
180  debugs(53, 5, "asnMatchIp: AS not in as db.");
181  return 0;
182 }
183 
184 void
186 {
187  for (CbDataList<int> *i = data; i; i = i->
188  next)
189  asnCacheStart(i->element);
190 }
191 
192 static void
194 {
195  Mgr::RegisterAction("asndb", "AS Number Database", asnStats, 0, 1);
196 }
197 
198 /* initialize the radix tree structure */
199 
200 SQUIDCEXTERN int squid_max_keylen; /* yuck.. this is in lib/radix.c */
201 
202 void
203 asnInit(void)
204 {
205  static bool inited = false;
206  squid_max_keylen = 40;
207 
208  if (!inited) {
209  inited = true;
210  squid_rn_init();
211  }
212 
213  squid_rn_inithead(&AS_tree_head, 8);
214 
216 }
217 
218 void
220 {
221  squid_rn_walktree(AS_tree_head, destroyRadixNode, AS_tree_head);
222 
223  destroyRadixNode((struct squid_radix_node *) 0, (void *) AS_tree_head);
224 }
225 
226 static void
228 {
229  storeAppendPrintf(sentry, "Address \tAS Numbers\n");
230  squid_rn_walktree(AS_tree_head, printRadixNode, sentry);
231 }
232 
233 /* PRIVATE */
234 
235 static void
237 {
238  // TODO: use class URL instead of generating a string and re-parsing
239  LOCAL_ARRAY(char, asres, 4096);
240  StoreEntry *e;
241  ASState *asState = new ASState;
242  debugs(53, 3, "AS " << as);
243  snprintf(asres, 4096, "whois://%s/!gAS%d", Config.as_whois_server, as);
244  asState->as_number = as;
246  asState->request = HttpRequest::FromUrl(asres, mx);
247  assert(asState->request != NULL);
248 
249  if ((e = storeGetPublic(asres, Http::METHOD_GET)) == NULL) {
250  e = storeCreateEntry(asres, asres, RequestFlags(), Http::METHOD_GET);
251  asState->sc = storeClientListAdd(e, asState);
253  } else {
254  e->lock("Asn");
255  asState->sc = storeClientListAdd(e, asState);
256  }
257 
258  asState->entry = e;
259  StoreIOBuffer readBuffer (AS_REQBUF_SZ, asState->offset, asState->reqbuf);
260  storeClientCopy(asState->sc, e, readBuffer, asHandleReply, asState);
261 }
262 
263 static void
265 {
266  ASState *asState = (ASState *)data;
267  StoreEntry *e = asState->entry;
268  char *s;
269  char *t;
270  char *buf = asState->reqbuf;
271  int leftoversz = -1;
272 
273  debugs(53, 3, "asHandleReply: Called with size=" << (unsigned int)result.length);
274  debugs(53, 3, "asHandleReply: buffer='" << buf << "'");
275 
276  /* First figure out whether we should abort the request */
277 
278  if (EBIT_TEST(e->flags, ENTRY_ABORTED)) {
279  delete asState;
280  return;
281  }
282 
283  if (result.length == 0 && asState->dataRead) {
284  debugs(53, 3, "asHandleReply: Done: " << e->url());
285  delete asState;
286  return;
287  } else if (result.flags.error) {
288  debugs(53, DBG_IMPORTANT, "asHandleReply: Called with Error set and size=" << (unsigned int) result.length);
289  delete asState;
290  return;
291  } else if (e->getReply()->sline.status() != Http::scOkay) {
292  debugs(53, DBG_IMPORTANT, "WARNING: AS " << asState->as_number << " whois request failed");
293  delete asState;
294  return;
295  }
296 
297  /*
298  * Next, attempt to parse our request
299  * Remembering that the actual buffer size is retsize + reqofs!
300  */
301  s = buf;
302 
303  while ((size_t)(s - buf) < result.length + asState->reqofs && *s != '\0') {
304  while (*s && xisspace(*s))
305  ++s;
306 
307  for (t = s; *t; ++t) {
308  if (xisspace(*t))
309  break;
310  }
311 
312  if (*t == '\0') {
313  /* oof, word should continue on next block */
314  break;
315  }
316 
317  *t = '\0';
318  debugs(53, 3, "asHandleReply: AS# " << s << " (" << asState->as_number << ")");
319  asnAddNet(s, asState->as_number);
320  s = t + 1;
321  asState->dataRead = true;
322  }
323 
324  /*
325  * Next, grab the end of the 'valid data' in the buffer, and figure
326  * out how much data is left in our buffer, which we need to keep
327  * around for the next request
328  */
329  leftoversz = (asState->reqofs + result.length) - (s - buf);
330 
331  assert(leftoversz >= 0);
332 
333  /*
334  * Next, copy the left over data, from s to s + leftoversz to the
335  * beginning of the buffer
336  */
337  memmove(buf, s, leftoversz);
338 
339  /*
340  * Next, update our offset and reqofs, and kick off a copy if required
341  */
342  asState->offset += result.length;
343 
344  asState->reqofs = leftoversz;
345 
346  debugs(53, 3, "asState->offset = " << asState->offset);
347 
348  if (e->store_status == STORE_PENDING) {
349  debugs(53, 3, "asHandleReply: store_status == STORE_PENDING: " << e->url() );
350  StoreIOBuffer tempBuffer (AS_REQBUF_SZ - asState->reqofs,
351  asState->offset,
352  asState->reqbuf + asState->reqofs);
353  storeClientCopy(asState->sc,
354  e,
355  tempBuffer,
357  asState);
358  } else {
359  StoreIOBuffer tempBuffer;
360  debugs(53, 3, "asHandleReply: store complete, but data received " << e->url() );
361  tempBuffer.offset = asState->offset;
362  tempBuffer.length = AS_REQBUF_SZ - asState->reqofs;
363  tempBuffer.data = asState->reqbuf + asState->reqofs;
364  storeClientCopy(asState->sc,
365  e,
366  tempBuffer,
368  asState);
369  }
370 }
371 
375 static int
376 asnAddNet(char *as_string, int as_number)
377 {
378  struct squid_radix_node *rn;
379  CbDataList<int> **Tail = NULL;
380  CbDataList<int> *q = NULL;
381  as_info *asinfo = NULL;
382 
383  Ip::Address mask;
385  char *t;
386  int bitl;
387 
388  t = strchr(as_string, '/');
389 
390  if (t == NULL) {
391  debugs(53, 3, "asnAddNet: failed, invalid response from whois server.");
392  return 0;
393  }
394 
395  *t = '\0';
396  addr = as_string;
397  bitl = atoi(t + 1);
398 
399  if (bitl < 0)
400  bitl = 0;
401 
402  // INET6 TODO : find a better way of identifying the base IPA family for mask than this.
403  t = strchr(as_string, '.');
404 
405  // generate Netbits Format Mask
406  mask.setNoAddr();
407  mask.applyMask(bitl, (t!=NULL?AF_INET:AF_INET6) );
408 
409  debugs(53, 3, "asnAddNet: called for " << addr << "/" << mask );
410 
411  rtentry_t *e = (rtentry_t *)xcalloc(1, sizeof(rtentry_t));
412 
413  e->e_addr.addr = addr;
414 
415  e->e_mask.addr = mask;
416 
417  rn = squid_rn_lookup(&e->e_addr, &e->e_mask, AS_tree_head);
418 
419  if (rn != NULL) {
420  asinfo = ((rtentry_t *) rn)->e_info;
421 
422  if (asinfo->as_number->find(as_number)) {
423  debugs(53, 3, "asnAddNet: Ignoring repeated network '" << addr << "/" << bitl << "' for AS " << as_number);
424  } else {
425  debugs(53, 3, "asnAddNet: Warning: Found a network with multiple AS numbers!");
426 
427  for (Tail = &asinfo->as_number; *Tail; Tail = &(*Tail)->next);
428  q = new CbDataList<int> (as_number);
429 
430  *(Tail) = q;
431 
432  e->e_info = asinfo;
433  }
434  } else {
435  q = new CbDataList<int> (as_number);
436  asinfo = (as_info *)xmalloc(sizeof(as_info));
437  asinfo->as_number = q;
438  squid_rn_addroute(&e->e_addr, &e->e_mask, AS_tree_head, e->e_nodes);
439  rn = squid_rn_match(&e->e_addr, AS_tree_head);
440  assert(rn != NULL);
441  e->e_info = asinfo;
442  }
443 
444  if (rn == 0) { /* assert might expand to nothing */
445  xfree(asinfo);
446  delete q;
447  xfree(e);
448  debugs(53, 3, "asnAddNet: Could not add entry.");
449  return 0;
450  }
451 
452  e->e_info = asinfo;
453  return 1;
454 }
455 
456 static int
457 destroyRadixNode(struct squid_radix_node *rn, void *w)
458 {
459 
460  struct squid_radix_node_head *rnh = (struct squid_radix_node_head *) w;
461 
462  if (rn && !(rn->rn_flags & RNF_ROOT)) {
463  rtentry_t *e = (rtentry_t *) rn;
464  rn = squid_rn_delete(rn->rn_key, rn->rn_mask, rnh);
465 
466  if (rn == 0)
467  debugs(53, 3, "destroyRadixNode: internal screwup");
468 
470 
471  xfree(rn);
472  }
473 
474  return 1;
475 }
476 
477 static void
479 {
480  CbDataList<int> *prev = NULL;
481  CbDataList<int> *data = e_info->as_number;
482 
483  while (data) {
484  prev = data;
485  data = data->next;
486  delete prev;
487  }
488 }
489 
490 static int
491 printRadixNode(struct squid_radix_node *rn, void *_sentry)
492 {
493  StoreEntry *sentry = (StoreEntry *)_sentry;
494  rtentry_t *e = (rtentry_t *) rn;
495  CbDataList<int> *q;
496  as_info *asinfo;
497  char buf[MAX_IPSTRLEN];
499  Ip::Address mask;
500 
501  assert(e);
502  assert(e->e_info);
503  addr = e->e_addr.addr;
504  mask = e->e_mask.addr;
505  storeAppendPrintf(sentry, "%s/%d\t",
506  addr.toStr(buf, MAX_IPSTRLEN),
507  mask.cidr() );
508  asinfo = e->e_info;
509  assert(asinfo->as_number);
510 
511  for (q = asinfo->as_number; q; q = q->next)
512  storeAppendPrintf(sentry, " %d", q->element);
513 
514  storeAppendPrintf(sentry, "\n");
515 
516  return 0;
517 }
518 
520 {
521  if (data)
522  delete data;
523 }
524 
525 bool
526 
528 {
529  return asnMatchIp(data, toMatch);
530 }
531 
532 SBufList
534 {
535  SBufList sl;
536 
537  CbDataList<int> *ldata = data;
538 
539  while (ldata != NULL) {
540  SBuf s;
541  s.Printf("%d", ldata->element);
542  sl.push_back(s);
543  ldata = ldata->next;
544  }
545 
546  return sl;
547 }
548 
549 bool
551 {
552  return data == NULL;
553 }
554 
555 void
557 {
558  CbDataList<int> **curlist = &data;
559  CbDataList<int> **Tail;
560  CbDataList<int> *q = NULL;
561  char *t = NULL;
562 
563  for (Tail = curlist; *Tail; Tail = &((*Tail)->next));
564  while ((t = ConfigParser::strtokFile())) {
565  q = new CbDataList<int> (atoi(t));
566  *(Tail) = q;
567  Tail = &q->next;
568  }
569 }
570 
573 {
574  if (data)
575  fatal ("cloning of ACLASN not implemented");
576 
577  return new ACLASN(*this);
578 }
579 
580 /* explicit template instantiation required for some systems */
581 
582 template class ACLStrategised<Ip::Address>;
583 
584 int
586 {
587  return data->match(checklist->src_addr);
588 }
589 
590 int
592 {
594 
595  if (ia) {
596  for (const auto ip: ia->goodAndBad()) {
597  if (data->match(ip))
598  return 1;
599  }
600 
601  return 0;
602 
603  } else if (!checklist->request->flags.destinationIpLookedUp) {
604  /* No entry in cache, lookup not attempted */
605  debugs(28, 3, "can't yet compare '" << AclMatchedName << "' ACL for " << checklist->request->url.host());
606  if (checklist->goAsync(DestinationIPLookup::Instance()))
607  return -1;
608  // else fall through to noaddr match, hiding the lookup failure (XXX)
609  }
610  Ip::Address noaddr;
611  noaddr.setNoAddr();
612  return data->match(noaddr);
613 }
614 
#define assert(EX)
Definition: assert.h:17
virtual bool match(M)=0
void storeClientCopy(store_client *sc, StoreEntry *e, StoreIOBuffer copyInto, STCB *callback, void *data)
StoreEntry * entry
Definition: Asn.cc:76
static int sc[16]
Definition: smbdes.c:121
SQUIDCEXTERN int squid_max_keylen
Definition: Asn.cc:200
m_ADDR e_mask
Definition: Asn.cc:112
int unlock(const char *context)
Definition: store.cc:485
char * as_whois_server
Definition: SquidConfig.h:171
virtual SBufList dump() const
Definition: Asn.cc:533
bool dataRead
Definition: Asn.cc:83
virtual void parse()
Definition: Asn.cc:556
Definition: SBuf.h:87
ASState()
Definition: Asn.cc:88
#define xcalloc
Definition: membanger.c:57
Ip::Address src_addr
bool isNoAddr() const
Definition: Address.cc:277
static int printRadixNode(struct squid_radix_node *rn, void *sentry)
Definition: Asn.cc:491
#define SQUIDCEXTERN
Definition: squid.h:26
struct _request * request(char *urlin)
Definition: tcp-banger2.c:291
int i
Definition: membanger.c:49
SQUIDCEXTERN struct squid_radix_node * squid_rn_lookup(void *, void *, struct squid_radix_node_head *)
Definition: radix.c:207
int cbdata_type
Definition: cbdata.h:195
Definition: Acl.h:39
virtual int match(ACLData< MatchType > *&, ACLFilledChecklist *)
Definition: Asn.cc:591
virtual void prepareForUse()
Definition: Asn.cc:185
SQUIDCEXTERN int squid_rn_walktree(struct squid_radix_node_head *, int(*)(struct squid_radix_node *, void *), void *)
Definition: radix.c:875
int applyMask(const Address &mask)
Definition: Address.cc:87
store_client * storeClientListAdd(StoreEntry *e, void *data)
Definition: store_client.cc:87
#define xisspace(x)
Definition: xis.h:17
void OBJH(StoreEntry *)
Definition: forward.h:44
Definition: Asn.cc:68
SQUIDCEXTERN struct squid_radix_node * squid_rn_delete(void *, void *, struct squid_radix_node_head *)
Definition: radix.c:696
void asnAclInitialize(ACL *acls)
StoreEntry * storeGetPublic(const char *uri, const HttpRequestMethod &method)
Definition: store.cc:549
bool isAnyAddr() const
Definition: Address.cc:163
int64_t offset
Definition: Asn.cc:80
CbDataList * next
Definition: CbDataList.h:31
void host(const char *src)
Definition: url.cc:47
static void fwdStart(const Comm::ConnectionPointer &client, StoreEntry *, HttpRequest *)
Same as Start() but no master xaction info (AccessLogEntry) available.
Definition: FwdState.cc:393
SQUIDCEXTERN struct squid_radix_node * squid_rn_match(void *, struct squid_radix_node_head *)
Definition: radix.c:245
bool find(C const &) const
Definition: CbDataList.h:110
m_ADDR()
Definition: Asn.cc:43
bool destinationIpLookedUp
Definition: RequestFlags.h:106
void setNoAddr()
Definition: Address.cc:285
virtual int match(ACLData< MatchType > *&, ACLFilledChecklist *) override
Definition: Asn.cc:585
void const char HLPCB void * data
Definition: stub_helper.cc:16
int64_t offset
Definition: StoreIOBuffer.h:55
CBDATA_CLASS_INIT(ASState)
static void asnCacheStart(int as)
Definition: Asn.cc:236
#define debugs(SECTION, LEVEL, CONTENT)
Definition: Debug.h:123
StoreEntry * storeCreateEntry(const char *url, const char *logUrl, const RequestFlags &flags, const HttpRequestMethod &method)
Definition: store.cc:800
bool goAsync(AsyncState *)
Definition: Checklist.cc:115
#define DBG_IMPORTANT
Definition: Debug.h:45
void RegisterAction(char const *action, char const *desc, OBJH *handler, int pw_req_flag, int atomic)
Definition: Registration.cc:16
Definition: Asn.cc:37
SBuf & Printf(const char *fmt,...)
Definition: SBuf.cc:236
virtual HttpReply const * getReply() const
Definition: store.cc:1742
as_info * e_info
Definition: Asn.cc:110
#define IP_LOOKUP_IF_MISS
Definition: defines.h:65
virtual ACLData< Ip::Address > * clone() const
Definition: Asn.cc:572
CbDataList< int > * as_number
Definition: Asn.cc:64
#define CBDATA_CLASS(type)
Definition: cbdata.h:302
void * addr
Definition: membanger.c:46
static int asnAddNet(char *, int)
Definition: Asn.cc:376
char reqbuf[AS_REQBUF_SZ]
Definition: Asn.cc:82
void fatal(const char *message)
Definition: fatal.cc:39
HttpRequest::Pointer request
Definition: Asn.cc:78
the ASN db subsystem
uint16_t flags
Definition: Store.h:173
Http::StatusLine sline
Definition: HttpReply.h:60
const char * AclMatchedName
Definition: Acl.cc:30
static void asnRegisterWithCacheManager(void)
Definition: Asn.cc:193
void asnInit(void)
Definition: Asn.cc:203
struct StoreIOBuffer::@146 flags
ACLASN()
Definition: Asn.h:30
uint8_t len
Definition: Asn.cc:40
URL url
the request URI
Definition: HttpRequest.h:103
#define LOCAL_ARRAY(type, name, size)
Definition: leakcheck.h:18
unsigned char rn_flags
Definition: radix.h:59
std::list< SBuf > SBufList
Definition: forward.h:26
const char * url() const
Definition: store.cc:1672
static HttpRequest * FromUrl(const char *url, const MasterXaction::Pointer &, const HttpRequestMethod &method=Http::METHOD_GET)
Definition: HttpRequest.cc:523
void const char * buf
Definition: stub_helper.cc:16
void asnFreeMemory(void)
Definition: Asn.cc:219
unsigned error
Definition: StoreIOBuffer.h:52
int storeUnregister(store_client *sc, StoreEntry *e, void *data)
HttpRequest * request
CbDataList< int > * data
Definition: Asn.h:41
virtual bool match(Ip::Address)
Definition: Asn.cc:527
RequestFlags flags
Definition: HttpRequest.h:129
store_status_t store_status
Definition: Store.h:185
const ipcache_addrs * ipcache_gethostbyname(const char *name, int flags)
Definition: ipcache.cc:720
#define xmalloc
time_t expires
Definition: Asn.cc:65
int cidr() const
Definition: Address.cc:44
~ASState()
Definition: Asn.cc:100
static char * strtokFile()
Definition: ConfigParser.cc:82
void STCB(void *, StoreIOBuffer)
Definition: StoreClient.h:16
static void destroyRadixNodeInfo(as_info *)
Definition: Asn.cc:478
store_client * sc
Definition: Asn.cc:77
int a
Definition: membanger.c:50
#define MAX_IPSTRLEN
Length of buffer that needs to be allocated to old a null-terminated IP-string.
Definition: forward.h:23
SQUIDCEXTERN int squid_rn_inithead(struct squid_radix_node_head **, int)
Definition: radix.c:911
m_ADDR e_addr
Definition: Asn.cc:111
static OBJH asnStats
Definition: Asn.cc:136
bool empty() const
Definition: Asn.cc:550
char * toStr(char *buf, const unsigned int blen, int force=AF_UNSPEC) const
Definition: Address.cc:810
Definition: Asn.cc:63
#define AS_REQBUF_SZ
Definition: Asn.cc:32
#define xfree
struct squid_radix_node e_nodes[2]
Definition: Asn.cc:109
static DestinationIPLookup * Instance()
virtual ~ACLASN()
Definition: Asn.cc:519
void storeAppendPrintf(StoreEntry *e, const char *fmt,...)
Definition: store.cc:904
Ip::Address addr
Definition: Asn.cc:41
SQUIDCEXTERN struct squid_radix_node * squid_rn_addroute(void *, void *, struct squid_radix_node_head *, struct squid_radix_node[2])
Definition: radix.c:543
IpsSelector< IpsIterator > goodAndBad() const
all IPs
Definition: ipcache.h:249
int asnMatchIp(CbDataList< int > *data, Ip::Address &addr)
Definition: Asn.cc:141
#define EBIT_TEST(flag, bit)
Definition: defines.h:107
static STCB asHandleReply
Definition: Asn.cc:119
C * getRaw() const
Definition: RefCount.h:74
class SquidConfig Config
Definition: SquidConfig.cc:12
#define NULL
Definition: types.h:166
int reqofs
Definition: Asn.cc:81
struct squid_radix_node_head * AS_tree_head
Definition: Asn.cc:50
int as_number
Definition: Asn.cc:79
static int destroyRadixNode(struct squid_radix_node *rn, void *w)
Definition: Asn.cc:457
#define false
Definition: GnuRegex.c:233
SQUIDCEXTERN void squid_rn_init(void)
Definition: radix.c:941
#define RNF_ROOT
Definition: radix.h:61
Http::StatusCode status() const
retrieve the status code for this status line
Definition: StatusLine.h:45
void lock(const char *context)
Definition: store.cc:448
Definition: Address.cc:190

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors