void
unlinkdInit(void)
{
#if USE_UNLINKD
int x;
char *args[2];
struct timeval slp;
args[0] = "(unlinkd)";
args[1] = NULL;
#if HAVE_POLL && defined(_SQUID_OSF_)
/* pipes and poll() don't get along on DUNIX -DW */
x = ipcCreate(IPC_TCP_SOCKET,
#else
x = ipcCreate(IPC_FIFO,
#endif
Config.Program.unlinkd,
args,
"unlinkd",
&unlinkd_rfd,
&unlinkd_wfd);
if (x < 0)
fatal("Failed to create unlinkd subprocess");
slp.tv_sec = 0;
slp.tv_usec = 250000;
select(0, NULL, NULL, NULL, &slp);
fd_note(unlinkd_wfd, "squid -> unlinkd");
fd_note(unlinkd_rfd, "unlinkd -> squid");
commSetTimeout(unlinkd_rfd, -1, NULL, NULL);
commSetTimeout(unlinkd_wfd, -1, NULL, NULL);
/*
* unlinkd_rfd should already be non-blocking because of
* ipcCreate. We change unlinkd_wfd to blocking mode because
* we never want to lose an unlink request, and we don't have
* code to retry if we get EWOULDBLOCK. Unfortunately, we can
* do this only for the IPC_FIFO case.
*/
assert(fd_table[unlinkd_rfd].flags.nonblocking);
if (FD_PIPE == fd_table[unlinkd_wfd].type)
commUnsetNonBlocking(unlinkd_wfd);
debug(12, 1) ("Unlinkd pipe opened on FD %d\n", unlinkd_wfd);
#else
debug(12, 1) ("Unlinkd is disabled\n");
#endif
}
void
unlinkdInit(void)
{
const char *args[2];
struct timeval slp;
args[0] = "(unlinkd)";
args[1] = NULL;
#if (HAVE_POLL && defined(_SQUID_OSF_)) || defined(_SQUID_MSWIN_)
/* pipes and poll() don't get along on DUNIX -DW */
/* On Windows select() will fail on a pipe */
pid = ipcCreate(IPC_STREAM,
#else
/* We currently need to use FIFO.. see below */
pid = ipcCreate(IPC_FIFO,
#endif
Config.Program.unlinkd,
args,
"unlinkd",
&unlinkd_rfd,
&unlinkd_wfd,
&hIpc);
if (pid < 0)
fatal("Failed to create unlinkd subprocess");
slp.tv_sec = 0;
slp.tv_usec = 250000;
select(0, NULL, NULL, NULL, &slp);
fd_note(unlinkd_wfd, "squid -> unlinkd");
fd_note(unlinkd_rfd, "unlinkd -> squid");
commSetTimeout(unlinkd_rfd, -1, NULL, NULL);
commSetTimeout(unlinkd_wfd, -1, NULL, NULL);
/*
* unlinkd_rfd should already be non-blocking because of
* ipcCreate. We change unlinkd_wfd to blocking mode because
* we never want to lose an unlink request, and we don't have
* code to retry if we get EWOULDBLOCK. Unfortunately, we can
* do this only for the IPC_FIFO case.
*/
assert(fd_table[unlinkd_rfd].flags.nonblocking);
if (FD_PIPE == fd_table[unlinkd_wfd].type)
commUnsetNonBlocking(unlinkd_wfd);
debug(2, 1) ("Unlinkd pipe opened on FD %d\n", unlinkd_wfd);
}
static unsigned int __stdcall
ipc_thread_1(void *in_params)
{
int t1, t2, t3, retval = -1;
int p2c[2] =
{-1, -1};
int c2p[2] =
{-1, -1};
HANDLE hProcess = NULL, thread = NULL;
pid_t pid = -1;
struct thread_params thread_params;
int x, tmp_s, fd = -1;
char *str;
#if HAVE_PUTENV
char *env_str = NULL;
#endif
STARTUPINFO si;
PROCESS_INFORMATION pi;
long F;
int prfd_ipc = -1, pwfd_ipc = -1, crfd_ipc = -1, cwfd_ipc = -1;
char *prog = NULL, *buf1 = NULL;
struct sockaddr_in CS_ipc, PS_ipc;
struct ipc_params *params = (struct ipc_params *) in_params;
int type = params->type;
int crfd = params->crfd;
int cwfd = params->cwfd;
char **args = params->args;
struct sockaddr_in PS = params->PS;
buf1 = xcalloc(1, 8192);
strcpy(buf1, params->prog);
prog = strtok(buf1, w_space);
if ((str = strrchr(prog, '/')))
prog = ++str;
if ((str = strrchr(prog, '\\')))
prog = ++str;
prog = xstrdup(prog);
if (type == IPC_TCP_SOCKET) {
debug(54, 3) ("ipcCreate: calling accept on FD %d\n", crfd);
if ((fd = accept(crfd, NULL, NULL)) < 0) {
debug(54, 0) ("ipcCreate: FD %d accept: %s\n", crfd, xstrerror());
goto cleanup;
}
debug(54, 3) ("ipcCreate: CHILD accepted new FD %d\n", fd);
comm_close(crfd);
snprintf(buf1, 8191, "%s CHILD socket", prog);
fd_open(fd, FD_SOCKET, buf1);
fd_table[fd].flags.ipc = 1;
cwfd = crfd = fd;
} else if (type == IPC_UDP_SOCKET) {
if (comm_connect_addr(crfd, &PS) == COMM_ERROR)
goto cleanup;
}
x = send(cwfd, hello_string, strlen(hello_string) + 1, 0);
if (x < 0) {
debug(54, 0) ("sendto FD %d: %s\n", cwfd, xstrerror());
debug(54, 0) ("ipcCreate: CHILD: hello write test failed\n");
goto cleanup;
}
#if HAVE_PUTENV
env_str = xcalloc((tmp_s = strlen(Config.debugOptions) + 32), 1);
snprintf(env_str, tmp_s, "SQUID_DEBUG=%s", Config.debugOptions);
putenv(env_str);
#endif
memset(buf1, '\0', sizeof(buf1));
x = recv(crfd, buf1, 8191, 0);
if (x < 0) {
debug(54, 0) ("ipcCreate: CHILD: OK read test failed\n");
debug(54, 0) ("--> read: %s\n", xstrerror());
goto cleanup;
} else if (strcmp(buf1, ok_string)) {
debug(54, 0) ("ipcCreate: CHILD: OK read test failed\n");
debug(54, 0) ("--> read returned %d\n", x);
debug(54, 0) ("--> got '%s'\n", rfc1738_escape(hello_buf));
goto cleanup;
}
/* assign file descriptors to child process */
if (_pipe(p2c, 1024, _O_BINARY | _O_NOINHERIT) < 0) {
debug(54, 0) ("ipcCreate: CHILD: pipe: %s\n", xstrerror());
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
if (_pipe(c2p, 1024, _O_BINARY | _O_NOINHERIT) < 0) {
debug(54, 0) ("ipcCreate: CHILD: pipe: %s\n", xstrerror());
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
if (type == IPC_UDP_SOCKET) {
snprintf(buf1, 8192, "%s(%ld) <-> ipc CHILD socket", prog, -1L);
crfd_ipc = cwfd_ipc = comm_open(SOCK_DGRAM, IPPROTO_UDP, local_addr, 0, 0, buf1);
if (crfd_ipc < 0) {
debug(54, 0) ("ipcCreate: CHILD: Failed to create child FD for %s.\n",
prog);
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
snprintf(buf1, 8192, "%s(%ld) <-> ipc PARENT socket", prog, -1L);
prfd_ipc = pwfd_ipc = comm_open(SOCK_DGRAM, IPPROTO_UDP, local_addr, 0, 0, buf1);
if (pwfd_ipc < 0) {
debug(54, 0) ("ipcCreate: CHILD: Failed to create server FD for %s.\n",
prog);
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
tmp_s = sizeof(PS_ipc);
memset(&PS_ipc, '\0', tmp_s);
if (getsockname(pwfd_ipc, (struct sockaddr *) &PS_ipc, &tmp_s) < 0) {
debug(54, 0) ("ipcCreate: getsockname: %s\n", xstrerror());
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
debug(54, 3) ("ipcCreate: FD %d sockaddr %s:%d\n",
pwfd_ipc, inet_ntoa(PS_ipc.sin_addr), ntohs(PS_ipc.sin_port));
tmp_s = sizeof(CS_ipc);
memset(&CS_ipc, '\0', tmp_s);
if (getsockname(crfd_ipc, (struct sockaddr *) &CS_ipc, &tmp_s) < 0) {
debug(54, 0) ("ipcCreate: getsockname: %s\n", xstrerror());
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
debug(54, 3) ("ipcCreate: FD %d sockaddr %s:%d\n",
crfd_ipc, inet_ntoa(CS_ipc.sin_addr), ntohs(CS_ipc.sin_port));
if (comm_connect_addr(pwfd_ipc, &CS_ipc) == COMM_ERROR) {
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
fd = crfd;
if (comm_connect_addr(crfd_ipc, &PS_ipc) == COMM_ERROR) {
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
} /* IPC_UDP_SOCKET */
t1 = dup(0);
t2 = dup(1);
t3 = dup(2);
dup2(c2p[0], 0);
dup2(p2c[1], 1);
dup2(fileno(debug_log), 2);
close(c2p[0]);
close(p2c[1]);
commUnsetNonBlocking(fd);
memset(&si, 0, sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
si.hStdInput = (HANDLE) _get_osfhandle(0);
si.hStdOutput = (HANDLE) _get_osfhandle(1);
si.hStdError = (HANDLE) _get_osfhandle(2);
si.dwFlags = STARTF_USESTDHANDLES;
/* Make sure all other valid handles are not inerithable */
for (x = 3; x < Squid_MaxFD; x++) {
if ((F = _get_osfhandle(x)) == -1)
continue;
SetHandleInformation((HANDLE) F, HANDLE_FLAG_INHERIT, 0);
}
*buf1 = '\0';
strcpy(buf1 + 4096, params->prog);
str = strtok(buf1 + 4096, w_space);
do {
strcat(buf1, str);
strcat(buf1, " ");
} while ((str = strtok(NULL, w_space)));
x = 1;
while (args[x]) {
strcat(buf1, args[x++]);
strcat(buf1, " ");
}
if (CreateProcess(buf1 + 4096, buf1, NULL, NULL, TRUE, CREATE_NO_WINDOW,
NULL, NULL, &si, &pi)) {
pid = pi.dwProcessId;
hProcess = pi.hProcess;
} else {
pid = -1;
WIN32_maperror(GetLastError());
x = errno;
}
dup2(t1, 0);
dup2(t2, 1);
dup2(t3, 2);
close(t1);
close(t2);
close(t3);
if (pid == -1) {
errno = x;
debug(54, 0) ("ipcCreate: CHILD: %s: %s\n", params->prog, xstrerror());
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
if (type == IPC_UDP_SOCKET) {
WSAPROTOCOL_INFO wpi;
memset(&wpi, 0, sizeof(wpi));
if (SOCKET_ERROR == WSADuplicateSocket(crfd_ipc, pid, &wpi)) {
debug(54, 0) ("ipcCreate: CHILD: WSADuplicateSocket: %s\n",
xstrerror());
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
x = write(c2p[1], (const char *) &wpi, sizeof(wpi));
if (x < sizeof(wpi)) {
debug(54, 0) ("ipcCreate: CHILD: write FD %d: %s\n", c2p[1],
xstrerror());
debug(54, 0) ("ipcCreate: CHILD: %s: socket exchange failed\n",
prog);
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
x = read(p2c[0], buf1, 8192);
if (x < 0) {
debug(54, 0) ("ipcCreate: CHILD: read FD %d: %s\n", p2c[0],
xstrerror());
debug(54, 0) ("ipcCreate: CHILD: %s: socket exchange failed\n",
prog);
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
} else if (strncmp(buf1, ok_string, strlen(ok_string))) {
debug(54, 0) ("ipcCreate: CHILD: %s: socket exchange failed\n",
prog);
debug(54, 0) ("--> read returned %d\n", x);
buf1[x] = '\0';
debug(54, 0) ("--> got '%s'\n", rfc1738_escape(buf1));
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
x = write(c2p[1], (const char *) &PS_ipc, sizeof(PS_ipc));
if (x < sizeof(PS_ipc)) {
debug(54, 0) ("ipcCreate: CHILD: write FD %d: %s\n", c2p[1],
xstrerror());
debug(54, 0) ("ipcCreate: CHILD: %s: socket exchange failed\n",
prog);
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
x = read(p2c[0], buf1, 8192);
if (x < 0) {
debug(54, 0) ("ipcCreate: CHILD: read FD %d: %s\n", p2c[0],
xstrerror());
debug(54, 0) ("ipcCreate: CHILD: %s: socket exchange failed\n",
prog);
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
} else if (strncmp(buf1, ok_string, strlen(ok_string))) {
debug(54, 0) ("ipcCreate: CHILD: %s: socket exchange failed\n",
prog);
debug(54, 0) ("--> read returned %d\n", x);
buf1[x] = '\0';
debug(54, 0) ("--> got '%s'\n", rfc1738_escape(buf1));
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
x = send(pwfd_ipc, ok_string, strlen(ok_string), 0);
x = recv(prfd_ipc, buf1 + 200, 8191 - 200, 0);
assert((size_t) x == strlen(ok_string)
&& !strncmp(ok_string, buf1 + 200, strlen(ok_string)));
} /* IPC_UDP_SOCKET */
snprintf(buf1, 8191, "%s(%ld) CHILD socket", prog, (long int) pid);
fd_note(fd, buf1);
if (prfd_ipc != -1) {
snprintf(buf1, 8191, "%s(%ld) <-> ipc CHILD socket", prog, (long int) pid);
fd_note(crfd_ipc, buf1);
snprintf(buf1, 8191, "%s(%ld) <-> ipc PARENT socket", prog, (long int) pid);
fd_note(prfd_ipc, buf1);
}
/* else { IPC_TCP_SOCKET */
/* commSetNoLinger(fd); */
/* } */
thread_params.prog = prog;
thread_params.send_fd = cwfd;
thread_params.pid = pid;
if ((thread_params.type = type) == IPC_TCP_SOCKET)
thread_params.rfd = p2c[0];
else
thread_params.rfd = prfd_ipc;
thread =
(HANDLE) _beginthreadex(NULL, 0, ipc_thread_2, &thread_params, 0, NULL);
if (!thread) {
debug(54, 0) ("ipcCreate: CHILD: _beginthreadex: %s\n", xstrerror());
ipcSend(cwfd, err_string, strlen(err_string));
goto cleanup;
}
snprintf(buf1, 8191, "%ld\n", (long int) pid);
if (-1 == ipcSend(cwfd, buf1, strlen(buf1)))
goto cleanup;
debug(54, 2) ("ipc(%s,%ld): started successfully\n", prog, (long int) pid);
/* cycle */
for (;;) {
x = recv(crfd, buf1, 8192, 0);
if (x <= 0) {
debug(54, 3) ("ipc(%s,%d): %d bytes received from parent. Exiting...\n",
prog, pid, x);
break;
}
buf1[x] = '\0';
if (type == IPC_UDP_SOCKET && !strcmp(buf1, shutdown_string)) {
debug(54, 3)
("ipc(%s,%d): request for shutdown received from parent. Exiting...\n",
prog, pid);
TerminateProcess(hProcess, 0);
break;
}
debug(54, 5) ("ipc(%s,%d): received from parent: %s\n", prog, pid,
rfc1738_escape_unescaped(buf1));
if (type == IPC_TCP_SOCKET)
x = write(c2p[1], buf1, x);
else
x = send(pwfd_ipc, buf1, x, 0);
if (x <= 0) {
debug(54, 3) ("ipc(%s,%d): %d bytes written to %s. Exiting...\n",
prog, pid, x, prog);
break;
}
}
retval = 0;
cleanup:
if (c2p[1] != -1)
close(c2p[1]);
if (fd_table[crfd].flags.open)
ipcCloseAllFD(-1, -1, crfd, cwfd);
if (prfd_ipc != -1) {
send(crfd_ipc, shutdown_string, strlen(shutdown_string), 0);
shutdown(crfd_ipc, SD_BOTH);
shutdown(prfd_ipc, SD_BOTH);
}
ipcCloseAllFD(prfd_ipc, pwfd_ipc, crfd_ipc, cwfd_ipc);
if (hProcess && WAIT_OBJECT_0 !=
WaitForSingleObject(hProcess, type == IPC_UDP_SOCKET ? 12000 : 5000)) {
getCurrentTime();
debug(54, 0) ("ipc(%s,%d): WARNING: %s didn't exit in %d seconds.\n",
prog, pid, prog, type == IPC_UDP_SOCKET ? 12 : 5);
}
if (thread && WAIT_OBJECT_0 != WaitForSingleObject(thread, 3000)) {
getCurrentTime();
debug(54, 0)
("ipc(%s,%d): WARNING: ipc_thread_2 didn't exit in 3 seconds.\n",
prog, pid);
}
getCurrentTime();
if (!retval)
debug(54, 2) ("ipc(%s,%d): normal exit\n", prog, pid);
if (buf1)
xfree(buf1);
if (prog)
xfree(prog);
if (env_str)
xfree(env_str);
if (thread)
CloseHandle(thread);
if (hProcess)
CloseHandle(hProcess);
if (p2c[0] != -1)
close(p2c[0]);
return retval;
}
