src/ipc_win32.cc

   1 /*
   2  * $Id: ipc_win32.cc,v 1.5 2007/12/14 23:11:47 amosjeffries Exp $
   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 "SquidTime.h"
  40
  41 #ifndef _MSWSOCK_
  42 #include <mswsock.h>
  43 #endif
  44 #include <process.h>
  45
  46 struct ipc_params
  47 {
  48     int type;
  49     int crfd;
  50     int cwfd;
  51     IPAddress local_addr;
  52     struct addrinfo PS;
  53     const char *prog;
  54     char **args;
  55 };
  56
  57 struct thread_params
  58 {
  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(Config.debugOptions) + 32), 1);
 104     snprintf(env_str, tmp_s, "SQUID_DEBUG=%s", Config.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, IPAddress &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     IPAddress 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 IPAddress 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] =
 368         {-1, -1};
 369     int c2p[2] =
 370         {-1, -1};
 371     HANDLE hProcess = NULL, thread = NULL;
 372     pid_t pid = -1;
 373
 374     struct thread_params thread_params;
 375     ssize_t x;
 376     int fd = -1;
 377     char *str;
 378     STARTUPINFO si;
 379     PROCESS_INFORMATION pi;
 380     long F;
 381     int prfd_ipc = -1, pwfd_ipc = -1, crfd_ipc = -1, cwfd_ipc = -1;
 382     char *prog = NULL, *buf1 = NULL;
 383
 384     IPAddress PS_ipc;
 385     IPAddress CS_ipc;
 386     struct addrinfo *aiPS_ipc = NULL;
 387     struct addrinfo *aiCS_ipc = NULL;
 388
 389     struct ipc_params *params = (struct ipc_params *) in_params;
 390     int type = params->type;
 391     int crfd = params->crfd;
 392     int cwfd = params->cwfd;
 393     char **args = params->args;
 394
 395     IPAddress PS = params->PS;
 396     IPAddress local_addr = params->local_addr;
 397
 398     buf1 = (char *)xcalloc(1, 8192);
 399     strcpy(buf1, params->prog);
 400     prog = strtok(buf1, w_space);
 401
 402     if ((str = strrchr(prog, '/')))
 403         prog = ++str;
 404
 405     if ((str = strrchr(prog, '\\')))
 406         prog = ++str;
 407
 408     prog = xstrdup(prog);
 409
 410     if (type == IPC_TCP_SOCKET) {
 411         debugs(54, 3, "ipcCreate: calling accept on FD " << crfd);
 412
 413         if ((fd = accept(crfd, NULL, NULL)) < 0) {
 414             debugs(54, 0, "ipcCreate: FD " << crfd << " accept: " << xstrerror());
 415             goto cleanup;
 416         }
 417
 418         debugs(54, 3, "ipcCreate: CHILD accepted new FD " << fd);
 419         comm_close(crfd);
 420         snprintf(buf1, 8191, "%s CHILD socket", prog);
 421         fd_open(fd, FD_SOCKET, buf1);
 422         fd_table[fd].flags.ipc = 1;
 423         cwfd = crfd = fd;
 424     } else if (type == IPC_UDP_SOCKET) {
 425         if (comm_connect_addr(crfd, params->PS) == COMM_ERROR)
 426             goto cleanup;
 427     }
 428
 429     x = send(cwfd, (const void *)hello_string, strlen(hello_string) + 1, 0);
 430
 431     if (x < 0) {
 432         debugs(54, 0, "sendto FD " << cwfd << ": " << xstrerror());
 433         debugs(54, 0, "ipcCreate: CHILD: hello write test failed");
 434         goto cleanup;
 435     }
 436
 437     PutEnvironment();
 438     memset(buf1, '\0', sizeof(buf1));
 439     x = recv(crfd, (void *)buf1, 8191, 0);
 440
 441     if (x < 0) {
 442         debugs(54, 0, "ipcCreate: CHILD: OK read test failed");
 443         debugs(54, 0, "--> read: " << xstrerror());
 444         goto cleanup;
 445     } else if (strcmp(buf1, ok_string)) {
 446         debugs(54, 0, "ipcCreate: CHILD: OK read test failed");
 447         debugs(54, 0, "--> read returned " << x);
 448         debugs(54, 0, "--> got '" << rfc1738_escape(hello_buf) << "'");
 449         goto cleanup;
 450     }
 451
 452     /* assign file descriptors to child process */
 453     if (_pipe(p2c, 1024, _O_BINARY | _O_NOINHERIT) < 0) {
 454         debugs(54, 0, "ipcCreate: CHILD: pipe: " << xstrerror());
 455         ipcSend(cwfd, err_string, strlen(err_string));
 456         goto cleanup;
 457     }
 458
 459     if (_pipe(c2p, 1024, _O_BINARY | _O_NOINHERIT) < 0) {
 460         debugs(54, 0, "ipcCreate: CHILD: pipe: " << xstrerror());
 461         ipcSend(cwfd, err_string, strlen(err_string));
 462         goto cleanup;
 463     }
 464
 465     if (type == IPC_UDP_SOCKET) {
 466         snprintf(buf1, 8192, "%s(%ld) <-> ipc CHILD socket", prog, -1L);
 467         crfd_ipc = cwfd_ipc = comm_open(SOCK_DGRAM, IPPROTO_UDP, local_addr, 0, buf1);
 468
 469         if (crfd_ipc < 0) {
 470             debugs(54, 0, "ipcCreate: CHILD: Failed to create child FD for " << prog << ".");
 471             ipcSend(cwfd, err_string, strlen(err_string));
 472             goto cleanup;
 473         }
 474
 475         snprintf(buf1, 8192, "%s(%ld) <-> ipc PARENT socket", prog, -1L);
 476         prfd_ipc = pwfd_ipc = comm_open(SOCK_DGRAM, IPPROTO_UDP, local_addr, 0, buf1);
 477
 478         if (pwfd_ipc < 0) {
 479             debugs(54, 0, "ipcCreate: CHILD: Failed to create server FD for " << prog << ".");
 480             ipcSend(cwfd, err_string, strlen(err_string));
 481             goto cleanup;
 482         }
 483
 484         PS_ipc.InitAddrInfo(aiPS_ipc);
 485
 486         if (getsockname(pwfd_ipc, aiPS_ipc->ai_addr, &(aiPS_ipc->ai_addrlen)) < 0) {
 487             debugs(54, 0, "ipcCreate: getsockname: " << xstrerror());
 488             ipcSend(cwfd, err_string, strlen(err_string));
 489             goto cleanup;
 490         }
 491
 492         PS_ipc = *aiPS_ipc;
 493
 494         debugs(54, 3, "ipcCreate: FD " << pwfd_ipc << " sockaddr " << PS_ipc);
 495
 496         CS_ipc.InitAddrInfo(aiCS_ipc);
 497
 498         if (getsockname(crfd_ipc, aiCS_ipc->ai_addr, &(aiCS_ipc->ai_addrlen)) < 0) {
 499             debugs(54, 0, "ipcCreate: getsockname: " << xstrerror());
 500             ipcSend(cwfd, err_string, strlen(err_string));
 501             goto cleanup;
 502         }
 503
 504         CS_ipc = *aiCS_ipc;
 505
 506         debugs(54, 3, "ipcCreate: FD " << crfd_ipc << " sockaddr " << CS_ipc);
 507
 508         if (comm_connect_addr(pwfd_ipc, CS_ipc) == COMM_ERROR) {
 509             ipcSend(cwfd, err_string, strlen(err_string));
 510             goto cleanup;
 511         }
 512
 513         fd = crfd;
 514
 515         if (comm_connect_addr(crfd_ipc, PS_ipc) == COMM_ERROR) {
 516             ipcSend(cwfd, err_string, strlen(err_string));
 517             goto cleanup;
 518         }
 519     }                           /* IPC_UDP_SOCKET */
 520
 521     t1 = dup(0);
 522
 523     t2 = dup(1);
 524
 525     t3 = dup(2);
 526
 527     dup2(c2p[0], 0);
 528
 529     dup2(p2c[1], 1);
 530
 531     dup2(fileno(debug_log), 2);
 532
 533     close(c2p[0]);
 534
 535     close(p2c[1]);
 536
 537     commUnsetNonBlocking(fd);
 538
 539     memset(&si, 0, sizeof(STARTUPINFO));
 540
 541     si.cb = sizeof(STARTUPINFO);
 542
 543     si.hStdInput = (HANDLE) _get_osfhandle(0);
 544
 545     si.hStdOutput = (HANDLE) _get_osfhandle(1);
 546
 547     si.hStdError = (HANDLE) _get_osfhandle(2);
 548
 549     si.dwFlags = STARTF_USESTDHANDLES;
 550
 551     /* Make sure all other valid handles are not inerithable */
 552     for (x = 3; x < Squid_MaxFD; x++) {
 553         if ((F = _get_osfhandle(x)) == -1)
 554             continue;
 555
 556         SetHandleInformation((HANDLE) F, HANDLE_FLAG_INHERIT, 0);
 557     }
 558
 559     *buf1 = '\0';
 560     strcpy(buf1 + 4096, params->prog);
 561     str = strtok(buf1 + 4096, w_space);
 562
 563     do {
 564         strcat(buf1, str);
 565         strcat(buf1, " ");
 566     } while ((str = strtok(NULL, w_space)));
 567
 568     x = 1;
 569
 570     while (args[x]) {
 571         strcat(buf1, args[x++]);
 572         strcat(buf1, " ");
 573     }
 574
 575     if (CreateProcess(buf1 + 4096, buf1, NULL, NULL, TRUE, CREATE_NO_WINDOW,
 576                       NULL, NULL, &si, &pi)) {
 577         pid = pi.dwProcessId;
 578         hProcess = pi.hProcess;
 579     } else {
 580         pid = -1;
 581         WIN32_maperror(GetLastError());
 582         x = errno;
 583     }
 584
 585     dup2(t1, 0);
 586     dup2(t2, 1);
 587     dup2(t3, 2);
 588     close(t1);
 589     close(t2);
 590     close(t3);
 591
 592     if (pid == -1) {
 593         errno = x;
 594         debugs(54, 0, "ipcCreate: CHILD: " << params->prog << ": " << xstrerror());
 595
 596         ipcSend(cwfd, err_string, strlen(err_string));
 597         goto cleanup;
 598     }
 599
 600     if (type == IPC_UDP_SOCKET) {
 601         WSAPROTOCOL_INFO wpi;
 602
 603         memset(&wpi, 0, sizeof(wpi));
 604
 605         if (SOCKET_ERROR == WSADuplicateSocket(crfd_ipc, pid, &wpi)) {
 606             debugs(54, 0, "ipcCreate: CHILD: WSADuplicateSocket: " << xstrerror());
 607
 608             ipcSend(cwfd, err_string, strlen(err_string));
 609             goto cleanup;
 610         }
 611
 612         x = write(c2p[1], (const char *) &wpi, sizeof(wpi));
 613
 614         if (x < (ssize_t)sizeof(wpi)) {
 615             debugs(54, 0, "ipcCreate: CHILD: write FD " << c2p[1] << ": " << xstrerror());
 616             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 617
 618             ipcSend(cwfd, err_string, strlen(err_string));
 619             goto cleanup;
 620         }
 621
 622         x = read(p2c[0], buf1, 8192);
 623
 624         if (x < 0) {
 625             debugs(54, 0, "ipcCreate: CHILD: read FD " << p2c[0] << ": " << xstrerror());
 626             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 627
 628             ipcSend(cwfd, err_string, strlen(err_string));
 629             goto cleanup;
 630         } else if (strncmp(buf1, ok_string, strlen(ok_string))) {
 631             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 632             debugs(54, 0, "--> read returned " << x);
 633             buf1[x] = '\0';
 634             debugs(54, 0, "--> got '" << rfc1738_escape(buf1) << "'");
 635             ipcSend(cwfd, err_string, strlen(err_string));
 636             goto cleanup;
 637         }
 638
 639         x = write(c2p[1], (const char *) &PS_ipc, sizeof(PS_ipc));
 640
 641         if (x < (ssize_t)sizeof(PS_ipc)) {
 642             debugs(54, 0, "ipcCreate: CHILD: write FD " << c2p[1] << ": " << xstrerror());
 643             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 644
 645             ipcSend(cwfd, err_string, strlen(err_string));
 646             goto cleanup;
 647         }
 648
 649         x = read(p2c[0], buf1, 8192);
 650
 651         if (x < 0) {
 652             debugs(54, 0, "ipcCreate: CHILD: read FD " << p2c[0] << ": " << xstrerror());
 653             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 654
 655             ipcSend(cwfd, err_string, strlen(err_string));
 656             goto cleanup;
 657         } else if (strncmp(buf1, ok_string, strlen(ok_string))) {
 658             debugs(54, 0, "ipcCreate: CHILD: " << prog << ": socket exchange failed");
 659             debugs(54, 0, "--> read returned " << x);
 660             buf1[x] = '\0';
 661             debugs(54, 0, "--> got '" << rfc1738_escape(buf1) << "'");
 662             ipcSend(cwfd, err_string, strlen(err_string));
 663             goto cleanup;
 664         }
 665
 666         x = send(pwfd_ipc, (const void *)ok_string, strlen(ok_string), 0);
 667         x = recv(prfd_ipc, (void *)(buf1 + 200), 8191 - 200, 0);
 668         assert((size_t) x == strlen(ok_string)
 669                && !strncmp(ok_string, buf1 + 200, strlen(ok_string)));
 670     }                           /* IPC_UDP_SOCKET */
 671
 672     snprintf(buf1, 8191, "%s(%ld) CHILD socket", prog, (long int) pid);
 673
 674     fd_note(fd, buf1);
 675
 676     if (prfd_ipc != -1) {
 677         snprintf(buf1, 8191, "%s(%ld) <-> ipc CHILD socket", prog, (long int) pid);
 678         fd_note(crfd_ipc, buf1);
 679         snprintf(buf1, 8191, "%s(%ld) <-> ipc PARENT socket", prog, (long int) pid);
 680         fd_note(prfd_ipc, buf1);
 681     }
 682
 683     /* else {                       IPC_TCP_SOCKET */
 684     /*     commSetNoLinger(fd); */
 685     /*  } */
 686     thread_params.prog = prog;
 687
 688     thread_params.send_fd = cwfd;
 689
 690     thread_params.pid = pid;
 691
 692     if ((thread_params.type = type) == IPC_TCP_SOCKET)
 693         thread_params.rfd = p2c[0];
 694     else
 695         thread_params.rfd = prfd_ipc;
 696
 697     thread =
 698         (HANDLE) _beginthreadex(NULL, 0, ipc_thread_2, &thread_params, 0, NULL);
 699
 700     if (!thread) {
 701         debugs(54, 0, "ipcCreate: CHILD: _beginthreadex: " << xstrerror());
 702         ipcSend(cwfd, err_string, strlen(err_string));
 703         goto cleanup;
 704     }
 705
 706     snprintf(buf1, 8191, "%ld\n", (long int) pid);
 707
 708     if (-1 == ipcSend(cwfd, buf1, strlen(buf1)))
 709         goto cleanup;
 710
 711         debugs(54, 2, "ipc(" << prog << "," << pid << "): started successfully");
 712
 713     /* cycle */
 714     for (;;) {
 715         x = recv(crfd, (void *)buf1, 8192, 0);
 716
 717         if (x <= 0) {
 718             debugs(54, 3, "ipc(" << prog << "," << pid << "): " << x << " bytes received from parent. Exiting...");
 719             break;
 720         }
 721
 722         buf1[x] = '\0';
 723
 724         if (type == IPC_UDP_SOCKET && !strcmp(buf1, shutdown_string)) {
 725             debugs(54, 3, "ipc(" << prog << "," << pid << "): request for shutdown received from parent. Exiting...");
 726
 727             TerminateProcess(hProcess, 0);
 728             break;
 729         }
 730
 731         debugs(54, 5, "ipc(" << prog << "," << pid << "): received from parent: " << rfc1738_escape_unescaped(buf1));
 732
 733         if (type == IPC_TCP_SOCKET)
 734             x = write(c2p[1], buf1, x);
 735         else
 736             x = send(pwfd_ipc, (const void *)buf1, x, 0);
 737
 738         if (x <= 0) {
 739             debugs(54, 3, "ipc(" << prog << "," << pid << "): " << x << " bytes written to " << prog << ". Exiting...");
 740
 741             break;
 742         }
 743     }
 744
 745     retval = 0;
 746
 747 cleanup:
 748
 749     if (c2p[1] != -1)
 750         close(c2p[1]);
 751
 752     if (fd_table[crfd].flags.open)
 753         ipcCloseAllFD(-1, -1, crfd, cwfd);
 754
 755     if (prfd_ipc != -1) {
 756         send(crfd_ipc, (const void *)shutdown_string, strlen(shutdown_string), 0);
 757         shutdown(crfd_ipc, SD_BOTH);
 758         shutdown(prfd_ipc, SD_BOTH);
 759     }
 760
 761     ipcCloseAllFD(prfd_ipc, pwfd_ipc, crfd_ipc, cwfd_ipc);
 762
 763     if (hProcess && WAIT_OBJECT_0 !=
 764             WaitForSingleObject(hProcess, type == IPC_UDP_SOCKET ? 12000 : 5000)) {
 765
 766         getCurrentTime();
 767         debugs(54, 0, "ipc(" << prog << "," << pid << "): WARNING: " << prog <<
 768                " didn't exit in " << (type == IPC_UDP_SOCKET ? 12 : 5) << " seconds.");
 769
 770     }
 771
 772     if (thread && WAIT_OBJECT_0 != WaitForSingleObject(thread, 3000)) {
 773         getCurrentTime();
 774         debugs(54, 0, "ipc(" << prog << "," << pid << "): WARNING: ipc_thread_2 didn't exit in 3 seconds.");
 775
 776     }
 777
 778     getCurrentTime();
 779
 780     if (!retval)
 781         debugs(54, 2, "ipc(" << prog << "," << pid << "): normal exit");
 782
 783     if (buf1)
 784         xfree(buf1);
 785
 786     if (prog)
 787         xfree(prog);
 788
 789     if (thread)
 790         CloseHandle(thread);
 791
 792     if (hProcess)
 793         CloseHandle(hProcess);
 794
 795     if (p2c[0] != -1)
 796         close(p2c[0]);
 797
 798     return retval;
 799 }
 800
 801 static unsigned int __stdcall
 802 ipc_thread_2(void *in_params)
 803 {
 804     int x;
 805
 806     struct thread_params *params = (struct thread_params *) in_params;
 807     int type = params->type;
 808     int rfd = params->rfd;
 809     int send_fd = params->send_fd;
 810     char *prog = xstrdup(params->prog);
 811     pid_t pid = params->pid;
 812     char *buf2 = (char *)xcalloc(1, 8192);
 813
 814     for (;;) {
 815         if (type == IPC_TCP_SOCKET)
 816             x = read(rfd, buf2, 8192);
 817         else
 818             x = recv(rfd, (void *)buf2, 8192, 0);
 819
 820         if ((x <= 0 && type == IPC_TCP_SOCKET) ||
 821                 (x < 0 && type == IPC_UDP_SOCKET)) {
 822             debugs(54, 3, "ipc(" << prog << "," << pid << "): " << x << " bytes read from " << prog << ". Exiting...");
 823
 824             break;
 825         }
 826
 827         buf2[x] = '\0';
 828
 829         if (type == IPC_UDP_SOCKET && !strcmp(buf2, shutdown_string)) {
 830             debugs(54, 3, "ipc(" << prog << "," << pid << "): request for shutdown received. Exiting...");
 831
 832             break;
 833         }
 834
 835         if (x >= 2) {
 836             if ((buf2[x - 1] == '\n') && (buf2[x - 2] == '\r')) {
 837                 buf2[x - 2] = '\n';
 838                 buf2[x - 1] = '\0';
 839                 x--;
 840             }
 841         }
 842
 843         debugs(54, 5, "ipc(" << prog << "," << pid << "): received from child : " << rfc1738_escape_unescaped(buf2));
 844
 845         x = send(send_fd, (const void *)buf2, x, 0);
 846
 847         if ((x <= 0 && type == IPC_TCP_SOCKET) ||
 848                 (x < 0 && type == IPC_UDP_SOCKET)) {
 849             debugs(54, 3, "ipc(" << prog << "," << pid << "): " << x << " bytes sent to parent. Exiting...");
 850
 851             break;
 852         }
 853     }
 854
 855     xfree(prog);
 856     xfree(buf2);
 857     return 0;
 858 }