src/structs.h

   1 /*
   2  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   3  * ----------------------------------------------------------
   4  *
   5  *  Squid is the result of efforts by numerous individuals from
   6  *  the Internet community; see the CONTRIBUTORS file for full
   7  *  details.   Many organizations have provided support for Squid's
   8  *  development; see the SPONSORS file for full details.  Squid is
   9  *  Copyrighted (C) 2001 by the Regents of the University of
  10  *  California; see the COPYRIGHT file for full details.  Squid
  11  *  incorporates software developed and/or copyrighted by other
  12  *  sources; see the CREDITS file for full details.
  13  *
  14  *  This program is free software; you can redistribute it and/or modify
  15  *  it under the terms of the GNU General Public License as published by
  16  *  the Free Software Foundation; either version 2 of the License, or
  17  *  (at your option) any later version.
  18  *
  19  *  This program is distributed in the hope that it will be useful,
  20  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *  GNU General Public License for more details.
  23  *
  24  *  You should have received a copy of the GNU General Public License
  25  *  along with this program; if not, write to the Free Software
  26  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  27  *
  28  */
  29 #ifndef SQUID_STRUCTS_H
  30 #define SQUID_STRUCTS_H
  31
  32 #include "config.h"
  33 #include "RefCount.h"
  34 #include "cbdata.h"
  35
  36 /* needed for various structures still in structs.h */
  37 #include "dlink.h"
  38 /* needed for the global config */
  39 #include "HttpHeader.h"
  40
  41 struct acl_name_list {
  42     char name[ACL_NAME_SZ];
  43     acl_name_list *next;
  44 };
  45
  46 struct acl_deny_info_list {
  47     err_type err_page_id;
  48     char *err_page_name;
  49     acl_name_list *acl_list;
  50     acl_deny_info_list *next;
  51 };
  52
  53
  54 class acl_access;
  55
  56 struct _header_mangler {
  57     acl_access *access_list;
  58     char *replacement;
  59 };
  60
  61 class ACLChecklist;
  62
  63 #if SQUID_SNMP
  64
  65 struct _snmp_request_t {
  66     u_char *buf;
  67     u_char *outbuf;
  68     int len;
  69     int sock;
  70     long reqid;
  71     int outlen;
  72
  73     IpAddress from;
  74
  75     struct snmp_pdu *PDU;
  76     ACLChecklist *acl_checklist;
  77     u_char *community;
  78
  79     struct snmp_session session;
  80 };
  81
  82 #endif
  83
  84 class ACLList;
  85
  86 struct acl_address {
  87     acl_address *next;
  88     ACLList *aclList;
  89
  90     IpAddress addr;
  91 };
  92
  93 struct acl_tos {
  94     acl_tos *next;
  95     ACLList *aclList;
  96     int tos;
  97 };
  98
  99 struct acl_size_t {
 100     acl_size_t *next;
 101     ACLList *aclList;
 102     int64_t size;
 103 };
 104
 105 struct ushortlist {
 106     u_short i;
 107     ushortlist *next;
 108 };
 109
 110 struct relist {
 111     char *pattern;
 112     regex_t regex;
 113     relist *next;
 114 };
 115
 116 #if DELAY_POOLS
 117 #include "DelayConfig.h"
 118 #endif
 119
 120 #if USE_ICMP
 121 #include "icmp/IcmpConfig.h"
 122 #endif
 123
 124 #if USE_ZPH_QOS
 125 #include "ip/QosConfig.h"
 126 #endif
 127
 128 /* forward decl for SquidConfig, see RemovalPolicy.h */
 129
 130 class RemovalPolicySettings;
 131 class external_acl;
 132 class Store;
 133
 134 struct SquidConfig {
 135
 136     struct {
 137         /* These should be for the Store::Root instance.
 138         * this needs pluggable parsing to be done smoothly.
 139         */
 140         int highWaterMark;
 141         int lowWaterMark;
 142     } Swap;
 143     size_t memMaxSize;
 144
 145     struct {
 146         int64_t min;
 147         int pct;
 148         int64_t max;
 149     } quickAbort;
 150     int64_t readAheadGap;
 151     RemovalPolicySettings *replPolicy;
 152     RemovalPolicySettings *memPolicy;
 153 #if HTTP_VIOLATIONS
 154     time_t negativeTtl;
 155 #endif
 156     time_t negativeDnsTtl;
 157     time_t positiveDnsTtl;
 158     time_t shutdownLifetime;
 159     time_t backgroundPingRate;
 160
 161     struct {
 162         time_t read;
 163         time_t lifetime;
 164         time_t connect;
 165         time_t forward;
 166         time_t peer_connect;
 167         time_t request;
 168         time_t persistent_request;
 169         time_t pconn;
 170         time_t siteSelect;
 171         time_t deadPeer;
 172         int icp_query;          /* msec */
 173         int icp_query_max;      /* msec */
 174         int icp_query_min;      /* msec */
 175         int mcast_icp_query;    /* msec */
 176 #if USE_IDENT
 177
 178         time_t ident;
 179 #endif
 180 #if !USE_DNSSERVERS
 181
 182         time_t idns_retransmit;
 183         time_t idns_query;
 184 #endif
 185
 186     } Timeout;
 187     size_t maxRequestHeaderSize;
 188     int64_t maxRequestBodySize;
 189     size_t maxReplyHeaderSize;
 190     acl_size_t *ReplyBodySize;
 191
 192     struct {
 193         u_short icp;
 194 #if USE_HTCP
 195
 196         u_short htcp;
 197 #endif
 198 #if SQUID_SNMP
 199
 200         u_short snmp;
 201 #endif
 202     } Port;
 203
 204     struct {
 205         http_port_list *http;
 206 #if USE_SSL
 207
 208         https_port_list *https;
 209 #endif
 210
 211     } Sockaddr;
 212 #if SQUID_SNMP
 213
 214     struct {
 215         char *configFile;
 216         char *agentInfo;
 217     } Snmp;
 218 #endif
 219 #if USE_WCCP
 220
 221     struct {
 222
 223         IpAddress router;
 224
 225         IpAddress address;
 226         int version;
 227     } Wccp;
 228 #endif
 229 #if USE_WCCPv2
 230
 231     struct {
 232         IpAddress_list *router;
 233
 234         IpAddress address;
 235         int forwarding_method;
 236         int return_method;
 237         int assignment_method;
 238         int weight;
 239         int rebuildwait;
 240         void *info;
 241     } Wccp2;
 242 #endif
 243
 244 #if USE_ICMP
 245     IcmpConfig pinger;
 246 #endif
 247
 248     char *as_whois_server;
 249
 250     struct {
 251         char *store;
 252         char *swap;
 253 #if USE_USERAGENT_LOG
 254
 255         char *useragent;
 256 #endif
 257 #if USE_REFERER_LOG
 258
 259         char *referer;
 260 #endif
 261 #if WIP_FWD_LOG
 262
 263         char *forward;
 264 #endif
 265
 266         logformat *logformats;
 267
 268         customlog *accesslogs;
 269
 270         int rotateNumber;
 271     } Log;
 272     char *adminEmail;
 273     char *EmailFrom;
 274     char *EmailProgram;
 275     char *effectiveUser;
 276     char *visible_appname_string;
 277     char *effectiveGroup;
 278
 279     struct {
 280 #if USE_DNSSERVERS
 281         char *dnsserver;
 282 #endif
 283
 284         wordlist *redirect;
 285 #if USE_UNLINKD
 286
 287         char *unlinkd;
 288 #endif
 289
 290         char *diskd;
 291 #if USE_SSL
 292
 293         char *ssl_password;
 294 #endif
 295
 296     } Program;
 297 #if USE_DNSSERVERS
 298
 299     int dnsChildren;
 300 #endif
 301
 302     int redirectChildren;
 303     int redirectConcurrency;
 304     time_t authenticateGCInterval;
 305     time_t authenticateTTL;
 306     time_t authenticateIpTTL;
 307
 308     struct {
 309 #if USE_SQUID_ESI
 310         char *surrogate_id;
 311 #endif
 312
 313     } Accel;
 314     char *appendDomain;
 315     size_t appendDomainLen;
 316     char *pidFilename;
 317     char *netdbFilename;
 318     char *mimeTablePathname;
 319     char *etcHostsPath;
 320     char *visibleHostname;
 321     char *uniqueHostname;
 322     wordlist *hostnameAliases;
 323     char *errHtmlText;
 324
 325     struct {
 326         char *host;
 327         char *file;
 328         time_t period;
 329         u_short port;
 330     } Announce;
 331
 332     struct {
 333
 334         IpAddress udp_incoming;
 335
 336         IpAddress udp_outgoing;
 337 #if SQUID_SNMP
 338
 339         IpAddress snmp_incoming;
 340
 341         IpAddress snmp_outgoing;
 342 #endif
 343         /* FIXME INET6 : this should really be a CIDR value */
 344         IpAddress client_netmask;
 345     } Addrs;
 346     size_t tcpRcvBufsz;
 347     size_t udpMaxHitObjsz;
 348     wordlist *hierarchy_stoplist;
 349     wordlist *mcast_group_list;
 350     wordlist *dns_nameservers;
 351     peer *peers;
 352     int npeers;
 353
 354     struct {
 355         int size;
 356         int low;
 357         int high;
 358     } ipcache;
 359
 360     struct {
 361         int size;
 362     } fqdncache;
 363     int minDirectHops;
 364     int minDirectRtt;
 365     cachemgr_passwd *passwd_list;
 366
 367     struct {
 368         int objectsPerBucket;
 369         int64_t avgObjectSize;
 370         int64_t maxObjectSize;
 371         int64_t minObjectSize;
 372         size_t maxInMemObjSize;
 373     } Store;
 374
 375     struct {
 376         int high;
 377         int low;
 378         time_t period;
 379     } Netdb;
 380
 381     struct {
 382         int log_udp;
 383         int res_defnames;
 384         int anonymizer;
 385         int client_db;
 386         int query_icmp;
 387         int icp_hit_stale;
 388         int buffered_logs;
 389         int common_log;
 390         int log_mime_hdrs;
 391         int log_fqdn;
 392         int announce;
 393         int mem_pools;
 394         int test_reachability;
 395         int half_closed_clients;
 396         int refresh_all_ims;
 397 #if HTTP_VIOLATIONS
 398
 399         int reload_into_ims;
 400 #endif
 401
 402         int offline;
 403         int redir_rewrites_host;
 404         int prefer_direct;
 405         int nonhierarchical_direct;
 406         int strip_query_terms;
 407         int redirector_bypass;
 408         int ignore_unknown_nameservers;
 409         int client_pconns;
 410         int server_pconns;
 411         int error_pconns;
 412 #if USE_CACHE_DIGESTS
 413
 414         int digest_generation;
 415 #endif
 416
 417         int log_ip_on_direct;
 418         int ie_refresh;
 419         int vary_ignore_expire;
 420         int pipeline_prefetch;
 421
 422 #if USE_SQUID_ESI
 423         int surrogate_is_remote;
 424 #endif
 425
 426         int request_entities;
 427         int detect_broken_server_pconns;
 428         int balance_on_multiple_ip;
 429         int relaxed_header_parser;
 430         int check_hostnames;
 431         int allow_underscore;
 432         int via;
 433         int emailErrData;
 434         int httpd_suppress_version_string;
 435         int global_internal_static;
 436         int dns_require_A;
 437
 438 #if FOLLOW_X_FORWARDED_FOR
 439         int acl_uses_indirect_client;
 440         int delay_pool_uses_indirect_client;
 441         int log_uses_indirect_client;
 442 #endif /* FOLLOW_X_FORWARDED_FOR */
 443
 444         int WIN32_IpAddrChangeMonitor;
 445     } onoff;
 446
 447     int forward_max_tries;
 448
 449     class ACL *aclList;
 450
 451     struct {
 452         acl_access *http;
 453         acl_access *icp;
 454         acl_access *miss;
 455         acl_access *NeverDirect;
 456         acl_access *AlwaysDirect;
 457         acl_access *ASlists;
 458         acl_access *noCache;
 459         acl_access *log;
 460 #if SQUID_SNMP
 461
 462         acl_access *snmp;
 463 #endif
 464 #if HTTP_VIOLATIONS
 465         acl_access *brokenPosts;
 466 #endif
 467 #if USE_IDENT
 468
 469         acl_access *identLookup;
 470 #endif
 471
 472         acl_access *redirector;
 473         acl_access *reply;
 474         acl_address *outgoing_address;
 475         acl_tos *outgoing_tos;
 476         acl_tos *clientside_tos;
 477 #if USE_HTCP
 478
 479         acl_access *htcp;
 480         acl_access *htcp_clr;
 481 #endif
 482
 483 #if USE_SSL
 484         acl_access *ssl_bump;
 485 #endif
 486 #if FOLLOW_X_FORWARDED_FOR
 487         acl_access *followXFF;
 488 #endif /* FOLLOW_X_FORWARDED_FOR */
 489
 490     } accessList;
 491     acl_deny_info_list *denyInfoList;
 492     authConfig authConfiguration;
 493
 494     struct {
 495         size_t list_width;
 496         int list_wrap;
 497         char *anon_user;
 498         int passive;
 499         int epsv_all;
 500         int sanitycheck;
 501         int telnet;
 502     } Ftp;
 503     refresh_t *Refresh;
 504
 505     struct _cacheSwap {
 506         RefCount<class Store> *swapDirs;
 507         int n_allocated;
 508         int n_configured;
 509     } cacheSwap;
 510
 511     struct {
 512         char *directory;
 513         int use_short_names;
 514     } icons;
 515     char *errorDirectory;
 516 #if USE_ERR_LOCALES
 517     char *errorDefaultLanguage;
 518     int errorLogMissingLanguages;
 519 #endif
 520     char *errorStylesheet;
 521
 522     struct {
 523         int maxtries;
 524         int onerror;
 525     } retry;
 526
 527     struct {
 528         size_t limit;
 529     } MemPools;
 530 #if DELAY_POOLS
 531
 532     DelayConfig Delay;
 533 #endif
 534
 535     struct {
 536         int icp_average;
 537         int dns_average;
 538         int http_average;
 539         int icp_min_poll;
 540         int dns_min_poll;
 541         int http_min_poll;
 542     } comm_incoming;
 543     int max_open_disk_fds;
 544     int uri_whitespace;
 545     int64_t rangeOffsetLimit;
 546 #if MULTICAST_MISS_STREAM
 547
 548     struct {
 549
 550         IpAddress addr;
 551         int ttl;
 552         unsigned short port;
 553         char *encode_key;
 554     } mcast_miss;
 555 #endif
 556
 557     /* one access list per header type we know of */
 558     header_mangler request_header_access[HDR_ENUM_END];
 559     /* one access list per header type we know of */
 560     header_mangler reply_header_access[HDR_ENUM_END];
 561     char *coredump_dir;
 562     char *chroot_dir;
 563 #if USE_CACHE_DIGESTS
 564
 565     struct {
 566         int bits_per_entry;
 567         time_t rebuild_period;
 568         time_t rewrite_period;
 569         size_t swapout_chunk_size;
 570         int rebuild_chunk_percentage;
 571     } digest;
 572 #endif
 573 #if USE_SSL
 574
 575     struct {
 576         int unclean_shutdown;
 577         char *ssl_engine;
 578     } SSL;
 579 #endif
 580
 581     wordlist *ext_methods;
 582
 583     struct {
 584         int high_rptm;
 585         int high_pf;
 586         size_t high_memory;
 587     } warnings;
 588     char *store_dir_select_algorithm;
 589     int sleep_after_fork;       /* microseconds */
 590     time_t minimum_expiry_time; /* seconds */
 591     external_acl *externalAclHelperList;
 592
 593 #if USE_ZPH_QOS
 594     QosConfig zph;
 595 #endif
 596
 597 #if USE_SSL
 598
 599     struct {
 600         char *cert;
 601         char *key;
 602         int version;
 603         char *options;
 604         char *cipher;
 605         char *cafile;
 606         char *capath;
 607         char *crlfile;
 608         char *flags;
 609         acl_access *cert_error;
 610         SSL_CTX *sslContext;
 611     } ssl_client;
 612 #endif
 613
 614     char *accept_filter;
 615     int umask;
 616
 617 #if USE_LOADABLE_MODULES
 618     wordlist *loadable_module_names;
 619 #endif
 620 };
 621
 622 SQUIDCEXTERN SquidConfig Config;
 623
 624 struct SquidConfig2 {
 625     struct {
 626         int enable_purge;
 627         int mangle_request_headers;
 628     } onoff;
 629     uid_t effectiveUserID;
 630     gid_t effectiveGroupID;
 631 };
 632
 633 SQUIDCEXTERN SquidConfig2 Config2;
 634
 635 struct _close_handler {
 636     PF *handler;
 637     void *data;
 638     close_handler *next;
 639 };
 640
 641 struct _dread_ctrl {
 642     int fd;
 643     off_t offset;
 644     int req_len;
 645     char *buf;
 646     int end_of_file;
 647     DRCB *handler;
 648     void *client_data;
 649 };
 650
 651 struct _dwrite_q {
 652     off_t file_offset;
 653     char *buf;
 654     size_t len;
 655     size_t buf_offset;
 656     dwrite_q *next;
 657     FREE *free_func;
 658 };
 659
 660
 661 /* ETag support is rudimantal;
 662  * this struct is likely to change
 663  * Note: "str" points to memory in HttpHeaderEntry (for now)
 664  *       so ETags should be used as tmp variables only (for now) */
 665
 666 struct _ETag {
 667     const char *str;            /* quoted-string */
 668     int weak;                   /* true if it is a weak validator */
 669 };
 670
 671 struct _fde_disk {
 672     DWCB *wrt_handle;
 673     void *wrt_handle_data;
 674     dwrite_q *write_q;
 675     dwrite_q *write_q_tail;
 676     off_t offset;
 677 };
 678
 679 struct _fileMap {
 680     int max_n_files;
 681     int n_files_in_map;
 682     int toggle;
 683     int nwords;
 684     unsigned long *file_map;
 685 };
 686
 687 /*
 688  * Note: HttpBody is used only for messages with a small content that is
 689  * known a priory (e.g., error messages).
 690  */
 691
 692 class MemBuf;
 693
 694 struct _HttpBody {
 695     /* private */
 696     MemBuf *mb;
 697 };
 698
 699 #include "SquidString.h"
 700 /* http header extention field */
 701
 702 class HttpHdrExtField
 703 {
 704     String name;                /* field-name  from HTTP/1.1 (no column after name) */
 705     String value;               /* field-value from HTTP/1.1 */
 706 };
 707
 708 /* http cache control header field */
 709
 710 class HttpHdrCc
 711 {
 712
 713 public:
 714     int mask;
 715     int max_age;
 716     int s_maxage;
 717     int max_stale;
 718     String other;
 719 };
 720
 721 /* some fields can hold either time or etag specs (e.g. If-Range) */
 722
 723 struct _TimeOrTag {
 724     ETag tag;                   /* entity tag */
 725     time_t time;
 726     int valid;                  /* true if struct is usable */
 727 };
 728
 729 /* per field statistics */
 730
 731 class HttpHeaderFieldStat
 732 {
 733
 734 public:
 735     HttpHeaderFieldStat() : aliveCount(0), seenCount(0), parsCount(0), errCount(0), repCount(0) {}
 736
 737     int aliveCount;             /* created but not destroyed (count) */
 738     int seenCount;              /* #fields we've seen */
 739     int parsCount;              /* #parsing attempts */
 740     int errCount;               /* #pasring errors */
 741     int repCount;               /* #repetitons */
 742 };
 743
 744 /* compiled version of HttpHeaderFieldAttrs plus stats */
 745
 746 class HttpHeaderFieldInfo
 747 {
 748
 749 public:
 750     HttpHeaderFieldInfo() : id (HDR_ACCEPT), type (ftInvalid) {}
 751
 752     http_hdr_type id;
 753     String name;
 754     field_type type;
 755     HttpHeaderFieldStat stat;
 756 };
 757
 758 struct _http_state_flags {
 759     unsigned int proxying:1;
 760     unsigned int keepalive:1;
 761     unsigned int only_if_cached:1;
 762     unsigned int headers_parsed:1;
 763     unsigned int front_end_https:2;
 764     unsigned int originpeer:1;
 765     unsigned int keepalive_broken:1;
 766     unsigned int abuse_detected:1;
 767     unsigned int request_sent:1;
 768     unsigned int do_next_read:1;
 769     unsigned int consume_body_data:1;
 770     unsigned int chunked:1;
 771 };
 772
 773 struct _ipcache_addrs {
 774     IpAddress *in_addrs;
 775     unsigned char *bad_mask;
 776     unsigned char count;
 777     unsigned char cur;
 778     unsigned char badcount;
 779 };
 780
 781 struct _domain_ping {
 782     char *domain;
 783     int do_ping;                /* boolean */
 784     domain_ping *next;
 785 };
 786
 787 struct _domain_type {
 788     char *domain;
 789     peer_t type;
 790     domain_type *next;
 791 };
 792
 793 #if USE_CACHE_DIGESTS
 794
 795 /* statistics for cache digests and other hit "predictors" */
 796
 797 struct _cd_guess_stats {
 798     /* public, read-only */
 799     int true_hits;
 800     int false_hits;
 801     int true_misses;
 802     int false_misses;
 803     int close_hits;             /* tmp, remove it later */
 804 };
 805
 806 #endif
 807
 808 class PeerDigest;
 809
 810 struct peer {
 811     u_int index;
 812     char *name;
 813     char *host;
 814     peer_t type;
 815
 816     IpAddress in_addr;
 817
 818     struct {
 819         int pings_sent;
 820         int pings_acked;
 821         int fetches;
 822         int rtt;
 823         int ignored_replies;
 824         int n_keepalives_sent;
 825         int n_keepalives_recv;
 826         time_t probe_start;
 827         time_t last_query;
 828         time_t last_reply;
 829         time_t last_connect_failure;
 830         time_t last_connect_probe;
 831         int logged_state;       /* so we can print dead/revived msgs */
 832         int conn_open;          /* current opened connections */
 833     } stats;
 834
 835     struct {
 836         int version;
 837         int counts[ICP_END+1];
 838         u_short port;
 839     } icp;
 840
 841 #if USE_HTCP
 842     struct {
 843         double version;
 844         int counts[2];
 845         u_short port;
 846     } htcp;
 847 #endif
 848
 849     u_short http_port;
 850     domain_ping *peer_domain;
 851     domain_type *typelist;
 852     acl_access *access;
 853
 854     struct {
 855         unsigned int proxy_only:1;
 856         unsigned int no_query:1;
 857         unsigned int background_ping:1;
 858         unsigned int no_digest:1;
 859         unsigned int default_parent:1;
 860         unsigned int roundrobin:1;
 861         unsigned int weighted_roundrobin:1;
 862         unsigned int mcast_responder:1;
 863         unsigned int closest_only:1;
 864 #if USE_HTCP
 865         unsigned int htcp:1;
 866         unsigned int htcp_oldsquid:1;
 867         unsigned int htcp_no_clr:1;
 868         unsigned int htcp_no_purge_clr:1;
 869         unsigned int htcp_only_clr:1;
 870         unsigned int htcp_forward_clr:1;
 871 #endif
 872         unsigned int no_netdb_exchange:1;
 873 #if DELAY_POOLS
 874         unsigned int no_delay:1;
 875 #endif
 876         unsigned int allow_miss:1;
 877         unsigned int carp:1;
 878         unsigned int userhash:1;
 879         unsigned int sourcehash:1;
 880         unsigned int originserver:1;
 881     } options;
 882
 883     int weight;
 884     int basetime;
 885
 886     struct {
 887         double avg_n_members;
 888         int n_times_counted;
 889         int n_replies_expected;
 890         int ttl;
 891         int id;
 892
 893         struct {
 894             unsigned int count_event_pending:1;
 895             unsigned int counting:1;
 896         } flags;
 897     } mcast;
 898 #if USE_CACHE_DIGESTS
 899
 900     PeerDigest *digest;
 901     char *digest_url;
 902 #endif
 903
 904     int tcp_up;                 /* 0 if a connect() fails */
 905
 906     IpAddress addresses[10];
 907     int n_addresses;
 908     int rr_count;
 909     peer *next;
 910     int test_fd;
 911
 912     struct {
 913         unsigned int hash;
 914         double load_multiplier;
 915         double load_factor;     /* normalized weight value */
 916     } carp;
 917
 918     struct {
 919         unsigned int hash;
 920         double load_multiplier;
 921         double load_factor;     /* normalized weight value */
 922     } userhash;
 923
 924     struct {
 925         unsigned int hash;
 926         double load_multiplier;
 927         double load_factor;     /* normalized weight value */
 928     } sourcehash;
 929
 930     char *login;                /* Proxy authorization */
 931     time_t connect_timeout;
 932     int connect_fail_limit;
 933     int max_conn;
 934     char *domain;               /* Forced domain */
 935 #if USE_SSL
 936
 937     int use_ssl;
 938     char *sslcert;
 939     char *sslkey;
 940     int sslversion;
 941     char *ssloptions;
 942     char *sslcipher;
 943     char *sslcafile;
 944     char *sslcapath;
 945     char *sslcrlfile;
 946     char *sslflags;
 947     char *ssldomain;
 948     SSL_CTX *sslContext;
 949     SSL_SESSION *sslSession;
 950 #endif
 951
 952     int front_end_https;
 953     int connection_auth;
 954 };
 955
 956 struct _net_db_name {
 957     hash_link hash;             /* must be first */
 958     net_db_name *next;
 959     netdbEntry *net_db_entry;
 960 };
 961
 962 struct _net_db_peer {
 963     const char *peername;
 964     double hops;
 965     double rtt;
 966     time_t expires;
 967 };
 968
 969 struct _netdbEntry {
 970     hash_link hash;             /* must be first */
 971     char network[MAX_IPSTRLEN];
 972     int pings_sent;
 973     int pings_recv;
 974     double hops;
 975     double rtt;
 976     time_t next_ping_time;
 977     time_t last_use_time;
 978     int link_count;
 979     net_db_name *hosts;
 980     net_db_peer *peers;
 981     int n_peers_alloc;
 982     int n_peers;
 983 };
 984
 985
 986 struct _iostats {
 987
 988     struct {
 989         int reads;
 990         int reads_deferred;
 991         int read_hist[16];
 992         int writes;
 993         int write_hist[16];
 994     }
 995
 996     Http, Ftp, Gopher;
 997 };
 998
 999
1000 struct request_flags {
1001     request_flags(): range(0),nocache(0),ims(0),auth(0),cachable(0),hierarchical(0),loopdetect(0),proxy_keepalive(0),proxying(0),refresh(0),redirected(0),need_validation(0),accelerated(0),intercepted(0),spoof_client_ip(0),internal(0),internalclient(0),must_keepalive(0),destinationIPLookedUp_(0) {
1002 #if HTTP_VIOLATIONS
1003         nocache_hack = 0;
1004 #endif
1005 #if FOLLOW_X_FORWARDED_FOR
1006         done_follow_x_forwarded_for = 0;
1007 #endif /* FOLLOW_X_FORWARDED_FOR */
1008     }
1009
1010     unsigned int range:1;
1011     unsigned int nocache:1;
1012     unsigned int ims:1;
1013     unsigned int auth:1;
1014     unsigned int cachable:1;
1015     unsigned int hierarchical:1;
1016     unsigned int loopdetect:1;
1017     unsigned int proxy_keepalive:1;
1018 unsigned int proxying:
1019     1;  /* this should be killed, also in httpstateflags */
1020     unsigned int refresh:1;
1021     unsigned int redirected:1;
1022     unsigned int need_validation:1;
1023 #if HTTP_VIOLATIONS
1024     unsigned int nocache_hack:1;        /* for changing/ignoring no-cache requests */
1025 #endif
1026     unsigned int accelerated:1;
1027     unsigned int intercepted:1;  /**< transparently intercepted request */
1028     unsigned int spoof_client_ip:1;  /**< spoof client ip if possible */
1029     unsigned int internal:1;
1030     unsigned int internalclient:1;
1031     unsigned int must_keepalive:1;
1032     unsigned int connection_auth:1; /** Request wants connection oriented auth */
1033     unsigned int connection_auth_disabled:1; /** Connection oriented auth can not be supported */
1034     unsigned int connection_proxy_auth:1; /** Request wants connection oriented auth */
1035     unsigned int pinned:1;      /* Request sent on a pinned connection */
1036     unsigned int auth_sent:1;   /* Authentication forwarded */
1037
1038     // When adding new flags, please update cloneAdaptationImmune() as needed.
1039
1040     bool resetTCP() const;
1041     void setResetTCP();
1042     void clearResetTCP();
1043     void destinationIPLookupCompleted();
1044     bool destinationIPLookedUp() const;
1045
1046     // returns a partial copy of the flags that includes only those flags
1047     // that are safe for a related (e.g., ICAP-adapted) request to inherit
1048     request_flags cloneAdaptationImmune() const;
1049
1050 #if FOLLOW_X_FORWARDED_FOR
1051     unsigned int done_follow_x_forwarded_for;
1052 #endif /* FOLLOW_X_FORWARDED_FOR */
1053 private:
1054
1055     unsigned int reset_tcp:1;
1056     unsigned int destinationIPLookedUp_:1;
1057 };
1058
1059 struct _link_list {
1060     void *ptr;
1061
1062     struct _link_list *next;
1063 };
1064
1065 struct _cachemgr_passwd {
1066     char *passwd;
1067     wordlist *actions;
1068     cachemgr_passwd *next;
1069 };
1070
1071 struct _refresh_t {
1072     const char *pattern;
1073     regex_t compiled_pattern;
1074     time_t min;
1075     double pct;
1076     time_t max;
1077     refresh_t *next;
1078
1079     struct {
1080         unsigned int icase:1;
1081         unsigned int refresh_ims:1;
1082 #if HTTP_VIOLATIONS
1083         unsigned int override_expire:1;
1084         unsigned int override_lastmod:1;
1085         unsigned int reload_into_ims:1;
1086         unsigned int ignore_reload:1;
1087         unsigned int ignore_no_cache:1;
1088         unsigned int ignore_no_store:1;
1089         unsigned int ignore_must_revalidate:1;
1090         unsigned int ignore_private:1;
1091         unsigned int ignore_auth:1;
1092 #endif
1093     } flags;
1094 };
1095
1096 /*
1097  * "very generic" histogram;
1098  * see important comments on hbase_f restrictions in StatHist.c
1099  */
1100
1101 struct _StatHist {
1102     int *bins;
1103     int capacity;
1104     double min;
1105     double max;
1106     double scale;
1107     hbase_f *val_in;            /* e.g., log() for log-based histogram */
1108     hbase_f *val_out;           /* e.g., exp() for log based histogram */
1109 };
1110
1111 /*
1112  * if you add a field to StatCounters,
1113  * you MUST sync statCountersInitSpecial, statCountersClean, and statCountersCopy
1114  */
1115
1116 struct _StatCounters {
1117
1118     struct {
1119         int clients;
1120         int requests;
1121         int hits;
1122         int mem_hits;
1123         int disk_hits;
1124         int errors;
1125         kb_t kbytes_in;
1126         kb_t kbytes_out;
1127         kb_t hit_kbytes_out;
1128         StatHist miss_svc_time;
1129         StatHist nm_svc_time;
1130         StatHist nh_svc_time;
1131         StatHist hit_svc_time;
1132         StatHist all_svc_time;
1133     } client_http;
1134
1135     struct {
1136
1137         struct {
1138             int requests;
1139             int errors;
1140             kb_t kbytes_in;
1141             kb_t kbytes_out;
1142         } all , http, ftp, other;
1143     } server;
1144
1145     struct {
1146         int pkts_sent;
1147         int queries_sent;
1148         int replies_sent;
1149         int pkts_recv;
1150         int queries_recv;
1151         int replies_recv;
1152         int hits_sent;
1153         int hits_recv;
1154         int replies_queued;
1155         int replies_dropped;
1156         kb_t kbytes_sent;
1157         kb_t q_kbytes_sent;
1158         kb_t r_kbytes_sent;
1159         kb_t kbytes_recv;
1160         kb_t q_kbytes_recv;
1161         kb_t r_kbytes_recv;
1162         StatHist query_svc_time;
1163         StatHist reply_svc_time;
1164         int query_timeouts;
1165         int times_used;
1166     } icp;
1167
1168     struct {
1169         int pkts_sent;
1170         int pkts_recv;
1171     } htcp;
1172
1173     struct {
1174         int requests;
1175     } unlink;
1176
1177     struct {
1178         StatHist svc_time;
1179     } dns;
1180
1181     struct {
1182         int times_used;
1183         kb_t kbytes_sent;
1184         kb_t kbytes_recv;
1185         kb_t memory;
1186         int msgs_sent;
1187         int msgs_recv;
1188 #if USE_CACHE_DIGESTS
1189
1190         cd_guess_stats guess;
1191 #endif
1192
1193         StatHist on_xition_count;
1194     } cd;
1195
1196     struct {
1197         int times_used;
1198     } netdb;
1199     int page_faults;
1200     int select_loops;
1201     int select_fds;
1202     double select_time;
1203     double cputime;
1204
1205     struct timeval timestamp;
1206     StatHist comm_icp_incoming;
1207     StatHist comm_dns_incoming;
1208     StatHist comm_http_incoming;
1209     StatHist select_fds_hist;
1210
1211     struct {
1212         struct {
1213             int opens;
1214             int closes;
1215             int reads;
1216             int writes;
1217             int seeks;
1218             int unlinks;
1219         } disk;
1220
1221         struct {
1222             int accepts;
1223             int sockets;
1224             int connects;
1225             int binds;
1226             int closes;
1227             int reads;
1228             int writes;
1229             int recvfroms;
1230             int sendtos;
1231         } sock;
1232         int selects;
1233     } syscalls;
1234     int aborted_requests;
1235
1236     struct {
1237         int files_cleaned;
1238         int outs;
1239         int ins;
1240     } swap;
1241 };
1242
1243 /* per header statistics */
1244
1245 struct _HttpHeaderStat {
1246     const char *label;
1247     HttpHeaderMask *owner_mask;
1248
1249     StatHist hdrUCountDistr;
1250     StatHist fieldTypeDistr;
1251     StatHist ccTypeDistr;
1252     StatHist scTypeDistr;
1253
1254     int parsedCount;
1255     int ccParsedCount;
1256     int scParsedCount;
1257     int destroyedCount;
1258     int busyDestroyedCount;
1259 };
1260
1261
1262 struct _CacheDigest {
1263     /* public, read-only */
1264     char *mask;                 /* bit mask */
1265     int mask_size;              /* mask size in bytes */
1266     int capacity;               /* expected maximum for .count, not a hard limit */
1267     int bits_per_entry;         /* number of bits allocated for each entry from capacity */
1268     int count;                  /* number of digested entries */
1269     int del_count;              /* number of deletions performed so far */
1270 };
1271
1272
1273 struct _store_rebuild_data {
1274     int objcount;               /* # objects successfully reloaded */
1275     int expcount;               /* # objects expired */
1276     int scancount;              /* # entries scanned or read from state file */
1277     int clashcount;             /* # swapfile clashes avoided */
1278     int dupcount;               /* # duplicates purged */
1279     int cancelcount;            /* # SWAP_LOG_DEL objects purged */
1280     int invalid;                /* # bad lines */
1281     int badflags;               /* # bad e->flags */
1282     int bad_log_op;
1283     int zero_object_sz;
1284 };
1285
1286 struct _Logfile {
1287     int fd;
1288     char path[MAXPATHLEN];
1289     char *buf;
1290     size_t bufsz;
1291     size_t offset;
1292
1293     struct {
1294         unsigned int fatal;
1295         unsigned int syslog;
1296     } flags;
1297
1298     int syslog_priority;
1299 };
1300
1301 class logformat_token;
1302
1303 struct _logformat {
1304     char *name;
1305     logformat_token *format;
1306     logformat *next;
1307 };
1308
1309 struct _customlog {
1310     char *filename;
1311     ACLList *aclList;
1312     logformat *logFormat;
1313     Logfile *logfile;
1314     customlog *next;
1315     customlog_type type;
1316 };
1317
1318 #endif /* SQUID_STRUCTS_H */