src/protos.h

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