]> git.ipfire.org Git - thirdparty/squid.git/blame - src/protos.h
projects / thirdparty / squid.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
url checksum debugging; sometimes URL memory gets trashed
[thirdparty/squid.git] / src / protos.h
CommitLineData
a8258824 1
9cef6668 2/*
bc87dc25 3 * $Id: protos.h,v 1.346 1999/09/29 00:22:16 wessels Exp $
9cef6668 4 *
5 *
6 * SQUID Internet Object Cache http://squid.nlanr.net/Squid/
7 * ----------------------------------------------------------
8 *
9 * Squid is the result of efforts by numerous individuals from the
10 * Internet community. Development is led by Duane Wessels of the
11 * National Laboratory for Applied Network Research and funded by the
12 * National Science Foundation. Squid is Copyrighted (C) 1998 by
13 * Duane Wessels and the University of California San Diego. Please
14 * see the COPYRIGHT file for full details. Squid incorporates
15 * software developed and/or copyrighted by other sources. Please see
16 * the CREDITS file for full details.
17 *
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation; either version 2 of the License, or
21 * (at your option) any later version.
22 *
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU General Public License for more details.
27 *
28 * You should have received a copy of the GNU General Public License
29 * along with this program; if not, write to the Free Software
30 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
31 *
32 */
a8258824 33
f5b8bbc4 34extern void accessLogLog(AccessLogEntry *);
35extern void accessLogRotate(void);
36extern void accessLogClose(void);
7a2f978b 37extern void accessLogInit(void);
c6e7cab0 38extern const char *accessLogTime(time_t);
0bdf2621 39extern void hierarchyNote(HierarchyLogEntry *, hier_code, const char *);
d21f1c54 40#if FORW_VIA_DB
41extern void fvdbCountVia(const char *key);
42extern void fvdbCountForw(const char *key);
43#endif
a8258824 44
f5b8bbc4 45extern aclCheck_t *aclChecklistCreate(const struct _acl_access *,
ea3a2a69 46 request_t *,
47 struct in_addr src,
ae2c08a2 48 struct in_addr me,
99edd1c3 49 const char *user_agent,
50 const char *ident);
f5b8bbc4 51extern void aclNBCheck(aclCheck_t *, PF *, void *);
ea3a2a69 52extern int aclCheckFast(const struct _acl_access *A, aclCheck_t *);
f5b8bbc4 53extern void aclChecklistFree(aclCheck_t *);
669fefd4 54extern int aclMatchAclList(const acl_list * list, aclCheck_t * checklist);
ea3a2a69 55extern void aclDestroyAccessList(struct _acl_access **list);
f5b8bbc4 56extern void aclDestroyAcls(acl **);
57extern void aclParseAccessLine(struct _acl_access **);
58extern void aclParseAclLine(acl **);
1cfdbcf0 59extern int aclIsProxyAuth(const char *name);
02922e76 60extern int aclGetDenyInfoPage(acl_deny_info_list ** head, const char *name);
f5b8bbc4 61extern void aclParseDenyInfoLine(struct _acl_deny_info_list **);
62extern void aclDestroyDenyInfoList(struct _acl_deny_info_list **);
ea3a2a69 63extern void aclDestroyRegexList(struct _relist *data);
f5b8bbc4 64extern int aclMatchRegex(relist * data, const char *word);
65extern void aclParseRegexList(void *curlist);
56b63fa1 66extern const char *aclTypeToStr(squid_acl);
67extern wordlist *aclDumpGeneric(const acl *);
f5b8bbc4 68
6cf028ab 69#if USE_ASYNC_IO
f5b8bbc4 70extern int aio_cancel(aio_result_t *);
71extern int aio_open(const char *, int, mode_t, aio_result_t *);
72extern int aio_read(int, char *, int, off_t, int, aio_result_t *);
73extern int aio_write(int, char *, int, off_t, int, aio_result_t *);
74extern int aio_close(int, aio_result_t *);
75extern int aio_stat(const char *, struct stat *, aio_result_t *);
76extern int aio_unlink(const char *, aio_result_t *);
77extern int aio_opendir(const char *, aio_result_t *);
78extern aio_result_t *aio_poll_done(void);
ddb43c58 79extern int aio_operations_pending(void);
a4b7ff34 80extern int aio_overloaded(void);
81extern int aio_sync(void);
1f38f50a 82extern int aio_get_queue_len(void);
f5b8bbc4 83
1f38f50a 84extern void aioInit(void);
53fa92a5 85extern void aioCancel(int);
86extern void aioOpen(const char *, int, mode_t, AIOCB *, void *);
f5b8bbc4 87extern void aioClose(int);
53fa92a5 88extern void aioWrite(int, int offset, char *, int size, AIOCB *, void *, FREE *);
20f92343 89extern void aioRead(int, int offset, char *, int size, AIOCB *, void *);
53fa92a5 90extern void aioStat(char *, struct stat *, AIOCB *, void *);
f5b8bbc4 91extern void aioUnlink(const char *, AIOCB *, void *);
92extern void aioCheckCallbacks(void);
ddb43c58 93extern void aioSync(void);
1f38f50a 94extern int aioQueueSize(void);
6cf028ab 95#endif
f5b8bbc4 96
0e4e0e7d 97/*
98 * cache_cf.c
99 */
f5b8bbc4 100extern int parseConfigFile(const char *file_name);
101extern void intlistDestroy(intlist **);
5db53b8f 102extern int intlistFind(intlist * list, int i);
c68e9c6b 103extern wordlist *wordlistAdd(wordlist **, const char *);
6b8e7481 104extern wordlist *wordlistDup(const wordlist *);
f5b8bbc4 105extern void wordlistDestroy(wordlist **);
106extern void configFreeMemory(void);
ba2d3770 107extern void wordlistCat(const wordlist *, MemBuf * mb);
0e4e0e7d 108extern void allocate_new_swapdir(cacheSwap *);
109extern void self_destruct(void);
110extern int GetInteger(void);
111
f5b8bbc4 112
113extern void cbdataInit(void);
4e3f712d 114#if CBDATA_DEBUG
db1cd23c 115extern void cbdataAddDbg(const void *p, CBDUNL *, int, const char *, int);
b7e6c377 116extern void cbdataLockDbg(const void *p, const char *, int);
117extern void cbdataUnlockDbg(const void *p, const char *, int);
4e3f712d 118#else
db1cd23c 119extern void cbdataAdd(const void *p, CBDUNL *, int);
2480550a 120extern void cbdataLock(const void *p);
121extern void cbdataUnlock(const void *p);
b7e6c377 122#endif
123extern void cbdataFree(void *p);
2480550a 124extern int cbdataValid(const void *p);
db1cd23c 125extern CBDUNL cbdataXfree;
f5b8bbc4 126
127extern void clientdbInit(void);
8b150ba8 128extern void clientdbUpdate(struct in_addr, log_type, protocol_t, size_t);
e711a2ff 129extern int clientdbCutoffDenied(struct in_addr);
f5b8bbc4 130extern void clientdbDump(StoreEntry *);
5ba476ec 131extern void clientdbFreeMemory(void);
a8258824 132
f5b8bbc4 133extern void clientAccessCheck(void *);
134extern void clientAccessCheckDone(int, void *);
f5b8bbc4 135extern int modifiedSince(StoreEntry *, request_t *);
136extern char *clientConstructTraceEcho(clientHttpRequest *);
137extern void clientPurgeRequest(clientHttpRequest *);
e33ba616 138extern int checkNegativeHit(StoreEntry *);
c9654574 139extern void clientHttpConnectionsOpen(void);
c0fbae16 140extern void clientHttpConnectionsClose(void);
92695e5e 141extern StoreEntry *clientCreateStoreEntry(clientHttpRequest *, method_t, request_flags);
cf50a0af 142extern int isTcpHit(log_type);
a8258824 143
f5b8bbc4 144extern int commSetNonBlocking(int fd);
145extern void commSetCloseOnExec(int fd);
146extern int comm_accept(int fd, struct sockaddr_in *, struct sockaddr_in *);
147extern void comm_close(int fd);
5492ad1d 148#if LINGERING_CLOSE
149extern void comm_lingering_close(int fd);
150#endif
f5b8bbc4 151extern void commConnectStart(int fd, const char *, u_short, CNCB *, void *);
152extern int comm_connect_addr(int sock, const struct sockaddr_in *);
d86b3703 153extern void comm_init(void);
f5b8bbc4 154extern int comm_listen(int sock);
155extern int comm_open(int, int, struct in_addr, u_short port, int, const char *note);
156extern u_short comm_local_port(int fd);
6a988308 157
f5b8bbc4 158extern void commSetSelect(int, unsigned int, PF *, void *, time_t);
159extern void comm_add_close_handler(int fd, PF *, void *);
160extern void comm_remove_close_handler(int fd, PF *, void *);
17b6e784 161extern int comm_udp_sendto(int, const struct sockaddr_in *, int, const void *, int);
f5b8bbc4 162extern void comm_write(int fd,
ea3a2a69 163 char *buf,
164 int size,
165 CWCB * handler,
166 void *handler_data,
167 FREE *);
2ac76861 168extern void comm_write_mbuf(int fd, MemBuf mb, CWCB * handler, void *handler_data);
f5b8bbc4 169extern void commCallCloseHandlers(int fd);
170extern int commSetTimeout(int fd, int, PF *, void *);
70a9dab4 171extern void commSetDefer(int fd, DEFER * func, void *);
b224ea98 172extern int ignoreErrno(int);
d723bf6b 173extern void commCloseAllSockets(void);
a8258824 174
d072e3a1 175
6a988308 176/*
177 * comm_select.c
178 */
179extern void comm_select_init(void);
180#if HAVE_POLL
181extern int comm_poll(int);
182#else
183extern int comm_select(int);
184#endif
d072e3a1 185extern void commUpdateReadBits(int, PF *);
186extern void commUpdateWriteBits(int, PF *);
6a988308 187
2ac76861 188extern void packerToStoreInit(Packer * p, StoreEntry * e);
189extern void packerToMemInit(Packer * p, MemBuf * mb);
190extern void packerClean(Packer * p);
191extern void packerAppend(Packer * p, const char *buf, int size);
6de2df60 192#if STDC_HEADERS
2ac76861 193extern void packerPrintf(Packer * p, const char *fmt,...);
adba4a64 194#else
195extern void packerPrintf();
196#endif
197
198
123abbe1 199/* see debug.c for info on context-based debugging */
200extern Ctx ctx_enter(const char *descr);
201extern void ctx_exit(Ctx ctx);
202
f5b8bbc4 203extern void _db_init(const char *logfile, const char *options);
204extern void _db_rotate_log(void);
a8258824 205
6de2df60 206#if STDC_HEADERS
f5b8bbc4 207extern void _db_print(const char *,...);
a8258824 208#else
f5b8bbc4 209extern void _db_print();
a8258824 210#endif
bb71ea1f 211extern void xassert(const char *, const char *, int);
a8258824 212
95e36d02 213/* packs, then prints an object using debug() */
214extern void debugObj(int section, int level, const char *label, void *obj, ObjPackMethod pm);
215
a8258824 216
1a94f598 217extern int file_open(const char *path, int mode);
f5b8bbc4 218extern void file_close(int fd);
5830cdb3 219extern void file_write(int, off_t, void *, int len, DWCB *, void *, FREE *);
137ee196 220extern void file_write_mbuf(int fd, off_t, MemBuf mb, DWCB * handler, void *handler_data);
2391a162 221extern void file_read(int, char *, int, off_t, DRCB *, void *);
04cece06 222extern void disk_init(void);
f5b8bbc4 223
74addf6c 224extern void dnsShutdown(void);
225extern void dnsInit(void);
226extern void dnsSubmit(const char *lookup, HLPCB * callback, void *data);
f5b8bbc4 227
7b724b86 228/* dns_internal.c */
229extern void idnsInit(void);
230extern void idnsShutdown(void);
231extern void idnsALookup(const char *, IDNSCB *, void *);
8db71107 232extern void idnsPTRLookup(const struct in_addr, IDNSCB *, void *);
7b724b86 233
52040193 234extern void eventAdd(const char *name, EVH * func, void *arg, double when, int);
235extern void eventAddIsh(const char *name, EVH * func, void *arg, double delta_ish, int);
f5b8bbc4 236extern void eventRun(void);
237extern time_t eventNextTime(void);
238extern void eventDelete(EVH * func, void *arg);
4ba55996 239extern void eventInit(void);
f1fc2a8d 240extern void eventFreeMemory(void);
46ca5fc6 241extern int eventFind(EVH *, void *);
a8258824 242
f5b8bbc4 243extern void fd_close(int fd);
244extern void fd_open(int fd, unsigned int type, const char *);
245extern void fd_note(int fd, const char *);
246extern void fd_bytes(int fd, int len, unsigned int type);
247extern void fdFreeMemory(void);
248extern void fdDumpOpen(void);
22f5d1ca 249extern int fdNFree(void);
4b23e114 250extern void fdAdjustReserved(void);
a8258824 251
f5b8bbc4 252extern fileMap *file_map_create(int);
253extern int file_map_allocate(fileMap *, int);
254extern int file_map_bit_set(fileMap *, int);
255extern int file_map_bit_test(fileMap *, int);
256extern void file_map_bit_reset(fileMap *, int);
257extern void filemapFreeMemory(fileMap *);
4b4cd312 258extern void filemapCopy(fileMap * old, fileMap * new);
a8258824 259
260
f5b8bbc4 261extern void fqdncache_nbgethostbyaddr(struct in_addr, FQDNH *, void *);
262extern int fqdncacheUnregister(struct in_addr, void *);
263extern const char *fqdncache_gethostbyaddr(struct in_addr, int flags);
264extern void fqdncache_init(void);
265extern void fqdnStats(StoreEntry *);
266extern void fqdncacheReleaseInvalid(const char *);
267extern const char *fqdnFromAddr(struct in_addr);
268extern int fqdncacheQueueDrain(void);
269extern void fqdncacheFreeMemory(void);
270extern void fqdncache_restart(void);
59c4d35b 271extern EVH fqdncache_purgelru;
a8258824 272
db1cd23c 273extern void ftpStart(FwdState *);
8f872bb6 274extern char *ftpUrlWith2f(const request_t *);
a8258824 275
db1cd23c 276extern void gopherStart(FwdState *);
f5b8bbc4 277extern int gopherCachable(const char *);
a8258824 278
279
db1cd23c 280extern void whoisStart(FwdState *);
4bd74768 281
f5b8bbc4 282extern int httpCachable(method_t);
db1cd23c 283extern void httpStart(FwdState *);
cb69b4c7 284extern void httpParseReplyHeaders(const char *, http_reply *);
f5b8bbc4 285extern void httpProcessReplyHeader(HttpStateData *, const char *, int);
99edd1c3 286extern size_t httpBuildRequestPrefix(request_t * request,
ea3a2a69 287 request_t * orig_request,
288 StoreEntry * entry,
52040193 289 MemBuf * mb,
ea3a2a69 290 int cfd,
b515fc11 291 http_state_flags);
99edd1c3 292extern void httpAnonInitModule();
293extern int httpAnonHdrAllowed(http_hdr_type hdr_id);
294extern int httpAnonHdrDenied(http_hdr_type hdr_id);
b515fc11 295extern void httpBuildRequestHeader(request_t *, request_t *, StoreEntry *, HttpHeader *, int, http_state_flags);
9b312a19 296
a9771e51 297/* ETag */
0cdcddb9 298extern int etagParseInit(ETag * etag, const char *str);
299extern int etagIsEqual(const ETag * tag1, const ETag * tag2);
a9771e51 300
adba4a64 301/* Http Status Line */
302/* init/clean */
2ac76861 303extern void httpStatusLineInit(HttpStatusLine * sline);
304extern void httpStatusLineClean(HttpStatusLine * sline);
395b813e 305/* set/get values */
2ac76861 306extern void httpStatusLineSet(HttpStatusLine * sline, double version,
adba4a64 307 http_status status, const char *reason);
395b813e 308extern const char *httpStatusLineReason(const HttpStatusLine * sline);
adba4a64 309/* parse/pack */
310/* parse a 0-terminating buffer and fill internal structires; returns true on success */
2ac76861 311extern int httpStatusLineParse(HttpStatusLine * sline, const char *start,
adba4a64 312 const char *end);
313/* pack fields using Packer */
2ac76861 314extern void httpStatusLinePackInto(const HttpStatusLine * sline, Packer * p);
910169e5 315extern const char *httpStatusString(http_status status);
adba4a64 316
317/* Http Body */
318/* init/clean */
2ac76861 319extern void httpBodyInit(HttpBody * body);
320extern void httpBodyClean(HttpBody * body);
adba4a64 321/* get body ptr (always use this) */
2ac76861 322extern const char *httpBodyPtr(const HttpBody * body);
1d21d91d 323/* set body, does not clone mb so you should not reuse it */
0cdcddb9 324extern void httpBodySet(HttpBody * body, MemBuf * mb);
adba4a64 325
326/* pack */
2ac76861 327extern void httpBodyPackInto(const HttpBody * body, Packer * p);
adba4a64 328
7faf2bdb 329/* Http Cache Control Header Field */
330extern void httpHdrCcInitModule();
de336bbe 331extern void httpHdrCcCleanModule();
7faf2bdb 332extern HttpHdrCc *httpHdrCcCreate();
52040193 333extern HttpHdrCc *httpHdrCcParseCreate(const String * str);
02922e76 334extern void httpHdrCcDestroy(HttpHdrCc * cc);
335extern HttpHdrCc *httpHdrCcDup(const HttpHdrCc * cc);
d76fcfa7 336extern void httpHdrCcPackInto(const HttpHdrCc * cc, Packer * p);
02922e76 337extern void httpHdrCcJoinWith(HttpHdrCc * cc, const HttpHdrCc * new_cc);
99edd1c3 338extern void httpHdrCcSetMaxAge(HttpHdrCc * cc, int max_age);
02922e76 339extern void httpHdrCcUpdateStats(const HttpHdrCc * cc, StatHist * hist);
7faf2bdb 340extern void httpHdrCcStatDumper(StoreEntry * sentry, int idx, double val, double size, int count);
341
b5107edb 342/* Http Range Header Field */
52040193 343extern HttpHdrRange *httpHdrRangeParseCreate(const String * range_spec);
b5107edb 344/* returns true if ranges are valid; inits HttpHdrRange */
52040193 345extern int httpHdrRangeParseInit(HttpHdrRange * range, const String * range_spec);
a369131d 346extern void httpHdrRangeDestroy(HttpHdrRange * range);
02922e76 347extern HttpHdrRange *httpHdrRangeDup(const HttpHdrRange * range);
d76fcfa7 348extern void httpHdrRangePackInto(const HttpHdrRange * range, Packer * p);
02922e76 349/* iterate through specs */
889b534a 350extern HttpHdrRangeSpec *httpHdrRangeGetSpec(const HttpHdrRange * range, HttpHdrRangePos * pos);
d192d11f 351/* adjust specs after the length is known */
352extern int httpHdrRangeCanonize(HttpHdrRange * range, size_t clen);
353/* other */
354extern String httpHdrRangeBoundaryStr(clientHttpRequest * http);
355extern int httpHdrRangeIsComplex(const HttpHdrRange * range);
cf872fef 356extern int httpHdrRangeWillBeComplex(const HttpHdrRange * range);
c68e9c6b 357extern size_t httpHdrRangeFirstOffset(const HttpHdrRange * range);
cfbf5373 358extern size_t httpHdrRangeLowestOffset(const HttpHdrRange * range, size_t size);
c68e9c6b 359
b5107edb 360
d76fcfa7 361/* Http Content Range Header Field */
d192d11f 362extern HttpHdrContRange *httpHdrContRangeCreate();
d76fcfa7 363extern HttpHdrContRange *httpHdrContRangeParseCreate(const char *crange_spec);
364/* returns true if range is valid; inits HttpHdrContRange */
a369131d 365extern int httpHdrContRangeParseInit(HttpHdrContRange * crange, const char *crange_spec);
366extern void httpHdrContRangeDestroy(HttpHdrContRange * crange);
d76fcfa7 367extern HttpHdrContRange *httpHdrContRangeDup(const HttpHdrContRange * crange);
368extern void httpHdrContRangePackInto(const HttpHdrContRange * crange, Packer * p);
d192d11f 369/* inits with given spec */
370extern void httpHdrContRangeSet(HttpHdrContRange *, HttpHdrRangeSpec, size_t ent_len);
b5107edb 371
7faf2bdb 372/* Http Header Tools */
de336bbe 373extern HttpHeaderFieldInfo *httpHeaderBuildFieldsInfo(const HttpHeaderFieldAttrs * attrs, int count);
a369131d 374extern void httpHeaderDestroyFieldsInfo(HttpHeaderFieldInfo * info, int count);
d8b249ef 375extern int httpHeaderIdByName(const char *name, int name_len, const HttpHeaderFieldInfo * attrs, int end);
97474590 376extern int httpHeaderIdByNameDef(const char *name, int name_len);
377extern void httpHeaderMaskInit(HttpHeaderMask * mask, int value);
ec878047 378extern void httpHeaderCalcMask(HttpHeaderMask * mask, const int *enums, int count);
52040193 379extern int httpHeaderHasConnDir(const HttpHeader * hdr, const char *directive);
d192d11f 380extern void httpHeaderAddContRange(HttpHeader * hdr, HttpHdrRangeSpec spec, size_t ent_len);
52040193 381extern void strListAdd(String * str, const char *item, char del);
382extern int strListIsMember(const String * str, const char *item, char del);
5999b776 383extern int strListIsSubstr(const String * list, const char *s, char del);
52040193 384extern int strListGetItem(const String * str, char del, const char **item, int *ilen, const char **pos);
d8b249ef 385extern const char *getStringPrefix(const char *str, const char *end);
b5107edb 386extern int httpHeaderParseInt(const char *start, int *val);
59c4d35b 387extern int httpHeaderParseSize(const char *start, size_t * sz);
460e1ef5 388extern int httpHeaderReset(HttpHeader * hdr);
6de2df60 389#if STDC_HEADERS
ba2d3770 390extern void httpHeaderPutStrf(HttpHeader * hdr, http_hdr_type id, const char *fmt,...);
2246b732 391#else
ba2d3770 392extern void
393 httpHeaderPutStrf();
2246b732 394#endif
7faf2bdb 395
d192d11f 396
4f087419 397/* Http Header */
ba2d3770 398extern void httpHeaderInitModule();
399extern void httpHeaderCleanModule();
d8b249ef 400/* init/clean */
ba2d3770 401extern void httpHeaderInit(HttpHeader * hdr, http_hdr_owner_type owner);
402extern void httpHeaderClean(HttpHeader * hdr);
2246b732 403/* append/update */
ba2d3770 404extern void httpHeaderAppend(HttpHeader * dest, const HttpHeader * src);
405extern void httpHeaderUpdate(HttpHeader * old, const HttpHeader * fresh, const HttpHeaderMask * denied_mask);
4f087419 406/* parse/pack */
ba2d3770 407extern int httpHeaderParse(HttpHeader * hdr, const char *header_start, const char *header_end);
408extern void httpHeaderPackInto(const HttpHeader * hdr, Packer * p);
4f087419 409/* field manipulation */
ba2d3770 410extern int httpHeaderHas(const HttpHeader * hdr, http_hdr_type type);
411extern void httpHeaderPutInt(HttpHeader * hdr, http_hdr_type type, int number);
412extern void httpHeaderPutTime(HttpHeader * hdr, http_hdr_type type, time_t time);
413extern void httpHeaderPutStr(HttpHeader * hdr, http_hdr_type type, const char *str);
414extern void httpHeaderPutAuth(HttpHeader * hdr, const char *authScheme, const char *realm);
415extern void httpHeaderPutCc(HttpHeader * hdr, const HttpHdrCc * cc);
0cdcddb9 416extern void httpHeaderPutContRange(HttpHeader * hdr, const HttpHdrContRange * cr);
417extern void httpHeaderPutRange(HttpHeader * hdr, const HttpHdrRange * range);
ba2d3770 418extern void httpHeaderPutExt(HttpHeader * hdr, const char *name, const char *value);
419extern int httpHeaderGetInt(const HttpHeader * hdr, http_hdr_type id);
420extern time_t httpHeaderGetTime(const HttpHeader * hdr, http_hdr_type id);
a9771e51 421extern TimeOrTag httpHeaderGetTimeOrTag(const HttpHeader * hdr, http_hdr_type id);
ba2d3770 422extern HttpHdrCc *httpHeaderGetCc(const HttpHeader * hdr);
a9771e51 423extern ETag httpHeaderGetETag(const HttpHeader * hdr, http_hdr_type id);
ba2d3770 424extern HttpHdrRange *httpHeaderGetRange(const HttpHeader * hdr);
425extern HttpHdrContRange *httpHeaderGetContRange(const HttpHeader * hdr);
426extern const char *httpHeaderGetStr(const HttpHeader * hdr, http_hdr_type id);
427extern const char *httpHeaderGetLastStr(const HttpHeader * hdr, http_hdr_type id);
428extern const char *httpHeaderGetAuth(const HttpHeader * hdr, http_hdr_type id, const char *authScheme);
429extern String httpHeaderGetList(const HttpHeader * hdr, http_hdr_type id);
430extern int httpHeaderDelByName(HttpHeader * hdr, const char *name);
431extern int httpHeaderDelById(HttpHeader * hdr, http_hdr_type id);
432extern void httpHeaderDelAt(HttpHeader * hdr, HttpHeaderPos pos);
99edd1c3 433/* avoid using these low level routines */
ba2d3770 434extern HttpHeaderEntry *httpHeaderGetEntry(const HttpHeader * hdr, HttpHeaderPos * pos);
435extern HttpHeaderEntry *httpHeaderFindEntry(const HttpHeader * hdr, http_hdr_type id);
436extern void httpHeaderAddEntry(HttpHeader * hdr, HttpHeaderEntry * e);
437extern HttpHeaderEntry *httpHeaderEntryClone(const HttpHeaderEntry * e);
438extern void httpHeaderEntryPackInto(const HttpHeaderEntry * e, Packer * p);
4f087419 439/* store report about current header usage and other stats */
ba2d3770 440extern void httpHeaderStoreReport(StoreEntry * e);
a8258824 441
99edd1c3 442/* Http Msg (currently in HttpReply.c @?@ ) */
ba2d3770 443extern int httpMsgIsPersistent(float http_ver, const HttpHeader * hdr);
444extern int httpMsgIsolateHeaders(const char **parse_start, const char **blk_start, const char **blk_end);
99edd1c3 445
adba4a64 446/* Http Reply */
ba2d3770 447extern void httpReplyInitModule();
2246b732 448/* create/destroy */
ba2d3770 449extern HttpReply *httpReplyCreate();
450extern void httpReplyDestroy(HttpReply * rep);
adba4a64 451/* reset: clean, then init */
ba2d3770 452extern void httpReplyReset(HttpReply * rep);
adba4a64 453/* absorb: copy the contents of a new reply to the old one, destroy new one */
ba2d3770 454extern void httpReplyAbsorb(HttpReply * rep, HttpReply * new_rep);
adba4a64 455/* parse returns -1,0,+1 on error,need-more-data,success */
ba2d3770 456extern int httpReplyParse(HttpReply * rep, const char *buf); /*, int atEnd); */
457extern void httpReplyPackInto(const HttpReply * rep, Packer * p);
adba4a64 458/* ez-routines */
459/* mem-pack: returns a ready to use mem buffer with a packed reply */
ba2d3770 460extern MemBuf httpReplyPack(const HttpReply * rep);
adba4a64 461/* swap: create swap-based packer, pack, destroy packer */
ba2d3770 462extern void httpReplySwapOut(const HttpReply * rep, StoreEntry * e);
adba4a64 463/* set commonly used info with one call */
ba2d3770 464extern void httpReplySetHeaders(HttpReply * rep, double ver, http_status status,
adba4a64 465 const char *reason, const char *ctype, int clen, time_t lmt, time_t expires);
466/* do everything in one call: init, set, pack, clean, return MemBuf */
ba2d3770 467extern MemBuf httpPackedReply(double ver, http_status status, const char *ctype,
adba4a64 468 int clen, time_t lmt, time_t expires);
469/* construct 304 reply and pack it into MemBuf, return MemBuf */
ba2d3770 470extern MemBuf httpPacked304Reply(const HttpReply * rep);
adba4a64 471/* update when 304 reply is received for a cached object */
ba2d3770 472extern void httpReplyUpdateOnNotModified(HttpReply * rep, HttpReply * freshRep);
99edd1c3 473/* header manipulation */
ba2d3770 474extern int httpReplyContentLen(const HttpReply * rep);
475extern const char *httpReplyContentType(const HttpReply * rep);
476extern time_t httpReplyExpires(const HttpReply * rep);
477extern int httpReplyHasCc(const HttpReply * rep, http_hdr_cc_type type);
6d38ef86 478extern void httpRedirectReply(HttpReply *, http_status, const char *);
35282fbf 479extern int httpReplyBodySize(method_t, HttpReply *);
adba4a64 480
99edd1c3 481/* Http Request */
ba2d3770 482extern request_t *requestCreate(method_t, protocol_t, const char *urlpath);
483extern void requestDestroy(request_t *);
484extern request_t *requestLink(request_t *);
485extern void requestUnlink(request_t *);
486extern int httpRequestParseHeader(request_t * req, const char *parse_start);
487extern void httpRequestSwapOut(const request_t * req, StoreEntry * e);
0cdcddb9 488extern void httpRequestPack(const request_t * req, Packer * p);
ba2d3770 489extern int httpRequestPrefixLen(const request_t * req);
490extern int httpRequestHdrAllowed(const HttpHeaderEntry * e, String * strConnection);
491
492extern void icmpOpen(void);
493extern void icmpClose(void);
494extern void icmpPing(struct in_addr to);
495extern void icmpSourcePing(struct in_addr to, const icp_common_t *, const char *url);
496extern void icmpDomainPing(struct in_addr to, const char *domain);
497
498extern void *icpCreateMessage(icp_opcode opcode,
ea3a2a69 499 int flags,
500 const char *url,
501 int reqnum,
502 int pad);
ba2d3770 503extern int icpUdpSend(int, const struct sockaddr_in *, icp_common_t *, log_type, int);
504extern PF icpHandleUdp;
48382032 505extern PF icpUdpSendQueue;
ba2d3770 506extern PF httpAccept;
c9654574 507
678c6099 508#ifdef SQUID_SNMP
ba2d3770 509extern PF snmpHandleUdp;
510extern void snmpInit(void);
ba2d3770 511extern void snmpConnectionOpen(void);
512extern void snmpConnectionShutdown(void);
513extern void snmpConnectionClose(void);
dba79ac5 514extern void snmpDebugOid(int lvl, oid * Name, snint Len);
515extern void addr2oid(struct in_addr addr, oid * Dest);
c68e9c6b 516extern struct in_addr *oid2addr(oid * id);
b6a2f15e 517extern struct in_addr *client_entry(struct in_addr *current);
518extern variable_list *snmp_basicFn(variable_list *, snint *);
519extern variable_list *snmp_confFn(variable_list *, snint *);
520extern variable_list *snmp_sysFn(variable_list *, snint *);
521extern variable_list *snmp_prfSysFn(variable_list *, snint *);
522extern variable_list *snmp_prfProtoFn(variable_list *, snint *);
523extern variable_list *snmp_prfPeerFn(variable_list *, snint *);
524extern variable_list *snmp_netIpFn(variable_list *, snint *);
525extern variable_list *snmp_netFqdnFn(variable_list *, snint *);
526extern variable_list *snmp_netDnsFn(variable_list *, snint *);
527extern variable_list *snmp_meshPtblFn(variable_list *, snint *);
528extern variable_list *snmp_meshCtblFn(variable_list *, snint *);
678c6099 529#endif /* SQUID_SNMP */
2bbd722b 530
eb824054 531#if USE_WCCP
320e9f36 532extern void wccpInit(void);
533extern void wccpConnectionOpen(void);
534extern void wccpConnectionShutdown(void);
535extern void wccpConnectionClose(void);
eb824054 536#endif /* USE_WCCP */
320e9f36 537
ba2d3770 538extern void icpHandleIcpV3(int, struct sockaddr_in, char *, int);
539extern int icpCheckUdpHit(StoreEntry *, request_t * request);
540extern void icpConnectionsOpen(void);
541extern void icpConnectionShutdown(void);
542extern void icpConnectionClose(void);
5942e8d4 543extern int icpSetCacheKey(const cache_key * key);
544extern const cache_key *icpGetCacheKey(const char *url, int reqnum);
a8258824 545
ba2d3770 546extern void ipcache_nbgethostbyname(const char *name,
ea3a2a69 547 IPH * handler,
548 void *handlerData);
ba2d3770 549extern EVH ipcache_purgelru;
550extern const ipcache_addrs *ipcache_gethostbyname(const char *, int flags);
551extern void ipcacheInvalidate(const char *);
552extern void ipcacheReleaseInvalid(const char *);
ba2d3770 553extern void ipcache_init(void);
554extern void stat_ipcache_get(StoreEntry *);
555extern int ipcacheQueueDrain(void);
556extern void ipcacheCycleAddr(const char *name, ipcache_addrs *);
557extern void ipcacheMarkBadAddr(const char *name, struct in_addr);
558extern void ipcacheMarkGoodAddr(const char *name, struct in_addr);
559extern void ipcacheFreeMemory(void);
560extern ipcache_addrs *ipcacheCheckNumeric(const char *name);
561extern void ipcache_restart(void);
562extern int ipcacheUnregister(const char *name, void *data);
f5b8bbc4 563
1a3db59c 564/* MemBuf */
565/* init with specific sizes */
ba2d3770 566extern void memBufInit(MemBuf * mb, mb_size_t szInit, mb_size_t szMax);
1a3db59c 567/* init with defaults */
ba2d3770 568extern void memBufDefInit(MemBuf * mb);
137ee196 569/* cleans mb; last function to call if you do not give .buf away */
ba2d3770 570extern void memBufClean(MemBuf * mb);
137ee196 571/* resets mb preserving (or initializing if needed) memory buffer */
ba2d3770 572extern void memBufReset(MemBuf * mb);
1d21d91d 573/* unfirtunate hack to test if the buffer has been Init()ialized */
574extern int memBufIsNull(MemBuf * mb);
1a3db59c 575/* calls memcpy, appends exactly size bytes, extends buffer if needed */
ba2d3770 576extern void memBufAppend(MemBuf * mb, const char *buf, mb_size_t size);
1a3db59c 577/* calls snprintf, extends buffer if needed */
6de2df60 578#if STDC_HEADERS
ba2d3770 579extern void memBufPrintf(MemBuf * mb, const char *fmt,...);
1a3db59c 580#else
ba2d3770 581extern void memBufPrintf();
1a3db59c 582#endif
583/* vprintf for other printf()'s to use */
ba2d3770 584extern void memBufVPrintf(MemBuf * mb, const char *fmt, va_list ap);
1a3db59c 585/* returns free() function to be used, _freezes_ the object! */
ba2d3770 586extern FREE *memBufFreeFunc(MemBuf * mb);
1a3db59c 587/* puts report on MemBuf _module_ usage into mb */
ba2d3770 588extern void memBufReport(MemBuf * mb);
1a3db59c 589
ba2d3770 590extern char *mime_get_header(const char *mime, const char *header);
591extern char *mime_get_header_field(const char *mime, const char *name, const char *prefix);
ba2d3770 592extern size_t headersEnd(const char *, size_t);
593extern const char *mime_get_auth(const char *hdr, const char *auth_scheme, const char **auth_field);
63259c34 594
ba2d3770 595extern void mimeInit(char *filename);
c68e9c6b 596extern void mimeFreeMemory(void);
ba2d3770 597extern char *mimeGetContentEncoding(const char *fn);
598extern char *mimeGetContentType(const char *fn);
599extern char *mimeGetIcon(const char *fn);
600extern char *mimeGetIconURL(const char *fn);
601extern char mimeGetTransferMode(const char *fn);
2a1ca944 602extern int mimeGetDownloadOption(const char *fn);
603extern int mimeGetViewOption(const char *fn);
f5b8bbc4 604
ba2d3770 605extern int mcastSetTtl(int, int);
606extern IPH mcastJoinGroups;
a8258824 607
608/* Labels for hierachical log file */
609/* put them all here for easier reference when writing a logfile analyzer */
610
611
ba2d3770 612extern peer *getFirstPeer(void);
613extern peer *getFirstUpParent(request_t *);
614extern peer *getNextPeer(peer *);
615extern peer *getSingleParent(request_t *);
616extern int neighborsCount(request_t *);
617extern int neighborsUdpPing(request_t *,
ea3a2a69 618 StoreEntry *,
619 IRCB * callback,
620 void *data,
52040193 621 int *exprep,
465dc415 622 int *timeout);
ba2d3770 623extern void neighborAddAcl(const char *, const char *);
624extern void neighborsUdpAck(const cache_key *, icp_common_t *, const struct sockaddr_in *);
625extern void neighborAdd(const char *, const char *, int, int, int, int, int);
626extern void neighbors_open(int);
627extern peer *peerFindByName(const char *);
db1cd23c 628extern peer *peerFindByNameAndPort(const char *, unsigned short);
ba2d3770 629extern peer *getDefaultParent(request_t * request);
630extern peer *getRoundRobinParent(request_t * request);
6a655df0 631extern peer *getAnyParent(request_t * request);
ba2d3770 632extern lookup_t peerDigestLookup(peer * p, request_t * request, StoreEntry * entry);
633extern peer *neighborsDigestSelect(request_t * request, StoreEntry * entry);
634extern void peerNoteDigestLookup(request_t * request, peer * p, lookup_t lookup);
8a6218c6 635extern void peerNoteDigestGone(peer * p);
ba2d3770 636extern int neighborUp(const peer * e);
db1cd23c 637extern CBDUNL peerDestroy;
ba2d3770 638extern char *neighborTypeStr(const peer * e);
701a8572 639extern peer_t neighborType(const peer *, const request_t *);
ba2d3770 640extern void peerCheckConnectStart(peer *);
641extern void dump_peer_options(StoreEntry *, peer *);
642extern int peerHTTPOkay(const peer *, request_t *);
d9f9d78b 643extern peer *whichPeer(const struct sockaddr_in *from);
86aebcda 644#if USE_HTCP
645extern void neighborsHtcpReply(const cache_key *, htcpReplyData *, const struct sockaddr_in *);
646#endif
ba2d3770 647
648extern void netdbInit(void);
649extern void netdbHandlePingReply(const struct sockaddr_in *from, int hops, int rtt);
650extern void netdbPingSite(const char *hostname);
651extern void netdbInit(void);
652extern void netdbDump(StoreEntry *);
653extern int netdbHops(struct in_addr);
654extern void netdbFreeMemory(void);
655extern int netdbHostHops(const char *host);
656extern int netdbHostRtt(const char *host);
657extern int netdbHostPeerRtt(const char *host, peer * peer);
658extern void netdbUpdatePeer(request_t *, peer * e, int rtt, int hops);
659extern void netdbDeleteAddrNetwork(struct in_addr addr);
660extern int netdbHostPeerRtt(const char *host, peer * peer);
661extern void netdbBinaryExchange(StoreEntry *);
662extern EVH netdbExchangeStart;
663extern void netdbExchangeUpdatePeer(struct in_addr, peer *, double, double);
664extern peer *netdbClosestParent(request_t *);
d239c2f5 665extern void netdbHostData(const char *host, int *samp, int *rtt, int *hops);
ba2d3770 666
667extern void cachemgrStart(int fd, request_t * request, StoreEntry * entry);
1da3b90b 668extern void cachemgrRegister(const char *, const char *, OBJH *, int, int);
ba2d3770 669extern void cachemgrInit(void);
670
db1cd23c 671extern void peerSelect(request_t *, StoreEntry *, PSC *, void *data);
ba2d3770 672extern void peerSelectInit(void);
f5b8bbc4 673
b89dd01a 674/* peer_digest.c */
8a6218c6 675extern PeerDigest *peerDigestCreate(peer * p);
676extern void peerDigestNeeded(PeerDigest * pd);
677extern void peerDigestNotePeerGone(PeerDigest * pd);
678extern void peerDigestStatsReport(const PeerDigest * pd, StoreEntry * e);
b89dd01a 679
41462d93 680/* forward.c */
ae2c08a2 681extern void fwdStart(int, StoreEntry *, request_t *, struct in_addr, struct in_addr);
41462d93 682extern DEFER fwdCheckDeferRead;
ec250dfd 683extern void fwdFail(FwdState *, ErrorState *);
22514be0 684extern void fwdUnregister(int fd, FwdState *);
db1cd23c 685extern void fwdComplete(FwdState * fwdState);
8ddcc35d 686extern void fwdInit(void);
b6a2f15e 687extern int fwdReforwardableStatus(http_status s);
64d8034e 688extern void fwdServersFree(FwdServer ** FS);
a8258824 689
ba2d3770 690extern void urnStart(request_t *, StoreEntry *);
23d92c64 691
ba2d3770 692extern void redirectStart(clientHttpRequest *, RH *, void *);
74addf6c 693extern void redirectInit(void);
694extern void redirectShutdown(void);
a8258824 695
73e67ee0 696extern void authenticateStart(acl_proxy_auth_user *, RH *, void *);
74addf6c 697extern void authenticateInit(void);
698extern void authenticateShutdown(void);
73e67ee0 699
ba2d3770 700extern void refreshAddToList(const char *, int, time_t, int, time_t);
cfa9f1cb 701extern int refreshIsCachable(const StoreEntry *);
829a9357 702extern int refreshCheckHTTP(const StoreEntry *, request_t *);
703extern int refreshCheckICP(const StoreEntry *, request_t *);
32b3cf93 704extern int refreshCheckHTCP(const StoreEntry *, request_t *);
829a9357 705extern int refreshCheckDigest(const StoreEntry *, time_t delta);
ba2d3770 706extern time_t getMaxAge(const char *url);
1c3e77cd 707extern void refreshInit(void);
a8258824 708
ba2d3770 709extern void serverConnectionsClose(void);
710extern void shut_down(int);
a8258824 711
712
ba2d3770 713extern void start_announce(void *unused);
714extern void sslStart(int fd, const char *, request_t *, size_t * sz);
db1cd23c 715extern void waisStart(FwdState *);
05832ae1 716
717/* ident.c */
3898f57f 718#if USE_IDENT
05832ae1 719extern void identStart(struct sockaddr_in *me, struct sockaddr_in *peer, IDCB * callback, void *cbdata);
720extern void identInit(void);
3898f57f 721#endif
a8258824 722
ba2d3770 723extern void statInit(void);
d2db411c 724extern void statFreeMemory(void);
ba2d3770 725extern double median_svc_get(int, int);
726extern void pconnHistCount(int, int);
727extern int stat5minClientRequests(void);
979533fa 728extern double stat5minCPUUsage(void);
415e0dd2 729extern const char *storeEntryFlags(const StoreEntry *);
1d5b6d43 730extern double statRequestHitRatio(int minutes);
731extern double statByteHitRatio(int minutes);
732
1f3c4622 733
12cf1be2 734
ae50d52a 735/* StatHist */
ba2d3770 736extern void statHistClean(StatHist * H);
737extern void statHistCount(StatHist * H, double val);
738extern void statHistCopy(StatHist * Dest, const StatHist * Orig);
739extern void statHistSafeCopy(StatHist * Dest, const StatHist * Orig);
740extern double statHistDeltaMedian(const StatHist * A, const StatHist * B);
741extern void statHistDump(const StatHist * H, StoreEntry * sentry, StatHistBinDumper bd);
742extern void statHistLogInit(StatHist * H, int capacity, double min, double max);
743extern void statHistEnumInit(StatHist * H, int last_enum);
26d6ee93 744extern void statHistIntInit(StatHist * H, int n);
ba2d3770 745extern StatHistBinDumper statHistEnumDumper;
746extern StatHistBinDumper statHistIntDumper;
7ae52c25 747
99edd1c3 748
02922e76 749/* MemMeter */
ba2d3770 750extern void memMeterSyncHWater(MemMeter * m);
d8b249ef 751#define memMeterCheckHWater(m) { if ((m).hwater_level < (m).level) memMeterSyncHWater(&(m)); }
02922e76 752#define memMeterInc(m) { (m).level++; memMeterCheckHWater(m); }
b4c1e3eb 753#define memMeterDec(m) { (m).level--; }
02922e76 754#define memMeterAdd(m, sz) { (m).level += (sz); memMeterCheckHWater(m); }
b4c1e3eb 755#define memMeterDel(m, sz) { (m).level -= (sz); }
a8258824 756
02922e76 757/* mem */
ba2d3770 758extern void memInit(void);
58a39dc9 759extern void memClean(void);
760extern void memInitModule(void);
761extern void memCleanModule(void);
762extern void memConfigure(void);
ba2d3770 763extern void *memAllocate(mem_type);
764extern void *memAllocBuf(size_t net_size, size_t * gross_size);
db1cd23c 765extern CBDUNL memFree;
ba2d3770 766extern void memFreeBuf(size_t size, void *);
767extern void memFree2K(void *);
768extern void memFree4K(void *);
769extern void memFree8K(void *);
770extern void memFreeDISK(void *);
771extern int memInUse(mem_type);
ddaad76a 772extern size_t memTotalAllocated(void);
58a39dc9 773extern void memDataInit(mem_type, const char *, size_t, int);
774extern void memCheckInit(void);
3f6c0fb2 775
02922e76 776/* MemPool */
ba2d3770 777extern MemPool *memPoolCreate(const char *label, size_t obj_size);
778extern void memPoolDestroy(MemPool * pool);
779extern void *memPoolAlloc(MemPool * pool);
780extern void memPoolFree(MemPool * pool, void *obj);
781extern int memPoolWasUsed(const MemPool * pool);
782extern int memPoolInUseCount(const MemPool * pool);
783extern size_t memPoolInUseSize(const MemPool * pool);
784extern int memPoolUsedCount(const MemPool * pool);
785extern void memPoolReport(const MemPool * pool, StoreEntry * e);
d8b249ef 786
787/* Mem */
ba2d3770 788extern void memReport(StoreEntry * e);
7021844c 789
ba2d3770 790extern int stmemFreeDataUpto(mem_hdr *, int);
791extern void stmemAppend(mem_hdr *, const char *, int);
792extern ssize_t stmemCopy(const mem_hdr *, off_t, char *, size_t);
793extern void stmemFree(mem_hdr *);
794extern void stmemFreeData(mem_hdr *);
a8258824 795
796/* ----------------------------------------------------------------- */
797
f09f5b26 798/*
799 * store.c
800 */
ba2d3770 801extern StoreEntry *new_StoreEntry(int, const char *, const char *);
802extern StoreEntry *storeGet(const cache_key *);
08e5d64f 803extern StoreEntry *storeGetPublic(const char *uri, const method_t method);
92695e5e 804extern StoreEntry *storeCreateEntry(const char *, const char *, request_flags, method_t);
ba2d3770 805extern void storeSetPublicKey(StoreEntry *);
806extern void storeComplete(StoreEntry *);
807extern void storeInit(void);
808extern int storeClientWaiting(const StoreEntry *);
7197b20d 809extern void storeAbort(StoreEntry *);
ba2d3770 810extern void storeAppend(StoreEntry *, const char *, int);
811extern void storeLockObject(StoreEntry *);
ba2d3770 812extern void storeRelease(StoreEntry *);
813extern int storeUnlockObject(StoreEntry *);
814extern int storeUnregister(StoreEntry *, void *);
815extern void storeClientCopy(StoreEntry * e,
ea3a2a69 816 off_t seen_offset,
817 off_t copy_offset,
818 size_t size,
819 char *buf,
820 STCB * callback,
821 void *data);
ba2d3770 822extern int storePendingNClients(const StoreEntry *);
ba2d3770 823extern EVH storeMaintainSwapSpace;
824extern void storeExpireNow(StoreEntry *);
825extern void storeReleaseRequest(StoreEntry *);
826extern off_t storeLowestMemReaderOffset(const StoreEntry *);
827extern void storeConfigure(void);
828extern void storeNegativeCache(StoreEntry *);
829extern void storeFreeMemory(void);
830extern int expiresMoreThan(time_t, time_t);
831extern int storeClientCopyPending(StoreEntry *, void *);
832extern void InvokeHandlers(StoreEntry *);
833extern int storeEntryValidToSend(StoreEntry *);
834extern void storeTimestampsSet(StoreEntry *);
835extern time_t storeExpiredReferenceAge(void);
836extern void storeRegisterAbort(StoreEntry * e, STABH * cb, void *);
837extern void storeUnregisterAbort(StoreEntry * e);
838extern void storeMemObjectDump(MemObject * mem);
569c4638 839extern void storeEntryDump(const StoreEntry * e, int debug_lvl);
ba2d3770 840extern const char *storeUrl(const StoreEntry *);
841extern void storeCreateMemObject(StoreEntry *, const char *, const char *);
842extern void storeCopyNotModifiedReplyHeaders(MemObject * O, MemObject * N);
843extern void storeBuffer(StoreEntry *);
844extern void storeBufferFlush(StoreEntry *);
845extern void storeHashInsert(StoreEntry * e, const cache_key *);
846extern void storeSetMemStatus(StoreEntry * e, int);
6de2df60 847#if STDC_HEADERS
ba2d3770 848extern void storeAppendPrintf(StoreEntry *, const char *,...);
f09f5b26 849#else
ba2d3770 850extern void storeAppendPrintf();
f09f5b26 851#endif
ba2d3770 852extern void storeAppendVPrintf(StoreEntry *, const char *, va_list ap);
853extern int storeCheckCachable(StoreEntry * e);
ba2d3770 854extern void storeSetPrivateKey(StoreEntry *);
855extern int objectLen(const StoreEntry * e);
856extern int contentLen(const StoreEntry * e);
857extern HttpReply *storeEntryReply(StoreEntry *);
c47511fd 858extern int storeTooManyDiskFilesOpen(void);
db1cd23c 859extern void storeEntryReset(StoreEntry *);
2b906e48 860extern void storeHeapPositionUpdate(StoreEntry *);
9fb13bb6 861
2391a162 862/* store_io.c */
b2c141d4 863extern STOBJOPEN storeOpen;
864extern STOBJCLOSE storeClose;
865extern STOBJREAD storeRead;
866extern STOBJWRITE storeWrite;
867extern STOBJUNLINK storeUnlink;
2391a162 868extern off_t storeOffset(storeIOState *);
869
53fa92a5 870/*
871 * store_io_ufs.c
872 */
873extern storeIOState *storeUfsOpen(sfileno, mode_t, STIOCB *, void *);
95dcd2b8 874extern void storeUfsClose(storeIOState * sio);
53fa92a5 875extern void storeUfsRead(storeIOState *, char *, size_t, off_t, STRCB *, void *);
876extern void storeUfsWrite(storeIOState *, char *, size_t, off_t, FREE *);
2391a162 877extern void storeUfsUnlink(int fileno);
53fa92a5 878
879#if USE_ASYNC_IO
880/*
881 * store_io_ufs.c
882 */
883extern storeIOState *storeAufsOpen(sfileno, mode_t, STIOCB *, void *);
884extern void storeAufsClose(storeIOState * sio);
885extern void storeAufsRead(storeIOState *, char *, size_t, off_t, STRCB *, void *);
886extern void storeAufsWrite(storeIOState *, char *, size_t, off_t, FREE *);
887extern void storeAufsUnlink(int fileno);
888#endif
2391a162 889
8798ad05 890#if USE_DISKD
891/*
892 * diskd.c
893 */
894extern storeIOState *storeDiskdOpen(sfileno, mode_t, STIOCB *, void *);
895extern void storeDiskdClose(storeIOState * sio);
896extern void storeDiskdRead(storeIOState *, char *, size_t, off_t, STRCB *, void *);
897extern void storeDiskdWrite(storeIOState *, char *, size_t, off_t, FREE *);
898extern void storeDiskdUnlink(int fileno);
899extern STINIT storeDiskdInit;
900extern void storeDiskdReadQueue(void);
901#endif
902
e3ef2b09 903/*
904 * store_log.c
905 */
ba2d3770 906extern void storeLog(int tag, const StoreEntry * e);
907extern void storeLogRotate(void);
908extern void storeLogClose(void);
909extern void storeLogOpen(void);
e3ef2b09 910
f09f5b26 911
912/*
913 * store_key_*.c
914 */
ba2d3770 915extern const cache_key *storeKeyDup(const cache_key *);
399cabec 916extern cache_key *storeKeyCopy(cache_key *, const cache_key *);
ba2d3770 917extern void storeKeyFree(const cache_key *);
918extern const cache_key *storeKeyScan(const char *);
919extern const char *storeKeyText(const cache_key *);
08e5d64f 920extern const cache_key *storeKeyPublic(const char *, const method_t);
ba2d3770 921extern const cache_key *storeKeyPrivate(const char *, method_t, int);
922extern int storeKeyHashBuckets(int);
923extern int storeKeyNull(const cache_key *);
924extern void storeKeyInit(void);
925extern HASHHASH storeKeyHashHash;
926extern HASHCMP storeKeyHashCmp;
a8258824 927
f09f5b26 928/*
1ffc4484 929 * store_digest.c
f09f5b26 930 */
58a39dc9 931extern void storeDigestInit(void);
932extern void storeDigestNoteStoreReady(void);
933extern void storeDigestScheduleRebuild(void);
ba2d3770 934extern void storeDigestDel(const StoreEntry * entry);
995105fe 935extern void storeDigestReport(StoreEntry *);
8638fc66 936
f09f5b26 937/*
938 * store_dir.c
939 */
95dcd2b8 940extern OBJH storeDirStats;
941extern char *storeDirSwapLogFile(int, const char *);
942extern char *storeSwapDir(int);
ba2d3770 943extern char *storeSwapFullPath(int, char *);
944extern char *storeSwapSubSubDir(int, char *);
ba2d3770 945extern const char *storeSwapPath(int);
ba2d3770 946extern int storeDirMapAllocate(void);
95dcd2b8 947extern int storeDirMapBitTest(int fn);
948extern int storeDirMapBitsInUse(void);
ba2d3770 949extern int storeDirNumber(int fileno);
ba2d3770 950extern int storeDirProperFileno(int dirn, int fn);
ba2d3770 951extern int storeDirValidFileno(int fn);
95dcd2b8 952extern int storeDirWriteCleanLogs(int reopen);
95dcd2b8 953extern int storeVerifySwapDirs(void);
954extern void storeCreateSwapDirectories(void);
955extern void storeDirCloseSwapLogs(void);
956extern void storeDirCloseTmpSwapLog(int dirn);
f4e3fa54 957extern void storeDirConfigure(void);
958extern void storeDirDiskFull(int fn);
9838d6c8 959extern void storeDirInit(void);
95dcd2b8 960extern void storeDirMapBitReset(int fn);
961extern void storeDirMapBitSet(int fn);
962extern void storeDirOpenSwapLogs(void);
963extern void storeDirSwapLog(const StoreEntry *, int op);
964extern void storeDirUpdateSwapSize(int fn, size_t size, int sign);
965
966/*
967 * store_dir_ufs.c
968 */
95dcd2b8 969extern OBJH storeUfsDirStats;
0e4e0e7d 970extern void storeUfsDirParse(cacheSwap * swap);
971extern void storeUfsDirDump(StoreEntry * entry, const char *name, SwapDir * s);
972extern void storeUfsDirFree(SwapDir *);
53fa92a5 973extern char *storeUfsFullPath(sfileno fn, char *fullpath);
8798ad05 974extern STINIT storeUfsDirInit;
53fa92a5 975#if USE_ASYNC_IO
976extern void storeAufsDirParse(cacheSwap * swap);
977#endif
8798ad05 978#if USE_DISKD
979extern void storeDiskdDirParse(cacheSwap *);
980#endif
e3ef2b09 981
f5b8bbc4 982
f09f5b26 983/*
984 * store_swapmeta.c
985 */
ba2d3770 986extern char *storeSwapMetaPack(tlv * tlv_list, int *length);
987extern tlv *storeSwapMetaBuild(StoreEntry * e);
988extern tlv *storeSwapMetaUnpack(const char *buf, int *hdrlen);
989extern void storeSwapTLVFree(tlv * n);
f09f5b26 990
991/*
992 * store_rebuild.c
993 */
b2c141d4 994extern void storeRebuildStart(void);
995extern void storeRebuildComplete(struct _store_rebuild_data *);
f09f5b26 996
f09f5b26 997/*
998 * store_swapin.c
999 */
1f38f50a 1000extern void storeSwapInStart(store_client *);
f09f5b26 1001
1002/*
1003 * store_swapout.c
1004 */
2391a162 1005extern void storeSwapOut(StoreEntry * e);
ba2d3770 1006extern void storeSwapOutFileClose(StoreEntry * e);
5f25e839 1007extern int storeSwapOutAble(const StoreEntry * e);
f09f5b26 1008
1009/*
1010 * store_client.c
1011 */
ba2d3770 1012extern store_client *storeClientListSearch(const MemObject * mem, void *data);
1013extern void storeClientListAdd(StoreEntry * e, void *data);
1014extern void storeClientCopy(StoreEntry *, off_t, off_t, size_t, char *, STCB *, void *);
1015extern int storeClientCopyPending(StoreEntry * e, void *data);
1016extern int storeUnregister(StoreEntry * e, void *data);
1017extern off_t storeLowestMemReaderOffset(const StoreEntry * entry);
1018extern void InvokeHandlers(StoreEntry * e);
1019extern int storePendingNClients(const StoreEntry * e);
1020
1021
1022extern const char *getMyHostname(void);
98829f69 1023extern const char *uniqueHostname(void);
ba2d3770 1024extern void safeunlink(const char *path, int quiet);
1025extern void death(int sig);
1026extern void fatal(const char *message);
6de2df60 1027#if STDC_HEADERS
ba2d3770 1028extern void fatalf(const char *fmt,...);
137ee196 1029#else
ba2d3770 1030extern void fatalf();
137ee196 1031#endif
ba2d3770 1032extern void fatal_dump(const char *message);
1033extern void sigusr2_handle(int sig);
1034extern void sig_child(int sig);
1035extern void leave_suid(void);
1036extern void enter_suid(void);
1037extern void no_suid(void);
1038extern void writePidFile(void);
1039extern void setSocketShutdownLifetimes(int);
1040extern void setMaxFD(void);
1041extern time_t getCurrentTime(void);
1042extern int percent(int, int);
1043extern double dpercent(double, double);
1044extern void squid_signal(int sig, SIGHDLR *, int flags);
1045extern pid_t readPidFile(void);
1046extern struct in_addr inaddrFromHostent(const struct hostent *hp);
1047extern int intAverage(int, int, int, int);
1048extern double doubleAverage(double, double, int, int);
1049extern void debug_trap(const char *);
1050extern void logsFlush(void);
1051extern char *checkNullString(char *p);
1052extern void squid_getrusage(struct rusage *r);
1053extern double rusage_cputime(struct rusage *r);
1054extern int rusage_maxrss(struct rusage *r);
1055extern int rusage_pagefaults(struct rusage *r);
1056extern void releaseServerSockets(void);
1057extern void PrintRusage(void);
1058extern void dumpMallocStats(void);
1059
1060extern void pumpInit(int fd, request_t * r, char *uri);
789f4e81 1061extern void pumpStart(int, FwdState *, CWCB * callback, void *);
ba2d3770 1062extern int pumpMethod(method_t method);
1063extern int pumpRestart(request_t *);
1064
1065extern void unlinkdInit(void);
1066extern void unlinkdClose(void);
1067extern void unlinkdUnlink(const char *);
1068
1069extern char *url_convert_hex(char *org_url, int allocate);
1070extern char *url_escape(const char *url);
1071extern protocol_t urlParseProtocol(const char *);
1072extern method_t urlParseMethod(const char *);
1073extern void urlInitialize(void);
1074extern request_t *urlParse(method_t, char *);
4aba13ed 1075extern const char *urlCanonical(request_t *);
ba2d3770 1076extern char *urlRInternal(const char *host, u_short port, const char *dir, const char *name);
1077extern char *urlInternal(const char *dir, const char *name);
1078extern int matchDomainName(const char *d, const char *h);
1079extern int urlCheckRequest(const request_t *);
1080extern int urlDefaultPort(protocol_t p);
1081extern char *urlCanonicalClean(const request_t *);
1082extern char *urlHostname(const char *url);
1083
1084extern void useragentOpenLog(void);
1085extern void useragentRotateLog(void);
1086extern void logUserAgent(const char *, const char *);
1087extern peer_t parseNeighborType(const char *s);
1088
c68e9c6b 1089extern void errorInitialize(void);
1090extern void errorClean(void);
ba2d3770 1091extern HttpReply *errorBuildReply(ErrorState * err);
1092extern void errorSend(int fd, ErrorState *);
1093extern void errorAppendEntry(StoreEntry *, ErrorState *);
1094extern void errorStateFree(ErrorState * err);
ba2d3770 1095extern int errorReservePageId(const char *page_name);
1f356f2c 1096extern ErrorState *errorCon(err_type type, http_status);
ba2d3770 1097
1098extern void pconnPush(int, const char *host, u_short port);
1099extern int pconnPop(const char *host, u_short port);
1100extern void pconnInit(void);
1101
1102extern int asnMatchIp(void *, struct in_addr);
1103extern void asnInit(void);
1104extern void asnFreeMemory(void);
d548ee64 1105
1106/* tools.c */
ba2d3770 1107extern void dlinkAdd(void *data, dlink_node *, dlink_list *);
b2329b6a 1108extern void dlinkAddTail(void *data, dlink_node *, dlink_list *);
ba2d3770 1109extern void dlinkDelete(dlink_node * m, dlink_list * list);
1110extern void kb_incr(kb_t *, size_t);
1111extern double gb_to_double(const gb_t *);
1112extern const char *gb_to_str(const gb_t *);
1113extern void gb_flush(gb_t *); /* internal, do not use this */
d548ee64 1114extern int stringHasWhitespace(const char *);
d03d26fb 1115extern void linklistPush(link_list **, void *);
1116extern void *linklistShift(link_list **);
1f38f50a 1117extern int xrename(const char *from, const char *to);
66c75c41 1118
767c5191 1119#if USE_HTCP
ba2d3770 1120extern void htcpInit(void);
1121extern void htcpQuery(StoreEntry * e, request_t * req, peer * p);
1122extern void htcpSocketShutdown(void);
1123extern void htcpSocketClose(void);
767c5191 1124#endif
1125
02922e76 1126/* String */
1127#define strLen(s) ((const int)(s).len)
1128#define strBuf(s) ((const char*)(s).buf)
1129#define strChr(s,ch) ((const char*)strchr(strBuf(s), (ch)))
1130#define strRChr(s,ch) ((const char*)strrchr(strBuf(s), (ch)))
1131#define strStr(s,str) ((const char*)strstr(strBuf(s), (str)))
1934cc67 1132#define strCmp(s,str) strcmp(strBuf(s), (str))
5a1bc610 1133#define strNCmp(s,str,n) strncmp(strBuf(s), (str), (n))
1934cc67 1134#define strCaseCmp(s,str) strcasecmp(strBuf(s), (str))
99edd1c3 1135#define strNCaseCmp(s,str,n) strncasecmp(strBuf(s), (str), (n))
02922e76 1136#define strSet(s,ptr,ch) (s).buf[ptr-(s).buf] = (ch)
4d62b0af 1137#define strCut(s,pos) (((s).len = pos) , ((s).buf[pos] = '\0'))
1138#define strCutPtr(s,ptr) (((s).len = (ptr)-(s).buf) , ((s).buf[(s).len] = '\0'))
02922e76 1139/* #define strCat(s,str) stringAppend(&(s), (str), strlen(str)+1) */
ba2d3770 1140extern void stringInit(String * s, const char *str);
1141extern void stringLimitInit(String * s, const char *str, int len);
1142extern String stringDup(const String * s);
1143extern void stringClean(String * s);
1144extern void stringReset(String * s, const char *str);
1145extern void stringAppend(String * s, const char *buf, int len);
02922e76 1146/* extern void stringAppendf(String *s, const char *fmt, ...); */
1147
66c75c41 1148/*
5a70d304 1149 * ipc.c
66c75c41 1150 */
ba2d3770 1151extern int ipcCreate(int type,
0e473d70 1152 const char *prog,
1153 char *const args[],
1154 const char *name,
1155 int *rfd,
1156 int *wfd);
ab013258 1157
c411be12 1158/* CacheDigest */
ba2d3770 1159extern CacheDigest *cacheDigestCreate(int capacity, int bpe);
1160extern void cacheDigestDestroy(CacheDigest * cd);
1161extern CacheDigest *cacheDigestClone(const CacheDigest * cd);
1162extern void cacheDigestClear(CacheDigest * cd);
1163extern void cacheDigestChangeCap(CacheDigest * cd, int new_cap);
1164extern int cacheDigestTest(const CacheDigest * cd, const cache_key * key);
1165extern void cacheDigestAdd(CacheDigest * cd, const cache_key * key);
1166extern void cacheDigestDel(CacheDigest * cd, const cache_key * key);
1167extern size_t cacheDigestCalcMaskSize(int cap, int bpe);
1168extern int cacheDigestBitUtil(const CacheDigest * cd);
1169extern void cacheDigestGuessStatsUpdate(cd_guess_stats * stats, int real_hit, int guess_hit);
1170extern void cacheDigestGuessStatsReport(const cd_guess_stats * stats, StoreEntry * sentry, const char *label);
1171extern void cacheDigestReport(CacheDigest * cd, const char *label, StoreEntry * e);
1172
1173extern void internalStart(request_t *, StoreEntry *);
1174extern int internalCheck(const char *urlpath);
1175extern int internalStaticCheck(const char *urlpath);
1176extern char *internalLocalUri(const char *dir, const char *name);
1177extern char *internalRemoteUri(const char *, u_short, const char *, const char *);
c68e9c6b 1178extern const char *internalHostname(void);
1f38f50a 1179extern int internalHostnameIs(const char *);
1da5651f 1180
afd88fbe 1181#if USE_CARP
1182extern void carpInit(void);
0cdcddb9 1183extern peer *carpSelectParent(request_t *);
afd88fbe 1184#endif
1185
95e36d02 1186#if DELAY_POOLS
95e36d02 1187extern void delayPoolsInit(void);
59715b38 1188extern void delayInitDelayData(unsigned short pools);
58a39dc9 1189extern void delayFreeDelayData(void);
59715b38 1190extern void delayCreateDelayPool(unsigned short pool, u_char class);
1191extern void delayInitDelayPool(unsigned short pool, u_char class, delaySpecSet * rates);
1192extern void delayFreeDelayPool(unsigned short pool);
58a39dc9 1193extern void delayPoolsReconfigure(void);
59715b38 1194extern void delaySetNoDelay(int fd);
1195extern void delayClearNoDelay(int fd);
1196extern int delayIsNoDelay(int fd);
1197extern delay_id delayClient(request_t *);
c59d39c4 1198extern EVH delayPoolsUpdate;
59715b38 1199extern int delayBytesWanted(delay_id d, int min, int max);
447e176b 1200extern void delayBytesIn(delay_id, int qty);
59715b38 1201extern int delayMostBytesWanted(const MemObject * mem, int max);
1202extern delay_id delayMostBytesAllowed(const MemObject * mem);
447e176b 1203extern void delaySetStoreClient(StoreEntry * e, void *data, delay_id delay_id);
b6a2f15e 1204void delayRegisterDelayIdPtr(delay_id * loc);
1205void delayUnregisterDelayIdPtr(delay_id * loc);
95e36d02 1206#endif
afd88fbe 1207
1f5f60dd 1208/* helper.c */
74addf6c 1209extern void helperOpenServers(helper * hlp);
1210extern void helperSubmit(helper * hlp, const char *buf, HLPCB * callback, void *data);
1211extern void helperStats(StoreEntry * sentry, helper * hlp);
1212extern void helperShutdown(helper * hlp);
1f5f60dd 1213extern helper *helperCreate(const char *);
1214extern void helperFree(helper *);
74addf6c 1215
5d620373 1216#if USE_LEAKFINDER
1217extern void leakInit(void);
1218extern void *leakAddFL(void *, const char *, int);
1219extern void *leakTouchFL(void *, const char *, int);
1220extern void *leakFree(void *);
1221#endif
1222
5a70d304 1223/*
1224 * prototypes for system functions missing from system includes
1225 */
1226
1227#ifdef _SQUID_SOLARIS_
ba2d3770 1228extern int getrusage(int, struct rusage *);
1229extern int getpagesize(void);
1230extern int gethostname(char *, int);
5a70d304 1231#endif
bc87dc25 1232
1233#if URL_CHECKSUM_DEBUG
1234extern unsigned int url_checksum(const char *url);
1235#endif
Mirror of https://github.com/squid-cache/squid.git