+ - Fixed aiops.c and async_iu.c so that they actually compile
+ with USE_ASYNC_IO (Arjan de Vet).
+ - Fixed errState->errno causing problems with some macros
+ (Michael O'Reilly).
+
Changes to squid-1.2.beta1 ():
- Reworked storage manager to not keep objects in memory during
struct _splay_node *right;
} splayNode;
-typedef int (*SPCMP) _PARAMS((const void *, splayNode *));
+typedef int (*SPCMP)(const void *, splayNode *);
extern int splayLastResult;
-splayNode *splay_insert _PARAMS((void *, splayNode *, SPCMP));
-splayNode *splay_splay _PARAMS((const void *, splayNode *, SPCMP));
-void splay_destroy _PARAMS((splayNode *, void (*)_PARAMS((void *))));
+splayNode *splay_insert(void *, splayNode *, SPCMP);
+splayNode *splay_splay(const void *, splayNode *, SPCMP);
+void splay_destroy(splayNode *, void (*)(void *));
#ifndef _TEMPNAM_H
#define _TEMPNAM_H
-extern char *tempnam _PARAMS((const char *, const char *));
+extern char *tempnam(const char *, const char *);
#endif /* _TEMPNAM_H */
/*
- * $Id: util.h,v 1.32 1997/10/16 19:22:36 kostas Exp $
+ * $Id: util.h,v 1.33 1997/10/25 17:22:27 wessels Exp $
*
* AUTHOR: Harvest Derived
*
#endif
#endif
-extern const char *getfullhostname _PARAMS((void));
-extern const char *mkhttpdlogtime _PARAMS((const time_t *));
-extern const char *mkrfc1123 _PARAMS((time_t));
-extern char *uudecode _PARAMS((const char *));
-extern char *xstrdup _PARAMS((const char *));
-extern const char *xstrerror _PARAMS((void));
-extern const char *xbstrerror _PARAMS((int));
-extern int tvSubMsec _PARAMS((struct timeval, struct timeval));
-extern int tvSubUsec _PARAMS((struct timeval, struct timeval));
-extern char *xstrncpy _PARAMS((char *, const char *, size_t));
-extern time_t parse_rfc1123 _PARAMS((const char *str));
-extern void *xcalloc _PARAMS((int, size_t));
-extern void *xmalloc _PARAMS((size_t));
-extern void *xrealloc _PARAMS((void *, size_t));
-extern void Tolower _PARAMS((char *));
-extern void xfree _PARAMS((void *));
-extern void xmemcpy _PARAMS((void *, void *, int));
-extern void xxfree _PARAMS((void *));
+extern const char *getfullhostname(void);
+extern const char *mkhttpdlogtime(const time_t *);
+extern const char *mkrfc1123(time_t);
+extern char *uudecode(const char *);
+extern char *xstrdup(const char *);
+extern const char *xstrerror(void);
+extern const char *xbstrerror(int);
+extern int tvSubMsec(struct timeval, struct timeval);
+extern int tvSubUsec(struct timeval, struct timeval);
+extern char *xstrncpy(char *, const char *, size_t);
+extern time_t parse_rfc1123(const char *str);
+extern void *xcalloc(int, size_t);
+extern void *xmalloc(size_t);
+extern void *xrealloc(void *, size_t);
+extern void Tolower(char *);
+extern void xfree(void *);
+extern void xxfree(void *);
/* rfc1738.c */
-extern char *rfc1738_escape _PARAMS((const char *));
+extern char *rfc1738_escape(const char *);
#if XMALLOC_STATISTICS
-void malloc_statistics _PARAMS((void (*)_PARAMS((int, int, void *)), void *));
+void malloc_statistics(void (*)(int, int, void *), void *);
#endif
typedef struct in_addr SIA;
-extern int safe_inet_addr _PARAMS((const char *, SIA *));
-extern time_t parse_iso3307_time _PARAMS((const char *buf));
-extern char *base64_decode _PARAMS((const char *coded));
+extern int safe_inet_addr(const char *, SIA *);
+extern time_t parse_iso3307_time(const char *buf);
+extern char *base64_decode(const char *coded);
#endif /* ndef _UTIL_H_ */
#include <stdlib.h>
#endif
-#include "ansiproto.h"
-
-static void base64_init _PARAMS((void));
+static void base64_init(void);
static int base64_initialized = 0;
int base64_value[256];
/*
- * $Id: getfullhostname.c,v 1.14 1997/07/16 20:31:53 wessels Exp $
+ * $Id: getfullhostname.c,v 1.15 1997/10/25 17:22:28 wessels Exp $
*
* DEBUG:
* AUTHOR: Harvest Derived
#include <unistd.h>
#endif
-#include "ansiproto.h"
#include "util.h"
/*
/*
- * $Id: rfc1123.c,v 1.7 1997/02/18 23:53:48 wessels Exp $
+ * $Id: rfc1123.c,v 1.8 1997/10/25 17:22:29 wessels Exp $
*
* DEBUG:
* AUTHOR: Harvest Derived
#include <sys/time.h>
#endif
-#include "ansiproto.h"
#include "util.h"
#define RFC850_STRFTIME "%A, %d-%b-%y %H:%M:%S GMT"
#define RFC1123_STRFTIME "%a, %d %b %Y %H:%M:%S GMT"
-static int make_month _PARAMS((const char *s));
-static int make_num _PARAMS((const char *s));
+static int make_month(const char *s);
+static int make_num(const char *s);
static char *month_names[12] =
{
/*
- * $Id: rfc1738.c,v 1.11 1997/06/04 07:12:24 wessels Exp $
+ * $Id: rfc1738.c,v 1.12 1997/10/25 17:22:30 wessels Exp $
*
* DEBUG:
* AUTHOR: Harvest Derived
#include <string.h>
#endif
-#include "ansiproto.h"
#include "util.h"
/*
#include <unistd.h>
#endif
-#include "ansiproto.h"
#include "splay.h"
#include "util.h"
}
void
-splay_destroy(splayNode * top, void (*free_func) _PARAMS((void *)))
+splay_destroy(splayNode * top, void (*free_func) (void *))
{
if (top->left)
splay_destroy(top->left, free_func);
/*
- * $Id: util.c,v 1.33 1997/10/20 22:59:42 wessels Exp $
+ * $Id: util.c,v 1.34 1997/10/25 17:22:31 wessels Exp $
*
* DEBUG:
* AUTHOR: Harvest Derived
#include <errno.h>
#endif
-#include "ansiproto.h"
#include "util.h"
-void (*failure_notify) _PARAMS((const char *)) = NULL;
+void (*failure_notify) (const char *) = NULL;
static char msg[128];
extern int sys_nerr;
#include "config.h"
-#include "ansiproto.h"
#include "util.h"
extern char **environ;
/*
- * $Id: acl.cc,v 1.109 1997/10/17 00:00:27 wessels Exp $
+ * $Id: acl.cc,v 1.110 1997/10/25 17:22:33 wessels Exp $
*
* DEBUG: section 28 Access Control
* AUTHOR: Duane Wessels
static int aclFromFile = 0;
static FILE *aclFile;
-static void aclDestroyAclList _PARAMS((struct _acl_list * list));
-static void aclDestroyTimeList _PARAMS((struct _acl_time_data * data));
-static int aclMatchAclList _PARAMS((const struct _acl_list *, aclCheck_t *));
-static int aclMatchInteger _PARAMS((intlist * data, int i));
-static int aclMatchTime _PARAMS((struct _acl_time_data * data, time_t when));
-static int aclMatchIdent _PARAMS((wordlist * data, const char *ident));
-static int aclMatchIp _PARAMS((void *dataptr, struct in_addr c));
-static int aclMatchDomainList _PARAMS((void *dataptr, const char *));
-static squid_acl aclType _PARAMS((const char *s));
-static int decode_addr _PARAMS((const char *, struct in_addr *, struct in_addr *));
-static void aclCheck _PARAMS((aclCheck_t * checklist));
-static void aclCheckCallback _PARAMS((aclCheck_t * checklist, int answer));
+static void aclDestroyAclList(struct _acl_list * list);
+static void aclDestroyTimeList(struct _acl_time_data * data);
+static int aclMatchAclList(const struct _acl_list *, aclCheck_t *);
+static int aclMatchInteger(intlist * data, int i);
+static int aclMatchTime(struct _acl_time_data * data, time_t when);
+static int aclMatchIdent(wordlist * data, const char *ident);
+static int aclMatchIp(void *dataptr, struct in_addr c);
+static int aclMatchDomainList(void *dataptr, const char *);
+static squid_acl aclType(const char *s);
+static int decode_addr(const char *, struct in_addr *, struct in_addr *);
+static void aclCheck(aclCheck_t * checklist);
+static void aclCheckCallback(aclCheck_t * checklist, int answer);
static IPH aclLookupDstIPDone;
static FQDNH aclLookupSrcFQDNDone;
static FQDNH aclLookupDstFQDNDone;
-static int aclReadProxyAuth _PARAMS((struct _acl_proxy_auth * p));
+static int aclReadProxyAuth(struct _acl_proxy_auth * p);
#if defined(USE_SPLAY_TREE)
-static int aclIpNetworkCompare _PARAMS((const void *, splayNode *));
-static int aclHostDomainCompare _PARAMS((const void *, splayNode *));
-static int aclDomainCompare _PARAMS((const void *, splayNode *));
+static int aclIpNetworkCompare(const void *, splayNode *);
+static int aclHostDomainCompare(const void *, splayNode *);
+static int aclDomainCompare(const void *, splayNode *);
#elif defined(USE_BIN_TREE)
-static int bintreeDomainCompare _PARAMS((void *, void *));
-static int bintreeHostDomainCompare _PARAMS((void *, void *));
-static int bintreeNetworkCompare _PARAMS((void *, void *));
-static int bintreeIpNetworkCompare _PARAMS((void *, void *));
-static int aclDomainCompare _PARAMS((const char *d1, const char *d2));
-static void aclDestroyTree _PARAMS((tree **));
+static int bintreeDomainCompare(void *, void *);
+static int bintreeHostDomainCompare(void *, void *);
+static int bintreeNetworkCompare(void *, void *);
+static int bintreeIpNetworkCompare(void *, void *);
+static int aclDomainCompare(const char *d1, const char *d2);
+static void aclDestroyTree(tree **);
#else /* LINKED LIST */
-static void aclDestroyIpList _PARAMS((struct _acl_ip_data * data));
+static void aclDestroyIpList(struct _acl_ip_data * data);
#endif /* USE_SPLAY_TREE */
#if defined(USE_BIN_TREE)
-static void aclParseDomainList _PARAMS((void **curtree));
-static void aclParseIpList _PARAMS((void **curtree));
+static void aclParseDomainList(void **curtree);
+static void aclParseIpList(void **curtree);
#else
-static void aclParseDomainList _PARAMS((void *curlist));
-static void aclParseIpList _PARAMS((void *curlist));
+static void aclParseDomainList(void *curlist);
+static void aclParseIpList(void *curlist);
#endif
-static void aclParseIntlist _PARAMS((void *curlist));
-static void aclParseWordList _PARAMS((void *curlist));
-static void aclParseProtoList _PARAMS((void *curlist));
-static void aclParseMethodList _PARAMS((void *curlist));
-static void aclParseTimeSpec _PARAMS((void *curlist));
-static char *strtokFile _PARAMS((void));
+static void aclParseIntlist(void *curlist);
+static void aclParseWordList(void *curlist);
+static void aclParseProtoList(void *curlist);
+static void aclParseMethodList(void *curlist);
+static void aclParseTimeSpec(void *curlist);
+static char *strtokFile(void);
static char *
strtokFile(void)
/*
- * $Id: cache_cf.cc,v 1.225 1997/10/17 00:00:29 wessels Exp $
+ * $Id: cache_cf.cc,v 1.226 1997/10/25 17:22:34 wessels Exp $
*
* DEBUG: section 3 Configuration File Parsing
* AUTHOR: Harvest Derived
static const char *const list_sep = ", \t\n\r";
static char fatal_str[BUFSIZ];
-static void self_destruct _PARAMS((void));
-static void wordlistAdd _PARAMS((wordlist **, const char *));
-
-static void configDoConfigure _PARAMS((void));
-static void parse_refreshpattern _PARAMS((refresh_t **));
-static int parseTimeUnits _PARAMS((const char *unit));
-static void parseTimeLine _PARAMS((time_t * tptr, const char *units));
-static void parse_string _PARAMS((char **));
-static void parse_wordlist _PARAMS((wordlist **));
-static void default_all _PARAMS((void));
-static void defaults_if_none _PARAMS((void));
-static int parse_line _PARAMS((char *));
-static void parseBytesLine _PARAMS((size_t * bptr, const char *units));
-static size_t parseBytesUnits _PARAMS((const char *unit));
+static void self_destruct(void);
+static void wordlistAdd(wordlist **, const char *);
+
+static void configDoConfigure(void);
+static void parse_refreshpattern(refresh_t **);
+static int parseTimeUnits(const char *unit);
+static void parseTimeLine(time_t * tptr, const char *units);
+static void parse_string(char **);
+static void parse_wordlist(wordlist **);
+static void default_all(void);
+static void defaults_if_none(void);
+static int parse_line(char *);
+static void parseBytesLine(size_t * bptr, const char *units);
+static size_t parseBytesUnits(const char *unit);
/* These come from cf_gen.c */
-static void default_all _PARAMS((void));
-static void free_all _PARAMS((void));
+static void default_all(void);
+static void free_all(void);
static void
self_destruct(void)
/*
- * $Id: cachemgr.cc,v 1.62 1997/10/17 00:00:30 wessels Exp $
+ * $Id: cachemgr.cc,v 1.63 1997/10/25 17:22:34 wessels Exp $
*
* DEBUG: section 0 CGI Cache Manager
* AUTHOR: Harvest Derived
#include <sys/select.h>
#endif
-#include "ansiproto.h"
#include "util.h"
#include "snprintf.h"
static time_t now;
static struct in_addr no_addr;
-static char x2c _PARAMS((char *));
-static int client_comm_connect _PARAMS((int sock, char *dest_host, u_short dest_port));
-static void print_trailer _PARAMS((void));
-static void noargs_html _PARAMS((char *, int, char *, char *));
-static void unescape_url _PARAMS((char *));
-static void plustospace _PARAMS((char *));
-static void parse_object _PARAMS((char *));
-static char *describeTimeSince _PARAMS((time_t then));
+static char x2c(char *);
+static int client_comm_connect(int sock, char *dest_host, u_short dest_port);
+static void print_trailer(void);
+static void noargs_html(char *, int, char *, char *);
+static void unescape_url(char *);
+static void plustospace(char *);
+static void parse_object(char *);
+static char *describeTimeSince(time_t then);
static void
print_trailer(void)
/*
- * $Id: client.cc,v 1.34 1997/10/23 23:27:17 wessels Exp $
+ * $Id: client.cc,v 1.35 1997/10/25 17:22:35 wessels Exp $
*
* DEBUG: section 0 WWW Client
* AUTHOR: Harvest Derived
#endif
/* Local functions */
-static int client_comm_connect _PARAMS((int sock, char *dest_host, u_short dest_port));
-static void usage _PARAMS((const char *progname));
+static int client_comm_connect(int sock, char *dest_host, u_short dest_port);
+static void usage(const char *progname);
static void
usage(const char *progname)
/*
- * $Id: client_db.cc,v 1.18 1997/10/24 02:49:35 wessels Exp $
+ * $Id: client_db.cc,v 1.19 1997/10/25 17:22:35 wessels Exp $
*
* DEBUG: section 0 Client Database
* AUTHOR: Duane Wessels
} ClientInfo;
static hash_table *client_table = NULL;
-static ClientInfo *clientdbAdd _PARAMS((struct in_addr addr));
+static ClientInfo *clientdbAdd(struct in_addr addr);
static ClientInfo *
clientdbAdd(struct in_addr addr)
/*
- * $Id: client_side.cc,v 1.132 1997/10/25 16:45:59 wessels Exp $
+ * $Id: client_side.cc,v 1.133 1997/10/25 17:22:36 wessels Exp $
*
* DEBUG: section 33 Client-side Routines
* AUTHOR: Duane Wessels
static RH clientRedirectDone;
static STCB icpHandleIMSReply;
-static int clientGetsOldEntry _PARAMS((StoreEntry * new, StoreEntry * old, request_t * request));
-static int checkAccelOnly _PARAMS((clientHttpRequest *));
+static int clientGetsOldEntry(StoreEntry * new, StoreEntry * old, request_t * request);
+static int checkAccelOnly(clientHttpRequest *);
static int
checkAccelOnly(clientHttpRequest * http)
/*
- * $Id: comm.cc,v 1.193 1997/10/25 16:47:06 wessels Exp $
+ * $Id: comm.cc,v 1.194 1997/10/25 17:22:37 wessels Exp $
*
* DEBUG: section 5 Socket Functions
* AUTHOR: Harvest Derived
/* STATIC */
static int polledinc = 0;
-static int commBind _PARAMS((int s, struct in_addr, u_short port));
+static int commBind(int s, struct in_addr, u_short port);
#if !HAVE_POLL
-static int examine_select _PARAMS((fd_set *, fd_set *));
+static int examine_select(fd_set *, fd_set *);
#endif
-static void checkTimeouts _PARAMS((void));
-static void commSetReuseAddr _PARAMS((int));
-static void commSetNoLinger _PARAMS((int));
+static void checkTimeouts(void);
+static void commSetReuseAddr(int);
+static void commSetNoLinger(int);
#if HAVE_POLL
-static void comm_poll_incoming _PARAMS((void));
+static void comm_poll_incoming(void);
#else
-static void comm_select_incoming _PARAMS((void));
+static void comm_select_incoming(void);
#endif
-static void CommWriteStateCallbackAndFree _PARAMS((int fd, int code));
+static void CommWriteStateCallbackAndFree(int fd, int code);
#ifdef TCP_NODELAY
-static void commSetTcpNoDelay _PARAMS((int));
+static void commSetTcpNoDelay(int);
#endif
-static void commSetTcpRcvbuf _PARAMS((int, int));
+static void commSetTcpRcvbuf(int, int);
static PF commConnectFree;
static PF commConnectHandle;
static PF commHandleWrite;
-static int fdIsHttpOrIcp _PARAMS((int fd));
+static int fdIsHttpOrIcp(int fd);
static IPH commConnectDnsHandle;
-static void commConnectCallback _PARAMS((ConnectStateData * cs, int status));
+static void commConnectCallback(ConnectStateData * cs, int status);
static int commDeferRead(int fd);
static int ignoreErrno(int errno);
/*
- * $Id: debug.cc,v 1.52 1997/10/13 22:09:06 kostas Exp $
+ * $Id: debug.cc,v 1.53 1997/10/25 17:22:38 wessels Exp $
*
* DEBUG: section 0 Debug Routines
* AUTHOR: Harvest Derived
#include "squid.h"
static char *debug_log_file = NULL;
-static char *accessLogTime _PARAMS((time_t));
+static char *accessLogTime(time_t);
#ifdef __STDC__
void
/*
- * $Id: disk.cc,v 1.86 1997/10/24 02:55:11 wessels Exp $
+ * $Id: disk.cc,v 1.87 1997/10/25 17:22:38 wessels Exp $
*
* DEBUG: section 6 Disk I/O Routines
* AUTHOR: Harvest Derived
static AIOCB diskHandleReadComplete;
static PF diskHandleRead;
static PF diskHandleWrite;
-static void file_open_complete _PARAMS((void *, int, int));
+static void file_open_complete(void *, int, int);
#if UNUSED_CODE
static AIOCB diskHandleWalkComplete;
/*
- * $Id: dns.cc,v 1.42 1997/10/17 00:00:33 wessels Exp $
+ * $Id: dns.cc,v 1.43 1997/10/25 17:22:39 wessels Exp $
*
* DEBUG: section 34 Dnsserver interface
* AUTHOR: Harvest Derived
void *data;
};
-static int dnsOpenServer _PARAMS((const char *command));
+static int dnsOpenServer(const char *command);
static PF dnsShutdownRead;
static dnsserver_t **dns_child_table = NULL;
/*
- * $Id: dnsserver.cc,v 1.37 1997/10/17 00:00:34 wessels Exp $
+ * $Id: dnsserver.cc,v 1.38 1997/10/25 17:22:40 wessels Exp $
*
* DEBUG: section 0 DNS Resolver
* AUTHOR: Harvest Derived
#include <resolv.h>
#endif
-#include "ansiproto.h"
#include "util.h"
#include "snprintf.h"
/*
- * $Id: errorpage.cc,v 1.85 1997/10/25 16:41:22 wessels Exp $
+ * $Id: errorpage.cc,v 1.86 1997/10/25 17:22:40 wessels Exp $
*
* DEBUG: section 4 Error Generation
* AUTHOR: Duane Wessels
static char *error_text[ERR_MAX];
-static void errorStateFree _PARAMS((ErrorState * err));
-static char *errorConvert _PARAMS((char token, ErrorState * err));
-static char *errorBuildBuf _PARAMS((ErrorState * err, int *len));
+static void errorStateFree(ErrorState * err);
+static char *errorConvert(char token, ErrorState * err);
+static char *errorBuildBuf(ErrorState * err, int *len);
static CWCB errorSendComplete;
void
/*
- * $Id: fd.cc,v 1.13 1997/10/18 00:01:06 wessels Exp $
+ * $Id: fd.cc,v 1.14 1997/10/25 17:22:41 wessels Exp $
*
* DEBUG: section 51 Filedescriptor Functions
* AUTHOR: Duane Wessels
#include "squid.h"
-static void fdUpdateBiggest _PARAMS((int fd, unsigned int status));
+static void fdUpdateBiggest(int fd, unsigned int status);
static void
fdUpdateBiggest(int fd, unsigned int status)
/*
- * $Id: fqdncache.cc,v 1.60 1997/10/13 22:09:08 kostas Exp $
+ * $Id: fqdncache.cc,v 1.61 1997/10/25 17:22:41 wessels Exp $
*
* DEBUG: section 35 FQDN Cache
* AUTHOR: Harvest Derived
int ghba_calls; /* # calls to blocking gethostbyaddr() */
} FqdncacheStats;
-static int fqdncache_compareLastRef _PARAMS((fqdncache_entry **, fqdncache_entry **));
-static void fqdncache_dnsHandleRead _PARAMS((int, void *));
-static fqdncache_entry *fqdncache_parsebuffer _PARAMS((const char *buf, dnsserver_t *));
-static int fqdncache_purgelru _PARAMS((void));
-static void fqdncache_release _PARAMS((fqdncache_entry *));
-static fqdncache_entry *fqdncache_GetFirst _PARAMS((void));
-static fqdncache_entry *fqdncache_GetNext _PARAMS((void));
-static fqdncache_entry *fqdncache_create _PARAMS((const char *name));
-static void fqdncache_add_to_hash _PARAMS((fqdncache_entry *));
-static void fqdncache_call_pending _PARAMS((fqdncache_entry *));
-static void fqdncacheAddHostent _PARAMS((fqdncache_entry *, const struct hostent *));
-static int fqdncacheHasPending _PARAMS((const fqdncache_entry *));
-static fqdncache_entry *fqdncache_get _PARAMS((const char *));
+static int fqdncache_compareLastRef(fqdncache_entry **, fqdncache_entry **);
+static void fqdncache_dnsHandleRead(int, void *);
+static fqdncache_entry *fqdncache_parsebuffer(const char *buf, dnsserver_t *);
+static int fqdncache_purgelru(void);
+static void fqdncache_release(fqdncache_entry *);
+static fqdncache_entry *fqdncache_GetFirst(void);
+static fqdncache_entry *fqdncache_GetNext(void);
+static fqdncache_entry *fqdncache_create(const char *name);
+static void fqdncache_add_to_hash(fqdncache_entry *);
+static void fqdncache_call_pending(fqdncache_entry *);
+static void fqdncacheAddHostent(fqdncache_entry *, const struct hostent *);
+static int fqdncacheHasPending(const fqdncache_entry *);
+static fqdncache_entry *fqdncache_get(const char *);
static FQDNH dummy_handler;
-static int fqdncacheExpiredEntry _PARAMS((const fqdncache_entry *));
-static void fqdncacheAddPending _PARAMS((fqdncache_entry *, FQDNH *, void *));
-static void fqdncacheEnqueue _PARAMS((fqdncache_entry *));
-static void *fqdncacheDequeue _PARAMS((void));
-static void fqdncache_dnsDispatch _PARAMS((dnsserver_t *, fqdncache_entry *));
-static void fqdncacheChangeKey _PARAMS((fqdncache_entry * i));
-static void fqdncacheLockEntry _PARAMS((fqdncache_entry * f));
-static void fqdncacheUnlockEntry _PARAMS((fqdncache_entry * f));
+static int fqdncacheExpiredEntry(const fqdncache_entry *);
+static void fqdncacheAddPending(fqdncache_entry *, FQDNH *, void *);
+static void fqdncacheEnqueue(fqdncache_entry *);
+static void *fqdncacheDequeue(void);
+static void fqdncache_dnsDispatch(dnsserver_t *, fqdncache_entry *);
+static void fqdncacheChangeKey(fqdncache_entry * i);
+static void fqdncacheLockEntry(fqdncache_entry * f);
+static void fqdncacheUnlockEntry(fqdncache_entry * f);
static hash_table *fqdn_table = NULL;
static struct fqdncacheQueueData *fqdncacheQueueHead = NULL;
/*
- * $Id: ftp.cc,v 1.149 1997/10/24 18:10:37 wessels Exp $
+ * $Id: ftp.cc,v 1.150 1997/10/25 17:22:42 wessels Exp $
*
* DEBUG: section 9 File Transfer Protocol (FTP)
* AUTHOR: Harvest Derived
char *link;
} ftpListParts;
-typedef void (FTPSM) _PARAMS((FtpStateData *));
+typedef void (FTPSM)(FtpStateData *);
/* Local functions */
static CNCB ftpConnectDone;
static PF ftpTimeout;
static PF ftpReadControlReply;
static CWCB ftpWriteCommandCallback;
-static char *ftpGetBasicAuth _PARAMS((const char *));
-static void ftpLoginParser _PARAMS((const char *, FtpStateData *));
-static void ftpFail _PARAMS((FtpStateData * ftpState));
-static wordlist *ftpParseControlReply _PARAMS((char *buf, size_t len, int *code));
-static void ftpSendPasv _PARAMS((FtpStateData * ftpState));
-static void ftpSendCwd _PARAMS((FtpStateData * ftpState));
-static void ftpSendPort _PARAMS((FtpStateData * ftpState));
-static void ftpRestOrList _PARAMS((FtpStateData * ftpState));
-static void ftpReadQuit _PARAMS((FtpStateData * ftpState));
-static void ftpDataTransferDone _PARAMS((FtpStateData * ftpState));
-static void ftpAppendSuccessHeader _PARAMS((FtpStateData * ftpState));
-static char *ftpAuthRequired _PARAMS((const request_t *, const char *));
+static char *ftpGetBasicAuth(const char *);
+static void ftpLoginParser(const char *, FtpStateData *);
+static void ftpFail(FtpStateData * ftpState);
+static wordlist *ftpParseControlReply(char *buf, size_t len, int *code);
+static void ftpSendPasv(FtpStateData * ftpState);
+static void ftpSendCwd(FtpStateData * ftpState);
+static void ftpSendPort(FtpStateData * ftpState);
+static void ftpRestOrList(FtpStateData * ftpState);
+static void ftpReadQuit(FtpStateData * ftpState);
+static void ftpDataTransferDone(FtpStateData * ftpState);
+static void ftpAppendSuccessHeader(FtpStateData * ftpState);
+static char *ftpAuthRequired(const request_t *, const char *);
static STABH ftpAbort;
static FTPSM ftpReadWelcome;
/*
- * $Id: gopher.cc,v 1.103 1997/10/24 18:10:38 wessels Exp $
+ * $Id: gopher.cc,v 1.104 1997/10/25 17:22:43 wessels Exp $
*
* DEBUG: section 10 Gopher
* AUTHOR: Harvest Derived
} GopherStateData;
static PF gopherStateFree;
-static void gopher_mime_content _PARAMS((char *buf, const char *name, const char *def));
-static void gopherMimeCreate _PARAMS((GopherStateData *));
+static void gopher_mime_content(char *buf, const char *name, const char *def);
+static void gopherMimeCreate(GopherStateData *);
static int gopher_url_parser(const char *url,
char *host,
int *port,
char *type_id,
char *request);
-static void gopherEndHTML _PARAMS((GopherStateData *));
-static void gopherToHTML _PARAMS((GopherStateData *, char *inbuf, int len));
+static void gopherEndHTML(GopherStateData *);
+static void gopherToHTML(GopherStateData *, char *inbuf, int len);
static PF gopherTimeout;
static PF gopherReadReply;
static void gopherSendComplete(int fd,
int errflag,
void *data);
static PF gopherSendRequest;
-static GopherStateData *CreateGopherStateData _PARAMS((void));
+static GopherStateData *CreateGopherStateData(void);
static CNCB gopherConnectDone;
static STABH gopherAbort;
/*
- * $Id: http.cc,v 1.200 1997/10/25 06:26:40 wessels Exp $
+ * $Id: http.cc,v 1.201 1997/10/25 17:22:44 wessels Exp $
*
* DEBUG: section 11 Hypertext Transfer Protocol (HTTP)
* AUTHOR: Harvest Derived
static PF httpSendRequest;
static PF httpStateFree;
static PF httpTimeout;
-static void httpAppendRequestHeader _PARAMS((char *hdr, const char *line, size_t * sz, size_t max, int));
-static void httpCacheNegatively _PARAMS((StoreEntry *));
-static void httpMakePrivate _PARAMS((StoreEntry *));
-static void httpMakePublic _PARAMS((StoreEntry *));
-static char *httpStatusString _PARAMS((int status));
+static void httpAppendRequestHeader(char *hdr, const char *line, size_t * sz, size_t max, int);
+static void httpCacheNegatively(StoreEntry *);
+static void httpMakePrivate(StoreEntry *);
+static void httpMakePublic(StoreEntry *);
+static char *httpStatusString(int status);
static STABH httpAbort;
-static HttpStateData *httpBuildState _PARAMS((int, StoreEntry *, request_t *, peer *));
-static int httpSocketOpen _PARAMS((StoreEntry *, request_t *));
-static void httpRestart _PARAMS((HttpStateData *));
+static HttpStateData *httpBuildState(int, StoreEntry *, request_t *, peer *);
+static int httpSocketOpen(StoreEntry *, request_t *);
+static void httpRestart(HttpStateData *);
static void
httpStateFree(int fd, void *data)
/*
- * $Id: icmp.cc,v 1.43 1997/10/17 00:00:38 wessels Exp $
+ * $Id: icmp.cc,v 1.44 1997/10/25 17:22:45 wessels Exp $
*
* DEBUG: section 37 ICMP Routines
* AUTHOR: Duane Wessels
char *msg;
int len;
struct _icmpQueueData *next;
- void (*free_func) _PARAMS((void *));
+ void (*free_func)(void *);
} icmpQueueData;
static icmpQueueData *IcmpQueueHead = NULL;
static PF icmpRecv;
-static void icmpQueueSend _PARAMS((pingerEchoData * pkt,
- int len,
- void (*free_func) _PARAMS((void *))));
+static void icmpQueueSend (pingerEchoData * pkt, int len, FREE *free_func);
static PF icmpSend;
-static void icmpHandleSourcePing _PARAMS((const struct sockaddr_in * from, const char *buf));
+static void icmpHandleSourcePing(const struct sockaddr_in * from, const char *buf);
static void
icmpSendEcho(struct in_addr to, int opcode, const char *payload, int len)
static void
icmpQueueSend(pingerEchoData * pkt,
int len,
- void (*free_func) _PARAMS((void *)))
+ FREE *free_func;
{
icmpQueueData *q = NULL;
icmpQueueData **H = NULL;
/*
- * $Id: ident.cc,v 1.34 1997/10/17 00:00:40 wessels Exp $
+ * $Id: ident.cc,v 1.35 1997/10/25 17:22:47 wessels Exp $
*
* DEBUG: section 30 Ident (RFC 931)
* AUTHOR: Duane Wessels
static PF identReadReply;
static PF identClose;
static CNCB identConnectDone;
-static void identCallback _PARAMS((ConnStateData * connState));
+static void identCallback(ConnStateData * connState);
static void
identClose(int fd, void *data)
/*
- * $Id: ipcache.cc,v 1.134 1997/10/21 18:40:32 wessels Exp $
+ * $Id: ipcache.cc,v 1.135 1997/10/25 17:22:48 wessels Exp $
*
* DEBUG: section 14 IP Cache
* AUTHOR: Harvest Derived
int release_locked;
} IpcacheStats;
-static int ipcache_testname _PARAMS((void));
-static int ipcache_compareLastRef _PARAMS((ipcache_entry **, ipcache_entry **));
-static int ipcache_reverseLastRef _PARAMS((ipcache_entry **, ipcache_entry **));
+static int ipcache_testname(void);
+static int ipcache_compareLastRef(ipcache_entry **, ipcache_entry **);
+static int ipcache_reverseLastRef(ipcache_entry **, ipcache_entry **);
static PF ipcache_dnsHandleRead;
-static ipcache_entry *ipcache_parsebuffer _PARAMS((const char *buf, dnsserver_t *));
-static void ipcache_release _PARAMS((ipcache_entry *));
-static ipcache_entry *ipcache_GetFirst _PARAMS((void));
-static ipcache_entry *ipcache_GetNext _PARAMS((void));
-static ipcache_entry *ipcache_create _PARAMS((const char *name));
-static void ipcache_add_to_hash _PARAMS((ipcache_entry *));
-static void ipcache_call_pending _PARAMS((ipcache_entry *));
-static ipcache_entry *ipcacheAddNew _PARAMS((const char *, const struct hostent *, ipcache_status_t));
-static void ipcacheAddHostent _PARAMS((ipcache_entry *, const struct hostent *));
-static int ipcacheHasPending _PARAMS((ipcache_entry *));
-static ipcache_entry *ipcache_get _PARAMS((const char *));
+static ipcache_entry *ipcache_parsebuffer(const char *buf, dnsserver_t *);
+static void ipcache_release(ipcache_entry *);
+static ipcache_entry *ipcache_GetFirst(void);
+static ipcache_entry *ipcache_GetNext(void);
+static ipcache_entry *ipcache_create(const char *name);
+static void ipcache_add_to_hash(ipcache_entry *);
+static void ipcache_call_pending(ipcache_entry *);
+static ipcache_entry *ipcacheAddNew(const char *, const struct hostent *, ipcache_status_t);
+static void ipcacheAddHostent(ipcache_entry *, const struct hostent *);
+static int ipcacheHasPending(ipcache_entry *);
+static ipcache_entry *ipcache_get(const char *);
static IPH dummy_handler;
-static int ipcacheExpiredEntry _PARAMS((ipcache_entry *));
-static void ipcacheAddPending _PARAMS((ipcache_entry *, IPH *, void *));
-static void ipcacheEnqueue _PARAMS((ipcache_entry *));
-static void *ipcacheDequeue _PARAMS((void));
-static void ipcache_dnsDispatch _PARAMS((dnsserver_t *, ipcache_entry *));
-static void ipcacheStatPrint _PARAMS((ipcache_entry *, StoreEntry *));
-static void ipcacheUnlockEntry _PARAMS((ipcache_entry *));
-static void ipcacheLockEntry _PARAMS((ipcache_entry *));
-static void ipcacheNudgeQueue _PARAMS((void));
-static void ipcacheChangeKey _PARAMS((ipcache_entry * i));
+static int ipcacheExpiredEntry(ipcache_entry *);
+static void ipcacheAddPending(ipcache_entry *, IPH *, void *);
+static void ipcacheEnqueue(ipcache_entry *);
+static void *ipcacheDequeue(void);
+static void ipcache_dnsDispatch(dnsserver_t *, ipcache_entry *);
+static void ipcacheStatPrint(ipcache_entry *, StoreEntry *);
+static void ipcacheUnlockEntry(ipcache_entry *);
+static void ipcacheLockEntry(ipcache_entry *);
+static void ipcacheNudgeQueue(void);
+static void ipcacheChangeKey(ipcache_entry * i);
static ipcache_addrs static_addrs;
static hash_table *ip_table = NULL;
/*
- * $Id: main.cc,v 1.177 1997/10/23 16:38:13 wessels Exp $
+ * $Id: main.cc,v 1.178 1997/10/25 17:22:49 wessels Exp $
*
* DEBUG: section 1 Startup and Main Loop
* AUTHOR: Harvest Derived
#include "squid.h"
/* for error reporting from xmalloc and friends */
-extern void (*failure_notify) _PARAMS((const char *));
+extern void (*failure_notify)(const char *);
static int opt_send_signal = -1;
static volatile int rotate_pending = 0; /* set by SIGUSR1 handler */
static int malloc_debug_level = 0;
#endif
-static void rotate_logs _PARAMS((int));
-static void reconfigure _PARAMS((int));
-static void time_tick _PARAMS((int));
-static void mainInitialize _PARAMS((void));
-static void mainReconfigure _PARAMS((void));
-static void usage _PARAMS((void));
-static void mainParseOptions _PARAMS((int, char **));
-static void sendSignal _PARAMS((void));
-static void serverConnectionsOpen _PARAMS((void));
+static void rotate_logs(int);
+static void reconfigure(int);
+static void time_tick(int);
+static void mainInitialize(void);
+static void mainReconfigure(void);
+static void usage(void);
+static void mainParseOptions(int, char **);
+static void sendSignal(void);
+static void serverConnectionsOpen(void);
static void
usage(void)
/*
- * $Id: mime.cc,v 1.40 1997/10/17 00:00:42 wessels Exp $
+ * $Id: mime.cc,v 1.41 1997/10/25 17:22:50 wessels Exp $
*
* DEBUG: section 25 MIME Parsing
* AUTHOR: Harvest Derived
static mimeEntry *MimeTable = NULL;
static mimeEntry **MimeTableTail = NULL;
-static void mimeLoadIconFile _PARAMS((const char *icon));
+static void mimeLoadIconFile(const char *icon);
char *
mime_get_header(const char *mime, const char *name)
/*
- * $Id: neighbors.cc,v 1.161 1997/10/16 23:59:59 wessels Exp $
+ * $Id: neighbors.cc,v 1.162 1997/10/25 17:22:50 wessels Exp $
*
* DEBUG: section 15 Neighbor Routines
* AUTHOR: Harvest Derived
/* count mcast group peers every 15 minutes */
#define MCAST_COUNT_RATE 900
-static int peerAllowedToUse _PARAMS((const peer *, request_t *));
-static int peerHTTPOkay _PARAMS((const peer *, request_t *));
-static int peerWouldBePinged _PARAMS((const peer *, request_t *));
-static void neighborRemove _PARAMS((peer *));
-static peer *whichPeer _PARAMS((const struct sockaddr_in * from));
-static void neighborAlive _PARAMS((peer *, const MemObject *, const icp_common_t *));
-static void neighborCountIgnored _PARAMS((peer *, icp_opcode op_unused));
-static void peerRefreshDNS _PARAMS((void *));
+static int peerAllowedToUse(const peer *, request_t *);
+static int peerHTTPOkay(const peer *, request_t *);
+static int peerWouldBePinged(const peer *, request_t *);
+static void neighborRemove(peer *);
+static peer *whichPeer(const struct sockaddr_in * from);
+static void neighborAlive(peer *, const MemObject *, const icp_common_t *);
+static void neighborCountIgnored(peer *, icp_opcode op_unused);
+static void peerRefreshDNS(void *);
static IPH peerDNSConfigure;
-static void peerCheckConnect _PARAMS((void *));
+static void peerCheckConnect(void *);
static IPH peerCheckConnect2;
static CNCB peerCheckConnectDone;
-static void peerCountMcastPeersDone _PARAMS((void *data));
-static void peerCountMcastPeersStart _PARAMS((void *data));
-static void peerCountMcastPeersSchedule _PARAMS((peer * p, time_t when));
+static void peerCountMcastPeersDone(void *data);
+static void peerCountMcastPeersStart(void *data);
+static void peerCountMcastPeersSchedule(peer * p, time_t when);
static IRCB peerCountHandleIcpReply;
-static void neighborIgnoreNonPeer _PARAMS((const struct sockaddr_in *, icp_opcode));
+static void neighborIgnoreNonPeer(const struct sockaddr_in *, icp_opcode);
static icp_common_t echo_hdr;
static u_short echo_port;
/*
- * $Id: net_db.cc,v 1.49 1997/10/13 22:09:17 kostas Exp $
+ * $Id: net_db.cc,v 1.50 1997/10/25 17:22:51 wessels Exp $
*
* DEBUG: section 37 Network Measurement Database
* AUTHOR: Duane Wessels
static hash_table *addr_table = NULL;
static hash_table *host_table = NULL;
-static struct in_addr networkFromInaddr _PARAMS((struct in_addr a));
-static void netdbRelease _PARAMS((netdbEntry * n));
-static netdbEntry *netdbGetFirst _PARAMS((hash_table * table));
-static netdbEntry *netdbGetNext _PARAMS((hash_table * table));
-static void netdbHashInsert _PARAMS((netdbEntry * n, struct in_addr addr));
-static void netdbHashDelete _PARAMS((const char *key));
-static void netdbHashLink _PARAMS((netdbEntry * n, const char *hostname));
-static void netdbHashUnlink _PARAMS((const char *key));
-static void netdbPurgeLRU _PARAMS((void));
-static net_db_peer *netdbPeerByName _PARAMS((const netdbEntry * n, const char *));
-static net_db_peer *netdbPeerAdd _PARAMS((netdbEntry * n, peer * e));
-static char *netdbPeerName _PARAMS((const char *name));
+static struct in_addr networkFromInaddr(struct in_addr a);
+static void netdbRelease(netdbEntry * n);
+static netdbEntry *netdbGetFirst(hash_table * table);
+static netdbEntry *netdbGetNext(hash_table * table);
+static void netdbHashInsert(netdbEntry * n, struct in_addr addr);
+static void netdbHashDelete(const char *key);
+static void netdbHashLink(netdbEntry * n, const char *hostname);
+static void netdbHashUnlink(const char *key);
+static void netdbPurgeLRU(void);
+static net_db_peer *netdbPeerByName(const netdbEntry * n, const char *);
+static net_db_peer *netdbPeerAdd(netdbEntry * n, peer * e);
+static char *netdbPeerName(const char *name);
static IPH netdbSendPing;
/* We have to keep a local list of peer names. The Peers structure
/*
- * $Id: pconn.cc,v 1.5 1997/10/25 16:58:25 wessels Exp $
+ * $Id: pconn.cc,v 1.6 1997/10/25 17:22:53 wessels Exp $
*
* DEBUG: section 48 Persistent Connections
* AUTHOR: Duane Wessels
static PF pconnRead;
static PF pconnTimeout;
-static const char *pconnKey _PARAMS((const char *host, u_short port));
+static const char *pconnKey(const char *host, u_short port);
static hash_table *table = NULL;
-static struct _pconn *pconnNew _PARAMS((const char *key));
-static void pconnDelete _PARAMS((struct _pconn * p));
-static void pconnRemoveFD _PARAMS((struct _pconn * p, int fd));
+static struct _pconn *pconnNew(const char *key);
+static void pconnDelete(struct _pconn * p);
+static void pconnRemoveFD(struct _pconn * p, int fd);
static const char *
/*
- * $Id: peer_select.cc,v 1.28 1997/10/22 19:23:45 wessels Exp $
+ * $Id: peer_select.cc,v 1.29 1997/10/25 17:22:54 wessels Exp $
*
* DEBUG: section 44 Peer Selection Algorithm
* AUTHOR: Duane Wessels
"DIRECT_YES"
};
-static void peerSelectFoo _PARAMS((ps_state *));
-static void peerPingTimeout _PARAMS((void *data));
-static void peerSelectCallbackFail _PARAMS((ps_state * psstate));
+static void peerSelectFoo(ps_state *);
+static void peerPingTimeout(void *data);
+static void peerSelectCallbackFail(ps_state * psstate);
static IRCB peerHandleIcpReply;
-static void peerSelectStateFree _PARAMS((ps_state * psstate));
-static void peerIcpParentMiss _PARAMS((peer *, icp_common_t *, ps_state *));
-static int peerCheckNetdbDirect _PARAMS((ps_state * psstate));
+static void peerSelectStateFree(ps_state * psstate);
+static void peerIcpParentMiss(peer *, icp_common_t *, ps_state *);
+static int peerCheckNetdbDirect(ps_state * psstate);
static void
peerSelectStateFree(ps_state * psstate)
/*
- * $Id: pinger.cc,v 1.26 1997/08/25 05:29:57 wessels Exp $
+ * $Id: pinger.cc,v 1.27 1997/10/25 17:22:54 wessels Exp $
*
* DEBUG: section 42 ICMP Pinger program
* AUTHOR: Duane Wessels
"Out of Range Type"
};
-static int in_cksum _PARAMS((unsigned short *ptr, int size));
-static void pingerRecv _PARAMS((void));
-static void pingerLog _PARAMS((struct icmphdr * icmp,
- struct in_addr addr,
- int rtt,
- int hops));
-static int ipHops _PARAMS((int ttl));
-static void pingerSendtoSquid _PARAMS((pingerReplyData * preply));
+static int in_cksum(unsigned short *ptr, int size);
+static void pingerRecv(void);
+static void pingerLog(struct icmphdr *, struct in_addr, int, int);
+static int ipHops(int ttl);
+static void pingerSendtoSquid(pingerReplyData * preply);
void
pingerOpen(void)
-extern void accessLogLog _PARAMS((AccessLogEntry *));
-extern void accessLogRotate _PARAMS((void));
-extern void accessLogClose _PARAMS((void));
-extern void accessLogOpen _PARAMS((const char *));
-extern void hierarchyNote _PARAMS((HierarchyLogEntry *, hier_code, icp_ping_data *, const char *));
+extern void accessLogLog(AccessLogEntry *);
+extern void accessLogRotate(void);
+extern void accessLogClose(void);
+extern void accessLogOpen(const char *);
+extern void hierarchyNote(HierarchyLogEntry *, hier_code, icp_ping_data *, const char *);
-extern aclCheck_t *aclChecklistCreate _PARAMS((const struct _acl_access *,
+extern aclCheck_t *aclChecklistCreate(const struct _acl_access *,
request_t *,
struct in_addr src,
char *ua,
- char *id));
-extern void aclNBCheck _PARAMS((aclCheck_t *, PF *, void *));
-extern int aclCheckFast _PARAMS((const struct _acl_access * A, aclCheck_t *));
-extern void aclChecklistFree _PARAMS((aclCheck_t *));
-extern int aclMatchAcl _PARAMS((struct _acl *, aclCheck_t *));
-extern void aclDestroyAccessList _PARAMS((struct _acl_access ** list));
-extern void aclDestroyAcls _PARAMS((acl **));
-extern void aclParseAccessLine _PARAMS((struct _acl_access **));
-extern void aclParseAclLine _PARAMS((acl **));
-extern struct _acl *aclFindByName _PARAMS((const char *name));
-extern char *aclGetDenyInfoUrl _PARAMS((struct _acl_deny_info_list **, const char *name));
-extern void aclParseDenyInfoLine _PARAMS((struct _acl_deny_info_list **));
-extern void aclDestroyDenyInfoList _PARAMS((struct _acl_deny_info_list **));
-extern void aclDestroyRegexList _PARAMS((struct _relist * data));
-extern int aclMatchRegex _PARAMS((relist * data, const char *word));
-extern void aclParseRegexList _PARAMS((void *curlist));
-
-
-extern int aio_cancel _PARAMS((aio_result_t *));
-extern int aio_open _PARAMS((const char *, int, mode_t, aio_result_t *));
-extern int aio_read _PARAMS((int, char *, int, off_t, int, aio_result_t *));
-extern int aio_write _PARAMS((int, char *, int, off_t, int, aio_result_t *));
-extern int aio_close _PARAMS((int, aio_result_t *));
-extern int aio_stat _PARAMS((const char *, struct stat *, aio_result_t *));
-extern int aio_unlink _PARAMS((const char *, aio_result_t *));
-extern int aio_opendir _PARAMS((const char *, aio_result_t *));
-extern aio_result_t *aio_poll_done _PARAMS((void));
-
-
-extern void aioCancel _PARAMS((int));
-extern void aioOpen _PARAMS((const char *, int, mode_t, AIOCB *, void *));
-extern void aioClose _PARAMS((int));
-extern void aioWrite _PARAMS((int, char *, int, AIOCB *, void *));
-extern void aioRead _PARAMS((int, char *, int, AIOCB *, void *));
-extern void aioStat _PARAMS((char *, struct stat *, AIOCB *, void *));
-extern void aioUnlink _PARAMS((const char *, AIOCB *, void *));
-extern void aioCheckCallbacks _PARAMS((void));
-
-extern int parseConfigFile _PARAMS((const char *file_name));
-extern void intlistDestroy _PARAMS((intlist **));
-extern void wordlistDestroy _PARAMS((wordlist **));
-extern void configFreeMemory _PARAMS((void));
-
-extern void cbdataInit _PARAMS((void));
-extern void cbdataAdd _PARAMS((void *p));
-extern void cbdataFree _PARAMS((void *p));
-extern void cbdataLock _PARAMS((void *p));
-extern void cbdataUnlock _PARAMS((void *p));
-extern int cbdataValid _PARAMS((void *p));
-extern void cbdataDump _PARAMS((StoreEntry *));
-
-extern void clientdbInit _PARAMS((void));
-extern void clientdbUpdate _PARAMS((struct in_addr, log_type, protocol_t));
-extern int clientdbDeniedPercent _PARAMS((struct in_addr));
-extern void clientdbDump _PARAMS((StoreEntry *));
+ char *id);
+extern void aclNBCheck(aclCheck_t *, PF *, void *);
+extern int aclCheckFast(const struct _acl_access * A, aclCheck_t *);
+extern void aclChecklistFree(aclCheck_t *);
+extern int aclMatchAcl(struct _acl *, aclCheck_t *);
+extern void aclDestroyAccessList(struct _acl_access ** list);
+extern void aclDestroyAcls(acl **);
+extern void aclParseAccessLine(struct _acl_access **);
+extern void aclParseAclLine(acl **);
+extern struct _acl *aclFindByName(const char *name);
+extern char *aclGetDenyInfoUrl(struct _acl_deny_info_list **, const char *name);
+extern void aclParseDenyInfoLine(struct _acl_deny_info_list **);
+extern void aclDestroyDenyInfoList(struct _acl_deny_info_list **);
+extern void aclDestroyRegexList(struct _relist * data);
+extern int aclMatchRegex(relist * data, const char *word);
+extern void aclParseRegexList(void *curlist);
+
+
+extern int aio_cancel(aio_result_t *);
+extern int aio_open(const char *, int, mode_t, aio_result_t *);
+extern int aio_read(int, char *, int, off_t, int, aio_result_t *);
+extern int aio_write(int, char *, int, off_t, int, aio_result_t *);
+extern int aio_close(int, aio_result_t *);
+extern int aio_stat(const char *, struct stat *, aio_result_t *);
+extern int aio_unlink(const char *, aio_result_t *);
+extern int aio_opendir(const char *, aio_result_t *);
+extern aio_result_t *aio_poll_done(void);
+
+
+extern void aioCancel(int);
+extern void aioOpen(const char *, int, mode_t, AIOCB *, void *);
+extern void aioClose(int);
+extern void aioWrite(int, char *, int, AIOCB *, void *);
+extern void aioRead(int, char *, int, AIOCB *, void *);
+extern void aioStat(char *, struct stat *, AIOCB *, void *);
+extern void aioUnlink(const char *, AIOCB *, void *);
+extern void aioCheckCallbacks(void);
+
+extern int parseConfigFile(const char *file_name);
+extern void intlistDestroy(intlist **);
+extern void wordlistDestroy(wordlist **);
+extern void configFreeMemory(void);
+
+extern void cbdataInit(void);
+extern void cbdataAdd(void *p);
+extern void cbdataFree(void *p);
+extern void cbdataLock(void *p);
+extern void cbdataUnlock(void *p);
+extern int cbdataValid(void *p);
+extern void cbdataDump(StoreEntry *);
+
+extern void clientdbInit(void);
+extern void clientdbUpdate(struct in_addr, log_type, protocol_t);
+extern int clientdbDeniedPercent(struct in_addr);
+extern void clientdbDump(StoreEntry *);
extern CWCB clientWriteComplete;
-extern void clientAccessCheck _PARAMS((void *));
-extern void clientAccessCheckDone _PARAMS((int, void *));
-extern void icpProcessExpired _PARAMS((int fd, void *));
-extern int modifiedSince _PARAMS((StoreEntry *, request_t *));
-extern char *clientConstructTraceEcho _PARAMS((clientHttpRequest *));
-extern void clientPurgeRequest _PARAMS((clientHttpRequest *));
+extern void clientAccessCheck(void *);
+extern void clientAccessCheckDone(int, void *);
+extern void icpProcessExpired(int fd, void *);
+extern int modifiedSince(StoreEntry *, request_t *);
+extern char *clientConstructTraceEcho(clientHttpRequest *);
+extern void clientPurgeRequest(clientHttpRequest *);
extern int checkNegativeHit(StoreEntry *);
#if USE_PROXY_AUTH
#endif /* USE_PROXY_AUTH */
-extern int commSetNonBlocking _PARAMS((int fd));
-extern void commSetCloseOnExec _PARAMS((int fd));
-extern int comm_accept _PARAMS((int fd, struct sockaddr_in *, struct sockaddr_in *));
-extern void comm_close _PARAMS((int fd));
-extern void commConnectStart _PARAMS((int fd, const char *, u_short, CNCB *, void *));
-extern int comm_connect_addr _PARAMS((int sock, const struct sockaddr_in *));
-extern int comm_init _PARAMS((void));
-extern int comm_listen _PARAMS((int sock));
-extern int comm_open _PARAMS((int, int, struct in_addr, u_short port, int, const char *note));
-extern u_short comm_local_port _PARAMS((int fd));
+extern int commSetNonBlocking(int fd);
+extern void commSetCloseOnExec(int fd);
+extern int comm_accept(int fd, struct sockaddr_in *, struct sockaddr_in *);
+extern void comm_close(int fd);
+extern void commConnectStart(int fd, const char *, u_short, CNCB *, void *);
+extern int comm_connect_addr(int sock, const struct sockaddr_in *);
+extern int comm_init(void);
+extern int comm_listen(int sock);
+extern int comm_open(int, int, struct in_addr, u_short port, int, const char *note);
+extern u_short comm_local_port(int fd);
#if HAVE_POLL
-extern int comm_poll _PARAMS((time_t));
+extern int comm_poll(time_t);
#else
-extern int comm_select _PARAMS((time_t));
+extern int comm_select(time_t);
#endif
-extern void commSetSelect _PARAMS((int, unsigned int, PF *, void *, time_t));
-extern void comm_add_close_handler _PARAMS((int fd, PF *, void *));
-extern void comm_remove_close_handler _PARAMS((int fd, PF *, void *));
-extern int comm_udp_send _PARAMS((int fd, const char *host, u_short port, const char *buf, int len));
-extern int comm_udp_sendto _PARAMS((int fd, const struct sockaddr_in *, int size, const char *buf, int len));
-extern void comm_write _PARAMS((int fd,
+extern void commSetSelect(int, unsigned int, PF *, void *, time_t);
+extern void comm_add_close_handler(int fd, PF *, void *);
+extern void comm_remove_close_handler(int fd, PF *, void *);
+extern int comm_udp_send(int fd, const char *host, u_short port, const char *buf, int len);
+extern int comm_udp_sendto(int fd, const struct sockaddr_in *, int size, const char *buf, int len);
+extern void comm_write(int fd,
char *buf,
int size,
CWCB * handler,
void *handler_data,
- FREE *));
-extern void commCallCloseHandlers _PARAMS((int fd));
-extern int commSetTimeout _PARAMS((int fd, int, PF *, void *));
+ FREE *);
+extern void commCallCloseHandlers(int fd);
+extern int commSetTimeout(int fd, int, PF *, void *);
extern void commSetDefer(int fd, DEFER * func, void *);
-extern void _db_init _PARAMS((const char *logfile, const char *options));
-extern void _db_rotate_log _PARAMS((void));
+extern void _db_init(const char *logfile, const char *options);
+extern void _db_rotate_log(void);
#ifdef __STDC__
-extern void _db_print _PARAMS((const char *,...));
+extern void _db_print(const char *,...);
#else
-extern void _db_print _PARAMS(());
+extern void _db_print();
#endif
-extern int file_open _PARAMS((const char *path, int mode, FOCB *, void *callback_data));
-extern void file_close _PARAMS((int fd));
-extern int file_write _PARAMS((int fd,
+extern int file_open(const char *path, int mode, FOCB *, void *callback_data);
+extern void file_close(int fd);
+extern int file_write(int fd,
char *buf,
int len,
DWCB * handle,
void *handle_data,
- FREE *));
-extern int file_read _PARAMS((int fd,
+ FREE *);
+extern int file_read(int fd,
char *buf,
int req_len,
int offset,
DRCB * handler,
- void *client_data));
-extern int file_walk _PARAMS((int fd, FILE_WALK_HD *, void *, FILE_WALK_LHD *, void *));
-extern int disk_init _PARAMS((void));
-extern int diskWriteIsComplete _PARAMS((int));
-
-extern void dnsShutdownServers _PARAMS((void));
-extern void dnsOpenServers _PARAMS((void));
-extern dnsserver_t *dnsGetFirstAvailable _PARAMS((void));
-extern void dnsStats _PARAMS((StoreEntry *));
-extern void dnsFreeMemory _PARAMS((void));
-
-extern char *squid_error_url _PARAMS((const char *, int, int, const char *, int, const char *));
-extern char *squid_error_request _PARAMS((const char *, int, int));
-extern char *access_denied_msg _PARAMS((int, int, const char *, const char *));
-extern char *access_denied_redirect _PARAMS((int, int, const char *, const char *, const char *));
+ void *client_data);
+extern int file_walk(int fd, FILE_WALK_HD *, void *, FILE_WALK_LHD *, void *);
+extern int disk_init(void);
+extern int diskWriteIsComplete(int);
+
+extern void dnsShutdownServers(void);
+extern void dnsOpenServers(void);
+extern dnsserver_t *dnsGetFirstAvailable(void);
+extern void dnsStats(StoreEntry *);
+extern void dnsFreeMemory(void);
+
+extern char *squid_error_url(const char *, int, int, const char *, int, const char *);
+extern char *squid_error_request(const char *, int, int);
+extern char *access_denied_msg(int, int, const char *, const char *);
+extern char *access_denied_redirect(int, int, const char *, const char *, const char *);
#if USE_PROXY_AUTH
-extern char *proxy_denied_msg _PARAMS((int, int, const char *, const char *));
+extern char *proxy_denied_msg(int, int, const char *, const char *);
#endif /* USE_PROXY_AUTH */
-extern char *authorization_needed_msg _PARAMS((const request_t *, const char *));
-extern void errorpageFreeMemory _PARAMS((void));
+extern char *authorization_needed_msg(const request_t *, const char *);
+extern void errorpageFreeMemory(void);
-extern void eventAdd _PARAMS((const char *name,
- EVH * func,
- void *arg,
- time_t when));
-extern void eventRun _PARAMS((void));
-extern time_t eventNextTime _PARAMS((void));
-extern void eventDelete _PARAMS((EVH * func, void *arg));
+extern void eventAdd(const char *name, EVH * func, void *arg, time_t when);
+extern void eventRun(void);
+extern time_t eventNextTime(void);
+extern void eventDelete(EVH * func, void *arg);
-extern void fd_close _PARAMS((int fd));
-extern void fd_open _PARAMS((int fd, unsigned int type, const char *));
-extern void fd_note _PARAMS((int fd, const char *));
-extern void fd_bytes _PARAMS((int fd, int len, unsigned int type));
-extern void fdFreeMemory _PARAMS((void));
-extern void fdDumpOpen _PARAMS((void));
+extern void fd_close(int fd);
+extern void fd_open(int fd, unsigned int type, const char *);
+extern void fd_note(int fd, const char *);
+extern void fd_bytes(int fd, int len, unsigned int type);
+extern void fdFreeMemory(void);
+extern void fdDumpOpen(void);
-extern void fdstat_init _PARAMS((void));
-extern int fdstat_are_n_free_fd _PARAMS((int));
+extern void fdstat_init(void);
+extern int fdstat_are_n_free_fd(int);
-extern fileMap *file_map_create _PARAMS((int));
-extern int file_map_allocate _PARAMS((fileMap *, int));
-extern int file_map_bit_set _PARAMS((fileMap *, int));
-extern int file_map_bit_test _PARAMS((fileMap *, int));
-extern void file_map_bit_reset _PARAMS((fileMap *, int));
-extern void filemapFreeMemory _PARAMS((fileMap *));
+extern fileMap *file_map_create(int);
+extern int file_map_allocate(fileMap *, int);
+extern int file_map_bit_set(fileMap *, int);
+extern int file_map_bit_test(fileMap *, int);
+extern void file_map_bit_reset(fileMap *, int);
+extern void filemapFreeMemory(fileMap *);
-extern void fqdncache_nbgethostbyaddr _PARAMS((struct in_addr, FQDNH *, void *));
-extern int fqdncacheUnregister _PARAMS((struct in_addr, void *));
-extern const char *fqdncache_gethostbyaddr _PARAMS((struct in_addr, int flags));
-extern void fqdncache_init _PARAMS((void));
-extern void fqdnStats _PARAMS((StoreEntry *));
-extern void fqdncacheReleaseInvalid _PARAMS((const char *));
-extern const char *fqdnFromAddr _PARAMS((struct in_addr));
-extern int fqdncacheQueueDrain _PARAMS((void));
-extern void fqdncacheFreeMemory _PARAMS((void));
-extern void fqdncache_restart _PARAMS((void));
+extern void fqdncache_nbgethostbyaddr(struct in_addr, FQDNH *, void *);
+extern int fqdncacheUnregister(struct in_addr, void *);
+extern const char *fqdncache_gethostbyaddr(struct in_addr, int flags);
+extern void fqdncache_init(void);
+extern void fqdnStats(StoreEntry *);
+extern void fqdncacheReleaseInvalid(const char *);
+extern const char *fqdnFromAddr(struct in_addr);
+extern int fqdncacheQueueDrain(void);
+extern void fqdncacheFreeMemory(void);
+extern void fqdncache_restart(void);
-extern void ftpStart _PARAMS((request_t * req, StoreEntry * entry));
+extern void ftpStart(request_t * req, StoreEntry * entry);
-extern void gopherStart _PARAMS((StoreEntry *));
-extern int gopherCachable _PARAMS((const char *));
+extern void gopherStart(StoreEntry *);
+extern int gopherCachable(const char *);
/* init */
-extern hash_table *hash_create _PARAMS((HASHCMP *, int, HASHHASH *));
-extern int hash_insert _PARAMS((hash_table *, const char *, void *));
-extern int hash_delete _PARAMS((hash_table *, const char *));
-extern int hash_delete_link _PARAMS((hash_table *, hash_link *));
-extern int hash_join _PARAMS((hash_table *, hash_link *));
-extern int hash_remove_link _PARAMS((hash_table *, hash_link *));
+extern hash_table *hash_create(HASHCMP *, int, HASHHASH *);
+extern int hash_insert(hash_table *, const char *, void *);
+extern int hash_delete(hash_table *, const char *);
+extern int hash_delete_link(hash_table *, hash_link *);
+extern int hash_join(hash_table *, hash_link *);
+extern int hash_remove_link(hash_table *, hash_link *);
/* searching, accessing */
-extern hash_link *hash_lookup _PARAMS((hash_table *, const char *));
-extern hash_link *hash_first _PARAMS((hash_table *));
-extern hash_link *hash_next _PARAMS((hash_table *));
-extern hash_link *hash_get_bucket _PARAMS((hash_table *, unsigned int));
-extern void hashFreeMemory _PARAMS((hash_table *));
+extern hash_link *hash_lookup(hash_table *, const char *);
+extern hash_link *hash_first(hash_table *);
+extern hash_link *hash_next(hash_table *);
+extern hash_link *hash_get_bucket(hash_table *, unsigned int);
+extern void hashFreeMemory(hash_table *);
extern HASHHASH hash_string;
extern HASHHASH hash_url;
extern HASHHASH hash4;
-extern int httpCachable _PARAMS((method_t));
-extern void httpStart _PARAMS((request_t *, StoreEntry *, peer *));
-extern void httpParseReplyHeaders _PARAMS((const char *, struct _http_reply *));
-extern void httpProcessReplyHeader _PARAMS((HttpStateData *, const char *, int));
-extern void httpReplyHeaderStats _PARAMS((StoreEntry *));
-extern size_t httpBuildRequestHeader _PARAMS((request_t * request,
+extern int httpCachable(method_t);
+extern void httpStart(request_t *, StoreEntry *, peer *);
+extern void httpParseReplyHeaders(const char *, struct _http_reply *);
+extern void httpProcessReplyHeader(HttpStateData *, const char *, int);
+extern void httpReplyHeaderStats(StoreEntry *);
+extern size_t httpBuildRequestHeader(request_t * request,
request_t * orig_request,
StoreEntry * entry,
size_t * in_len,
char *hdr_out,
size_t out_sz,
int cfd,
- int flags));
-extern int httpAnonAllowed _PARAMS((const char *line));
-extern int httpAnonDenied _PARAMS((const char *line));
-extern char *httpReplyHeader _PARAMS((double ver,
+ int flags);
+extern int httpAnonAllowed(const char *line);
+extern int httpAnonDenied(const char *line);
+extern char *httpReplyHeader(double ver,
http_status status,
char *ctype,
int clen,
time_t lmt,
- time_t expires));
+ time_t expires);
-extern void icmpOpen _PARAMS((void));
-extern void icmpClose _PARAMS((void));
-extern void icmpPing _PARAMS((struct in_addr to));
-extern void icmpSourcePing _PARAMS((struct in_addr to, const icp_common_t *, const char *url));
-extern void icmpDomainPing _PARAMS((struct in_addr to, const char *domain));
+extern void icmpOpen(void);
+extern void icmpClose(void);
+extern void icmpPing(struct in_addr to);
+extern void icmpSourcePing(struct in_addr to, const icp_common_t *, const char *url);
+extern void icmpDomainPing(struct in_addr to, const char *domain);
-extern void *icpCreateMessage _PARAMS((icp_opcode opcode,
+extern void *icpCreateMessage(icp_opcode opcode,
int flags,
const char *url,
int reqnum,
- int pad));
-extern void icpUdpSend _PARAMS((int fd,
+ int pad);
+extern void icpUdpSend(int fd,
const struct sockaddr_in *,
icp_common_t * msg,
log_type,
- protocol_t));
+ protocol_t);
extern PF icpHandleUdp;
extern PF httpAccept;
extern DEFER httpAcceptDefer;
#ifdef SQUID_SNMP
extern PF snmpAccept;
#endif /* SQUID_SNMP */
-extern void icpSendERROR _PARAMS((int fd,
+extern void icpSendERROR(int fd,
log_type errorCode,
const char *text,
clientHttpRequest *,
- int httpCode));
-extern void AppendUdp _PARAMS((icpUdpData *));
-extern void icpParseRequestHeaders _PARAMS((clientHttpRequest *));
-extern void icpProcessRequest _PARAMS((int, clientHttpRequest *));
+ int httpCode);
+extern void AppendUdp(icpUdpData *);
+extern void icpParseRequestHeaders(clientHttpRequest *);
+extern void icpProcessRequest(int, clientHttpRequest *);
extern PF icpUdpReply;
extern ERCB icpErrorComplete;
extern STCB icpSendMoreData;
extern STCB clientCacheHit;
-extern void ipcache_nbgethostbyname _PARAMS((const char *name,
+extern void ipcache_nbgethostbyname(const char *name,
IPH * handler,
- void *handlerData));
+ void *handlerData);
extern EVH ipcache_purgelru;
-extern const ipcache_addrs *ipcache_gethostbyname _PARAMS((const char *, int flags));
-extern void ipcacheInvalidate _PARAMS((const char *));
-extern void ipcacheReleaseInvalid _PARAMS((const char *));
-extern void ipcacheShutdownServers _PARAMS((void));
-extern void ipcache_init _PARAMS((void));
-extern void stat_ipcache_get _PARAMS((StoreEntry *));
-extern int ipcacheQueueDrain _PARAMS((void));
-extern void ipcacheCycleAddr _PARAMS((const char *name));
-extern void ipcacheRemoveBadAddr _PARAMS((const char *name, struct in_addr));
-extern void ipcacheFreeMemory _PARAMS((void));
-extern ipcache_addrs *ipcacheCheckNumeric _PARAMS((const char *name));
-extern void ipcache_restart _PARAMS((void));
-extern int ipcacheUnregister _PARAMS((const char *name, void *data));
-
-extern char *mime_get_header _PARAMS((const char *mime, const char *header));
-extern char *mime_headers_end _PARAMS((const char *mime));
-extern int mk_mime_hdr _PARAMS((char *result, const char *type, int size, time_t ttl, time_t lmt));
-extern void mimeInit _PARAMS((char *filename));
-extern char *mimeGetContentEncoding _PARAMS((const char *fn));
-extern char *mimeGetContentType _PARAMS((const char *fn));
-extern char *mimeGetIcon _PARAMS((const char *fn));
-extern char mimeGetTransferMode _PARAMS((const char *fn));
-
-extern int mcastSetTtl _PARAMS((int, int));
+extern const ipcache_addrs *ipcache_gethostbyname(const char *, int flags);
+extern void ipcacheInvalidate(const char *);
+extern void ipcacheReleaseInvalid(const char *);
+extern void ipcacheShutdownServers(void);
+extern void ipcache_init(void);
+extern void stat_ipcache_get(StoreEntry *);
+extern int ipcacheQueueDrain(void);
+extern void ipcacheCycleAddr(const char *name);
+extern void ipcacheRemoveBadAddr(const char *name, struct in_addr);
+extern void ipcacheFreeMemory(void);
+extern ipcache_addrs *ipcacheCheckNumeric(const char *name);
+extern void ipcache_restart(void);
+extern int ipcacheUnregister(const char *name, void *data);
+
+extern char *mime_get_header(const char *mime, const char *header);
+extern char *mime_headers_end(const char *mime);
+extern int mk_mime_hdr(char *result, const char *type, int size, time_t ttl, time_t lmt);
+extern void mimeInit(char *filename);
+extern char *mimeGetContentEncoding(const char *fn);
+extern char *mimeGetContentType(const char *fn);
+extern char *mimeGetIcon(const char *fn);
+extern char mimeGetTransferMode(const char *fn);
+
+extern int mcastSetTtl(int, int);
extern IPH mcastJoinGroups;
/* Labels for hierachical log file */
/* put them all here for easier reference when writing a logfile analyzer */
-extern peer *getFirstPeer _PARAMS((void));
-extern peer *getFirstUpParent _PARAMS((request_t *));
-extern peer *getNextPeer _PARAMS((peer *));
-extern peer *getSingleParent _PARAMS((request_t *));
-extern int neighborsCount _PARAMS((request_t *));
-extern int neighborsUdpPing _PARAMS((request_t *,
+extern peer *getFirstPeer(void);
+extern peer *getFirstUpParent(request_t *);
+extern peer *getNextPeer(peer *);
+extern peer *getSingleParent(request_t *);
+extern int neighborsCount(request_t *);
+extern int neighborsUdpPing(request_t *,
StoreEntry *,
IRCB * callback,
void *data,
- int *exprep));
-extern void neighborAddAcl _PARAMS((const char *, const char *));
-extern void neighborsUdpAck _PARAMS((int, const char *, icp_common_t *, const struct sockaddr_in *, StoreEntry *, char *, int));
-extern void neighborAdd _PARAMS((const char *, const char *, int, int, int, int, int));
-extern void neighbors_open _PARAMS((int));
-extern peer *peerFindByName _PARAMS((const char *));
-extern peer *getDefaultParent _PARAMS((request_t * request));
-extern peer *getRoundRobinParent _PARAMS((request_t * request));
-extern int neighborUp _PARAMS((const peer * e));
-extern void peerDestroy _PARAMS((peer * e));
-extern char *neighborTypeStr _PARAMS((const peer * e));
-extern void peerCheckConnectStart _PARAMS((peer *));
-
-extern void netdbHandlePingReply _PARAMS((const struct sockaddr_in * from, int hops, int rtt));
-extern void netdbPingSite _PARAMS((const char *hostname));
-extern void netdbInit _PARAMS((void));
-extern void netdbDump _PARAMS((StoreEntry *));
-extern int netdbHops _PARAMS((struct in_addr));
-extern void netdbFreeMemory _PARAMS((void));
-extern int netdbHostHops _PARAMS((const char *host));
-extern int netdbHostRtt _PARAMS((const char *host));
-extern void netdbUpdatePeer _PARAMS((request_t *, peer * e, int rtt, int hops));
-
-extern void objcachePasswdAdd _PARAMS((cachemgr_passwd **, char *, wordlist *));
-extern void objcachePasswdDestroy _PARAMS((cachemgr_passwd ** a));
-extern void objcacheStart _PARAMS((int fd, StoreEntry *));
-extern void objcacheInit _PARAMS((void));
-
-extern void peerSelect _PARAMS((request_t *, StoreEntry *, PSC *, PSC *, void *data));
-extern peer *peerGetSomeParent _PARAMS((request_t *, hier_code *));
-extern void peerSelectInit _PARAMS((void));
-
-extern void protoDispatch _PARAMS((int, StoreEntry *, request_t *));
-
-extern int protoUnregister _PARAMS((StoreEntry *, request_t *, struct in_addr));
-extern void protoStart _PARAMS((int, StoreEntry *, peer *, request_t *));
-extern int protoAbortFetch _PARAMS((StoreEntry * entry));
+ int *exprep);
+extern void neighborAddAcl(const char *, const char *);
+extern void neighborsUdpAck(int, const char *, icp_common_t *, const struct sockaddr_in *, StoreEntry *, char *, int);
+extern void neighborAdd(const char *, const char *, int, int, int, int, int);
+extern void neighbors_open(int);
+extern peer *peerFindByName(const char *);
+extern peer *getDefaultParent(request_t * request);
+extern peer *getRoundRobinParent(request_t * request);
+extern int neighborUp(const peer * e);
+extern void peerDestroy(peer * e);
+extern char *neighborTypeStr(const peer * e);
+extern void peerCheckConnectStart(peer *);
+
+extern void netdbHandlePingReply(const struct sockaddr_in * from, int hops, int rtt);
+extern void netdbPingSite(const char *hostname);
+extern void netdbInit(void);
+extern void netdbDump(StoreEntry *);
+extern int netdbHops(struct in_addr);
+extern void netdbFreeMemory(void);
+extern int netdbHostHops(const char *host);
+extern int netdbHostRtt(const char *host);
+extern void netdbUpdatePeer(request_t *, peer * e, int rtt, int hops);
+
+extern void objcachePasswdAdd(cachemgr_passwd **, char *, wordlist *);
+extern void objcachePasswdDestroy(cachemgr_passwd ** a);
+extern void objcacheStart(int fd, StoreEntry *);
+extern void objcacheInit(void);
+
+extern void peerSelect(request_t *, StoreEntry *, PSC *, PSC *, void *data);
+extern peer *peerGetSomeParent(request_t *, hier_code *);
+extern void peerSelectInit(void);
+
+extern void protoDispatch(int, StoreEntry *, request_t *);
+
+extern int protoUnregister(StoreEntry *, request_t *, struct in_addr);
+extern void protoStart(int, StoreEntry *, peer *, request_t *);
+extern int protoAbortFetch(StoreEntry * entry);
extern DEFER protoCheckDeferRead;
-extern void redirectStart _PARAMS((clientHttpRequest *, RH *, void *));
-extern void redirectOpenServers _PARAMS((void));
-extern void redirectShutdownServers _PARAMS((void));
-extern void redirectStats _PARAMS((StoreEntry *));
-extern int redirectUnregister _PARAMS((const char *url, void *));
-extern void redirectFreeMemory _PARAMS((void));
+extern void redirectStart(clientHttpRequest *, RH *, void *);
+extern void redirectOpenServers(void);
+extern void redirectShutdownServers(void);
+extern void redirectStats(StoreEntry *);
+extern int redirectUnregister(const char *url, void *);
+extern void redirectFreeMemory(void);
-extern void refreshAddToList _PARAMS((const char *, int, time_t, int, time_t));
-extern int refreshCheck _PARAMS((const StoreEntry *, const request_t *, time_t delta));
-extern time_t getMaxAge _PARAMS((const char *url));
+extern void refreshAddToList(const char *, int, time_t, int, time_t);
+extern int refreshCheck(const StoreEntry *, const request_t *, time_t delta);
+extern time_t getMaxAge(const char *url);
-extern void serverConnectionsClose _PARAMS((void));
-extern void shut_down _PARAMS((int));
+extern void serverConnectionsClose(void);
+extern void shut_down(int);
-extern void start_announce _PARAMS((void *unused));
-extern void sslStart _PARAMS((int fd, const char *, request_t *, size_t * sz));
-extern void waisStart _PARAMS((request_t *, StoreEntry *));
-extern void storeDirClean _PARAMS((void *unused));
-extern void passStart _PARAMS((int, const char *, request_t *, size_t *));
-extern void identStart _PARAMS((int, ConnStateData *, IDCB * callback));
+extern void start_announce(void *unused);
+extern void sslStart(int fd, const char *, request_t *, size_t * sz);
+extern void waisStart(request_t *, StoreEntry *);
+extern void storeDirClean(void *unused);
+extern void passStart(int, const char *, request_t *, size_t *);
+extern void identStart(int, ConnStateData *, IDCB * callback);
-extern void *pop _PARAMS((Stack *));
-extern int empty_stack _PARAMS((const Stack *));
-extern int full_stack _PARAMS((const Stack *));
-extern void push _PARAMS((Stack *, void *));
-extern void init_stack _PARAMS((Stack *, int));
-extern void stackFreeMemory _PARAMS((Stack *));
+extern void *pop(Stack *);
+extern int empty_stack(const Stack *);
+extern int full_stack(const Stack *);
+extern void push(Stack *, void *);
+extern void init_stack(Stack *, int);
+extern void stackFreeMemory(Stack *);
-extern void stat_init _PARAMS((cacheinfo **, const char *));
-extern void pconnHistCount _PARAMS((int, int));
+extern void stat_init(cacheinfo **, const char *);
+extern void pconnHistCount(int, int);
/* To reduce memory fragmentation, we now store the memory version of an
* object in fixed size blocks of size PAGE_SIZE and instead of calling
* malloc and free, we manage our own fixed block free list.
*/
-extern char *get_free_4k_page _PARAMS((void));
-extern char *get_free_8k_page _PARAMS((void));
-extern void *get_free_request_t _PARAMS((void));
-extern void *get_free_mem_obj _PARAMS((void));
-extern mem_hdr *memInit _PARAMS((void));
-extern void put_free_4k_page _PARAMS((void *));
-extern void put_free_8k_page _PARAMS((void *));
-extern void put_free_request_t _PARAMS((void *));
-extern void put_free_mem_obj _PARAMS((void *));
-extern void stmemInit _PARAMS((void));
-extern void stmemFreeMemory _PARAMS((void));
+extern char *get_free_4k_page(void);
+extern char *get_free_8k_page(void);
+extern void *get_free_request_t(void);
+extern void *get_free_mem_obj(void);
+extern mem_hdr *memInit(void);
+extern void put_free_4k_page(void *);
+extern void put_free_8k_page(void *);
+extern void put_free_request_t(void *);
+extern void put_free_mem_obj(void *);
+extern void stmemInit(void);
+extern void stmemFreeMemory(void);
-extern int memFreeDataUpto _PARAMS((mem_hdr *, int));
-extern void memAppend _PARAMS((mem_hdr *, const char *, int));
-extern ssize_t memCopy _PARAMS((const mem_hdr *, off_t, char *, size_t));
-extern void memFree _PARAMS((mem_hdr *));
-extern void memFreeData _PARAMS((mem_hdr *));
+extern int memFreeDataUpto(mem_hdr *, int);
+extern void memAppend(mem_hdr *, const char *, int);
+extern ssize_t memCopy(const mem_hdr *, off_t, char *, size_t);
+extern void memFree(mem_hdr *);
+extern void memFreeData(mem_hdr *);
/* ----------------------------------------------------------------- */
-extern StoreEntry *storeGet _PARAMS((const char *));
-extern StoreEntry *storeCreateEntry _PARAMS((const char *, const char *, int, method_t));
-extern void storeSetPublicKey _PARAMS((StoreEntry *));
-extern StoreEntry *storeGetFirst _PARAMS((void));
-extern StoreEntry *storeGetNext _PARAMS((void));
-extern void storeComplete _PARAMS((StoreEntry *));
-extern void storeInit _PARAMS((void));
-extern int storeClientWaiting _PARAMS((const StoreEntry *));
-extern void storeAbort _PARAMS((StoreEntry *, int));
-extern void storeAppend _PARAMS((StoreEntry *, const char *, int));
-extern void storeGetSwapSpace _PARAMS((int));
-extern void storeLockObject _PARAMS((StoreEntry *));
-extern void storeSwapInStart _PARAMS((StoreEntry *, SIH *, void *data));
-extern int storeRelease _PARAMS((StoreEntry *));
-extern int storeUnlockObject _PARAMS((StoreEntry *));
-extern int storeUnregister _PARAMS((StoreEntry *, void *));
-extern const char *storeGeneratePublicKey _PARAMS((const char *, method_t));
-extern const char *storeGeneratePrivateKey _PARAMS((const char *, method_t, int));
-extern void storeClientCopy _PARAMS((StoreEntry * e,
+extern StoreEntry *storeGet(const char *);
+extern StoreEntry *storeCreateEntry(const char *, const char *, int, method_t);
+extern void storeSetPublicKey(StoreEntry *);
+extern StoreEntry *storeGetFirst(void);
+extern StoreEntry *storeGetNext(void);
+extern void storeComplete(StoreEntry *);
+extern void storeInit(void);
+extern int storeClientWaiting(const StoreEntry *);
+extern void storeAbort(StoreEntry *, int);
+extern void storeAppend(StoreEntry *, const char *, int);
+extern void storeGetSwapSpace(int);
+extern void storeLockObject(StoreEntry *);
+extern void storeSwapInStart(StoreEntry *, SIH *, void *data);
+extern int storeRelease(StoreEntry *);
+extern int storeUnlockObject(StoreEntry *);
+extern int storeUnregister(StoreEntry *, void *);
+extern const char *storeGeneratePublicKey(const char *, method_t);
+extern const char *storeGeneratePrivateKey(const char *, method_t, int);
+extern void storeClientCopy(StoreEntry * e,
off_t seen_offset,
off_t copy_offset,
size_t size,
char *buf,
STCB * callback,
- void *data));
-extern int storePendingNClients _PARAMS((const StoreEntry *));
-extern int storeWriteCleanLogs _PARAMS((int reopen));
+ void *data);
+extern int storePendingNClients(const StoreEntry *);
+extern int storeWriteCleanLogs(int reopen);
extern HASHCMP urlcmp;
extern EVH storeMaintainSwapSpace;
-extern void storeExpireNow _PARAMS((StoreEntry *));
-extern void storeReleaseRequest _PARAMS((StoreEntry *));
-extern void storeRotateLog _PARAMS((void));
-extern off_t storeLowestMemReaderOffset _PARAMS((const StoreEntry *));
-extern void storeCloseLog _PARAMS((void));
-extern void storeConfigure _PARAMS((void));
-extern void storeNegativeCache _PARAMS((StoreEntry *));
-extern void storeFreeMemory _PARAMS((void));
-extern int expiresMoreThan _PARAMS((time_t, time_t));
-extern void storeClientListAdd _PARAMS((StoreEntry *, void *));
-extern void InvokeHandlers _PARAMS((const StoreEntry *));
-extern int storeEntryValidToSend _PARAMS((StoreEntry *));
-extern void storeTimestampsSet _PARAMS((StoreEntry *));
-extern unsigned int storeReqnum _PARAMS((StoreEntry * entry, method_t));
-extern time_t storeExpiredReferenceAge _PARAMS((void));
-extern void storeRegisterAbort _PARAMS((StoreEntry * e, STABH * cb, void *));
-extern void storeUnregisterAbort _PARAMS((StoreEntry * e));
-extern void storeMemObjectDump _PARAMS((MemObject * mem));
+extern void storeExpireNow(StoreEntry *);
+extern void storeReleaseRequest(StoreEntry *);
+extern void storeRotateLog(void);
+extern off_t storeLowestMemReaderOffset(const StoreEntry *);
+extern void storeCloseLog(void);
+extern void storeConfigure(void);
+extern void storeNegativeCache(StoreEntry *);
+extern void storeFreeMemory(void);
+extern int expiresMoreThan(time_t, time_t);
+extern void storeClientListAdd(StoreEntry *, void *);
+extern void InvokeHandlers(const StoreEntry *);
+extern int storeEntryValidToSend(StoreEntry *);
+extern void storeTimestampsSet(StoreEntry *);
+extern unsigned int storeReqnum(StoreEntry * entry, method_t);
+extern time_t storeExpiredReferenceAge(void);
+extern void storeRegisterAbort(StoreEntry * e, STABH * cb, void *);
+extern void storeUnregisterAbort(StoreEntry * e);
+extern void storeMemObjectDump(MemObject * mem);
#ifdef __STDC__
-extern void storeAppendPrintf _PARAMS((StoreEntry *, const char *,...));
+extern void storeAppendPrintf(StoreEntry *, const char *,...);
#else
-extern void storeAppendPrintf _PARAMS(());
+extern void storeAppendPrintf();
#endif
-extern char *storeSwapFullPath _PARAMS((int, char *));
-extern char *storeSwapSubSubDir _PARAMS((int, char *));
-extern int storeVerifySwapDirs _PARAMS((void));
-extern void storeCreateSwapSubDirs _PARAMS((int));
-extern const char *storeSwapPath _PARAMS((int));
-extern int storeDirMapBitTest _PARAMS((int fn));
-extern void storeDirMapBitSet _PARAMS((int fn));
-extern void storeDirMapBitReset _PARAMS((int fn));
-extern int storeDirMapAllocate _PARAMS((void));
-extern char *storeSwapDir _PARAMS((int));
-extern FILE *storeDirOpenTmpSwapLog _PARAMS((int dirn, int *clean_flag));
-extern void storeDirCloseTmpSwapLog _PARAMS((int dirn));
-extern void storeDirOpenSwapLogs _PARAMS((void));
-extern void storeDirCloseSwapLogs _PARAMS((void));
-extern char *storeDirSwapLogFile _PARAMS((int, const char *));
-extern void storeDirSwapLog _PARAMS((const StoreEntry *));
-extern int storeDirNumber _PARAMS((int fileno));
-extern void storeDirUpdateSwapSize _PARAMS((int fn, size_t size, int sign));
-extern int storeDirProperFileno _PARAMS((int dirn, int fn));
-
-
-extern const char *getMyHostname _PARAMS((void));
-extern void safeunlink _PARAMS((const char *path, int quiet));
-extern void death _PARAMS((int sig));
-extern void fatal _PARAMS((const char *message));
-extern void fatal_dump _PARAMS((const char *message));
-extern void sigusr2_handle _PARAMS((int sig));
-extern void sig_child _PARAMS((int sig));
-extern void leave_suid _PARAMS((void));
-extern void enter_suid _PARAMS((void));
-extern void no_suid _PARAMS((void));
-extern void writePidFile _PARAMS((void));
-extern void setSocketShutdownLifetimes _PARAMS((int));
-extern void setMaxFD _PARAMS((void));
-extern time_t getCurrentTime _PARAMS((void));
-extern void normal_shutdown _PARAMS((void));
-extern int percent _PARAMS((int, int));
-extern void squid_signal _PARAMS((int sig, void (*func) _PARAMS((int)), int flags));
-extern pid_t readPidFile _PARAMS((void));
-extern struct in_addr inaddrFromHostent _PARAMS((const struct hostent * hp));
-extern int intAverage _PARAMS((int, int, int, int));
-extern double doubleAverage _PARAMS((double, double, int, int));
-extern void debug_trap _PARAMS((const char *));
-extern void logsFlush _PARAMS((void));
-extern char *checkNullString _PARAMS((char *p));
-
-extern void unlinkdInit _PARAMS((void));
-extern void unlinkdClose _PARAMS((void));
-extern void unlinkdUnlink _PARAMS((const char *));
-
-extern char *url_convert_hex _PARAMS((char *org_url, int allocate));
-extern char *url_escape _PARAMS((const char *url));
-extern protocol_t urlParseProtocol _PARAMS((const char *));
-extern method_t urlParseMethod _PARAMS((const char *));
-extern void urlInitialize _PARAMS((void));
-extern request_t *urlParse _PARAMS((method_t, char *));
-extern char *urlCanonical _PARAMS((const request_t *, char *));
-extern request_t *requestLink _PARAMS((request_t *));
-extern void requestUnlink _PARAMS((request_t *));
-extern int matchDomainName _PARAMS((const char *d, const char *h));
-extern int urlCheckRequest _PARAMS((const request_t *));
-extern int urlDefaultPort _PARAMS((protocol_t p));
-extern char *urlClean _PARAMS((char *));
-extern char *urlCanonicalClean _PARAMS((const request_t *));
-
-
-extern void useragentOpenLog _PARAMS((void));
-extern void useragentRotateLog _PARAMS((void));
-extern void logUserAgent _PARAMS((const char *, const char *));
-extern peer_t parseNeighborType _PARAMS((const char *s));
-
-extern void errorSend _PARAMS((int fd, ErrorState *));
-extern void errorAppendEntry _PARAMS((StoreEntry *, ErrorState *));
-extern void errorInitialize _PARAMS((void));
+extern char *storeSwapFullPath(int, char *);
+extern char *storeSwapSubSubDir(int, char *);
+extern int storeVerifySwapDirs(void);
+extern void storeCreateSwapSubDirs(int);
+extern const char *storeSwapPath(int);
+extern int storeDirMapBitTest(int fn);
+extern void storeDirMapBitSet(int fn);
+extern void storeDirMapBitReset(int fn);
+extern int storeDirMapAllocate(void);
+extern char *storeSwapDir(int);
+extern FILE *storeDirOpenTmpSwapLog(int dirn, int *clean_flag);
+extern void storeDirCloseTmpSwapLog(int dirn);
+extern void storeDirOpenSwapLogs(void);
+extern void storeDirCloseSwapLogs(void);
+extern char *storeDirSwapLogFile(int, const char *);
+extern void storeDirSwapLog(const StoreEntry *);
+extern int storeDirNumber(int fileno);
+extern void storeDirUpdateSwapSize(int fn, size_t size, int sign);
+extern int storeDirProperFileno(int dirn, int fn);
+
+
+extern const char *getMyHostname(void);
+extern void safeunlink(const char *path, int quiet);
+extern void death(int sig);
+extern void fatal(const char *message);
+extern void fatal_dump(const char *message);
+extern void sigusr2_handle(int sig);
+extern void sig_child(int sig);
+extern void leave_suid(void);
+extern void enter_suid(void);
+extern void no_suid(void);
+extern void writePidFile(void);
+extern void setSocketShutdownLifetimes(int);
+extern void setMaxFD(void);
+extern time_t getCurrentTime(void);
+extern void normal_shutdown(void);
+extern int percent(int, int);
+extern void squid_signal(int sig, SIGHDLR *, int flags);
+extern pid_t readPidFile(void);
+extern struct in_addr inaddrFromHostent(const struct hostent * hp);
+extern int intAverage(int, int, int, int);
+extern double doubleAverage(double, double, int, int);
+extern void debug_trap(const char *);
+extern void logsFlush(void);
+extern char *checkNullString(char *p);
+
+extern void unlinkdInit(void);
+extern void unlinkdClose(void);
+extern void unlinkdUnlink(const char *);
+
+extern char *url_convert_hex(char *org_url, int allocate);
+extern char *url_escape(const char *url);
+extern protocol_t urlParseProtocol(const char *);
+extern method_t urlParseMethod(const char *);
+extern void urlInitialize(void);
+extern request_t *urlParse(method_t, char *);
+extern char *urlCanonical(const request_t *, char *);
+extern request_t *requestLink(request_t *);
+extern void requestUnlink(request_t *);
+extern int matchDomainName(const char *d, const char *h);
+extern int urlCheckRequest(const request_t *);
+extern int urlDefaultPort(protocol_t p);
+extern char *urlClean(char *);
+extern char *urlCanonicalClean(const request_t *);
+
+
+extern void useragentOpenLog(void);
+extern void useragentRotateLog(void);
+extern void logUserAgent(const char *, const char *);
+extern peer_t parseNeighborType(const char *s);
+
+extern void errorSend(int fd, ErrorState *);
+extern void errorAppendEntry(StoreEntry *, ErrorState *);
+extern void errorInitialize(void);
extern OBJH stat_io_get;
extern OBJH stat_objects_get;
extern OBJH dump_config;
extern OBJH storeDirStats;
extern OBJH pconnHistDump;
-extern void dump_peers _PARAMS((StoreEntry * sentry, peer * peers));
+extern void dump_peers(StoreEntry * sentry, peer * peers);
-extern void pconnPush _PARAMS((int, const char *host, u_short port));
-extern int pconnPop _PARAMS((const char *host, u_short port));
-extern void pconnInit _PARAMS((void));
+extern void pconnPush(int, const char *host, u_short port);
+extern int pconnPop(const char *host, u_short port);
+extern void pconnInit(void);
/*
- * $Id: recv-announce.cc,v 1.13 1997/10/24 04:55:35 wessels Exp $
+ * $Id: recv-announce.cc,v 1.14 1997/10/25 17:22:56 wessels Exp $
*
* DEBUG: section 0 Announcement Server
* AUTHOR: Harvest Derived
#include <unistd.h>
#include <signal.h>
-#include "ansiproto.h"
-
#define RECV_BUF_SIZE 8192
-extern void xmemcpy _PARAMS((void *from, void *to, int len));
+extern void xmemcpy(void *from, void *to, int len);
/*
* This program must be run from inetd. First add something like this
/*
- * $Id: redirect.cc,v 1.47 1997/10/17 00:00:44 wessels Exp $
+ * $Id: redirect.cc,v 1.48 1997/10/25 17:22:57 wessels Exp $
*
* DEBUG: section 29 Redirector
* AUTHOR: Duane Wessels
redirectStateData *redirectState;
};
-static redirector_t *GetFirstAvailable _PARAMS((void));
-static int redirectCreateRedirector _PARAMS((const char *command));
+static redirector_t *GetFirstAvailable(void);
+static int redirectCreateRedirector(const char *command);
static PF redirectHandleRead;
-static redirectStateData *Dequeue _PARAMS((void));
-static void Enqueue _PARAMS((redirectStateData *));
-static void redirectDispatch _PARAMS((redirector_t *, redirectStateData *));
-static void redirectStateFree _PARAMS((redirectStateData * r));
+static redirectStateData *Dequeue(void);
+static void Enqueue(redirectStateData *);
+static void redirectDispatch(redirector_t *, redirectStateData *);
+static void redirectStateFree(redirectStateData * r);
static redirector_t **redirect_child_table = NULL;
static int NRedirectors = 0;
/*
- * $Id: squid.h,v 1.131 1997/10/24 04:55:56 wessels Exp $
+ * $Id: squid.h,v 1.132 1997/10/25 17:22:57 wessels Exp $
*
* AUTHOR: Duane Wessels
*
#define LOCAL_ARRAY(type,name,size) static type name[size]
#endif
-#include "ansiproto.h"
-
#ifdef USE_GNUREGEX
#include "GNUregex.h"
#elif HAVE_REGEX_H
/*
- * $Id: ssl.cc,v 1.64 1997/10/24 18:10:40 wessels Exp $
+ * $Id: ssl.cc,v 1.65 1997/10/25 17:22:58 wessels Exp $
*
* DEBUG: section 26 Secure Sockets Layer Proxy
* AUTHOR: Duane Wessels
static const char *const conn_established = "HTTP/1.0 200 Connection established\r\n\r\n";
static PF sslTimeout;
-static void sslReadServer _PARAMS((int fd, void *));
-static void sslReadClient _PARAMS((int fd, void *));
-static void sslWriteServer _PARAMS((int fd, void *));
-static void sslWriteClient _PARAMS((int fd, void *));
-static void sslConnected _PARAMS((int fd, void *));
-static void sslProxyConnected _PARAMS((int fd, void *));
+static void sslReadServer(int fd, void *);
+static void sslReadClient(int fd, void *);
+static void sslWriteServer(int fd, void *);
+static void sslWriteClient(int fd, void *);
+static void sslConnected(int fd, void *);
+static void sslProxyConnected(int fd, void *);
static ERCB sslErrorComplete;
-static void sslClose _PARAMS((SslStateData * sslState));
-static void sslClientClosed _PARAMS((int fd, void *));
+static void sslClose(SslStateData * sslState);
+static void sslClientClosed(int fd, void *);
static CNCB sslConnectDone;
-static void sslStateFree _PARAMS((int fd, void *data));
-static void sslPeerSelectComplete _PARAMS((peer * p, void *data));
-static void sslPeerSelectFail _PARAMS((peer * p, void *data));
+static void sslStateFree(int fd, void *data);
+static void sslPeerSelectComplete(peer * p, void *data);
+static void sslPeerSelectFail(peer * p, void *data);
static void
sslClose(SslStateData * sslState)
/*
- * $Id: stat.cc,v 1.161 1997/10/23 05:13:44 wessels Exp $
+ * $Id: stat.cc,v 1.162 1997/10/25 17:22:59 wessels Exp $
*
* DEBUG: section 18 Cache Manager Statistics
* AUTHOR: Harvest Derived
} squid_read_data_t;
/* LOCALS */
-static const char *describeStatuses _PARAMS((const StoreEntry *));
-static const char *describeFlags _PARAMS((const StoreEntry *));
-static const char *describeTimestamps _PARAMS((const StoreEntry *));
-static void proto_count _PARAMS((cacheinfo *, protocol_t, log_type));
-static void proto_newobject _PARAMS((cacheinfo *, protocol_t, int, int));
-static void proto_purgeobject _PARAMS((cacheinfo *, protocol_t, int));
-static void proto_touchobject _PARAMS((cacheinfo *, protocol_t, int));
-static int memoryAccounted _PARAMS((void));
+static const char *describeStatuses(const StoreEntry *);
+static const char *describeFlags(const StoreEntry *);
+static const char *describeTimestamps(const StoreEntry *);
+static void proto_count(cacheinfo *, protocol_t, log_type);
+static void proto_newobject(cacheinfo *, protocol_t, int, int);
+static void proto_purgeobject(cacheinfo *, protocol_t, int);
+static void proto_touchobject(cacheinfo *, protocol_t, int);
+static int memoryAccounted(void);
#ifdef XMALLOC_STATISTICS
-static void info_get_mallstat _PARAMS((int, int, StoreEntry *));
+static void info_get_mallstat(int, int, StoreEntry *);
#endif
#define PCONN_HIST_SZ 256
/*
- * $Id: stmem.cc,v 1.51 1997/10/23 05:13:45 wessels Exp $
+ * $Id: stmem.cc,v 1.52 1997/10/25 17:23:00 wessels Exp $
*
* DEBUG: section 19 Memory Primitives
* AUTHOR: Harvest Derived
#define USE_MEMALIGN 0
#endif
-static void *get_free_thing _PARAMS((stmem_stats *));
-static void put_free_thing _PARAMS((stmem_stats *, void *));
-static void stmemFreeThingMemory _PARAMS((stmem_stats *));
+static void *get_free_thing(stmem_stats *);
+static void put_free_thing(stmem_stats *, void *);
+static void stmemFreeThingMemory(stmem_stats *);
void
memFree(mem_hdr * mem)
/*
- * $Id: store.cc,v 1.312 1997/10/25 16:45:00 wessels Exp $
+ * $Id: store.cc,v 1.313 1997/10/25 17:23:01 wessels Exp $
*
* DEBUG: section 20 Storeage Manager
* AUTHOR: Harvest Derived
struct storeCleanList *next;
} storeCleanList;
-typedef void (VCB) _PARAMS((void *));
+typedef void (VCB)(void *);
typedef struct valid_ctrl_t {
struct stat *sb;
};
/* Static Functions */
-static void storeCreateHashTable _PARAMS((int (*)_PARAMS((const char *, const char *))));
-static int compareLastRef _PARAMS((StoreEntry **, StoreEntry **));
-static int compareBucketOrder _PARAMS((struct _bucketOrder *, struct _bucketOrder *));
-static int storeCheckExpired _PARAMS((const StoreEntry *, int flag));
-static store_client *storeClientListSearch _PARAMS((const MemObject *, void *));
-static int storeCopy _PARAMS((const StoreEntry *, off_t, size_t, char *, size_t *));
-static int storeEntryLocked _PARAMS((const StoreEntry *));
-static int storeEntryValidLength _PARAMS((const StoreEntry *));
-static void storeGetMemSpace _PARAMS((int));
-static int storeHashDelete _PARAMS((StoreEntry *));
+static void storeCreateHashTable(HASHCMP *);
+static int compareLastRef(StoreEntry **, StoreEntry **);
+static int compareBucketOrder(struct _bucketOrder *, struct _bucketOrder *);
+static int storeCheckExpired(const StoreEntry *, int flag);
+static store_client *storeClientListSearch(const MemObject *, void *);
+static int storeCopy(const StoreEntry *, off_t, size_t, char *, size_t *);
+static int storeEntryLocked(const StoreEntry *);
+static int storeEntryValidLength(const StoreEntry *);
+static void storeGetMemSpace(int);
+static int storeHashDelete(StoreEntry *);
static VCB storeSwapInValidateComplete;
-static mem_hdr *new_MemObjectData _PARAMS((void));
-static MemObject *new_MemObject _PARAMS((const char *));
-static StoreEntry *new_StoreEntry _PARAMS((int, const char *));
-static StoreEntry *storeAddDiskRestore _PARAMS((const char *,
+static mem_hdr *new_MemObjectData(void);
+static MemObject *new_MemObject(const char *);
+static StoreEntry *new_StoreEntry(int, const char *);
+static StoreEntry *storeAddDiskRestore(const char *,
int,
int,
time_t,
time_t,
u_num32,
u_num32,
- int));
-static unsigned int storeGetBucketNum _PARAMS((void));
-static void destroy_MemObject _PARAMS((MemObject *));
-static void destroy_MemObjectData _PARAMS((MemObject *));
-static void destroy_StoreEntry _PARAMS((StoreEntry *));
-static void storePurgeMem _PARAMS((StoreEntry *));
-static void storeStartRebuildFromDisk _PARAMS((void));
-static void storeSwapOutStart _PARAMS((StoreEntry * e));
+ int);
+static unsigned int storeGetBucketNum(void);
+static void destroy_MemObject(MemObject *);
+static void destroy_MemObjectData(MemObject *);
+static void destroy_StoreEntry(StoreEntry *);
+static void storePurgeMem(StoreEntry *);
+static void storeStartRebuildFromDisk(void);
+static void storeSwapOutStart(StoreEntry * e);
static DWCB storeSwapOutHandle;
-static void storeSetPrivateKey _PARAMS((StoreEntry *));
+static void storeSetPrivateKey(StoreEntry *);
static EVH storeDoRebuildFromDisk;
static EVH storeCleanup;
static VCB storeCleanupComplete;
-static void storeValidate _PARAMS((StoreEntry *, VCB *, void *));
+static void storeValidate(StoreEntry *, VCB *, void *);
static AIOCB storeValidateComplete;
-static void storeRebuiltFromDisk _PARAMS((struct storeRebuildState * data));
-static unsigned int getKeyCounter _PARAMS((void));
-static void storePutUnusedFileno _PARAMS((int fileno));
-static int storeGetUnusedFileno _PARAMS((void));
+static void storeRebuiltFromDisk(struct storeRebuildState * data);
+static unsigned int getKeyCounter(void);
+static void storePutUnusedFileno(int fileno);
+static int storeGetUnusedFileno(void);
static void storeCheckSwapOut(StoreEntry * e);
static void storeSwapoutFileOpened(void *data, int fd);
/*
- * $Id: tools.cc,v 1.125 1997/10/25 16:49:06 wessels Exp $
+ * $Id: tools.cc,v 1.126 1997/10/25 17:23:02 wessels Exp $
*
* DEBUG: section 21 Misc Functions
* AUTHOR: Harvest Derived
\n\
Thanks!\n"
-static void fatal_common _PARAMS((const char *));
-static void mail_warranty _PARAMS((void));
-static void shutdownTimeoutHandler _PARAMS((int fd, void *data));
+static void fatal_common(const char *);
+static void mail_warranty(void);
+static void shutdownTimeoutHandler(int fd, void *data);
#if USE_ASYNC_IO
-static void safeunlinkComplete _PARAMS((void *data, int retcode, int errcode));
+static void safeunlinkComplete(void *data, int retcode, int errcode);
#endif
#ifdef _SQUID_SOLARIS_
-int getrusage _PARAMS((int, struct rusage *));
-int getpagesize _PARAMS((void));
-int gethostname _PARAMS((char *, int));
+int getrusage(int, struct rusage *);
+int getpagesize(void);
+int gethostname(char *, int);
#endif
static void
}
void
-squid_signal(int sig, void (*func) _PARAMS((int)), int flags)
+squid_signal(int sig, SIGHDLR *func, int flags)
{
#if HAVE_SIGACTION
struct sigaction sa;
/*
- * $Id: tunnel.cc,v 1.64 1997/10/24 18:10:40 wessels Exp $
+ * $Id: tunnel.cc,v 1.65 1997/10/25 17:22:58 wessels Exp $
*
* DEBUG: section 26 Secure Sockets Layer Proxy
* AUTHOR: Duane Wessels
static const char *const conn_established = "HTTP/1.0 200 Connection established\r\n\r\n";
static PF sslTimeout;
-static void sslReadServer _PARAMS((int fd, void *));
-static void sslReadClient _PARAMS((int fd, void *));
-static void sslWriteServer _PARAMS((int fd, void *));
-static void sslWriteClient _PARAMS((int fd, void *));
-static void sslConnected _PARAMS((int fd, void *));
-static void sslProxyConnected _PARAMS((int fd, void *));
+static void sslReadServer(int fd, void *);
+static void sslReadClient(int fd, void *);
+static void sslWriteServer(int fd, void *);
+static void sslWriteClient(int fd, void *);
+static void sslConnected(int fd, void *);
+static void sslProxyConnected(int fd, void *);
static ERCB sslErrorComplete;
-static void sslClose _PARAMS((SslStateData * sslState));
-static void sslClientClosed _PARAMS((int fd, void *));
+static void sslClose(SslStateData * sslState);
+static void sslClientClosed(int fd, void *);
static CNCB sslConnectDone;
-static void sslStateFree _PARAMS((int fd, void *data));
-static void sslPeerSelectComplete _PARAMS((peer * p, void *data));
-static void sslPeerSelectFail _PARAMS((peer * p, void *data));
+static void sslStateFree(int fd, void *data);
+static void sslPeerSelectComplete(peer * p, void *data);
+static void sslPeerSelectFail(peer * p, void *data);
static void
sslClose(SslStateData * sslState)
typedef struct _CommWriteStateData CommWriteStateData;
typedef struct _ErrorState ErrorState;
-typedef void AIOCB _PARAMS((void *, int aio_return, int aio_errno));
-typedef void CWCB _PARAMS((int fd, char *, int size, int errflag, void *data));
-typedef void CNCB _PARAMS((int fd, int status, void *));
-typedef void FREE _PARAMS((void *));
-typedef void FOCB _PARAMS((void *, int fd));
-typedef void EVH _PARAMS((void *));
-typedef void PF _PARAMS((int, void *));
-typedef void DRCB _PARAMS((int fd, const char *buf, int size, int errflag, void *data));
-typedef void DWCB _PARAMS((int, int, size_t, void *));
-typedef void FILE_WALK_HD _PARAMS((int fd, int errflag, void *data));
-typedef void FILE_WALK_LHD _PARAMS((int fd, const char *buf, int size, void *line_data));
-typedef void FQDNH _PARAMS((const char *, void *));
-typedef int HASHCMP _PARAMS((const char *, const char *));
-typedef unsigned int HASHHASH _PARAMS((const char *, unsigned int));
-typedef void IDCB _PARAMS((void *));
-typedef void IPH _PARAMS((const ipcache_addrs *, void *));
-typedef void IRCB _PARAMS((peer *, peer_t, icp_common_t *, void *data));
-typedef void PSC _PARAMS((peer *, void *));
-typedef void RH _PARAMS((void *data, char *result));
+typedef void AIOCB(void *, int aio_return, int aio_errno);
+typedef void CWCB(int fd, char *, int size, int errflag, void *data);
+typedef void CNCB(int fd, int status, void *);
+typedef void FREE(void *);
+typedef void FOCB(void *, int fd);
+typedef void EVH(void *);
+typedef void PF(int, void *);
+typedef void DRCB(int fd, const char *buf, int size, int errflag, void *data);
+typedef void DWCB(int, int, size_t, void *);
+typedef void FILE_WALK_HD(int fd, int errflag, void *data);
+typedef void FILE_WALK_LHD(int fd, const char *buf, int size, void *line_data);
+typedef void FQDNH(const char *, void *);
+typedef int HASHCMP(const char *, const char *);
+typedef unsigned int HASHHASH(const char *, unsigned int);
+typedef void IDCB(void *);
+typedef void IPH(const ipcache_addrs *, void *);
+typedef void IRCB(peer *, peer_t, icp_common_t *, void *data);
+typedef void PSC(peer *, void *);
+typedef void RH(void *data, char *result);
typedef int DEFER(int fd, void *data);
-typedef void SIH _PARAMS((int fd, void *)); /* swap in */
-typedef int QS _PARAMS((const void *, const void *)); /* qsort */
-typedef void STCB _PARAMS((void *, char *, ssize_t)); /* store callback */
-typedef void STABH _PARAMS((void *));
-typedef void ERCB _PARAMS((int fd, void *, int size));
-typedef void OBJH _PARAMS((StoreEntry *));
+typedef void SIH(int fd, void *); /* swap in */
+typedef int QS(const void *, const void *); /* qsort */
+typedef void STCB(void *, char *, ssize_t); /* store callback */
+typedef void STABH(void *);
+typedef void ERCB(int fd, void *, int size);
+typedef void OBJH(StoreEntry *);
+typedef void SIGHDLR(int sig);
/*
- * $Id: unlinkd.cc,v 1.9 1997/07/16 20:32:21 wessels Exp $
+ * $Id: unlinkd.cc,v 1.10 1997/10/25 17:23:04 wessels Exp $
*
* DEBUG: section 43 Unlink Daemon
* AUTHOR: Duane Wessels
static int unlinkd_fd = -1;
-static int unlinkdCreate _PARAMS((void));
+static int unlinkdCreate(void);
#define HELLO_BUFSIZ 128
static int
projects / thirdparty / squid.git / commitdiff
