src/structs.h

   1
   2 struct _acl_ip_data {
   3     struct in_addr addr1;       /* if addr2 non-zero then its a range */
   4     struct in_addr addr2;
   5     struct in_addr mask;
   6 #ifndef USE_SPLAY_TREE
   7     struct _acl_ip_data *next;
   8 #endif
   9 };
  10
  11 struct _acl_time_data {
  12     int weekbits;
  13     int start;
  14     int stop;
  15     struct _acl_time_data *next;
  16 };
  17
  18 struct _acl_name_list {
  19     char name[ACL_NAME_SZ];
  20     struct _acl_name_list *next;
  21 };
  22
  23 struct _acl_proxy_auth {
  24     char *filename;
  25     time_t last_time;
  26     time_t change_time;
  27     int check_interval;
  28     hash_table *hash;
  29 };
  30
  31 struct _acl_deny_info_list {
  32     char url[MAX_URL];
  33     struct _acl_name_list *acl_list;
  34     struct _acl_deny_info_list *next;
  35 };
  36
  37 struct _acl {
  38     char name[ACL_NAME_SZ];
  39     squid_acl type;
  40     void *data;
  41     char *cfgline;
  42     struct _acl *next;
  43 };
  44
  45 struct _acl_list {
  46     int op;
  47     struct _acl *acl;
  48     struct _acl_list *next;
  49 };
  50
  51 struct _acl_access {
  52     int allow;
  53     struct _acl_list *acl_list;
  54     char *cfgline;
  55     struct _acl_access *next;
  56 };
  57
  58 struct _aclCheck_t {
  59     const struct _acl_access *access_list;
  60     struct in_addr src_addr;
  61     struct in_addr dst_addr;
  62     request_t *request;
  63     char ident[ICP_IDENT_SZ];
  64     char browser[BROWSERNAMELEN];
  65     acl_lookup_state state[ACL_ENUM_MAX];
  66     PF *callback;
  67     void *callback_data;
  68 };
  69
  70 struct _aio_result_t {
  71     int aio_return;
  72     int aio_errno;
  73 };
  74
  75 struct _wordlist {
  76     char *key;
  77     struct _wordlist *next;
  78 };
  79
  80 struct _intlist {
  81     int i;
  82     struct _intlist *next;
  83 };
  84
  85 struct _ushortlist {
  86     u_short i;
  87     struct _ushortlist *next;
  88 };
  89
  90 struct _relist {
  91     char *pattern;
  92     regex_t regex;
  93     struct _relist *next;
  94 };
  95
  96 struct _SquidConfig {
  97     struct {
  98         size_t maxSize;
  99         int highWaterMark;
 100         int lowWaterMark;
 101     } Mem , Swap;
 102     struct {
 103         char *relayHost;
 104         u_short relayPort;
 105     } Wais;
 106     struct {
 107         size_t min;
 108         int pct;
 109         size_t max;
 110     } quickAbort;
 111     time_t referenceAge;
 112     time_t negativeTtl;
 113     time_t negativeDnsTtl;
 114     time_t positiveDnsTtl;
 115     time_t shutdownLifetime;
 116     time_t neighborTimeout;
 117     time_t stallDelay;
 118     struct {
 119         time_t read;
 120         time_t defer;
 121         time_t lifetime;
 122         time_t connect;
 123         time_t request;
 124         time_t pconn;
 125     } Timeout;
 126     size_t maxRequestSize;
 127     struct {
 128         ushortlist *http;
 129         u_short icp;
 130 #ifdef SQUID_SNMP
 131         u_short snmp;
 132 #endif
 133     } Port;
 134     struct {
 135         char *log;
 136         char *access;
 137         char *store;
 138         char *swap;
 139         char *useragent;
 140         int rotateNumber;
 141     } Log;
 142     char *adminEmail;
 143     char *effectiveUser;
 144     char *effectiveGroup;
 145     struct {
 146         char *dnsserver;
 147         char *redirect;
 148         char *pinger;
 149         char *unlinkd;
 150     } Program;
 151     int dnsChildren;
 152     int redirectChildren;
 153     struct {
 154         char *host;
 155         u_short port;
 156     } Accel;
 157     char *appendDomain;
 158     size_t appendDomainLen;
 159     char *debugOptions;
 160     char *pidFilename;
 161     char *mimeTablePathname;
 162     char *visibleHostname;
 163     char *errHtmlText;
 164     struct {
 165         char *host;
 166         char *file;
 167         time_t period;
 168         u_short port;
 169     } Announce;
 170     struct {
 171         struct in_addr tcp_incoming;
 172         struct in_addr tcp_outgoing;
 173         struct in_addr udp_incoming;
 174 #ifdef SQUID_SNMP
 175         struct in_addr snmp_incoming;
 176 #endif                          /* SQUID_SNMP */
 177         struct in_addr udp_outgoing;
 178         struct in_addr client_netmask;
 179     } Addrs;
 180     size_t tcpRcvBufsz;
 181     size_t udpMaxHitObjsz;
 182     wordlist *cache_stoplist;
 183     wordlist *hierarchy_stoplist;
 184     wordlist *mcast_group_list;
 185     wordlist *dns_testname_list;
 186     relist *cache_stop_relist;
 187     peer *peers;
 188     int npeers;
 189     struct {
 190         int size;
 191         int low;
 192         int high;
 193     } ipcache;
 194     int minDirectHops;
 195     cachemgr_passwd *passwd_list;
 196     struct {
 197         int objectsPerBucket;
 198         size_t avgObjectSize;
 199         size_t maxObjectSize;
 200     } Store;
 201     struct {
 202         int high;
 203         int low;
 204         time_t period;
 205     } Netdb;
 206     struct {
 207         int log_udp;
 208         int enable_purge;
 209         int res_defnames;
 210         int anonymizer;
 211         int client_db;
 212         int query_icmp;
 213         int icp_hit_stale;
 214         int buffered_logs;
 215         int source_ping;
 216         int common_log;
 217         int log_mime_hdrs;
 218         int ident_lookup;
 219         int single_parent_bypass;
 220         int log_fqdn;
 221         int announce;
 222         int accel_with_proxy;
 223     } onoff;
 224     struct _acl *aclList;
 225     struct {
 226         struct _acl_access *http;
 227         struct _acl_access *icp;
 228         struct _acl_access *miss;
 229         struct _acl_access *NeverDirect;
 230         struct _acl_access *AlwaysDirect;
 231     } accessList;
 232     struct _acl_deny_info_list *denyInfoList;
 233     struct {
 234         size_t list_width;
 235         int list_wrap;
 236         char *icon_prefix;
 237         char *icon_suffix;
 238         char *anon_user;
 239     } Ftp;
 240     refresh_t *Refresh;
 241     struct _cacheSwap {
 242         SwapDir *swapDirs;
 243         int n_allocated;
 244         int n_configured;
 245     } cacheSwap;
 246     char *fake_ua;
 247     struct {
 248         char *directory;
 249         char *content_type;
 250     } icons;
 251     char *errorDirectory;
 252 };
 253
 254 struct _SquidConfig2 {
 255     struct {
 256         char *prefix;
 257         int on;
 258     } Accel;
 259 };
 260
 261 struct _close_handler {
 262     PF *handler;
 263     void *data;
 264     close_handler *next;
 265 };
 266
 267 struct _dread_ctrl {
 268     int fd;
 269     off_t offset;
 270     int req_len;
 271     char *buf;
 272     int end_of_file;
 273     DRCB *handler;
 274     void *client_data;
 275 };
 276
 277 struct _dnsserver_t {
 278     int id;
 279     int flags;
 280     int inpipe;
 281     int outpipe;
 282     time_t answer;
 283     off_t offset;
 284     size_t size;
 285     char *ip_inbuf;
 286     struct timeval dispatch_time;
 287     void *data;
 288 };
 289
 290 struct _dnsStatData {
 291     int requests;
 292     int replies;
 293     int hist[DefaultDnsChildrenMax];
 294 };
 295
 296 struct _dwrite_q {
 297     char *buf;
 298     int len;
 299     off_t cur_offset;
 300     struct _dwrite_q *next;
 301     void (*free) (void *);
 302 };
 303
 304 struct _fde {
 305     unsigned int type;
 306     unsigned int open;
 307     u_short local_port;
 308     u_short remote_port;
 309     char ipaddr[16];            /* dotted decimal address of peer */
 310     char desc[FD_DESC_SZ];
 311     int flags;
 312     int bytes_read;
 313     int bytes_written;
 314     int uses;                   /* ie # req's over persistent conn */
 315     struct _fde_disk {
 316         DWCB *wrt_handle;
 317         void *wrt_handle_data;
 318         dwrite_q *write_q;
 319         dwrite_q *write_q_tail;
 320         off_t offset;
 321     } disk;
 322     PF *read_handler;
 323     void *read_data;
 324     PF *write_handler;
 325     void *write_data;
 326     PF *timeout_handler;
 327     time_t timeout;
 328     void *timeout_data;
 329     void *lifetime_data;
 330     close_handler *close_handler;       /* linked list */
 331     time_t stall_until;         /* don't select for read until this time */
 332     CommWriteStateData *rwstate;        /* State data for comm_write */
 333 };
 334
 335 struct _fileMap {
 336     int max_n_files;
 337     int n_files_in_map;
 338     int last_file_number_allocated;
 339     int toggle;
 340     int nwords;
 341     unsigned long *file_map;
 342 };
 343
 344 struct _fqdncache_entry {
 345     /* first two items must be equivalent to hash_link in hash.h */
 346     char *name;
 347     struct _fqdncache_entry *next;
 348     time_t lastref;
 349     time_t expires;
 350     unsigned char name_count;
 351     char *names[FQDN_MAX_NAMES + 1];
 352     struct _fqdn_pending *pending_head;
 353     char *error_message;
 354     unsigned char locks;
 355     fqdncache_status_t status:3;
 356 };
 357
 358 struct _hash_link {
 359     char *key;
 360     struct _hash_link *next;
 361     void *item;
 362 };
 363
 364 struct _hash_table {
 365     int valid;
 366     hash_link **buckets;
 367     HASHCMP *cmp;
 368     HASHHASH *hash;
 369     unsigned int size;
 370     unsigned int current_slot;
 371     hash_link *current_ptr;
 372 };
 373
 374 struct _http_reply {
 375     double version;
 376     int code;
 377     int content_length;
 378     int hdr_sz;
 379     int cache_control;
 380     int misc_headers;
 381     time_t date;
 382     time_t expires;
 383     time_t last_modified;
 384     char content_type[HTTP_REPLY_FIELD_SZ];
 385     char user_agent[HTTP_REPLY_FIELD_SZ << 2];
 386 };
 387
 388 struct _HttpStateData {
 389     StoreEntry *entry;
 390     request_t *request;
 391     char *reply_hdr;
 392     int reply_hdr_state;
 393     peer *neighbor;             /* neighbor request made to */
 394     int eof;                    /* reached end-of-object? */
 395     request_t *orig_request;
 396     int fd;                     /* needed as identifier for ipcache */
 397     int flags;
 398 };
 399
 400 struct _icpUdpData {
 401     struct sockaddr_in address;
 402     void *msg;
 403     size_t len;
 404     icpUdpData *next;
 405 #ifndef LESS_TIMING
 406     struct timeval start;
 407 #endif
 408     log_type logcode;
 409     protocol_t proto;
 410 };
 411
 412 struct _icp_ping_data {
 413     struct timeval start;
 414     struct timeval stop;
 415     int n_sent;
 416     int n_recv;
 417     int n_replies_expected;
 418     int timeout;
 419     int w_rtt;
 420     int p_rtt;
 421 };
 422
 423 struct _HierarchyLogEntry {
 424     hier_code code;
 425     char host[SQUIDHOSTNAMELEN];
 426     struct _icp_ping_data icp;
 427 };
 428
 429 struct _AccessLogEntry {
 430     const char *url;
 431     struct {
 432         method_t method;
 433         int code;
 434         const char *content_type;
 435     } http;
 436     struct {
 437         icp_opcode opcode;
 438     } icp;
 439     struct {
 440         struct in_addr caddr;
 441         size_t size;
 442         log_type code;
 443         int msec;
 444         const char *ident;
 445     } cache;
 446     struct _HierarchyLogEntry hier;
 447     struct {
 448         char *request;
 449         char *reply;
 450     } headers;
 451     struct {
 452         const char *method_str;
 453     } private;
 454 };
 455
 456 struct _clientHttpRequest {
 457     ConnStateData *conn;
 458     request_t *request;         /* Parsed URL ... */
 459     char *url;
 460     char *log_url;
 461     struct {
 462         char *buf;
 463         off_t offset;
 464         size_t size;
 465     } out;
 466     size_t req_sz;
 467     StoreEntry *entry;
 468     StoreEntry *old_entry;
 469     log_type log_type;
 470     http_status http_code;
 471     int accel;
 472     struct timeval start;
 473     float http_ver;
 474     int redirect_state;
 475     aclCheck_t *acl_checklist;  /* need ptr back so we can unreg if needed */
 476     clientHttpRequest *next;
 477     struct _AccessLogEntry al;
 478 };
 479
 480 struct _ConnStateData {
 481     int fd;
 482     struct {
 483         char *buf;
 484         off_t offset;
 485         size_t size;
 486     } in;
 487     clientHttpRequest *chr;
 488     struct sockaddr_in peer;
 489     struct sockaddr_in me;
 490     struct in_addr log_addr;
 491     struct {
 492         int fd;
 493         char ident[ICP_IDENT_SZ];
 494         IDCB *callback;
 495         int state;
 496     } ident;
 497     CommWriteStateData *commWriteState;
 498     int nrequests;
 499     int persistent;
 500 };
 501
 502 struct _ipcache_addrs {
 503     unsigned char count;
 504     unsigned char cur;
 505     struct in_addr *in_addrs;
 506 };
 507
 508 struct _ipcache_entry {
 509     /* first two items must be equivalent to hash_link in hash.h */
 510     char *name;
 511     struct _ipcache_entry *next;
 512     time_t lastref;
 513     time_t expires;
 514     ipcache_addrs addrs;
 515     struct _ip_pending *pending_head;
 516     char *error_message;
 517     unsigned char locks;
 518     ipcache_status_t status:3;
 519 };
 520
 521 struct _ext_table_entry {
 522     char *name;
 523     char *mime_type;
 524     char *mime_encoding;
 525     char *icon;
 526 };
 527
 528 struct _domain_ping {
 529     char *domain;
 530     int do_ping;                /* boolean */
 531     struct _domain_ping *next;
 532 };
 533
 534 struct _domain_type {
 535     char *domain;
 536     peer_t type;
 537     struct _domain_type *next;
 538 };
 539
 540 struct _peer {
 541     char *host;
 542     peer_t type;
 543     struct sockaddr_in in_addr;
 544     struct {
 545         int pings_sent;
 546         int pings_acked;
 547         int ack_deficit;
 548         int fetches;
 549         int rtt;
 550         int counts[ICP_OP_END];
 551         int ignored_replies;
 552     } stats;
 553     u_short icp_port;
 554     u_short http_port;
 555     int icp_version;
 556     struct _domain_ping *pinglist;
 557     struct _domain_type *typelist;
 558     struct _acl_list *acls;
 559     int options;
 560     int weight;
 561     struct {
 562         double avg_n_members;
 563         int n_times_counted;
 564         int n_replies_expected;
 565         int ttl;
 566         int reqnum;
 567         int flags;
 568     } mcast;
 569     int tcp_up;                 /* 0 if a connect() fails */
 570     time_t last_fail_time;
 571     struct in_addr addresses[10];
 572     int n_addresses;
 573     int rr_count;
 574     struct _peer *next;
 575     int ip_lookup_pending;
 576     int ck_conn_event_pend;
 577     int test_fd;
 578 };
 579
 580 struct _net_db_name {
 581     char *name;
 582     struct _net_db_name *next;
 583 };
 584
 585 struct _net_db_peer {
 586     char *peername;
 587     double hops;
 588     double rtt;
 589     time_t expires;
 590 };
 591
 592 struct _netdbEntry {
 593     char *key;
 594     struct _net_db *next;
 595     char network[16];
 596     int pings_sent;
 597     int pings_recv;
 598     double hops;
 599     double rtt;
 600     time_t next_ping_time;
 601     time_t last_use_time;
 602     int link_count;
 603     net_db_name *hosts;
 604     net_db_peer *peers;
 605     int n_peers_alloc;
 606     int n_peers;
 607 };
 608
 609 struct _ps_state {
 610     request_t *request;
 611     StoreEntry *entry;
 612     int always_direct;
 613     int never_direct;
 614     PSC *callback;
 615     PSC *fail_callback;
 616     void *callback_data;
 617     peer *first_parent_miss;
 618     peer *closest_parent_miss;
 619     icp_ping_data icp;
 620     aclCheck_t *acl_checklist;
 621 };
 622
 623 struct _pingerEchoData {
 624     struct in_addr to;
 625     unsigned char opcode;
 626     int psize;
 627     char payload[8192];
 628 };
 629
 630 struct _pingerReplyData {
 631     struct in_addr from;
 632     unsigned char opcode;
 633     int rtt;
 634     int hops;
 635     int psize;
 636     char payload[8192];
 637 };
 638
 639 struct _icp_common_t {
 640     unsigned char opcode;       /* opcode */
 641     unsigned char version;      /* version number */
 642     unsigned short length;      /* total length (bytes) */
 643     u_num32 reqnum;             /* req number (req'd for UDP) */
 644     u_num32 flags;
 645     u_num32 pad;
 646     /* u_num32 auth[ICP_AUTH_SIZE];     authenticator (old) */
 647     u_num32 shostid;            /* sender host id */
 648 };
 649
 650 struct _Stack {
 651     void **base;
 652     void **top;
 653     int stack_size;
 654 };
 655
 656 struct _proto_stat {
 657     char protoname[25];
 658     int object_count;
 659     struct _usage {
 660         int max;
 661         int avg;
 662         int min;
 663         int now;
 664     } kb;
 665     unsigned int hit;
 666     unsigned int miss;
 667     float hitratio;
 668     unsigned int transferrate;
 669     unsigned int refcount;
 670     unsigned int transferbyte;
 671 };
 672
 673 struct _Meta_data {
 674     int hot_vm;
 675     int store_entries;
 676     int mem_obj_count;
 677     int mem_data_count;
 678     int ipcache_count;
 679     int fqdncache_count;
 680     int netdb_addrs;
 681     int netdb_hosts;
 682     int netdb_peers;
 683     int url_strings;
 684     int misc;
 685     int client_info;
 686 };
 687
 688 struct _cacheinfo {
 689     protocol_t(*proto_id) (const char *url);
 690     void (*proto_newobject) (struct _cacheinfo * c, protocol_t proto_id, int len, int flag);
 691     void (*proto_purgeobject) (struct _cacheinfo * c, protocol_t proto_id, int len);
 692     void (*proto_touchobject) (struct _cacheinfo * c, protocol_t proto_id, int len);
 693     void (*proto_count) (struct _cacheinfo * obj, protocol_t proto_id,
 694         log_type);
 695     proto_stat proto_stat_data[PROTO_MAX + 1];
 696 };
 697
 698 struct _iostats {
 699     struct {
 700         int reads;
 701         int reads_deferred;
 702         int read_hist[16];
 703         int writes;
 704         int write_hist[16];
 705     } Http, Ftp, Gopher, Wais;
 706 };
 707
 708 struct _mem_node {
 709     char *data;
 710     int len;
 711     mem_node *next;
 712 };
 713
 714 struct _mem_hdr {
 715     mem_node *head;
 716     mem_node *tail;
 717     int origin_offset;
 718 };
 719
 720 /* Memory allocator routines for fixed size blocks */
 721 struct _stmem_stats {
 722     int max_pages;
 723     int total_pages_allocated;
 724     size_t page_size;
 725     int n_pages_in_use;
 726     Stack free_page_stack;
 727 };
 728
 729 /* keep track each client receiving data from that particular StoreEntry */
 730 struct _store_client {
 731     off_t copy_offset;
 732     off_t seen_offset;
 733     size_t copy_size;
 734     char *copy_buf;
 735     STCB *callback;
 736     void *callback_data;
 737     MemObject *mem;             /* ptr to the parent structure, argh! */
 738     short swapin_fd;
 739 };
 740
 741
 742 /* This structure can be freed while object is purged out from memory */
 743 struct _MemObject {
 744     mem_hdr *data;
 745     char *e_swap_buf;
 746     size_t e_swap_buf_len;
 747     unsigned char pending_list_size;
 748     off_t inmem_hi;
 749     off_t inmem_lo;
 750     struct _store_client *clients;
 751     int nclients;
 752     struct {
 753         off_t queue_offset;
 754         off_t done_offset;
 755         int fd;
 756     } swapout;
 757     struct _http_reply *reply;
 758     request_t *request;
 759     struct timeval start_ping;
 760     IRCB *icp_reply_callback;
 761     void *ircb_data;
 762     int fd;                     /* FD of client creating this entry */
 763     struct {
 764         STABH *callback;
 765         void *data;
 766     } abort;
 767     char *log_url;
 768 };
 769
 770 /* A cut down structure for store manager */
 771 struct _StoreEntry {
 772     /* first two items must be same as hash_link in hash.h */
 773     char *key;
 774     struct sentry *next;
 775     char *url;
 776     MemObject *mem_obj;
 777     u_num32 flag;
 778     u_num32 refcount;
 779     time_t timestamp;
 780     time_t lastref;
 781     time_t expires;
 782     time_t lastmod;
 783     int object_len;
 784     int swap_file_number;
 785     mem_status_t mem_status:3;
 786     ping_status_t ping_status:3;
 787     store_status_t store_status:3;
 788     swap_status_t swap_status:3;
 789     method_t method:4;
 790     unsigned char lock_count;   /* Assume < 256! */
 791 };
 792
 793 struct _SwapDir {
 794     char *path;
 795     int l1;
 796     int l2;
 797     int cur_size;
 798     int max_size;
 799     int read_only;
 800     int suggest;
 801     fileMap *map;
 802     int swaplog_fd;
 803 };
 804
 805 struct _request_t {
 806     method_t method;
 807     protocol_t protocol;
 808     char login[MAX_LOGIN_SZ];
 809     char host[SQUIDHOSTNAMELEN + 1];
 810     u_short port;
 811     char urlpath[MAX_URL];
 812     int link_count;             /* free when zero */
 813     int flags;
 814     time_t max_age;
 815     float http_ver;
 816     time_t ims;
 817     int imslen;
 818     int max_forwards;
 819     struct in_addr client_addr;
 820     char *headers;
 821     size_t headers_sz;
 822     char *body;
 823     size_t body_sz;
 824     struct _HierarchyLogEntry hier;
 825 };
 826
 827 struct _cachemgr_passwd {
 828     char *passwd;
 829     long actions;
 830     struct _cachemgr_passwd *next;
 831 };
 832
 833 struct _refresh_t {
 834     char *pattern;
 835     regex_t compiled_pattern;
 836     time_t min;
 837     int pct;
 838     time_t max;
 839     struct _refresh_t *next;
 840 };
 841
 842 struct _CommWriteStateData {
 843     char *buf;
 844     size_t size;
 845     off_t offset;
 846     CWCB *handler;
 847     void *handler_data;
 848     FREE *free;
 849 };
 850
 851 struct _ErrorState {
 852     err_type type;
 853     http_status http_status;
 854     request_t *request;
 855     char *url;
 856     int errno;
 857     char *host;
 858     u_short port;
 859     char *dnsserver_msg;
 860     time_t ttl;
 861     struct in_addr src_addr;
 862     char *redirect_url;
 863     ERCB *callback;
 864     void *callback_data;
 865 };