1 2 /*--------------------------------------------------------------------*/ 3 /*--- A simple debuginfo server for Valgrind. ---*/ 4 /*--- valgrind-di-server.c ---*/ 5 /*--------------------------------------------------------------------*/ 6 7 /* To build for an x86_64-linux host: 8 gcc -g -Wall -O -o valgrind-di-server \ 9 auxprogs/valgrind-di-server.c -Icoregrind -Iinclude \ 10 -IVEX/pub -DVGO_linux -DVGA_amd64 11 12 To build for an x86 (32-bit) host 13 The same, except change -DVGA_amd64 to -DVGA_x86 14 */ 15 16 /* 17 This file is part of Valgrind, a dynamic binary instrumentation 18 framework. 19 20 Copyright (C) 2013-2017 Mozilla Foundation 21 22 This program is free software; you can redistribute it and/or 23 modify it under the terms of the GNU General Public License as 24 published by the Free Software Foundation; either version 2 of the 25 License, or (at your option) any later version. 26 27 This program is distributed in the hope that it will be useful, but 28 WITHOUT ANY WARRANTY; without even the implied warranty of 29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 30 General Public License for more details. 31 32 You should have received a copy of the GNU General Public License 33 along with this program; if not, write to the Free Software 34 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 35 02111-1307, USA. 36 37 The GNU General Public License is contained in the file COPYING. 38 */ 39 40 /* Contributed by Julian Seward <jseward (at) acm.org> */ 41 42 /* This code works (just), but it's a mess. Cleanups (also for 43 coregrind/m_debuginfo/image.c): 44 45 * Build this file for the host arch, not the target. But how? 46 Even Tromey had difficulty figuring out how to do that. 47 48 * Change the use of pread w/ fd to FILE*, for the file we're 49 serving. Or, at least, put a loop around the pread uses 50 so that it works correctly in the case where pread reads more 51 than zero but less than we asked for. 52 53 * CRC3 request/response: pass session-IDs back and forth and 54 check them 55 56 * Check that all error cases result in a FAIL frame being returned. 57 58 * image.c: don't assert in cases where a FAIL frame is returned; 59 instead cause the debuginfo reading to fail gracefully. (Not 60 sure how to do this) 61 62 * Improve diagnostic printing 63 64 * image.c: do we need to do VG_(write_socket) ? Will it work 65 just to use ordinary VG_(write) ? 66 67 * Both files: document the reason for setting TCP_NODELAY 68 69 * Add a command line argument saying where the served-from 70 directory is -- changes clo_serverpath. 71 72 * Fix up (common up) massive code duplication between client and 73 server. 74 75 * Tidy up the LZO source files; integrate properly in the build 76 system. 77 */ 78 79 /*---------------------------------------------------------------*/ 80 81 /* Include valgrind headers before system headers to avoid problems 82 with the system headers #defining things which are used as names 83 of structure members in vki headers. */ 84 85 #include "pub_core_basics.h" 86 #include "pub_core_libcassert.h" // For VG_BUGS_TO 87 #include "pub_core_vki.h" // Avoids warnings from 88 // pub_core_libcfile.h 89 #include "pub_core_libcfile.h" // For VG_CLO_DEFAULT_LOGPORT 90 91 /* Needed to get a definition for pread() from unistd.h */ 92 #ifndef _XOPEN_SOURCE 93 #define _XOPEN_SOURCE 600 94 #endif 95 96 #include <stdio.h> 97 #include <unistd.h> 98 #include <string.h> 99 #include <time.h> 100 #include <fcntl.h> 101 #include <stdlib.h> 102 #include <signal.h> 103 #include <sys/poll.h> 104 #include <sys/types.h> 105 #include <sys/socket.h> 106 #include <netinet/in.h> 107 #include <sys/stat.h> 108 #include <netinet/tcp.h> 109 110 #include "../coregrind/m_debuginfo/minilzo.h" 111 112 /*---------------------------------------------------------------*/ 113 114 /* The default allowable number of concurrent connections. */ 115 #define M_CONNECTIONS_DEFAULT 50 116 /* The maximum allowable number of concurrent connections. */ 117 #define M_CONNECTIONS_MAX 5000 118 119 /* The maximum allowable number of concurrent connections. */ 120 unsigned M_CONNECTIONS = 0; 121 122 static const char* clo_serverpath = "."; 123 124 125 /*---------------------------------------------------------------*/ 126 127 __attribute__ ((noreturn)) 128 static void panic ( const char* str ) 129 { 130 fprintf(stderr, 131 "\nvalgrind-di-server: the " 132 "'impossible' happened:\n %s\n", str); 133 fprintf(stderr, 134 "Please report this bug at: %s\n\n", VG_BUGS_TO); 135 exit(1); 136 } 137 138 __attribute__ ((noreturn)) 139 static void my_assert_fail ( const char* expr, const char* file, int line, const char* fn ) 140 { 141 fprintf(stderr, 142 "\nvalgrind-di-server: %s:%d (%s): Assertion '%s' failed.\n", 143 file, line, fn, expr ); 144 fprintf(stderr, 145 "Please report this bug at: %s\n\n", VG_BUGS_TO); 146 exit(1); 147 } 148 149 #undef assert 150 151 #define assert(expr) \ 152 ((void) ((expr) ? 0 : \ 153 (my_assert_fail (VG_STRINGIFY(expr), \ 154 __FILE__, __LINE__, \ 155 __PRETTY_FUNCTION__), 0))) 156 157 158 /*---------------------------------------------------------------*/ 159 160 /* Allocate some memory. Return iff successful. */ 161 static void *my_malloc(size_t amount) 162 { 163 void *p = malloc(amount ?: 1); 164 165 if (p == NULL) { 166 fprintf(stderr, "Memory allocation failed; cannot continue.\n"); 167 exit(1); 168 } 169 return p; 170 } 171 172 /*---------------------------------------------------------------*/ 173 174 /* Holds the state that we need to track, for each connection. */ 175 typedef 176 struct { 177 // is this entry in use? 178 Bool in_use; 179 // socket descriptor to communicate with client. Initialised as 180 // soon as this entry is created. 181 int conn_sd; 182 // fd for the file that we are connected to. Zero if not 183 // currently connected to any file. 184 int file_fd; 185 ULong file_size; 186 // Session ID 187 ULong session_id; 188 // How many bytes and chunks sent? 189 ULong stats_n_rdok_frames; 190 ULong stats_n_read_unz_bytes; // bytes via READ (uncompressed) 191 ULong stats_n_read_z_bytes; // bytes via READ (compressed) 192 } 193 ConnState; 194 195 /* The state itself. */ 196 static int conn_count = 0; 197 static ConnState *conn_state; 198 199 /* Issues unique session ID values. */ 200 static ULong next_session_id = 1; 201 202 203 /*---------------------------------------------------------------*/ 204 205 // Code that is duplicated with the client :-( 206 207 /* The following Adler-32 checksum code is taken from zlib-1.2.3, which 208 has the following copyright notice. */ 209 /* 210 Copyright notice: 211 212 (C) 1995-2004 Jean-loup Gailly and Mark Adler 213 214 This software is provided 'as-is', without any express or implied 215 warranty. In no event will the authors be held liable for any damages 216 arising from the use of this software. 217 218 Permission is granted to anyone to use this software for any purpose, 219 including commercial applications, and to alter it and redistribute it 220 freely, subject to the following restrictions: 221 222 1. The origin of this software must not be misrepresented; you must not 223 claim that you wrote the original software. If you use this software 224 in a product, an acknowledgment in the product documentation would be 225 appreciated but is not required. 226 2. Altered source versions must be plainly marked as such, and must not be 227 misrepresented as being the original software. 228 3. This notice may not be removed or altered from any source distribution. 229 230 Jean-loup Gailly Mark Adler 231 jloup (at) gzip.org madler (at) alumni.caltech.edu 232 233 If you use the zlib library in a product, we would appreciate *not* 234 receiving lengthy legal documents to sign. The sources are provided 235 for free but without warranty of any kind. The library has been 236 entirely written by Jean-loup Gailly and Mark Adler; it does not 237 include third-party code. 238 239 If you redistribute modified sources, we would appreciate that you include 240 in the file ChangeLog history information documenting your changes. Please 241 read the FAQ for more information on the distribution of modified source 242 versions. 243 */ 244 245 /* Update a running Adler-32 checksum with the bytes buf[0..len-1] and 246 return the updated checksum. If buf is NULL, this function returns 247 the required initial value for the checksum. An Adler-32 checksum is 248 almost as reliable as a CRC32 but can be computed much faster. */ 249 static 250 UInt adler32( UInt adler, const UChar* buf, UInt len ) 251 { 252 # define BASE 65521UL /* largest prime smaller than 65536 */ 253 # define NMAX 5552 254 /* NMAX is the largest n such that 255 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ 256 257 # define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} 258 # define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); 259 # define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); 260 # define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); 261 # define DO16(buf) DO8(buf,0); DO8(buf,8); 262 263 /* The zlib sources recommend this definition of MOD if the 264 processor cannot do integer division in hardware. */ 265 # define MOD(a) \ 266 do { \ 267 if (a >= (BASE << 16)) a -= (BASE << 16); \ 268 if (a >= (BASE << 15)) a -= (BASE << 15); \ 269 if (a >= (BASE << 14)) a -= (BASE << 14); \ 270 if (a >= (BASE << 13)) a -= (BASE << 13); \ 271 if (a >= (BASE << 12)) a -= (BASE << 12); \ 272 if (a >= (BASE << 11)) a -= (BASE << 11); \ 273 if (a >= (BASE << 10)) a -= (BASE << 10); \ 274 if (a >= (BASE << 9)) a -= (BASE << 9); \ 275 if (a >= (BASE << 8)) a -= (BASE << 8); \ 276 if (a >= (BASE << 7)) a -= (BASE << 7); \ 277 if (a >= (BASE << 6)) a -= (BASE << 6); \ 278 if (a >= (BASE << 5)) a -= (BASE << 5); \ 279 if (a >= (BASE << 4)) a -= (BASE << 4); \ 280 if (a >= (BASE << 3)) a -= (BASE << 3); \ 281 if (a >= (BASE << 2)) a -= (BASE << 2); \ 282 if (a >= (BASE << 1)) a -= (BASE << 1); \ 283 if (a >= BASE) a -= BASE; \ 284 } while (0) 285 # define MOD4(a) \ 286 do { \ 287 if (a >= (BASE << 4)) a -= (BASE << 4); \ 288 if (a >= (BASE << 3)) a -= (BASE << 3); \ 289 if (a >= (BASE << 2)) a -= (BASE << 2); \ 290 if (a >= (BASE << 1)) a -= (BASE << 1); \ 291 if (a >= BASE) a -= BASE; \ 292 } while (0) 293 294 UInt sum2; 295 UInt n; 296 297 /* split Adler-32 into component sums */ 298 sum2 = (adler >> 16) & 0xffff; 299 adler &= 0xffff; 300 301 /* in case user likes doing a byte at a time, keep it fast */ 302 if (len == 1) { 303 adler += buf[0]; 304 if (adler >= BASE) 305 adler -= BASE; 306 sum2 += adler; 307 if (sum2 >= BASE) 308 sum2 -= BASE; 309 return adler | (sum2 << 16); 310 } 311 312 /* initial Adler-32 value (deferred check for len == 1 speed) */ 313 if (buf == NULL) 314 return 1L; 315 316 /* in case short lengths are provided, keep it somewhat fast */ 317 if (len < 16) { 318 while (len--) { 319 adler += *buf++; 320 sum2 += adler; 321 } 322 if (adler >= BASE) 323 adler -= BASE; 324 MOD4(sum2); /* only added so many BASE's */ 325 return adler | (sum2 << 16); 326 } 327 328 /* do length NMAX blocks -- requires just one modulo operation */ 329 while (len >= NMAX) { 330 len -= NMAX; 331 n = NMAX / 16; /* NMAX is divisible by 16 */ 332 do { 333 DO16(buf); /* 16 sums unrolled */ 334 buf += 16; 335 } while (--n); 336 MOD(adler); 337 MOD(sum2); 338 } 339 340 /* do remaining bytes (less than NMAX, still just one modulo) */ 341 if (len) { /* avoid modulos if none remaining */ 342 while (len >= 16) { 343 len -= 16; 344 DO16(buf); 345 buf += 16; 346 } 347 while (len--) { 348 adler += *buf++; 349 sum2 += adler; 350 } 351 MOD(adler); 352 MOD(sum2); 353 } 354 355 /* return recombined sums */ 356 return adler | (sum2 << 16); 357 358 # undef MOD4 359 # undef MOD 360 # undef DO16 361 # undef DO8 362 # undef DO4 363 # undef DO2 364 # undef DO1 365 # undef NMAX 366 # undef BASE 367 } 368 369 370 /* A frame. The first 4 bytes of |data| give the kind of the frame, 371 and the rest of it is kind-specific data. */ 372 typedef struct { UChar* data; SizeT n_data; } Frame; 373 374 375 static void write_UInt_le ( /*OUT*/UChar* dst, UInt n ) 376 { 377 Int i; 378 for (i = 0; i <= 3; i++) { 379 dst[i] = (UChar)(n & 0xFF); 380 n >>= 8; 381 } 382 } 383 384 static UInt read_UInt_le ( UChar* src ) 385 { 386 UInt r = 0; 387 Int i; 388 for (i = 3; i >= 0; i--) { 389 r <<= 8; 390 r += (UInt)src[i]; 391 } 392 return r; 393 } 394 395 static void write_ULong_le ( /*OUT*/UChar* dst, ULong n ) 396 { 397 Int i; 398 for (i = 0; i <= 7; i++) { 399 dst[i] = (UChar)(n & 0xFF); 400 n >>= 8; 401 } 402 } 403 404 static ULong read_ULong_le ( UChar* src ) 405 { 406 ULong r = 0; 407 Int i; 408 for (i = 7; i >= 0; i--) { 409 r <<= 8; 410 r += (ULong)src[i]; 411 } 412 return r; 413 } 414 415 static Frame* mk_Frame_asciiz ( const char* tag, const char* str ) 416 { 417 assert(strlen(tag) == 4); 418 Frame* f = calloc(sizeof(Frame), 1); 419 size_t n_str = strlen(str); 420 f->n_data = 4 + n_str + 1; 421 f->data = calloc(f->n_data, 1); 422 memcpy(&f->data[0], tag, 4); 423 memcpy(&f->data[4], str, n_str); 424 assert(f->data[4 + n_str] == 0); 425 return f; 426 } 427 428 static Bool parse_Frame_noargs ( Frame* fr, const HChar* tag ) 429 { 430 assert(strlen(tag) == 4); 431 if (!fr || !fr->data) return False; 432 if (fr->n_data < 4) return False; 433 if (memcmp(&fr->data[0], tag, 4) != 0) return False; 434 if (fr->n_data != 4) return False; 435 return True; 436 } 437 438 static Bool parse_Frame_asciiz ( Frame* fr, const HChar* tag, 439 /*OUT*/UChar** str ) 440 { 441 assert(strlen(tag) == 4); 442 if (!fr || !fr->data) return False; 443 if (fr->n_data < 4) return False; 444 if (memcmp(&fr->data[0], tag, 4) != 0) return False; 445 if (fr->n_data < 5) return False; // else there isn't even enough 446 // space for the terminating zero 447 /* Find the terminating zero and ensure it's right at the end 448 of the data. If not, the frame is malformed. */ 449 SizeT i = 4; 450 while (True) { 451 if (i >= fr->n_data) break; 452 if (fr->data[i] == 0) break; 453 i++; 454 } 455 assert(i <= fr->n_data); 456 if (i == fr->n_data-1 && fr->data[i] == 0) { 457 *str = &fr->data[4]; 458 return True; 459 } else { 460 return False; 461 } 462 } 463 464 static Frame* mk_Frame_le64 ( const HChar* tag, ULong n1 ) 465 { 466 assert(strlen(tag) == 4); 467 Frame* f = calloc(sizeof(Frame), 1); 468 f->n_data = 4 + 1*8; 469 f->data = calloc(f->n_data, 1); 470 memcpy(&f->data[0], tag, 4); 471 write_ULong_le(&f->data[4 + 0*8], n1); 472 return f; 473 } 474 475 static Frame* mk_Frame_le64_le64 ( const HChar* tag, ULong n1, ULong n2 ) 476 { 477 assert(strlen(tag) == 4); 478 Frame* f = calloc(sizeof(Frame), 1); 479 f->n_data = 4 + 2*8; 480 f->data = calloc(f->n_data, 1); 481 memcpy(&f->data[0], tag, 4); 482 write_ULong_le(&f->data[4 + 0*8], n1); 483 write_ULong_le(&f->data[4 + 1*8], n2); 484 return f; 485 } 486 487 static Bool parse_Frame_le64_le64_le64 ( Frame* fr, const HChar* tag, 488 /*OUT*/ULong* n1, /*OUT*/ULong* n2, 489 /*OUT*/ULong* n3 ) 490 { 491 assert(strlen(tag) == 4); 492 if (!fr || !fr->data) return False; 493 if (fr->n_data < 4) return False; 494 if (memcmp(&fr->data[0], tag, 4) != 0) return False; 495 if (fr->n_data != 4 + 3*8) return False; 496 *n1 = read_ULong_le(&fr->data[4 + 0*8]); 497 *n2 = read_ULong_le(&fr->data[4 + 1*8]); 498 *n3 = read_ULong_le(&fr->data[4 + 2*8]); 499 return True; 500 } 501 502 static Frame* mk_Frame_le64_le64_le64_bytes ( 503 const HChar* tag, 504 ULong n1, ULong n2, ULong n3, ULong n_data, 505 /*OUT*/UChar** data ) 506 { 507 assert(strlen(tag) == 4); 508 Frame* f = calloc(sizeof(Frame), 1); 509 f->n_data = 4 + 3*8 + n_data; 510 f->data = calloc(f->n_data, 1); 511 memcpy(&f->data[0], tag, 4); 512 write_ULong_le(&f->data[4 + 0*8], n1); 513 write_ULong_le(&f->data[4 + 1*8], n2); 514 write_ULong_le(&f->data[4 + 2*8], n3); 515 *data = &f->data[4 + 3*8]; 516 return f; 517 } 518 519 static void free_Frame ( Frame* fr ) 520 { 521 assert(fr && fr->data); 522 free(fr->data); 523 free(fr); 524 } 525 526 527 static void set_blocking ( int sd ) 528 { 529 int res; 530 res = fcntl(sd, F_GETFL); 531 res = fcntl(sd, F_SETFL, res & ~O_NONBLOCK); 532 if (res != 0) { 533 perror("fcntl failed"); 534 panic("set_blocking"); 535 } 536 } 537 538 539 #if 0 540 static void set_nonblocking ( int sd ) 541 { 542 int res; 543 res = fcntl(sd, F_GETFL); 544 res = fcntl(sd, F_SETFL, res | O_NONBLOCK); 545 if (res != 0) { 546 perror("fcntl failed"); 547 panic("set_nonblocking"); 548 } 549 } 550 #endif 551 552 553 /* Tries to read 'len' bytes from fd, blocking if necessary. Assumes 554 fd has been set in blocking mode. If it returns with the number of 555 bytes read < len, it means that either fd was closed, or there was 556 an error on it. */ 557 static SizeT my_read ( Int fd, UChar* buf, SizeT len ) 558 { 559 //set_blocking(fd); 560 SizeT nRead = 0; 561 while (1) { 562 if (nRead == len) return nRead; 563 assert(nRead < len); 564 SizeT nNeeded = len - nRead; 565 assert(nNeeded > 0); 566 SSizeT n = read(fd, &buf[nRead], nNeeded); 567 if (n <= 0) return nRead; /* error or EOF */ 568 nRead += n; 569 } 570 } 571 572 /* Tries to write 'len' bytes to fd, blocking if necessary. Assumes 573 fd has been set in blocking mode. If it returns with the number of 574 bytes written < len, it means that either fd was closed, or there was 575 an error on it. */ 576 static SizeT my_write ( Int fd, UChar* buf, SizeT len ) 577 { 578 //set_nonblocking(fd); 579 SizeT nWritten = 0; 580 while (1) { 581 if (nWritten == len) return nWritten; 582 assert(nWritten < len); 583 SizeT nStillToDo = len - nWritten; 584 assert(nStillToDo > 0); 585 SSizeT n = write(fd, &buf[nWritten], nStillToDo); 586 if (n < 0) return nWritten; /* error or EOF */ 587 nWritten += n; 588 } 589 } 590 591 592 static UInt calc_gnu_debuglink_crc32(/*OUT*/Bool* ok, int fd, ULong size) 593 { 594 static const UInt crc32_table[256] = 595 { 596 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 597 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 598 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 599 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 600 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 601 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 602 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 603 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 604 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 605 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 606 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 607 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 608 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 609 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 610 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 611 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 612 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 613 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 614 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 615 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 616 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 617 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 618 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 619 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 620 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 621 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 622 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 623 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 624 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 625 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 626 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 627 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 628 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 629 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 630 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 631 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 632 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 633 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 634 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 635 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 636 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 637 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 638 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 639 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 640 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 641 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 642 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 643 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 644 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 645 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 646 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 647 0x2d02ef8d 648 }; 649 650 /* Work through the image in 1 KB chunks. */ 651 UInt crc = 0xFFFFFFFF; 652 ULong img_szB = size; 653 ULong curr_off = 0; 654 while (1) { 655 assert(curr_off >= 0 && curr_off <= img_szB); 656 if (curr_off == img_szB) break; 657 ULong avail = img_szB - curr_off; 658 assert(avail > 0 && avail <= img_szB); 659 if (avail > 65536) avail = 65536; 660 UChar buf[65536]; 661 Int nRead = pread(fd, buf, avail, curr_off); 662 if (nRead <= 0) { /* EOF or error on the file; neither should happen */ 663 *ok = False; 664 return 0; 665 } 666 /* this is a kludge .. we should loop around pread and deal 667 with short reads, for whatever reason */ 668 assert(nRead == avail); 669 UInt i; 670 for (i = 0; i < (UInt)nRead; i++) 671 crc = crc32_table[(crc ^ buf[i]) & 0xff] ^ (crc >> 8); 672 curr_off += nRead; 673 } 674 *ok = True; 675 return ~crc & 0xFFFFFFFF; 676 } 677 678 679 /*---------------------------------------------------------------*/ 680 681 /* Handle a transaction for conn_state[conn_no]. There is incoming 682 data available; read it and send back an appropriate response. 683 Returns a boolean indicating whether the connection has been 684 closed; in which case this function does all necessary cleanup and 685 leaves conn_state[conn_no] in a not-in-use state. */ 686 687 static Bool handle_transaction ( int conn_no ) 688 { 689 Frame* req = NULL; /* the request frame that we receive */ 690 Frame* res = NULL; /* the response frame that we send back */ 691 692 assert(conn_no >= 0 && conn_no < M_CONNECTIONS); 693 assert(conn_state[conn_no].in_use); 694 695 //printf("SERVER: handle_transaction(%d)\n", conn_no); fflush(stdout); 696 697 Int sd = conn_state[conn_no].conn_sd; 698 699 /* Get a frame out of the channel. */ 700 UChar rd_first8[8]; // adler32; length32 701 { Int r = my_read(sd, &rd_first8[0], 8); 702 if (r == 0) goto client_closed_conn; 703 if (r != 8) goto fail; 704 } 705 UInt rd_adler = read_UInt_le(&rd_first8[0]); 706 UInt rd_len = read_UInt_le(&rd_first8[4]); 707 /* Allocate a Frame to hold the result data, and read into it. */ 708 // Reject obviously-insane length fields. 709 if (rd_len > 4*1024*1024) goto fail; 710 assert(req == NULL); 711 req = calloc(sizeof(Frame), 1); 712 req->n_data = rd_len; 713 req->data = calloc(rd_len, 1); 714 if (rd_len > 0) { 715 Int r = my_read(sd, req->data, req->n_data); 716 if (r != rd_len) goto fail; 717 } 718 //printf("SERVER: recv %c%c%c%c\n", req->data[0], req->data[1], req->data[2], req->data[3]); fflush(stdout); 719 720 /* Compute the checksum for the received data, and check it. */ 721 UInt adler = adler32(0, NULL, 0); // initial value 722 adler = adler32(adler, &rd_first8[4], 4); 723 if (req->n_data > 0) 724 adler = adler32(adler, req->data, req->n_data); 725 726 if (adler/*computed*/ != rd_adler/*expected*/) goto fail; 727 728 /* Now we have a request frame. Cook up a response. */ 729 assert(res == NULL); 730 731 UChar* filename = NULL; 732 ULong req_session_id = 0, req_offset = 0, req_len = 0; 733 734 if (parse_Frame_noargs(req, "VERS")) { 735 res = mk_Frame_asciiz("VEOK", "Valgrind Debuginfo Server, Version 1"); 736 } 737 else 738 if (parse_Frame_noargs(req, "CRC3")) { 739 /* FIXME: add a session ID to this request, and check it */ 740 if (conn_state[conn_no].file_fd == 0) { 741 res = mk_Frame_asciiz("CRC3", "FAIL: not connected to file"); 742 } else { 743 Bool ok = False; 744 UInt crc32 = calc_gnu_debuglink_crc32(&ok, 745 conn_state[conn_no].file_fd, 746 conn_state[conn_no].file_size); 747 if (ok) { 748 res = mk_Frame_le64("CROK", (ULong)crc32); 749 } else { 750 res = mk_Frame_asciiz("FAIL", "CRC3: I/O error reading file"); 751 } 752 } 753 } 754 else 755 if (parse_Frame_asciiz(req, "OPEN", &filename)) { 756 Bool ok = True; 757 int fd = 0; 758 if (conn_state[conn_no].file_fd != 0) { 759 res = mk_Frame_asciiz("FAIL", "OPEN: already connected to file"); 760 ok = False; 761 } 762 if (ok) { 763 assert(clo_serverpath); 764 fd = open((char*)filename, O_RDONLY); 765 if (fd == -1) { 766 res = mk_Frame_asciiz("FAIL", "OPEN: cannot open file"); 767 printf("(%d) SessionID %llu: open failed for \"%s\"\n", 768 conn_count, conn_state[conn_no].session_id, filename ); 769 ok = False; 770 } else { 771 assert(fd > 2); 772 } 773 } 774 if (ok) { 775 struct stat stat_buf; 776 int r = fstat(fd, &stat_buf); 777 if (r != 0) { 778 res = mk_Frame_asciiz("FAIL", "OPEN: cannot stat file"); 779 ok = False; 780 } 781 if (ok && stat_buf.st_size == 0) { 782 res = mk_Frame_asciiz("FAIL", "OPEN: file has zero size"); 783 ok = False; 784 } 785 if (ok) { 786 conn_state[conn_no].file_fd = fd; 787 conn_state[conn_no].file_size = stat_buf.st_size; 788 assert(res == NULL); 789 res = mk_Frame_le64_le64("OPOK", conn_state[conn_no].session_id, 790 conn_state[conn_no].file_size); 791 printf("(%d) SessionID %llu: open successful for \"%s\"\n", 792 conn_count, conn_state[conn_no].session_id, filename ); 793 fflush(stdout); 794 } 795 } 796 } 797 else 798 if (parse_Frame_le64_le64_le64(req, "READ", &req_session_id, 799 &req_offset, &req_len)) { 800 /* Because each new connection is associated with its own socket 801 descriptor and hence with a particular conn_no, the requested 802 session-ID is redundant -- it must be the one associated with 803 this slot. But check anyway. */ 804 Bool ok = True; 805 if (req_session_id != conn_state[conn_no].session_id) { 806 res = mk_Frame_asciiz("FAIL", "READ: invalid session ID"); 807 ok = False; 808 } 809 /* Check we're connected to a file, and if so range-check the 810 request. */ 811 if (ok && conn_state[conn_no].file_fd == 0) { 812 res = mk_Frame_asciiz("FAIL", "READ: no associated file"); 813 ok = False; 814 } 815 if (ok && (req_len == 0 || req_len > 4*1024*1024)) { 816 res = mk_Frame_asciiz("FAIL", "READ: invalid request size"); 817 ok = False; 818 } 819 if (ok && req_len + req_offset > conn_state[conn_no].file_size) { 820 res = mk_Frame_asciiz("FAIL", "READ: request exceeds file size"); 821 ok = False; 822 } 823 /* Try to read the file. */ 824 if (ok) { 825 /* First, allocate a temp buf and read from the file into it. */ 826 /* FIXME: what if pread reads short and we have to redo it? */ 827 UChar* unzBuf = my_malloc(req_len); 828 size_t nRead = pread(conn_state[conn_no].file_fd, 829 unzBuf, req_len, req_offset); 830 if (nRead != req_len) { 831 free_Frame(res); 832 res = mk_Frame_asciiz("FAIL", "READ: I/O error reading file"); 833 ok = False; 834 } 835 if (ok) { 836 // Now compress it with LZO. LZO appears to recommend 837 // the worst-case output size as (in_len + in_len / 16 + 67). 838 // Be more conservative here. 839 # define STACK_ALLOC(var,size) \ 840 lzo_align_t __LZO_MMODEL \ 841 var [ ((size) \ 842 + (sizeof(lzo_align_t) - 1)) / sizeof(lzo_align_t) ] 843 STACK_ALLOC(wrkmem, LZO1X_1_MEM_COMPRESS); 844 # undef STACK_ALLOC 845 UInt zLenMax = req_len + req_len / 4 + 1024; 846 UChar* zBuf = my_malloc(zLenMax); 847 lzo_uint zLen = zLenMax; 848 Int lzo_rc = lzo1x_1_compress(unzBuf, req_len, 849 zBuf, &zLen, wrkmem); 850 if (lzo_rc == LZO_E_OK) { 851 //printf("XXXXX req_len %u zLen %u\n", (UInt)req_len, (UInt)zLen); 852 assert(zLen <= zLenMax); 853 /* Make a frame to put the results in. Bytes 24 and 854 onwards need to be filled from the compressed data, 855 and 'buf' is set to point to the right bit. */ 856 UChar* buf = NULL; 857 res = mk_Frame_le64_le64_le64_bytes 858 ("RDOK", req_session_id, req_offset, req_len, zLen, &buf); 859 assert(res); 860 assert(buf); 861 memcpy(buf, zBuf, zLen); 862 // Update stats 863 conn_state[conn_no].stats_n_rdok_frames++; 864 conn_state[conn_no].stats_n_read_unz_bytes += req_len; 865 conn_state[conn_no].stats_n_read_z_bytes += zLen; 866 } else { 867 ok = False; 868 free_Frame(res); 869 res = mk_Frame_asciiz("FAIL", "READ: LZO failed"); 870 } 871 free(zBuf); 872 } 873 free(unzBuf); 874 } 875 } 876 else { 877 res = mk_Frame_asciiz("FAIL", "Invalid request frame type"); 878 } 879 880 /* All paths through the above should result in an assignment to |res|. */ 881 assert(res != NULL); 882 883 /* And send the response frame back to the client. */ 884 /* What goes on the wire is: 885 adler(le32) n_data(le32) data[0 .. n_data-1] 886 where the checksum covers n_data as well as data[]. 887 */ 888 /* The initial Adler-32 value */ 889 adler = adler32(0, NULL, 0); 890 891 /* Fold in the length field, encoded as le32. */ 892 UChar wr_first8[8]; 893 write_UInt_le(&wr_first8[4], res->n_data); 894 adler = adler32(adler, &wr_first8[4], 4); 895 /* Fold in the data values */ 896 adler = adler32(adler, res->data, res->n_data); 897 write_UInt_le(&wr_first8[0], adler); 898 899 Int r = my_write(sd, &wr_first8[0], 8); 900 if (r != 8) goto fail; 901 assert(res->n_data >= 4); // else ill formed -- no KIND field 902 r = my_write(sd, res->data, res->n_data); 903 if (r != res->n_data) goto fail; 904 905 //printf("SERVER: send %c%c%c%c\n", res->data[0], res->data[1], res->data[2], res->data[3]); fflush(stdout); 906 907 /* So, success. */ 908 free_Frame(req); 909 free_Frame(res); 910 return False; /* "connection still in use" */ 911 912 // Is there any difference between these? 913 client_closed_conn: 914 fail: 915 if (conn_state[conn_no].conn_sd > 0) 916 close(conn_state[conn_no].conn_sd); 917 if (conn_state[conn_no].file_fd > 0) 918 close(conn_state[conn_no].file_fd); 919 920 if (conn_state[conn_no].stats_n_rdok_frames > 0) { 921 printf("(%d) SessionID %llu: sent %llu frames, " 922 "%llu MB (unz), %llu MB (z), ratio %4.2f:1\n", 923 conn_count, conn_state[conn_no].session_id, 924 conn_state[conn_no].stats_n_rdok_frames, 925 conn_state[conn_no].stats_n_read_unz_bytes / 1000000, 926 conn_state[conn_no].stats_n_read_z_bytes / 1000000, 927 (double)conn_state[conn_no].stats_n_read_unz_bytes 928 / (double)conn_state[conn_no].stats_n_read_z_bytes); 929 printf("(%d) SessionID %llu: closed\n", 930 conn_count, conn_state[conn_no].session_id); 931 932 fflush(stdout); 933 } 934 935 memset(&conn_state[conn_no], 0, sizeof(conn_state[conn_no])); 936 if (req) free_Frame(req); 937 if (res) free_Frame(res); 938 return True; /* "connection has been closed" */ 939 } 940 941 942 /*---------------------------------------------------------------*/ 943 944 945 946 #if 0 947 static void copyout ( char* buf, int nbuf ) 948 { 949 int i; 950 for (i = 0; i < nbuf; i++) { 951 if (buf[i] == '\n') { 952 fprintf(stdout, "\n(%d) ", conn_count); 953 } else { 954 __attribute__((unused)) size_t ignored 955 = fwrite(&buf[i], 1, 1, stdout); 956 } 957 } 958 fflush(stdout); 959 } 960 961 static int read_from_sd ( int sd ) 962 { 963 char buf[100]; 964 int n; 965 966 set_blocking(sd); 967 n = read(sd, buf, 99); 968 if (n <= 0) return 0; /* closed */ 969 copyout(buf, n); 970 971 set_nonblocking(sd); 972 while (1) { 973 n = read(sd, buf, 100); 974 if (n <= 0) return 1; /* not closed */ 975 copyout(buf, n); 976 } 977 } 978 #endif 979 980 static void snooze ( void ) 981 { 982 struct timespec req; 983 req.tv_sec = 0; 984 req.tv_nsec = 200 * 1000 * 1000; 985 nanosleep(&req,NULL); 986 } 987 988 989 /* returns 0 if negative, or > BOUND or invalid characters were found */ 990 static int atoi_with_bound ( const char* str, int bound ) 991 { 992 int n = 0; 993 while (1) { 994 if (*str == 0) 995 break; 996 if (*str < '0' || *str > '9') 997 return 0; 998 n = 10*n + (int)(*str - '0'); 999 str++; 1000 if (n >= bound) 1001 return 0; 1002 } 1003 return n; 1004 } 1005 1006 1007 /* returns 0 if invalid, else port # */ 1008 static int atoi_portno ( const char* str ) 1009 { 1010 int n = atoi_with_bound(str, 65536); 1011 1012 if (n < 1024) 1013 return 0; 1014 return n; 1015 } 1016 1017 1018 static void usage ( void ) 1019 { 1020 fprintf(stderr, 1021 "\n" 1022 "usage is:\n" 1023 "\n" 1024 " valgrind-di-server [--exit-at-zero|-e] [port-number]\n" 1025 "\n" 1026 " where --exit-at-zero or -e causes the listener to exit\n" 1027 " when the number of connections falls back to zero\n" 1028 " (the default is to keep listening forever)\n" 1029 "\n" 1030 " --max-connect=INT can be used to increase the maximum\n" 1031 " number of connected processes (default = %d).\n" 1032 " INT must be positive and less than %d.\n" 1033 "\n" 1034 " port-number is the default port on which to listen for\n" 1035 " connections. It must be between 1024 and 65535.\n" 1036 " Current default is %d.\n" 1037 "\n" 1038 , 1039 M_CONNECTIONS_DEFAULT, M_CONNECTIONS_MAX, VG_CLO_DEFAULT_LOGPORT 1040 ); 1041 exit(1); 1042 } 1043 1044 1045 static void banner ( const char* str ) 1046 { 1047 time_t t; 1048 t = time(NULL); 1049 printf("valgrind-di-server %s at %s", str, ctime(&t)); 1050 fflush(stdout); 1051 } 1052 1053 1054 static void exit_routine ( void ) 1055 { 1056 banner("exited"); 1057 exit(0); 1058 } 1059 1060 1061 static void sigint_handler ( int signo ) 1062 { 1063 exit_routine(); 1064 } 1065 1066 1067 int main (int argc, char** argv) 1068 { 1069 int i, j, res, one; 1070 int main_sd, new_sd; 1071 socklen_t client_len; 1072 struct sockaddr_in client_addr, server_addr; 1073 1074 char /*bool*/ exit_when_zero = 0; 1075 int port = VG_CLO_DEFAULT_LOGPORT; 1076 1077 for (i = 1; i < argc; i++) { 1078 if (0==strcmp(argv[i], "--exit-at-zero") 1079 || 0==strcmp(argv[i], "-e")) { 1080 exit_when_zero = 1; 1081 } 1082 else if (0 == strncmp(argv[i], "--max-connect=", 14)) { 1083 M_CONNECTIONS = atoi_with_bound(strchr(argv[i], '=') + 1, 5000); 1084 if (M_CONNECTIONS <= 0 || M_CONNECTIONS > M_CONNECTIONS_MAX) 1085 usage(); 1086 } 1087 else 1088 if (atoi_portno(argv[i]) > 0) { 1089 port = atoi_portno(argv[i]); 1090 } 1091 else 1092 usage(); 1093 } 1094 1095 if (M_CONNECTIONS == 0) // nothing specified on command line 1096 M_CONNECTIONS = M_CONNECTIONS_DEFAULT; 1097 1098 conn_state = my_malloc(M_CONNECTIONS * sizeof conn_state[0]); 1099 1100 banner("started"); 1101 signal(SIGINT, sigint_handler); 1102 1103 conn_count = 0; 1104 memset(conn_state, 0, M_CONNECTIONS * sizeof conn_state[0]); 1105 1106 /* create socket */ 1107 main_sd = socket(AF_INET, SOCK_STREAM, 0); 1108 if (main_sd < 0) { 1109 perror("cannot open socket "); 1110 panic("main -- create socket"); 1111 } 1112 1113 /* allow address reuse to avoid "address already in use" errors */ 1114 1115 one = 1; 1116 if (setsockopt(main_sd, SOL_SOCKET, SO_REUSEADDR, 1117 &one, sizeof(one)) < 0) { 1118 perror("cannot enable address reuse "); 1119 panic("main -- enable address reuse"); 1120 } 1121 1122 /* bind server port */ 1123 server_addr.sin_family = AF_INET; 1124 server_addr.sin_addr.s_addr = htonl(INADDR_ANY); 1125 server_addr.sin_port = htons(port); 1126 1127 if (bind(main_sd, (struct sockaddr *) &server_addr, 1128 sizeof(server_addr) ) < 0) { 1129 perror("cannot bind port "); 1130 panic("main -- bind port"); 1131 } 1132 1133 res = listen(main_sd, M_CONNECTIONS); 1134 if (res != 0) { 1135 perror("listen failed "); 1136 panic("main -- listen"); 1137 } 1138 1139 Bool do_snooze = False; 1140 while (1) { 1141 1142 if (0 && do_snooze) 1143 snooze(); 1144 1145 /* Snooze after this iteration, unless something happened. */ 1146 do_snooze = True; 1147 1148 /* enquire, using poll, whether there is any activity available on 1149 the main socket descriptor. If so, someone is trying to 1150 connect; get the fd and add it to our table thereof. */ 1151 { struct pollfd ufd; 1152 while (1) { 1153 ufd.fd = main_sd; 1154 ufd.events = POLLIN; 1155 ufd.revents = 0; 1156 res = poll(&ufd, 1, 0/*ms*/ /* 0=return immediately. */); 1157 if (res == 0) break; 1158 1159 /* ok, we have someone waiting to connect. Get the sd. */ 1160 client_len = sizeof(client_addr); 1161 new_sd = accept(main_sd, (struct sockaddr *)&client_addr, 1162 &client_len); 1163 if (new_sd < 0) { 1164 perror("cannot accept connection "); 1165 panic("main -- accept connection"); 1166 } 1167 1168 /* find a place to put it. */ 1169 assert(new_sd > 0); 1170 for (i = 0; i < M_CONNECTIONS; i++) 1171 if (!conn_state[i].in_use) 1172 break; 1173 1174 if (i >= M_CONNECTIONS) { 1175 fprintf(stderr, "\n\nMore than %d concurrent connections.\n" 1176 "Restart the server giving --max-connect=INT on the\n" 1177 "commandline to increase the limit.\n\n", 1178 M_CONNECTIONS); 1179 exit(1); 1180 } 1181 1182 assert(one == 1); 1183 int ret = setsockopt( new_sd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)); 1184 assert(ret != -1); 1185 1186 memset(&conn_state[i], 0, sizeof(conn_state[i])); 1187 conn_state[i].in_use = True; 1188 conn_state[i].conn_sd = new_sd; 1189 conn_state[i].file_fd = 0; /* not known yet */ 1190 conn_state[i].session_id = next_session_id++; 1191 set_blocking(new_sd); 1192 conn_count++; 1193 do_snooze = False; 1194 } /* while (1) */ 1195 } 1196 1197 /* We've processed all new connect requests. Listen for changes 1198 to the current set of fds. This requires gathering up all 1199 the known conn_sd values and doing poll() on them. */ 1200 static struct pollfd *tmp_pollfd; 1201 if (tmp_pollfd == NULL) 1202 tmp_pollfd = my_malloc(M_CONNECTIONS * sizeof tmp_pollfd[0]); 1203 1204 /* And a parallel array which maps entries in tmp_pollfd back to 1205 entries in conn_state. */ 1206 static int *tmp_pollfd_to_conn_state; 1207 if (tmp_pollfd_to_conn_state == NULL) 1208 tmp_pollfd_to_conn_state = 1209 my_malloc(M_CONNECTIONS * sizeof tmp_pollfd_to_conn_state[0]); 1210 1211 j = 0; 1212 for (i = 0; i < M_CONNECTIONS; i++) { 1213 if (!conn_state[i].in_use) 1214 continue; 1215 assert(conn_state[i].conn_sd > 2); 1216 tmp_pollfd[j].fd = conn_state[i].conn_sd; 1217 tmp_pollfd[j].events = POLLIN /* | POLLHUP | POLLNVAL */; 1218 tmp_pollfd[j].revents = 0; 1219 tmp_pollfd_to_conn_state[j] = i; 1220 j++; 1221 } 1222 1223 res = poll(tmp_pollfd, j, 20/*ms*/ /* 0=return immediately. */ ); 1224 if (res < 0) { 1225 perror("poll(main) failed"); 1226 panic("poll(main) failed"); 1227 } 1228 1229 /* nothing happened. go round again. */ 1230 if (res == 0) { 1231 continue; 1232 } 1233 1234 /* inspect the fds. */ 1235 for (i = 0; i < j; i++) { 1236 1237 if (tmp_pollfd[i].revents & POLLIN) { 1238 /* We have some activity on tmp_pollfd[i]. We need to 1239 figure out which conn_state[] entry that corresponds 1240 to, which is what tmp_pollfd_to_conn_state is for. */ 1241 Int conn_no = tmp_pollfd_to_conn_state[i]; 1242 Bool finished = handle_transaction(conn_no); 1243 if (finished) { 1244 /* this connection has been closed or otherwise gone 1245 bad; forget about it. */ 1246 conn_count--; 1247 fflush(stdout); 1248 if (conn_count == 0 && exit_when_zero) { 1249 if (0) printf("\n"); 1250 fflush(stdout); 1251 exit_routine(); 1252 } 1253 } else { 1254 // maybe show stats 1255 if (conn_state[i].stats_n_rdok_frames > 0 1256 && (conn_state[i].stats_n_rdok_frames % 1000) == 0) { 1257 printf("(%d) SessionID %llu: sent %llu frames, " 1258 "%llu MB (unz), %llu MB (z)\n", 1259 conn_count, conn_state[conn_no].session_id, 1260 conn_state[conn_no].stats_n_rdok_frames, 1261 conn_state[conn_no].stats_n_read_unz_bytes / 1000000, 1262 conn_state[conn_no].stats_n_read_z_bytes / 1000000); 1263 fflush(stdout); 1264 } 1265 } 1266 } 1267 1268 } /* for (i = 0; i < j; i++) */ 1269 1270 do_snooze = False; 1271 1272 } /* while (1) */ 1273 1274 /* NOTREACHED */ 1275 } 1276 1277 //////////////////////////////////////////////////// 1278 #include "../coregrind/m_debuginfo/minilzo-inl.c" 1279 1280 /*--------------------------------------------------------------------*/ 1281 /*--- end valgrind-di-server.c ---*/ 1282 /*--------------------------------------------------------------------*/ 1283
