const char *
bfd_errmsg (bfd_error_type error_tag)
{
#ifndef errno
extern int errno;
#endif
if (error_tag == bfd_error_system_call)
return xstrerror (errno);
if (error_tag > bfd_error_invalid_error_code)
error_tag = bfd_error_invalid_error_code; /* sanity check */
return _(bfd_errmsgs [error_tag]);
}
// generate public/private key pair for digital signatures
void genkeys (void)
{
if (open_crypt())
{
if (CryptGenKey (hProv, AT_SIGNATURE,
keylen<<16 | CRYPT_EXPORTABLE, &hKey))
{
// export as C array and binary
export_key (PUBLICKEYBLOB, RSA_PUBLIC_H, RSA_C_ARRAY);
export_key (PUBLICKEYBLOB, RSA_PUBLIC_BIN, RSA_BINARY);
export_key (PRIVATEKEYBLOB, RSA_PRIVATE_H, RSA_C_ARRAY);
export_key (PRIVATEKEYBLOB, RSA_PRIVATE_BIN, RSA_BINARY);
close_key();
} else {
xstrerror ("CryptGenKey(%i)", keylen);
}
close_crypt();
} else {
xstrerror ("CryptAcquireContext()");
}
}
LPVOID init_func (char *asmcode, DWORD len)
{
LPVOID sc=NULL;
// allocate write/executable memory for code
sc = VirtualAlloc (0, len, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
if (sc!=NULL) {
// copy code
memcpy (sc, asmcode, len);
} else {
xstrerror ("VirtualAlloc()");
}
return sc;
}
static void
netdbSaveState(void *foo)
{
Logfile *lf;
netdbEntry *n;
net_db_name *x;
struct timeval start = current_time;
int count = 0;
if (strcmp(Config.netdbFilename, "none") == 0)
return;
/*
* This was nicer when we were using stdio, but thanks to
* Solaris bugs, its a bad idea. fopen can fail if more than
* 256 FDs are open.
*/
/*
* unlink() is here because there is currently no way to make
* logfileOpen() use O_TRUNC.
*/
unlink(Config.netdbFilename);
lf = logfileOpen(Config.netdbFilename, 4096, 0);
if (NULL == lf) {
debug(50, 1) ("netdbSaveState: %s: %s\n", Config.netdbFilename, xstrerror());
return;
}
hash_first(addr_table);
while ((n = (netdbEntry *) hash_next(addr_table))) {
if (n->pings_recv == 0)
continue;
logfilePrintf(lf, "%s %d %d %10.5f %10.5f %d %d",
n->network,
n->pings_sent,
n->pings_recv,
n->hops,
n->rtt,
(int) n->next_ping_time,
(int) n->last_use_time);
for (x = n->hosts; x; x = x->next)
logfilePrintf(lf, " %s", hashKeyStr(&x->hash));
logfilePrintf(lf, "\n");
count++;
#undef RBUF_SZ
}
logfileClose(lf);
getCurrentTime();
debug(38, 1) ("NETDB state saved; %d entries, %d msec\n",
count, tvSubMsec(start, current_time));
eventAddIsh("netdbSaveState", netdbSaveState, NULL, 3600.0, 1);
}
static void
whoisReadReply(int fd, void *data)
{
WhoisState *p = data;
StoreEntry *entry = p->entry;
char *buf = memAllocate(MEM_4K_BUF);
MemObject *mem = entry->mem_obj;
int len;
statCounter.syscalls.sock.reads++;
len = FD_READ_METHOD(fd, buf, 4095);
buf[len] = '\0';
debug(75, 3) ("whoisReadReply: FD %d read %d bytes\n", fd, len);
debug(75, 5) ("{%s}\n", buf);
if (len > 0) {
if (0 == mem->inmem_hi) {
http_reply *reply = mem->reply;
storeBuffer(entry);
httpReplySetHeaders(reply, HTTP_OK, "Gatewaying", "text/plain", -1, -1, -1);
httpReplySwapOut(reply, entry);
}
fd_bytes(fd, len, FD_READ);
kb_incr(&statCounter.server.all.kbytes_in, len);
kb_incr(&statCounter.server.http.kbytes_in, len);
storeAppend(entry, buf, len);
storeBufferFlush(entry);
commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);
} else if (len < 0) {
debug(50, 2) ("whoisReadReply: FD %d: read failure: %s.\n",
fd, xstrerror());
if (ignoreErrno(errno)) {
commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);
} else {
ErrorState *err;
err = errorCon(ERR_READ_ERROR, HTTP_BAD_GATEWAY, p->fwd->request);
err->xerrno = errno;
fwdFail(p->fwd, err);
comm_close(fd);
}
} else {
storeTimestampsSet(entry);
storeBufferFlush(entry);
if (!EBIT_TEST(entry->flags, RELEASE_REQUEST))
storeSetPublicKey(entry);
fwdComplete(p->fwd);
debug(75, 3) ("whoisReadReply: Done: %s\n", storeUrl(entry));
comm_close(fd);
}
memFree(buf, MEM_4K_BUF);
}
/* Return 1 if the file is a directory, 0 if not, -1 on error. */
int is_dir (const char *file)
{
struct stat file_stat;
if (is_url (file))
return 0;
if (stat (file, &file_stat) == -1) {
char *err = xstrerror (errno);
error ("Can't stat %s: %s", file, err);
free (err);
return -1;
}
return S_ISDIR(file_stat.st_mode) ? 1 : 0;
}
// connect to server
void client(args_t *p)
{
spp_ctx c;
int term=0;
do
{
spp_init(&c, SPP_CLIENT);
// create socket
p->s=socket(p->ai_family, SOCK_STREAM, IPPROTO_TCP);
if (p->s!=SOCKET_ERROR)
{
printf ("[ connecting to %s\n", addr2ip(p));
if (connect (p->s, p->ai_addr, p->ai_addrlen)!=SOCKET_ERROR)
{
printf ("[ connected\n");
c.s=p->s;
printf ("[ performing key exchange\n");
if (spp_handshake(&c))
{
term = dispatch(&c);
printf ("[ closing connection\n");
} else xstrerror("");
} else {
xstrerror ("connect");
}
shutdown (p->s, SD_BOTH);
closesocket (p->s);
}
if (!term) {
Sleep (2000); // sleep for 2 seconds, then try again
}
spp_end(&c);
} while (!term);
}
/*
* Aborts with fatal message if write() returns something other
* than its length argument.
*/
static void
logfileWriteWrapper(Logfile * lf, const void *buf, size_t len)
{
l_stdio_t *ll = (l_stdio_t *) lf->data;
size_t s;
s = FD_WRITE_METHOD(ll->fd, (char const *) buf, len);
fd_bytes(ll->fd, s, FD_WRITE);
if (s == len)
return;
if (!lf->flags.fatal)
return;
fatalf("logfileWrite (stdio): %s: %s\n", lf->path, xstrerror());
}
storeIOState *
storeUfsCreate(SwapDir * SD, StoreEntry * e, STFNCB * file_callback, STIOCB * callback, void *callback_data)
{
storeIOState *sio;
int fd;
int mode = (O_WRONLY | O_CREAT | O_TRUNC | O_BINARY);
char *path;
ufsinfo_t *ufsinfo = (ufsinfo_t *) SD->fsdata;
sfileno filn;
sdirno dirn;
/* Allocate a number */
dirn = SD->index;
filn = storeUfsDirMapBitAllocate(SD);
ufsinfo->suggest = filn + 1;
/* Shouldn't we handle a 'bitmap full' error here? */
path = storeUfsDirFullPath(SD, filn, NULL);
debug(79, 3) ("storeUfsCreate: fileno %08X\n", filn);
fd = file_open(path, mode);
if (fd < 0) {
debug(79, 1) ("storeUfsCreate: Failed to create %s (%s)\n", path, xstrerror());
return NULL;
}
debug(79, 3) ("storeUfsCreate: opened FD %d\n", fd);
CBDATA_INIT_TYPE_FREECB(storeIOState, storeUfsIOFreeEntry);
sio = cbdataAlloc(storeIOState);
sio->fsstate = memPoolAlloc(ufs_state_pool);
sio->swap_filen = filn;
sio->swap_dirn = dirn;
sio->mode = mode;
sio->callback = callback;
sio->callback_data = callback_data;
cbdataLock(callback_data);
sio->e = (StoreEntry *) e;
((ufsstate_t *) (sio->fsstate))->fd = fd;
((ufsstate_t *) (sio->fsstate))->flags.writing = 0;
((ufsstate_t *) (sio->fsstate))->flags.reading = 0;
((ufsstate_t *) (sio->fsstate))->flags.close_request = 0;
store_open_disk_fd++;
ufsinfo->open_files++;
/* now insert into the replacement policy */
storeUfsDirReplAdd(SD, e);
return sio;
}
void
a_file_read(async_queue_t * q, int fd, void *buf, int req_len, off_t offset,
DRCB * callback, void *data)
{
int slot;
async_queue_entry_t *qe;
assert(q->aq_state == AQ_STATE_SETUP);
assert(offset >= 0);
/* Find a free slot */
slot = a_file_findslot(q);
if (slot < 0) {
/* No free slot? Callback error, and return */
debug(79, 1) ("WARNING: out of aiocb slots!\n");
/* fall back to blocking method */
file_read(fd, buf, req_len, offset, callback, data);
return;
}
/* Mark slot as ours */
qe = &q->aq_queue[slot];
qe->aq_e_state = AQ_ENTRY_USED;
qe->aq_e_callback.read = callback;
qe->aq_e_callback_data = data;
qe->aq_e_type = AQ_ENTRY_READ;
qe->aq_e_free = NULL;
qe->aq_e_buf = buf;
qe->aq_e_fd = fd;
qe->aq_e_aiocb.aio_fildes = fd;
qe->aq_e_aiocb.aio_nbytes = req_len;
qe->aq_e_aiocb.aio_offset = offset;
qe->aq_e_aiocb.aio_buf = buf;
/* Account */
q->aq_numpending++;
/* Lock */
cbdataLock(data);
/* Initiate aio */
if (aio_read(&qe->aq_e_aiocb) < 0) {
debug(79, 1) ("WARNING: aio_read() returned error: %s\n", xstrerror());
/* fall back to blocking method */
file_read(fd, buf, req_len, offset, callback, data);
}
}
void
storeLogRotate(void)
{
char *fname = NULL;
int i;
LOCAL_ARRAY(char, from, MAXPATHLEN);
LOCAL_ARRAY(char, to, MAXPATHLEN);
#ifdef S_ISREG
struct stat sb;
#endif
if (storelog_fd > -1) {
file_close(storelog_fd);
storelog_fd = -1;
}
if ((fname = Config.Log.store) == NULL)
return;
if (strcmp(fname, "none") == 0)
return;
#ifdef S_ISREG
if (stat(fname, &sb) == 0)
if (S_ISREG(sb.st_mode) == 0)
return;
#endif
debug(20, 1) ("storeLogRotate: Rotating.\n");
/* Rotate numbers 0 through N up one */
for (i = Config.Log.rotateNumber; i > 1;) {
i--;
snprintf(from, MAXPATHLEN, "%s.%d", fname, i - 1);
snprintf(to, MAXPATHLEN, "%s.%d", fname, i);
xrename(from, to);
}
/* Rotate the current log to .0 */
if (Config.Log.rotateNumber > 0) {
snprintf(to, MAXPATHLEN, "%s.%d", fname, 0);
xrename(fname, to);
}
storelog_fd = file_open(fname, O_WRONLY | O_CREAT);
if (storelog_fd < 0) {
debug(50, 0) ("storeLogRotate: %s: %s\n", fname, xstrerror());
debug(20, 1) ("Store logging disabled\n");
}
}
// Resolve host, create socket and event handle associated with it
BOOL open_tcp (void)
{
struct addrinfo *list, *e;
struct addrinfo hints;
BOOL bStatus=FALSE;
WSADATA wsa;
int on=1;
WSAStartup (MAKEWORD (2, 0), &wsa);
ZeroMemory (&hints, sizeof (hints));
hints.ai_family = args.ai_family;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
// get all resolvable addresses for this machine name
if (getaddrinfo (args.address, args.port, &hints, &list) == 0)
{
for (e=list; e!=NULL; e=e->ai_next)
{
if (args.ai_family==AF_INET) {
memcpy (&sin_ipv4, e->ai_addr, e->ai_addrlen);
ai_addr = (SOCKADDR*)&sin_ipv4;
} else {
memcpy (&sin_ipv6, e->ai_addr, e->ai_addrlen);
ai_addr = (SOCKADDR*)&sin_ipv6;
}
ai_addrlen = e->ai_addrlen;
// create socket
s=socket (args.ai_family, SOCK_STREAM, IPPROTO_TCP);
evt[sck_evt = evt_cnt++] = WSACreateEvent();
if (s!=SOCKET_ERROR) {
// ensure we can reuse same port later
setsockopt (s, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof (on));
bStatus=TRUE;
}
break;
}
freeaddrinfo (list);
} else {
xstrerror ("getaddrinfo(%s)", args.address);
}
return bStatus;
}
static struct value *sys_read_file(struct info *info, struct value *n) {
assert(n->tag == V_STRING);
char *str = NULL;
str = xread_file(n->string->str);
if (str == NULL) {
char error_buf[1024];
const char *errmsg;
errmsg = xstrerror(errno, error_buf, sizeof(error_buf));
struct value *exn = make_exn_value(ref(info),
"reading file %s failed:", n->string->str);
exn_printf_line(exn, "%s", errmsg);
return exn;
}
struct value *v = make_value(V_STRING, ref(info));
v->string = make_string(str);
return v;
}
static void
logfile_mod_udp_write(Logfile * lf, const char *buf, size_t len)
{
l_udp_t *ll = (l_udp_t *) lf->data;
ssize_t s;
s = write(ll->fd, (char const *) buf, len);
fd_bytes(ll->fd, s, FD_WRITE);
#if 0
if (s < 0) {
debug(1, 1) ("logfile (udp): got errno %d (%s)\n", errno, xstrerror());
}
if (s != len) {
debug(1, 1) ("logfile (udp): len %d, wrote %d\n", len, s);
}
#endif
/* We don't worry about network errors for now */
}
static int
do_comm_select(int msec)
{
int num, saved_errno;
struct timeval tv;
fd_set readfds;
fd_set writefds;
fd_set errfds;
int fd;
if (nreadfds + nwritefds == 0) {
assert(shutting_down);
return COMM_SHUTDOWN;
}
memcpy(&readfds, &global_readfds, sizeof(fd_set));
memcpy(&writefds, &global_writefds, sizeof(fd_set));
memcpy(&errfds, &global_writefds, sizeof(fd_set));
tv.tv_sec = msec / 1000;
tv.tv_usec = (msec % 1000) * 1000;
statCounter.syscalls.selects++;
num = select(Biggest_FD + 1, &readfds, &writefds, &errfds, &tv);
saved_errno = errno;
getCurrentTime();
debug(5, 5) ("do_comm_select: %d fds ready\n", num);
if (num < 0) {
if (ignoreErrno(saved_errno))
return COMM_OK;
debug(5, 1) ("comm_select: select failure: %s\n", xstrerror());
return COMM_ERROR;
}
statHistCount(&statCounter.select_fds_hist, num);
if (num == 0)
return COMM_TIMEOUT;
for (fd = 0; fd <= Biggest_FD; fd++) {
int read_event = FD_ISSET(fd, &readfds);
int write_event = FD_ISSET(fd, &writefds) || FD_ISSET(fd, &errfds);
if (read_event || write_event)
comm_call_handlers(fd, read_event, write_event);
}
return COMM_OK;
}
/* Read from FD */
static void
diskHandleRead(int fd, void *data)
{
dread_ctrl *ctrl_dat = data;
fde *F = &fd_table[fd];
int len;
int rc = DISK_OK;
/*
* FD < 0 indicates premature close; we just have to free
* the state data.
*/
if (fd < 0) {
memFree(ctrl_dat, MEM_DREAD_CTRL);
return;
}
if (F->disk.offset != ctrl_dat->file_offset) {
debug(6, 3) ("diskHandleRead: FD %d seeking to offset %d\n",
fd, (int) ctrl_dat->file_offset);
lseek(fd, ctrl_dat->file_offset, SEEK_SET); /* XXX ignore return? */
statCounter.syscalls.disk.seeks++;
F->disk.offset = ctrl_dat->file_offset;
}
errno = 0;
len = FD_READ_METHOD(fd, ctrl_dat->buf, ctrl_dat->req_len);
if (len > 0)
F->disk.offset += len;
statCounter.syscalls.disk.reads++;
fd_bytes(fd, len, FD_READ);
if (len < 0) {
if (ignoreErrno(errno)) {
commSetSelect(fd, COMM_SELECT_READ, diskHandleRead, ctrl_dat, 0);
return;
}
debug(50, 1) ("diskHandleRead: FD %d: %s\n", fd, xstrerror());
len = 0;
rc = DISK_ERROR;
} else if (len == 0) {
rc = DISK_EOF;
}
if (cbdataValid(ctrl_dat->client_data))
ctrl_dat->handler(fd, ctrl_dat->buf, len, rc, ctrl_dat->client_data);
cbdataUnlock(ctrl_dat->client_data);
memFree(ctrl_dat, MEM_DREAD_CTRL);
}
static void *sndfile_open (const char *file)
{
int fd;
struct sndfile_data *data;
data = (struct sndfile_data *)xmalloc (sizeof(struct sndfile_data));
decoder_error_init (&data->error);
memset (&data->snd_info, 0, sizeof(data->snd_info));
data->timing_broken = false;
fd = open (file, O_RDONLY);
if (fd == -1) {
char *err = xstrerror (errno);
decoder_error (&data->error, ERROR_FATAL, 0,
"Can't open file: %s", err);
free (err);
return data;
}
/* sf_open_fd() close()s 'fd' on error and in sf_close(). */
data->sndfile = sf_open_fd (fd, SFM_READ, &data->snd_info, SF_TRUE);
if (!data->sndfile) {
/* FIXME: sf_strerror is not thread safe with NULL argument */
decoder_error (&data->error, ERROR_FATAL, 0,
"Can't open file: %s", sf_strerror(NULL));
return data;
}
/* If the timing is broken, sndfile only decodes up to the broken value. */
data->timing_broken = is_timing_broken (fd, data);
if (data->timing_broken) {
decoder_error (&data->error, ERROR_FATAL, 0,
"File too large for audio format!");
return data;
}
debug ("Opened file %s", file);
debug ("Channels: %d", data->snd_info.channels);
debug ("Format: %08X", data->snd_info.format);
debug ("Sample rate: %d", data->snd_info.samplerate);
return data;
}
static void m3u8Event(void *args)
{
if(!is_m3u8_prefetch_alive()){
debug(207,3)("m3u8_prefetch dont run,now starting it!\n");
enter_suid();
int cid = fork();
if (cid == 0) {
int ret = execl("/usr/local/squid/bin/m3u8_prefetch", "m3u8_prefetch","15101",(char *)0);
if (ret < 0) {
debug(207,3)("(m3u8) --> execl error : %s\n",xstrerror());
}
exit(-1);
}
leave_suid();
}
eventAdd("m3u8Event", m3u8Event, NULL, 30, 0);
}
static void
icmpSend(pingerEchoData * pkt, int len)
{
int x;
if (icmp_sock < 0)
return;
debug(37, 2) ("icmpSend: to %s, opcode %d, len %d\n",
inet_ntoa(pkt->to), (int) pkt->opcode, pkt->psize);
x = send(icmp_sock, (char *) pkt, len, 0);
if (x < 0) {
debug(50, 1) ("icmpSend: send: %s\n", xstrerror());
if (errno == ECONNREFUSED || errno == EPIPE) {
icmpClose();
return;
}
} else if (x != len) {
debug(37, 1) ("icmpSend: Wrote %d of %d bytes\n", x, len);
}
}
static int
do_comm_select(int msec)
{
int num;
int i;
if (nfds == 0) {
assert(shutting_down);
return COMM_SHUTDOWN;
}
statCounter.syscalls.selects++;
num = poll(pfds, nfds, msec);
if (num < 0) {
getCurrentTime();
if (ignoreErrno(errno))
return COMM_OK;
debug(5, 1) ("comm_select: poll failure: %s\n", xstrerror());
return COMM_ERROR;
}
statHistCount(&statCounter.select_fds_hist, num);
if (num == 0)
return COMM_TIMEOUT;
for (i = nfds - 1; num > 0 && i >= 0; i--) {
struct pollfd *pfd = &pfds[i];
short read_event, write_event;
if (!pfd->revents)
continue;
read_event = pfd->revents & (POLLRDNORM | POLLIN | POLLHUP | POLLERR);
write_event = pfd->revents & (POLLWRNORM | POLLOUT | POLLHUP | POLLERR);
pfd->revents = 0;
comm_call_handlers(pfd->fd, read_event, write_event);
num--;
}
return COMM_OK;
}
static void
pfatal_pexecute (const char *errmsg_fmt, const char *errmsg_arg)
{
if (errmsg_arg)
{
int save_errno = errno;
/* Space for trailing '\0' is in %s. */
char *msg = (char *) malloc (strlen (errmsg_fmt) + strlen (errmsg_arg));
sprintf (msg, errmsg_fmt, errmsg_arg);
errmsg_fmt = msg;
errno = save_errno;
}
fprintf (stderr,"%s: %s: %s\n", progname, errmsg_fmt, xstrerror (errno));
delete_out_files ();
exit (1);
}
void
storeDiskdRead(SwapDir * SD, storeIOState * sio, char *buf, size_t size, squid_off_t offset, STRCB * callback, void *callback_data)
{
int x;
int shm_offset;
char *rbuf;
diskdstate_t *diskdstate = sio->fsstate;
debug(79, 3) ("storeDiskdRead: dirno %d, fileno %08X\n", sio->swap_dirn, sio->swap_filen);
if (diskdstate->flags.close_request) {
debug(79, 2) ("storeDiskRead: closing, so ignore!\n");
return;
}
if (!cbdataValid(sio))
return;
if (diskdstate->flags.reading) {
debug(79, 1) ("storeDiskdRead: already reading!\n");
return;
}
assert(sio->read.callback == NULL);
assert(sio->read.callback_data == NULL);
sio->read.callback = callback;
sio->read.callback_data = callback_data;
diskdstate->read_buf = buf; /* the one passed from above */
cbdataLock(sio->read.callback_data);
sio->offset = offset;
diskdstate->flags.reading = 1;
rbuf = storeDiskdShmGet(SD, &shm_offset);
assert(rbuf);
x = storeDiskdSend(_MQD_READ,
SD,
diskdstate->id,
sio,
size,
(off_t) offset,
shm_offset);
if (x < 0) {
debug(79, 1) ("storeDiskdSend READ: %s\n", xstrerror());
storeDiskdShmPut(SD, shm_offset);
storeDiskdIOCallback(sio, DISK_ERROR);
}
diskd_stats.read.ops++;
}
static void
whoisReadReply(int fd, void *data)
{
WhoisState *p = data;
StoreEntry *entry = p->entry;
char *buf = memAllocate(MEM_4K_BUF);
MemObject *mem = entry->mem_obj;
int len;
statCounter.syscalls.sock.reads++;
len = FD_READ_METHOD(fd, buf, 4095);
buf[len] = '\0';
debug(75, 3) ("whoisReadReply: FD %d read %d bytes\n", fd, len);
debug(75, 5) ("{%s}\n", buf);
if (len > 0) {
if (0 == mem->inmem_hi)
mem->reply->sline.status = HTTP_OK;
fd_bytes(fd, len, FD_READ);
kb_incr(&statCounter.server.all.kbytes_in, len);
kb_incr(&statCounter.server.http.kbytes_in, len);
storeAppend(entry, buf, len);
commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);
} else if (len < 0) {
debug(50, 2) ("whoisReadReply: FD %d: read failure: %s.\n",
fd, xstrerror());
if (ignoreErrno(errno)) {
commSetSelect(fd, COMM_SELECT_READ, whoisReadReply, p, Config.Timeout.read);
} else if (mem->inmem_hi == 0) {
ErrorState *err;
err = errorCon(ERR_READ_ERROR, HTTP_INTERNAL_SERVER_ERROR);
err->xerrno = errno;
fwdFail(p->fwd, err);
comm_close(fd);
} else {
comm_close(fd);
}
} else {
fwdComplete(p->fwd);
debug(75, 3) ("whoisReadReply: Done: %s\n", storeUrl(entry));
comm_close(fd);
}
memFree(buf, MEM_4K_BUF);
}
static void
icmpRecv(int unused1, void *unused2)
{
int n;
static int fail_count = 0;
pingerReplyData preply;
static struct sockaddr_in F;
commSetSelect(icmp_sock, COMM_SELECT_READ, icmpRecv, NULL, 0);
memset(&preply, '\0', sizeof(pingerReplyData));
Counter.syscalls.sock.recvfroms++;
n = recv(icmp_sock,
(char *) &preply,
sizeof(pingerReplyData),
0);
if (n < 0) {
debug(50, 1) ("icmpRecv: recv: %s\n", xstrerror());
if (++fail_count == 10 || errno == ECONNREFUSED)
icmpClose();
return;
}
fail_count = 0;
if (n == 0) /* test probe from pinger */
return;
F.sin_family = AF_INET;
F.sin_addr = preply.from;
F.sin_port = 0;
switch (preply.opcode) {
case S_ICMP_ECHO:
break;
#if ALLOW_SOURCE_PING
case S_ICMP_ICP:
icmpHandleSourcePing(&F, preply.payload);
break;
#endif
case S_ICMP_DOM:
netdbHandlePingReply(&F, preply.hops, preply.rtt);
break;
default:
debug(37, 1) ("icmpRecv: Bad opcode: %d\n", (int) preply.opcode);
break;
}
}
/*
* opens a disk file specified by 'path'. This function always
* blocks! There is no callback.
*/
int
file_open(const char *path, int mode)
{
int fd;
if (FILE_MODE(mode) == O_WRONLY)
mode |= O_APPEND;
errno = 0;
fd = open(path, mode, 0644);
statCounter.syscalls.disk.opens++;
if (fd < 0) {
debug(50, 3) ("file_open: error opening file %s: %s\n", path,
xstrerror());
fd = DISK_ERROR;
} else {
debug(6, 5) ("file_open: FD %d\n", fd);
commSetCloseOnExec(fd);
fd_open(fd, FD_FILE, path);
}
return fd;
}
struct str *listing(struct post *post, const char *fname)
{
char path[FILENAME_MAX];
struct str *in;
snprintf(path, FILENAME_MAX, "%s/posts/%d/%s",
str_cstr(config.data_dir), post->id, fname);
in = file_cache_get_cb(path, post->preview ? NULL : revalidate_post,
post);
if (IS_ERR(in))
goto err;
return listing_str(in);
err:
snprintf(path, FILENAME_MAX, "Failed to read in listing '%d/%s': %s",
post->id, fname, xstrerror(PTR_ERR(in)));
return STR_DUP(path);
}
char *
read_file (const location &loc, const char *path)
{
FILE *f_in = fopen (path, "r");
if (!f_in)
fail_formatted (loc, "unable to open file: %s", path);
/* Read content, allocating FIXME. */
char *result = NULL;
size_t total_sz = 0;
size_t alloc_sz = 0;
char buf[4096];
size_t iter_sz_in;
while ( (iter_sz_in = fread (buf, 1, sizeof (buf), f_in)) )
{
gcc_assert (alloc_sz >= total_sz);
size_t old_total_sz = total_sz;
total_sz += iter_sz_in;
/* Allow 1 extra byte for 0-termination. */
if (alloc_sz < (total_sz + 1))
{
size_t new_alloc_sz = alloc_sz ? alloc_sz * 2: total_sz + 1;
result = (char *)xrealloc (result, new_alloc_sz);
alloc_sz = new_alloc_sz;
}
memcpy (result + old_total_sz, buf, iter_sz_in);
}
if (!feof (f_in))
fail_formatted (loc, "error reading from %s: %s", path,
xstrerror (errno));
fclose (f_in);
/* 0-terminate the buffer. */
gcc_assert (total_sz < alloc_sz);
result[total_sz] = '\0';
return result;
}
void
as_perror (const char *gripe, /* Unpunctuated error theme. */
const char *filename)
{
const char *errtxt;
int saved_errno = errno;
as_show_where ();
fprintf (stderr, gripe, filename);
errno = saved_errno;
#ifdef BFD_ASSEMBLER
errtxt = bfd_errmsg (bfd_get_error ());
#else
errtxt = xstrerror (errno);
#endif
fprintf (stderr, ": %s\n", errtxt);
errno = 0;
#ifdef BFD_ASSEMBLER
bfd_set_error (bfd_error_no_error);
#endif
}
void
storeDiskdClose(SwapDir * SD, storeIOState * sio)
{
int x;
diskdstate_t *diskdstate = sio->fsstate;
debug(79, 3) ("storeDiskdClose: dirno %d, fileno %08X\n", SD->index,
sio->swap_filen);
diskdstate->flags.close_request = 1;
x = storeDiskdSend(_MQD_CLOSE,
SD,
diskdstate->id,
sio,
0,
0,
-1);
if (x < 0) {
debug(79, 1) ("storeDiskdSend CLOSE: %s\n", xstrerror());
storeDiskdIOCallback(sio, DISK_ERROR);
}
diskd_stats.close.ops++;
}
static void errorTryLoadText(MemBuf * text, char *path)
{
int fd;
struct stat sb;
// char *text = NULL;
//snprintf(path, sizeof(path), "%s/%s", dir, page_name);
#ifdef _SQUID_MSWIN_
fd = open(path, O_RDONLY | O_BINARY);
#else
fd = open(path, O_RDONLY | O_TEXT);
#endif
if (fd < 0 || fstat(fd, &sb) < 0)
{
debug(115, 0) ("mod_customized_server_side_error_page errorTryLoadText: '%s': %s\n", path, xstrerror());
if (fd >= 0)
file_close(fd);
//return NULL;
memBufInit(text, 1*sizeof(char), 1*sizeof(char));
memBufPrintf(text, "%s", "");
}
else
{
memBufInit(text, (size_t)sb.st_size+2+1, (size_t)sb.st_size+2+1);
if (read(fd, text->buf, (int) sb.st_size) != sb.st_size)
{
debug(115,0) ("mod_customized_server_side_error_page errorTryLoadText: failed to fully read: '%s': %s\n",
path, xstrerror());
memBufClean(text);
}
text->size += sb.st_size;
text->buf[text->size] = '\0';
debug(115,4)("mod_customized_server_side_error_page errorTryLoadText: the path is: %s point before end and text is: %s.....\n", path,text->buf);
close(fd);
}
#ifndef CC_FRAMEWORK
if (NULL != text->buf && strstr(text->buf, "%s") == NULL)
memBufAppend(text,"%S", strlen("%S")); /* add signature */
#endif
}
