src/ipc_win32.cc

   1 /*
   2  * $Id$
   3  *
   4  * DEBUG: section 54    Windows Interprocess Communication
   5  * AUTHOR: Andrey Shorin <tolsty@tushino.com>
   6  * AUTHOR: Guido Serassio <serassio@squid-cache.org>
   7  *
   8  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   9  * ----------------------------------------------------------
  10  *
  11  *  Squid is the result of efforts by numerous individuals from
  12  *  the Internet community; see the CONTRIBUTORS file for full
  13  *  details.   Many organizations have provided support for Squid's
  14  *  development; see the SPONSORS file for full details.  Squid is
  15  *  Copyrighted (C) 2001 by the Regents of the University of
  16  *  California; see the COPYRIGHT file for full details.  Squid
  17  *  incorporates software developed and/or copyrighted by other
  18  *  sources; see the CREDITS file for full details.
  19  *
  20  *  This program is free software; you can redistribute it and/or modify
  21  *  it under the terms of the GNU General Public License as published by
  22  *  the Free Software Foundation; either version 2 of the License, or
  23  *  (at your option) any later version.
  24  *
  25  *  This program is distributed in the hope that it will be useful,
  26  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28  *  GNU General Public License for more details.
  29  *
  30  *  You should have received a copy of the GNU General Public License
  31  *  along with this program; if not, write to the Free Software
  32  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  33  *
  34  */
  35
  36 #include "squid.h"
  37 #include "comm.h"
  38 #include "fde.h"
  39 #include "ip/Address.h"
  40 #include "rfc1738.h"
  41 #include "SquidTime.h"
  42
  43 #ifndef _MSWSOCK_
  44 #include <mswsock.h>
  45 #endif
  46 #include <process.h>
  47
  48 struct ipc_params {
  49     int type;
  50     int crfd;
  51     int cwfd;
  52     Ip::Address local_addr;
  53     struct addrinfo PS;
  54     const char *prog;
  55     char **args;
  56 };
  57
  58 struct thread_params {
  59     int type;
  60     int rfd;
  61     int send_fd;
  62     const char *prog;
  63     pid_t pid;
  64 };
  65
  66 static unsigned int __stdcall ipc_thread_1(void *params);
  67 static unsigned int __stdcall ipc_thread_2(void *params);
  68
  69 static const char *ok_string = "OK\n";
  70 static const char *err_string = "ERR\n";
  71 static const char *shutdown_string = "$shutdown\n";
  72
  73 static const char *hello_string = "hi there\n";
  74 #define HELLO_BUF_SZ 32
  75 static char hello_buf[HELLO_BUF_SZ];
  76
  77 static int
  78 ipcCloseAllFD(int prfd, int pwfd, int crfd, int cwfd)
  79 {
  80     if (prfd >= 0)
  81         comm_close(prfd);
  82
  83     if (prfd != pwfd)
  84         if (pwfd >= 0)
  85             comm_close(pwfd);
  86
  87     if (crfd >= 0)
  88         comm_close(crfd);
  89
  90     if (crfd != cwfd)
  91         if (cwfd >= 0)
  92             comm_close(cwfd);
  93
  94     return -1;
  95 }
  96
  97 static void
  98 PutEnvironment()
  99 {
 100 #if HAVE_PUTENV
 101     char *env_str;
 102     int tmp_s;
 103     env_str = (char *)xcalloc((tmp_s = strlen(Debug::debugOptions) + 32), 1);
 104     snprintf(env_str, tmp_s, "SQUID_DEBUG=%s", Debug::debugOptions);
 105     putenv(env_str);
 106 #endif
 107 }
 108
 109 pid_t
 110 ipcCreate(int type, const char *prog, const char *const args[], const char *name, Ip::Address &local_addr, int *rfd, int *wfd, void **hIpc)
 111 {
 112     unsigned long thread;
 113
 114     struct ipc_params params;
 115     int opt;
 116     int optlen = sizeof(opt);
 117     DWORD ecode = 0;
 118     pid_t pid;
 119
 120     Ip::Address tmp_addr;
 121     struct addrinfo *aiCS = NULL;
 122     struct addrinfo *aiPS = NULL;
 123
 124     int crfd = -1;
 125     int prfd = -1;
 126     int cwfd = -1;
 127     int pwfd = -1;
 128     int x;
 129
 130     requirePathnameExists(name, prog);
 131
 132     if (rfd)
 133         *rfd = -1;
 134
 135     if (wfd)
 136         *wfd = -1;
 137
 138     if (hIpc)
 139         *hIpc = NULL;
 140
 141     if (WIN32_OS_version != _WIN_OS_WINNT) {
 142         getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *) &opt, &optlen);
 143         opt = opt & ~(SO_SYNCHRONOUS_NONALERT | SO_SYNCHRONOUS_ALERT);
 144         setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *) &opt, sizeof(opt));
 145     }
 146
 147     if (type == IPC_TCP_SOCKET) {
 148         crfd = cwfd = comm_open(SOCK_STREAM,
 149                                 IPPROTO_TCP,
 150                                 local_addr,
 151                                 COMM_NOCLOEXEC,
 152                                 name);
 153         prfd = pwfd = comm_open(SOCK_STREAM,
 154                                 IPPROTO_TCP,    /* protocol */
 155                                 local_addr,
 156                                 0,                      /* blocking */
 157                                 name);
 158     } else if (type == IPC_UDP_SOCKET) {
 159         crfd = cwfd = comm_open(SOCK_DGRAM,
 160                                 IPPROTO_UDP,
 161                                 local_addr,
 162                                 COMM_NOCLOEXEC,
 163                                 name);
 164         prfd = pwfd = comm_open(SOCK_DGRAM,
 165                                 IPPROTO_UDP,
 166                                 local_addr,
 167                                 0,
 168                                 name);
 169     } else if (type == IPC_FIFO) {
 170         debugs(54, 0, "ipcCreate: " << prog << ": use IPC_TCP_SOCKET instead of IP_FIFO on Windows");
 171         assert(0);
 172     } else {
 173         assert(IPC_NONE);
 174     }
 175
 176     debugs(54, 3, "ipcCreate: prfd FD " << prfd);
 177     debugs(54, 3, "ipcCreate: pwfd FD " << pwfd);
 178     debugs(54, 3, "ipcCreate: crfd FD " << crfd);
 179     debugs(54, 3, "ipcCreate: cwfd FD " << cwfd);
 180
 181     if (WIN32_OS_version != _WIN_OS_WINNT) {
 182         getsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *) &opt, &optlen);
 183         opt = opt | SO_SYNCHRONOUS_NONALERT;
 184         setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE, (char *) &opt, optlen);
 185     }
 186
 187     if (crfd < 0) {
 188         debugs(54, 0, "ipcCreate: Failed to create child FD.");
 189         return ipcCloseAllFD(prfd, pwfd, crfd, cwfd);
 190     }
 191
 192     if (pwfd < 0) {
 193         debugs(54, 0, "ipcCreate: Failed to create server FD.");
 194         return ipcCloseAllFD(prfd, pwfd, crfd, cwfd);
 195     }
 196
 197 // AYJ: these flags should be neutral, but if not IPv6 version needs adding
 198     if (type == IPC_TCP_SOCKET || type == IPC_UDP_SOCKET) {
 199
 200         tmp_addr.InitAddrInfo(aiPS);
 201
 202         if (getsockname(pwfd, aiPS->ai_addr, &(aiPS->ai_addrlen) ) < 0) {
 203             debugs(54, 0, "ipcCreate: getsockname: " << xstrerror());
 204             return ipcCloseAllFD(prfd, pwfd, crfd, cwfd);
 205         }
 206
 207         tmp_addr = *aiPS;
 208
 209         debugs(54, 3, "ipcCreate: FD " << pwfd << " sockaddr " << tmp_addr );
 210
 211         tmp_addr.InitAddrInfo(aiCS);
 212
 213         if (getsockname(crfd, aiCS->ai_addr, &(aiCS->ai_addrlen) ) < 0) {
 214             debugs(54, 0, "ipcCreate: getsockname: " << xstrerror());
 215             return ipcCloseAllFD(prfd, pwfd, crfd, cwfd);
 216         }
 217
 218         tmp_addr.SetEmpty();
 219         tmp_addr = *aiCS;
 220
 221         debugs(54, 3, "ipcCreate: FD " << crfd << " sockaddr " << tmp_addr );
 222     }
 223
 224     if (type == IPC_TCP_SOCKET) {
 225         if (listen(crfd, 1) < 0) {
 226             debugs(54, 1, "ipcCreate: listen FD " << crfd << ": " << xstrerror());
 227             return ipcCloseAllFD(prfd, pwfd, crfd, cwfd);
 228         }
 229
 230         debugs(54, 3, "ipcCreate: FD " << crfd << " listening...");
 231     }
 232
 233     /* flush or else we get dup data if unbuffered_logs is set */
 234     logsFlush();
 235
 236     params.type = type;
 237
 238     params.crfd = crfd;
 239
 240     params.cwfd = cwfd;
 241
 242     params.PS = *aiPS;
 243
 244     params.local_addr = local_addr;
 245
 246     params.prog = prog;
 247
 248     params.args = (char **) args;
 249
 250     thread = _beginthreadex(NULL, 0, ipc_thread_1, &params, 0, NULL);
 251
 252     if (thread == 0) {
 253         debugs(54, 1, "ipcCreate: _beginthread: " << xstrerror());
 254         return ipcCloseAllFD(prfd, pwfd, crfd, cwfd);
 255     }
 256
 257     /* NP: tmp_addr was left with eiether empty or aiCS in Ip::Address format */
 258     if (comm_connect_addr(pwfd, tmp_addr) == COMM_ERROR) {
 259         CloseHandle((HANDLE) thread);
 260         return ipcCloseAllFD(prfd, pwfd, -1, -1);
 261     }
 262
 263     memset(hello_buf, '\0', HELLO_BUF_SZ);
 264     x = recv(prfd, (void *)hello_buf, HELLO_BUF_SZ - 1, 0);
 265
 266     if (x < 0) {
 267         debugs(54, 0, "ipcCreate: PARENT: hello read test failed");
 268         debugs(54, 0, "--> read: " << xstrerror());
 269         CloseHandle((HANDLE) thread);
 270         return ipcCloseAllFD(prfd, pwfd, -1, -1);
 271     } else if (strcmp(hello_buf, hello_string)) {
 272         debugs(54, 0, "ipcCreate: PARENT: hello read test failed");
 273         debugs(54, 0, "--> read returned " << x);
 274         debugs(54, 0, "--> got '" << rfc1738_escape(hello_buf) << "'");
 275         CloseHandle((HANDLE) thread);
 276         return ipcCloseAllFD(prfd, pwfd, -1, -1);
 277     }
 278
 279     x = send(pwfd, (const void *)ok_string, strlen(ok_string), 0);
 280
 281     if (x < 0) {
 282         debugs(54, 0, "ipcCreate: PARENT: OK write test failed");
 283         debugs(54, 0, "--> read: " << xstrerror());
 284         CloseHandle((HANDLE) thread);
 285         return ipcCloseAllFD(prfd, pwfd, -1, -1);
 286     }
 287
 288     memset(hello_buf, '\0', HELLO_BUF_SZ);
 289     x = recv(prfd, (void *)hello_buf, HELLO_BUF_SZ - 1, 0);
 290
 291     if (x < 0) {
 292         debugs(54, 0, "ipcCreate: PARENT: OK read test failed");
 293         debugs(54, 0, "--> read: " << xstrerror());
 294         CloseHandle((HANDLE) thread);
 295         return ipcCloseAllFD(prfd, pwfd, -1, -1);
 296     } else if (!strcmp(hello_buf, err_string)) {
 297         debugs(54, 0, "ipcCreate: PARENT: OK read test failed");
 298         debugs(54, 0, "--> read returned " << x);
 299         debugs(54, 0, "--> got '" << rfc1738_escape(hello_buf) << "'");
 300         CloseHandle((HANDLE) thread);
 301         return ipcCloseAllFD(prfd, pwfd, -1, -1);
 302     }
 303
 304     hello_buf[x] = '\0';
 305     pid = atol(hello_buf);
 306     commSetTimeout(prfd, -1, NULL, NULL);
 307     commSetNonBlocking(prfd);
 308     commSetNonBlocking(pwfd);
 309     commSetCloseOnExec(prfd);
 310     commSetCloseOnExec(pwfd);
 311
 312     if (rfd)
 313         *rfd = prfd;
 314
 315     if (wfd)
 316         *wfd = pwfd;
 317
 318     fd_table[prfd].flags.ipc = 1;
 319
 320     fd_table[pwfd].flags.ipc = 1;
 321
 322     fd_table[crfd].flags.ipc = 1;
 323
 324     fd_table[cwfd].flags.ipc = 1;
 325
 326     if (Config.sleep_after_fork) {
 327         /* XXX emulation of usleep() */
 328         DWORD sl;
 329         sl = Config.sleep_after_fork / 1000;
 330
 331         if (sl == 0)
 332             sl = 1;
 333
 334         Sleep(sl);
 335     }
 336
 337     if (GetExitCodeThread((HANDLE) thread, &ecode) && ecode == STILL_ACTIVE) {
 338         if (hIpc)
 339             *hIpc = (HANDLE) thread;
 340
 341         return pid;
 342     } else {
 343         CloseHandle((HANDLE) thread);
 344         return ipcCloseAllFD(prfd, pwfd, -1, -1);
 345     }
 346 }
 347
 348 static int
 349 ipcSend(int cwfd, const char *buf, int len)
 350 {
 351     int x;
 352
 353     x = send(cwfd, (const void *)buf, len, 0);
 354
 355     if (x < 0) {
 356         debugs(54, 0, "sendto FD " << cwfd << ": " << xstrerror());
 357         debugs(54, 0, "ipcCreate: CHILD: hello write test failed");
 358     }
 359
 360     return x;
 361 }
 362
 363 static unsigned int __stdcall
 364 ipc_thread_1(void *in_params)
 365 {
 366     int t1, t2, t3, retval = -1;
 367     int p2c[2] = {-1, -1};
 368     int c2p[2] = {-1, -1};
 369     HANDLE hProcess = NULL, thread = NULL;
 370     pid_t pid = -1;
 371
 372     struct thread_params thread_params;
 373     ssize_t x;
 374     int fd = -1;
 375     char *str;
 376     STARTUPINFO si;
 377     PROCESS_INFORMATION pi;
 378     long F;
 379     int prfd_ipc = -1, pwfd_ipc = -1, crfd_ipc = -1, cwfd_ipc = -1;
 380     char *prog = NULL, *buf1 = NULL;
 381
 382     Ip::Address PS_ipc;
 383     Ip::Address CS_ipc;
 384     struct addrinfo *aiPS_ipc = NULL;
 385     struct addrinfo *aiCS_ipc = NULL;
 386
 387     struct ipc_params *params = (struct ipc_params *) in_params;
 388     int type = params->type;
 389     int crfd = params->crfd;
 390     int cwfd = params->cwfd;
 391     char **args = params->args;
 392
 393     Ip::Address PS = params->PS;
 394     Ip::Address local_addr = params->local_addr;
 395
 396     buf1 = (char *)xcalloc(1, 8192);
 397     strcpy(buf1, params->prog);
 398     prog = strtok(buf1, w_space);
 399
 400     if ((str = strrchr(prog, '/')))
 401         prog = ++str;
 402
 403     if ((str = strrchr(prog, '\\')))
 404         prog = ++str;
 405
 406     prog = xstrdup(prog);
 407
 408     if (type == IPC_TCP_SOCKET) {
 409         debugs(54, 3, "ipcCreate: calling accept on FD " << crfd);
 410
 411         if ((fd = accept(crfd, NULL, NULL)) < 0) {
 412             debugs(54, 0, "ipcCreate: FD " << crfd << " accept: " << xstrerror());
 413             goto cleanup;
 414         }
 415
 416         debugs(54, 3, "ipcCreate: CHILD accepted new FD " << fd);
 417         comm_close(crfd);
 418         snprintf(buf1, 8191, "%s CHILD socket", prog);
 419         fd_open(fd, FD_SOCKET, buf1);
 420         fd_table[fd].flags.ipc = 1;
 421         cwfd = crfd = fd;
 422     } else if (type == IPC_UDP_SOCKET) {
 423         if (comm_connect_addr(crfd, params->PS) == COMM_ERROR)
 424             goto cleanup;
 425     }
 426
 427     x = send(cwfd, (const void *)hello_string, strlen(hello_string) + 1, 0);
 428
 429     if (x < 0) {
 430         debugs(54, 0, "sendto FD " << cwfd << ": " << xstrerror());
 431         debugs(54, 0, "ipcCreate: CHILD: hello write test failed");
 432         goto cleanup;
 433     }
 434
 435     PutEnvironment();
 436     memset(buf1, '\0', sizeof(buf1));
 437     x = recv(crfd, (void *)buf1, 8191, 0);
 438
 439     if (x < 0) {
 440         debugs(54, 0, "ipcCreate: CHILD: OK read test failed");
 441         debugs(54, 0, "--> read: " << xstrerror());
 442         goto cleanup;
 443     } else if (strcmp(buf1, ok_string)) {
 444         debugs(54, 0, "ipcCreate: CHILD: OK read test failed");
 445         debugs(54, 0, "--> read returned " << x);
 446         debugs(54, 0, "--> got '" << rfc1738_escape(hello_buf) << "'");
 447         goto cleanup;
 448     }
 449
 450     /* assign file descriptors to child process */
 451     if (_pipe(p2c, 1024, _O_BINARY | _O_NOINHERIT) < 0) {
 452         debugs(54, 0, "ipcCreate: CHILD: pipe: " << xstrerror());
 453         ipcSend(cwfd, err_string, strlen(err_string));
 454         goto cleanup;
 455     }
 456
 457     if (_pipe(c2p, 1024, _O_BINARY | _O_NOINHERIT) < 0) {
 458         debugs(54, 0, "ipcCreate: CHILD: pipe: " << xstrerror());
 459         ipcSend(cwfd, err_string, strlen(err_string));
 460         goto cleanup;
 461     }
 462
 463     if (type == IPC_UDP_SOCKET) {
 464         snprintf(buf1, 8192, "%s(%ld) <-> ipc CHILD socket", prog, -1L);
 465         crfd_ipc = cwfd_ipc = comm_open(SOCK_DGRAM, IPPROTO_UDP, local_addr, 0, buf1);
 466
 467         if (crfd_ipc < 0) {
 468             debugs(54, 0, "ipcCreate: CHILD: Failed to create child FD for " << prog << ".");
 469             ipcSend(cwfd, err_string, strlen(err_string));
 470             goto cleanup;
 471         }
 472
 473         snprintf(buf1, 8192, "%s(%ld) <-> ipc PARENT socket", prog, -1L);
 474         prfd_ipc = pwfd_ipc = comm_open(SOCK_DGRAM, IPPROTO_UDP, local_addr, 0, buf1);
 475
 476         if (pwfd_ipc < 0) {
 477             debugs(54, 0, "ipcCreate: CHILD: Failed to create server FD for " << prog << ".");
 478             ipcSend(cwfd, err_string, strlen(err_string));
 479             goto cleanup;
 480         }
 481
 482         PS_ipc.InitAddrInfo(aiPS_ipc);
 483
 484         if (getsockname(pwfd_ipc, aiPS_ipc->ai_addr, &(aiPS_ipc->ai_addrlen)) < 0) {
 485             debugs(54, 0, "ipcCreate: getsockname: " << xstrerror());
 486             ipcSend(cwfd, err_string, strlen(err_string));
 487             goto cleanup;
 488         }
 489
 490         PS_ipc = *aiPS_ipc;
 491
 492         debugs(54, 3, "ipcCreate: FD " << pwfd_ipc << " sockaddr " << PS_ipc);
 493
 494         CS_ipc.InitAddrInfo(aiCS_ipc);
 495
 496         if (getsockname(crfd_ipc, aiCS_ipc->ai_addr, &(aiCS_ipc->ai_addrlen)) < 0) {
 497             debugs(54, 0, "ipcCreate: getsockname: " << xstrerror());
 498             ipcSend(cwfd, err_string, strlen(err_string));
 499             goto cleanup;
 500         }
 501
 502         CS_ipc = *aiCS_ipc;
 503
 504         debugs(54, 3, "ipcCreate: FD " << crfd_ipc << " sockaddr " << CS_ipc);
 505
 506         if (comm_connect_addr(pwfd_ipc, CS_ipc) == COMM_ERROR) {
 507             ipcSend(cwfd, err_string, strlen(err_string));
 508             goto cleanup;
 509         }
 510
 511         fd = crfd;
 512
 513         if (comm_connect_addr(crfd_ipc, PS_ipc) == COMM_ERROR) {
 514             ipcSend(cwfd, err_string, strlen(err_string));
 515             goto cleanup;
 516         }
 517     }                           /* IPC_UDP_SOCKET */
 518
 519     t1 = dup(0);
 520
 521     t2 = dup(1);
 522
 523     t3 = dup(2);
 524
 525     dup2(c2p[0], 0);
 526
 527     dup2(p2c[1], 1);
 528
 529     dup2(fileno(debug_log), 2);
 530
 531     close(c2p[0]);
 532
 533     close(p2c[1]);
 534
 535     commUnsetNonBlocking(fd);
 536
 537     memset(&si, 0, sizeof(STARTUPINFO));
 538
 539     si.cb = sizeof(STARTUPINFO);
 540
 541     si.hStdInput = (HANDLE) _get_osfhandle(0);
 542
 543     si.hStdOutput = (HANDLE) _get_osfhandle(1);
 544
 545     si.hStdError = (HANDLE) _get_osfhandle(2);
 546
 547     si.dwFlags = STARTF_USESTDHANDLES;
 548
 549     /* Make sure all other valid handles are not inerithable */
 550     for (x = 3; x < Squid_MaxFD; x++) {
 551         if ((F = _get_osfhandle(x)) == -1)
 552             continue;
 553
 554         SetHandleInformation((HANDLE) F, HANDLE_FLAG_INHERIT, 0);
 555     }
 556
 557     *buf1 = '\0';
 558     strcpy(buf1 + 4096, params->prog);
 559     str = strtok(buf1 + 4096, w_space);
 560
 561     do {
 562         strcat(buf1, str);
 563         strcat(buf1, " ");
 564     } while ((str = strtok(NULL, w_space)));
 565
 566     x = 1;
 567
 568     while (args[x]) {
 569         strcat(buf1, args[x++]);
 570         strcat(buf1, " ");
 571     }
 572
 573     if (CreateProcess(buf1 + 4096, buf1, NULL, NULL, TRUE, CREATE_NO_WINDOW,
 574                       NULL, NULL, &si, &pi)) {
 575         pid = pi.dwProcessId;
 576         hProcess = pi.hProcess;
 577     } else {
 578         pid = -1;
 579         WIN32_maperror(GetLastError());
 580         x = errno;
 581     }
 582
 583     dup2(t1, 0);
 584     dup2(t2, 1);
 585     dup2(t3, 2);
 586     close(t1);
 587     close(t2);
 588     close(t3);
 589
 590     if (pid == -1) {
 591         errno = x;
 592         debugs(54, 0, "ipcCreate: CHILD: " << params->prog << ": " << xstrerror());
 593
 594         ipcSend(cwfd, err_string, strlen(err_string));
 595         goto cleanup;
 596     }
 597
 598     if (type == IPC_UDP_SOCKET) {
 599         WSAPROTOCOL_INFO wpi;
 600
 601         memset(&wpi, 0, sizeof(wpi));
 602
 603         if (SOCKET_ERROR == WSADuplicateSocket(crfd_ipc, pid, &wpi)) {
 604             debugs(54, 0, "ipcCreate: CHILD: WSADuplicateSocket: " << xstrerror());
 605
 606             ipcSend(cwfd, err_string, strlen(err_string));
 607             goto cleanup;
 608         }
 609
 610         x = write(c2p[1], (const char *) &wpi, sizeof(wpi));
 611
 612         if (x < (ssize_t)sizeof(wpi)) {
 613             debugs(54, 0, "ipcCreate: CHILD: write FD " << c2p[1] << ": " << xstrerror());
 614             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 615
 616             ipcSend(cwfd, err_string, strlen(err_string));
 617             goto cleanup;
 618         }
 619
 620         x = read(p2c[0], buf1, 8192);
 621
 622         if (x < 0) {
 623             debugs(54, 0, "ipcCreate: CHILD: read FD " << p2c[0] << ": " << xstrerror());
 624             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 625
 626             ipcSend(cwfd, err_string, strlen(err_string));
 627             goto cleanup;
 628         } else if (strncmp(buf1, ok_string, strlen(ok_string))) {
 629             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 630             debugs(54, 0, "--> read returned " << x);
 631             buf1[x] = '\0';
 632             debugs(54, 0, "--> got '" << rfc1738_escape(buf1) << "'");
 633             ipcSend(cwfd, err_string, strlen(err_string));
 634             goto cleanup;
 635         }
 636
 637         x = write(c2p[1], (const char *) &PS_ipc, sizeof(PS_ipc));
 638
 639         if (x < (ssize_t)sizeof(PS_ipc)) {
 640             debugs(54, 0, "ipcCreate: CHILD: write FD " << c2p[1] << ": " << xstrerror());
 641             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 642
 643             ipcSend(cwfd, err_string, strlen(err_string));
 644             goto cleanup;
 645         }
 646
 647         x = read(p2c[0], buf1, 8192);
 648
 649         if (x < 0) {
 650             debugs(54, 0, "ipcCreate: CHILD: read FD " << p2c[0] << ": " << xstrerror());
 651             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 652
 653             ipcSend(cwfd, err_string, strlen(err_string));
 654             goto cleanup;
 655         } else if (strncmp(buf1, ok_string, strlen(ok_string))) {
 656             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 657             debugs(54, 0, "--> read returned " << x);
 658             buf1[x] = '\0';
 659             debugs(54, 0, "--> got '" << rfc1738_escape(buf1) << "'");
 660             ipcSend(cwfd, err_string, strlen(err_string));
 661             goto cleanup;
 662         }
 663
 664         x = send(pwfd_ipc, (const void *)ok_string, strlen(ok_string), 0);
 665         x = recv(prfd_ipc, (void *)(buf1 + 200), 8191 - 200, 0);
 666         assert((size_t) x == strlen(ok_string)
 667                && !strncmp(ok_string, buf1 + 200, strlen(ok_string)));
 668     }                           /* IPC_UDP_SOCKET */
 669
 670     snprintf(buf1, 8191, "%s(%ld) CHILD socket", prog, (long int) pid);
 671
 672     fd_note(fd, buf1);
 673
 674     if (prfd_ipc != -1) {
 675         snprintf(buf1, 8191, "%s(%ld) <-> ipc CHILD socket", prog, (long int) pid);
 676         fd_note(crfd_ipc, buf1);
 677         snprintf(buf1, 8191, "%s(%ld) <-> ipc PARENT socket", prog, (long int) pid);
 678         fd_note(prfd_ipc, buf1);
 679     }
 680
 681     /* else {                       IPC_TCP_SOCKET */
 682     /*     commSetNoLinger(fd); */
 683     /*  } */
 684     thread_params.prog = prog;
 685
 686     thread_params.send_fd = cwfd;
 687
 688     thread_params.pid = pid;
 689
 690     if ((thread_params.type = type) == IPC_TCP_SOCKET)
 691         thread_params.rfd = p2c[0];
 692     else
 693         thread_params.rfd = prfd_ipc;
 694
 695     thread = (HANDLE)_beginthreadex(NULL, 0, ipc_thread_2, &thread_params, 0, NULL);
 696
 697     if (!thread) {
 698         debugs(54, 0, "ipcCreate: CHILD: _beginthreadex: " << xstrerror());
 699         ipcSend(cwfd, err_string, strlen(err_string));
 700         goto cleanup;
 701     }
 702
 703     snprintf(buf1, 8191, "%ld\n", (long int) pid);
 704
 705     if (-1 == ipcSend(cwfd, buf1, strlen(buf1)))
 706         goto cleanup;
 707
 708     debugs(54, 2, "ipc(" << prog << "," << pid << "): started successfully");
 709
 710     /* cycle */
 711     for (;;) {
 712         x = recv(crfd, (void *)buf1, 8192, 0);
 713
 714         if (x <= 0) {
 715             debugs(54, 3, "ipc(" << prog << "," << pid << "): " << x << " bytes received from parent. Exiting...");
 716             break;
 717         }
 718
 719         buf1[x] = '\0';
 720
 721         if (type == IPC_UDP_SOCKET && !strcmp(buf1, shutdown_string)) {
 722             debugs(54, 3, "ipc(" << prog << "," << pid << "): request for shutdown received from parent. Exiting...");
 723
 724             TerminateProcess(hProcess, 0);
 725             break;
 726         }
 727
 728         debugs(54, 5, "ipc(" << prog << "," << pid << "): received from parent: " << rfc1738_escape_unescaped(buf1));
 729
 730         if (type == IPC_TCP_SOCKET)
 731             x = write(c2p[1], buf1, x);
 732         else
 733             x = send(pwfd_ipc, (const void *)buf1, x, 0);
 734
 735         if (x <= 0) {
 736             debugs(54, 3, "ipc(" << prog << "," << pid << "): " << x << " bytes written to " << prog << ". Exiting...");
 737
 738             break;
 739         }
 740     }
 741
 742     retval = 0;
 743
 744 cleanup:
 745
 746     if (c2p[1] != -1)
 747         close(c2p[1]);
 748
 749     if (fd_table[crfd].flags.open)
 750         ipcCloseAllFD(-1, -1, crfd, cwfd);
 751
 752     if (prfd_ipc != -1) {
 753         send(crfd_ipc, (const void *)shutdown_string, strlen(shutdown_string), 0);
 754         shutdown(crfd_ipc, SD_BOTH);
 755         shutdown(prfd_ipc, SD_BOTH);
 756     }
 757
 758     ipcCloseAllFD(prfd_ipc, pwfd_ipc, crfd_ipc, cwfd_ipc);
 759
 760     if (hProcess && WAIT_OBJECT_0 !=
 761             WaitForSingleObject(hProcess, type == IPC_UDP_SOCKET ? 12000 : 5000)) {
 762
 763         getCurrentTime();
 764         debugs(54, 0, "ipc(" << prog << "," << pid << "): WARNING: " << prog <<
 765                " didn't exit in " << (type == IPC_UDP_SOCKET ? 12 : 5) << " seconds.");
 766
 767     }
 768
 769     if (thread && WAIT_OBJECT_0 != WaitForSingleObject(thread, 3000)) {
 770         getCurrentTime();
 771         debugs(54, 0, "ipc(" << prog << "," << pid << "): WARNING: ipc_thread_2 didn't exit in 3 seconds.");
 772
 773     }
 774
 775     getCurrentTime();
 776
 777     if (!retval)
 778         debugs(54, 2, "ipc(" << prog << "," << pid << "): normal exit");
 779
 780     if (buf1)
 781         xfree(buf1);
 782
 783     if (prog)
 784         xfree(prog);
 785
 786     if (thread)
 787         CloseHandle(thread);
 788
 789     if (hProcess)
 790         CloseHandle(hProcess);
 791
 792     if (p2c[0] != -1)
 793         close(p2c[0]);
 794
 795     return retval;
 796 }
 797
 798 static unsigned int __stdcall
 799 ipc_thread_2(void *in_params)
 800 {
 801     int x;
 802
 803     struct thread_params *params = (struct thread_params *) in_params;
 804     int type = params->type;
 805     int rfd = params->rfd;
 806     int send_fd = params->send_fd;
 807     char *prog = xstrdup(params->prog);
 808     pid_t pid = params->pid;
 809     char *buf2 = (char *)xcalloc(1, 8192);
 810
 811     for (;;) {
 812         if (type == IPC_TCP_SOCKET)
 813             x = read(rfd, buf2, 8192);
 814         else
 815             x = recv(rfd, (void *)buf2, 8192, 0);
 816
 817         if ((x <= 0 && type == IPC_TCP_SOCKET) ||
 818                 (x < 0 && type == IPC_UDP_SOCKET)) {
 819             debugs(54, 3, "ipc(" << prog << "," << pid << "): " << x << " bytes read from " << prog << ". Exiting...");
 820
 821             break;
 822         }
 823
 824         buf2[x] = '\0';
 825
 826         if (type == IPC_UDP_SOCKET && !strcmp(buf2, shutdown_string)) {
 827             debugs(54, 3, "ipc(" << prog << "," << pid << "): request for shutdown received. Exiting...");
 828
 829             break;
 830         }
 831
 832         if (x >= 2) {
 833             if ((buf2[x - 1] == '\n') && (buf2[x - 2] == '\r')) {
 834                 buf2[x - 2] = '\n';
 835                 buf2[x - 1] = '\0';
 836                 x--;
 837             }
 838         }
 839
 840         debugs(54, 5, "ipc(" << prog << "," << pid << "): received from child : " << rfc1738_escape_unescaped(buf2));
 841
 842         x = send(send_fd, (const void *)buf2, x, 0);
 843
 844         if ((x <= 0 && type == IPC_TCP_SOCKET) ||
 845                 (x < 0 && type == IPC_UDP_SOCKET)) {
 846             debugs(54, 3, "ipc(" << prog << "," << pid << "): " << x << " bytes sent to parent. Exiting...");
 847
 848             break;
 849         }
 850     }
 851
 852     xfree(prog);
 853     xfree(buf2);
 854     return 0;
 855 }