Asn.cc
Go to the documentation of this file.
1 /*
2  * Copyright (C) 1996-2018 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 AnyP::Uri 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  // XXX: Missing a hittingRequiresCollapsing() && startCollapsingOn() check.
250  if ((e = storeGetPublic(asres, Http::METHOD_GET)) == NULL) {
251  e = storeCreateEntry(asres, asres, RequestFlags(), Http::METHOD_GET);
252  asState->sc = storeClientListAdd(e, asState);
254  } else {
255  e->lock("Asn");
256  asState->sc = storeClientListAdd(e, asState);
257  }
258 
259  asState->entry = e;
260  StoreIOBuffer readBuffer (AS_REQBUF_SZ, asState->offset, asState->reqbuf);
261  storeClientCopy(asState->sc, e, readBuffer, asHandleReply, asState);
262 }
263 
264 static void
266 {
267  ASState *asState = (ASState *)data;
268  StoreEntry *e = asState->entry;
269  char *s;
270  char *t;
271  char *buf = asState->reqbuf;
272  int leftoversz = -1;
273 
274  debugs(53, 3, "asHandleReply: Called with size=" << (unsigned int)result.length);
275  debugs(53, 3, "asHandleReply: buffer='" << buf << "'");
276 
277  /* First figure out whether we should abort the request */
278 
279  if (EBIT_TEST(e->flags, ENTRY_ABORTED)) {
280  delete asState;
281  return;
282  }
283 
284  if (result.length == 0 && asState->dataRead) {
285  debugs(53, 3, "asHandleReply: Done: " << e->url());
286  delete asState;
287  return;
288  } else if (result.flags.error) {
289  debugs(53, DBG_IMPORTANT, "asHandleReply: Called with Error set and size=" << (unsigned int) result.length);
290  delete asState;
291  return;
292  } else if (e->getReply()->sline.status() != Http::scOkay) {
293  debugs(53, DBG_IMPORTANT, "WARNING: AS " << asState->as_number << " whois request failed");
294  delete asState;
295  return;
296  }
297 
298  /*
299  * Next, attempt to parse our request
300  * Remembering that the actual buffer size is retsize + reqofs!
301  */
302  s = buf;
303 
304  while ((size_t)(s - buf) < result.length + asState->reqofs && *s != '\0') {
305  while (*s && xisspace(*s))
306  ++s;
307 
308  for (t = s; *t; ++t) {
309  if (xisspace(*t))
310  break;
311  }
312 
313  if (*t == '\0') {
314  /* oof, word should continue on next block */
315  break;
316  }
317 
318  *t = '\0';
319  debugs(53, 3, "asHandleReply: AS# " << s << " (" << asState->as_number << ")");
320  asnAddNet(s, asState->as_number);
321  s = t + 1;
322  asState->dataRead = true;
323  }
324 
325  /*
326  * Next, grab the end of the 'valid data' in the buffer, and figure
327  * out how much data is left in our buffer, which we need to keep
328  * around for the next request
329  */
330  leftoversz = (asState->reqofs + result.length) - (s - buf);
331 
332  assert(leftoversz >= 0);
333 
334  /*
335  * Next, copy the left over data, from s to s + leftoversz to the
336  * beginning of the buffer
337  */
338  memmove(buf, s, leftoversz);
339 
340  /*
341  * Next, update our offset and reqofs, and kick off a copy if required
342  */
343  asState->offset += result.length;
344 
345  asState->reqofs = leftoversz;
346 
347  debugs(53, 3, "asState->offset = " << asState->offset);
348 
349  if (e->store_status == STORE_PENDING) {
350  debugs(53, 3, "asHandleReply: store_status == STORE_PENDING: " << e->url() );
351  StoreIOBuffer tempBuffer (AS_REQBUF_SZ - asState->reqofs,
352  asState->offset,
353  asState->reqbuf + asState->reqofs);
354  storeClientCopy(asState->sc,
355  e,
356  tempBuffer,
358  asState);
359  } else {
360  StoreIOBuffer tempBuffer;
361  debugs(53, 3, "asHandleReply: store complete, but data received " << e->url() );
362  tempBuffer.offset = asState->offset;
363  tempBuffer.length = AS_REQBUF_SZ - asState->reqofs;
364  tempBuffer.data = asState->reqbuf + asState->reqofs;
365  storeClientCopy(asState->sc,
366  e,
367  tempBuffer,
369  asState);
370  }
371 }
372 
376 static int
377 asnAddNet(char *as_string, int as_number)
378 {
379  struct squid_radix_node *rn;
380  CbDataList<int> **Tail = NULL;
381  CbDataList<int> *q = NULL;
382  as_info *asinfo = NULL;
383 
384  Ip::Address mask;
386  char *t;
387  int bitl;
388 
389  t = strchr(as_string, '/');
390 
391  if (t == NULL) {
392  debugs(53, 3, "asnAddNet: failed, invalid response from whois server.");
393  return 0;
394  }
395 
396  *t = '\0';
397  addr = as_string;
398  bitl = atoi(t + 1);
399 
400  if (bitl < 0)
401  bitl = 0;
402 
403  // INET6 TODO : find a better way of identifying the base IPA family for mask than this.
404  t = strchr(as_string, '.');
405 
406  // generate Netbits Format Mask
407  mask.setNoAddr();
408  mask.applyMask(bitl, (t!=NULL?AF_INET:AF_INET6) );
409 
410  debugs(53, 3, "asnAddNet: called for " << addr << "/" << mask );
411 
412  rtentry_t *e = (rtentry_t *)xcalloc(1, sizeof(rtentry_t));
413 
414  e->e_addr.addr = addr;
415 
416  e->e_mask.addr = mask;
417 
418  rn = squid_rn_lookup(&e->e_addr, &e->e_mask, AS_tree_head);
419 
420  if (rn != NULL) {
421  asinfo = ((rtentry_t *) rn)->e_info;
422 
423  if (asinfo->as_number->find(as_number)) {
424  debugs(53, 3, "asnAddNet: Ignoring repeated network '" << addr << "/" << bitl << "' for AS " << as_number);
425  } else {
426  debugs(53, 3, "asnAddNet: Warning: Found a network with multiple AS numbers!");
427 
428  for (Tail = &asinfo->as_number; *Tail; Tail = &(*Tail)->next);
429  q = new CbDataList<int> (as_number);
430 
431  *(Tail) = q;
432 
433  e->e_info = asinfo;
434  }
435  } else {
436  q = new CbDataList<int> (as_number);
437  asinfo = (as_info *)xmalloc(sizeof(as_info));
438  asinfo->as_number = q;
439  squid_rn_addroute(&e->e_addr, &e->e_mask, AS_tree_head, e->e_nodes);
440  rn = squid_rn_match(&e->e_addr, AS_tree_head);
441  assert(rn != NULL);
442  e->e_info = asinfo;
443  }
444 
445  if (rn == 0) { /* assert might expand to nothing */
446  xfree(asinfo);
447  delete q;
448  xfree(e);
449  debugs(53, 3, "asnAddNet: Could not add entry.");
450  return 0;
451  }
452 
453  e->e_info = asinfo;
454  return 1;
455 }
456 
457 static int
458 destroyRadixNode(struct squid_radix_node *rn, void *w)
459 {
460 
461  struct squid_radix_node_head *rnh = (struct squid_radix_node_head *) w;
462 
463  if (rn && !(rn->rn_flags & RNF_ROOT)) {
464  rtentry_t *e = (rtentry_t *) rn;
465  rn = squid_rn_delete(rn->rn_key, rn->rn_mask, rnh);
466 
467  if (rn == 0)
468  debugs(53, 3, "destroyRadixNode: internal screwup");
469 
471 
472  xfree(rn);
473  }
474 
475  return 1;
476 }
477 
478 static void
480 {
481  CbDataList<int> *prev = NULL;
482  CbDataList<int> *data = e_info->as_number;
483 
484  while (data) {
485  prev = data;
486  data = data->next;
487  delete prev;
488  }
489 }
490 
491 static int
492 printRadixNode(struct squid_radix_node *rn, void *_sentry)
493 {
494  StoreEntry *sentry = (StoreEntry *)_sentry;
495  rtentry_t *e = (rtentry_t *) rn;
496  CbDataList<int> *q;
497  as_info *asinfo;
498  char buf[MAX_IPSTRLEN];
500  Ip::Address mask;
501 
502  assert(e);
503  assert(e->e_info);
504  addr = e->e_addr.addr;
505  mask = e->e_mask.addr;
506  storeAppendPrintf(sentry, "%s/%d\t",
507  addr.toStr(buf, MAX_IPSTRLEN),
508  mask.cidr() );
509  asinfo = e->e_info;
510  assert(asinfo->as_number);
511 
512  for (q = asinfo->as_number; q; q = q->next)
513  storeAppendPrintf(sentry, " %d", q->element);
514 
515  storeAppendPrintf(sentry, "\n");
516 
517  return 0;
518 }
519 
521 {
522  if (data)
523  delete data;
524 }
525 
526 bool
527 
529 {
530  return asnMatchIp(data, toMatch);
531 }
532 
533 SBufList
535 {
536  SBufList sl;
537 
538  CbDataList<int> *ldata = data;
539 
540  while (ldata != NULL) {
541  SBuf s;
542  s.Printf("%d", ldata->element);
543  sl.push_back(s);
544  ldata = ldata->next;
545  }
546 
547  return sl;
548 }
549 
550 bool
552 {
553  return data == NULL;
554 }
555 
556 void
558 {
559  CbDataList<int> **curlist = &data;
560  CbDataList<int> **Tail;
561  CbDataList<int> *q = NULL;
562  char *t = NULL;
563 
564  for (Tail = curlist; *Tail; Tail = &((*Tail)->next));
565  while ((t = ConfigParser::strtokFile())) {
566  q = new CbDataList<int> (atoi(t));
567  *(Tail) = q;
568  Tail = &q->next;
569  }
570 }
571 
574 {
575  if (data)
576  fatal ("cloning of ACLASN not implemented");
577 
578  return new ACLASN(*this);
579 }
580 
581 /* explicit template instantiation required for some systems */
582 
583 template class ACLStrategised<Ip::Address>;
584 
585 int
587 {
588  return data->match(checklist->src_addr);
589 }
590 
591 int
593 {
595 
596  if (ia) {
597  for (const auto ip: ia->goodAndBad()) {
598  if (data->match(ip))
599  return 1;
600  }
601 
602  return 0;
603 
604  } else if (!checklist->request->flags.destinationIpLookedUp) {
605  /* No entry in cache, lookup not attempted */
606  debugs(28, 3, "can't yet compare '" << AclMatchedName << "' ACL for " << checklist->request->url.host());
607  if (checklist->goAsync(DestinationIPLookup::Instance()))
608  return -1;
609  // else fall through to noaddr match, hiding the lookup failure (XXX)
610  }
611  Ip::Address noaddr;
612  noaddr.setNoAddr();
613  return data->match(noaddr);
614 }
615 
#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:457
char * as_whois_server
Definition: SquidConfig.h:175
virtual SBufList dump() const
Definition: Asn.cc:534
bool dataRead
Definition: Asn.cc:83
virtual void parse()
Definition: Asn.cc:557
Definition: SBuf.h:86
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:492
#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:592
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)
#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:516
bool isAnyAddr() const
Definition: Address.cc:163
int64_t offset
Definition: Asn.cc:80
CbDataList * next
Definition: CbDataList.h:31
static void fwdStart(const Comm::ConnectionPointer &client, StoreEntry *, HttpRequest *)
Same as Start() but no master xaction info (AccessLogEntry) available.
Definition: FwdState.cc:394
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:586
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:124
StoreEntry * storeCreateEntry(const char *url, const char *logUrl, const RequestFlags &flags, const HttpRequestMethod &method)
Definition: store.cc:776
bool goAsync(AsyncState *)
Definition: Checklist.cc:115
#define DBG_IMPORTANT
Definition: Debug.h:46
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:224
HttpReply const * getReply() const
Definition: store.cc:1670
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:573
CbDataList< int > * as_number
Definition: Asn.cc:64
#define CBDATA_CLASS(type)
Definition: cbdata.h:302
AnyP::Uri url
the request URI
Definition: HttpRequest.h:107
void * addr
Definition: membanger.c:46
static int asnAddNet(char *, int)
Definition: Asn.cc:377
char reqbuf[AS_REQBUF_SZ]
Definition: Asn.cc:82
void fatal(const char *message)
Definition: fatal.cc:28
HttpRequest::Pointer request
Definition: Asn.cc:78
the ASN db subsystem
uint16_t flags
Definition: Store.h:208
Http::StatusLine sline
Definition: HttpReply.h:60
const char * AclMatchedName
Definition: Acl.cc:30
void host(const char *src)
Definition: Uri.cc:47
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
#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:22
const char * url() const
Definition: store.cc:1600
static HttpRequest * FromUrl(const char *url, const MasterXaction::Pointer &, const HttpRequestMethod &method=Http::METHOD_GET)
Definition: HttpRequest.cc:522
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:528
RequestFlags flags
Definition: HttpRequest.h:133
store_status_t store_status
Definition: Store.h:220
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:479
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:551
char * toStr(char *buf, const unsigned int blen, int force=AF_UNSPEC) const
Definition: Address.cc:795
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:520
void storeAppendPrintf(StoreEntry *e, const char *fmt,...)
Definition: store.cc:875
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:458
#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:433
Definition: Address.cc:190

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors