Annotation of embedaddon/mtr/ui/cmdpipe.c, revision 1.1
1.1 ! misho 1: /*
! 2: mtr -- a network diagnostic tool
! 3: Copyright (C) 2016 Matt Kimball
! 4:
! 5: This program is free software; you can redistribute it and/or modify
! 6: it under the terms of the GNU General Public License version 2 as
! 7: published by the Free Software Foundation.
! 8:
! 9: This program is distributed in the hope that it will be useful,
! 10: but WITHOUT ANY WARRANTY; without even the implied warranty of
! 11: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 12: GNU General Public License for more details.
! 13:
! 14: You should have received a copy of the GNU General Public License
! 15: along with this program; if not, write to the Free Software
! 16: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
! 17: */
! 18:
! 19: #include "cmdpipe.h"
! 20:
! 21: #include <assert.h>
! 22: #include <errno.h>
! 23: #include <fcntl.h>
! 24: #include <signal.h>
! 25: #include <stdbool.h>
! 26: #include <stdio.h>
! 27: #include <stdlib.h>
! 28: #include <string.h>
! 29: #include <strings.h>
! 30: #include <sys/wait.h>
! 31: #include <unistd.h>
! 32:
! 33: #ifdef HAVE_ERROR_H
! 34: #include <error.h>
! 35: #else
! 36: #include "portability/error.h"
! 37: #endif
! 38:
! 39: #include "packet/cmdparse.h"
! 40: #include "display.h"
! 41:
! 42:
! 43: /* Set a file descriptor to non-blocking */
! 44: static
! 45: void set_fd_nonblock(
! 46: int fd)
! 47: {
! 48: int flags;
! 49:
! 50: /* Get the current flags of the file descriptor */
! 51: flags = fcntl(fd, F_GETFL, 0);
! 52: if (flags == -1) {
! 53: error(EXIT_FAILURE, errno, "F_GETFL failure");
! 54: exit(1);
! 55: }
! 56:
! 57: /* Add the O_NONBLOCK bit to the current flags */
! 58: if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
! 59: error(EXIT_FAILURE, errno, "Failure to set O_NONBLOCK");
! 60: exit(1);
! 61: }
! 62: }
! 63:
! 64:
! 65: /*
! 66: Send a command synchronously to mtr-packet, blocking until a result
! 67: is available. This is intended to be used at start-up to check the
! 68: capabilities of mtr-packet, but probes should be sent asynchronously
! 69: to avoid blocking other probes and the user interface.
! 70: */
! 71: static
! 72: int send_synchronous_command(
! 73: struct mtr_ctl *ctl,
! 74: struct packet_command_pipe_t *cmdpipe,
! 75: const char *cmd,
! 76: struct command_t *result)
! 77: {
! 78: char reply[PACKET_REPLY_BUFFER_SIZE];
! 79: int command_length;
! 80: int write_length;
! 81: int read_length;
! 82:
! 83: /* Query send-probe support */
! 84: command_length = strlen(cmd);
! 85: write_length = write(cmdpipe->write_fd, cmd, command_length);
! 86:
! 87: if (write_length == -1) {
! 88: return -1;
! 89: }
! 90:
! 91: if (write_length != command_length) {
! 92: errno = EIO;
! 93: return -1;
! 94: }
! 95:
! 96: /* Read the reply to our query */
! 97: read_length =
! 98: read(cmdpipe->read_fd, reply, PACKET_REPLY_BUFFER_SIZE - 1);
! 99:
! 100: if (read_length < 0) {
! 101: return -1;
! 102: }
! 103:
! 104: /* Parse the query reply */
! 105: reply[read_length] = 0;
! 106: if (parse_command(result, reply)) {
! 107: return -1;
! 108: }
! 109:
! 110: return 0;
! 111: }
! 112:
! 113:
! 114: /* Check support for a particular feature with the mtr-packet we invoked */
! 115: static
! 116: int check_feature(
! 117: struct mtr_ctl *ctl,
! 118: struct packet_command_pipe_t *cmdpipe,
! 119: const char *feature)
! 120: {
! 121: char check_command[COMMAND_BUFFER_SIZE];
! 122: struct command_t reply;
! 123:
! 124: snprintf(check_command, COMMAND_BUFFER_SIZE,
! 125: "1 check-support feature %s\n", feature);
! 126:
! 127: if (send_synchronous_command(ctl, cmdpipe, check_command, &reply) ==
! 128: -1) {
! 129: return -1;
! 130: }
! 131:
! 132: /* Check that the feature is supported */
! 133: if (!strcmp(reply.command_name, "feature-support")
! 134: && reply.argument_count >= 1
! 135: && !strcmp(reply.argument_name[0], "support")
! 136: && !strcmp(reply.argument_value[0], "ok")) {
! 137:
! 138: /* Looks good */
! 139: return 0;
! 140: }
! 141:
! 142: errno = ENOTSUP;
! 143: return -1;
! 144: }
! 145:
! 146:
! 147: /*
! 148: Check the protocol selected against the mtr-packet we are using.
! 149: Returns zero if everything is fine, or -1 with errno for either
! 150: a failure during the check, or for an unsupported feature.
! 151: */
! 152: static
! 153: int check_packet_features(
! 154: struct mtr_ctl *ctl,
! 155: struct packet_command_pipe_t *cmdpipe)
! 156: {
! 157: /* Check the IP protocol version */
! 158: if (ctl->af == AF_INET6) {
! 159: if (check_feature(ctl, cmdpipe, "ip-6")) {
! 160: return -1;
! 161: }
! 162: } else if (ctl->af == AF_INET) {
! 163: if (check_feature(ctl, cmdpipe, "ip-4")) {
! 164: return -1;
! 165: }
! 166: } else {
! 167: errno = EINVAL;
! 168: return -1;
! 169: }
! 170:
! 171: /* Check the transport protocol */
! 172: if (ctl->mtrtype == IPPROTO_ICMP) {
! 173: if (check_feature(ctl, cmdpipe, "icmp")) {
! 174: return -1;
! 175: }
! 176: } else if (ctl->mtrtype == IPPROTO_UDP) {
! 177: if (check_feature(ctl, cmdpipe, "udp")) {
! 178: return -1;
! 179: }
! 180: } else if (ctl->mtrtype == IPPROTO_TCP) {
! 181: if (check_feature(ctl, cmdpipe, "tcp")) {
! 182: return -1;
! 183: }
! 184: #ifdef HAS_SCTP
! 185: } else if (ctl->mtrtype == IPPROTO_SCTP) {
! 186: if (check_feature(ctl, cmdpipe, "sctp")) {
! 187: return -1;
! 188: }
! 189: #endif
! 190: } else {
! 191: errno = EINVAL;
! 192: return -1;
! 193: }
! 194:
! 195: #ifdef SO_MARK
! 196: if (ctl->mark) {
! 197: if (check_feature(ctl, cmdpipe, "mark")) {
! 198: return -1;
! 199: }
! 200: }
! 201: #endif
! 202:
! 203: return 0;
! 204: }
! 205:
! 206:
! 207: /*
! 208: Execute mtr-packet, allowing the MTR_PACKET evironment to override
! 209: the PATH when locating the executable.
! 210: */
! 211: static
! 212: void execute_packet_child(
! 213: void)
! 214: {
! 215: /*
! 216: Allow the MTR_PACKET environment variable to override
! 217: the path to the mtr-packet executable. This is necessary
! 218: for debugging changes for mtr-packet.
! 219: */
! 220: char *mtr_packet_path = getenv("MTR_PACKET");
! 221: if (mtr_packet_path == NULL) {
! 222: mtr_packet_path = "mtr-packet";
! 223: }
! 224:
! 225: /*
! 226: First, try to execute mtr-packet from PATH
! 227: or MTR_PACKET environment variable.
! 228: */
! 229: execlp(mtr_packet_path, "mtr-packet", (char *) NULL);
! 230:
! 231: /*
! 232: If mtr-packet is not found, try to use mtr-packet from current directory
! 233: */
! 234: execl("./mtr-packet", "./mtr-packet", (char *) NULL);
! 235:
! 236: /* Both exec attempts failed, so nothing to do but exit */
! 237: exit(1);
! 238: }
! 239:
! 240:
! 241: /* Create the command pipe to a new mtr-packet subprocess */
! 242: int open_command_pipe(
! 243: struct mtr_ctl *ctl,
! 244: struct packet_command_pipe_t *cmdpipe)
! 245: {
! 246: int stdin_pipe[2];
! 247: int stdout_pipe[2];
! 248: pid_t child_pid;
! 249: int i;
! 250:
! 251: /*
! 252: We actually need two Unix pipes. One for stdin and one for
! 253: stdout on the new process.
! 254: */
! 255: if (pipe(stdin_pipe) || pipe(stdout_pipe)) {
! 256: return errno;
! 257: }
! 258:
! 259: child_pid = fork();
! 260: if (child_pid == -1) {
! 261: return errno;
! 262: }
! 263:
! 264: if (child_pid == 0) {
! 265: /*
! 266: In the child process, attach our created pipes to stdin
! 267: and stdout
! 268: */
! 269: dup2(stdin_pipe[0], STDIN_FILENO);
! 270: dup2(stdout_pipe[1], STDOUT_FILENO);
! 271:
! 272: /* Close all unnecessary fds */
! 273: for (i = STDERR_FILENO + 1; i <= stdout_pipe[1]; i++) {
! 274: close(i);
! 275: }
! 276:
! 277: execute_packet_child();
! 278: } else {
! 279: memset(cmdpipe, 0, sizeof(struct packet_command_pipe_t));
! 280:
! 281: /*
! 282: In the parent process, save the opposite ends of the pipes
! 283: attached as stdin and stdout in the child.
! 284: */
! 285: cmdpipe->pid = child_pid;
! 286: cmdpipe->read_fd = stdout_pipe[0];
! 287: cmdpipe->write_fd = stdin_pipe[1];
! 288:
! 289: /* We don't need the child ends of the pipe open in the parent. */
! 290: close(stdout_pipe[1]);
! 291: close(stdin_pipe[0]);
! 292:
! 293: /*
! 294: Check that we can communicate with the client. If we failed to
! 295: execute the mtr-packet binary, we will discover that here.
! 296: */
! 297: if (check_feature(ctl, cmdpipe, "send-probe")) {
! 298: error(EXIT_FAILURE, errno, "Failure to start mtr-packet");
! 299: }
! 300:
! 301: if (check_packet_features(ctl, cmdpipe)) {
! 302: error(EXIT_FAILURE, errno, "Packet type unsupported");
! 303: }
! 304:
! 305: /* We will need non-blocking reads from the child */
! 306: set_fd_nonblock(cmdpipe->read_fd);
! 307: }
! 308:
! 309: return 0;
! 310: }
! 311:
! 312:
! 313: /* Kill the mtr-packet child process and close the command pipe */
! 314: void close_command_pipe(
! 315: struct packet_command_pipe_t *cmdpipe)
! 316: {
! 317: int child_exit_value;
! 318:
! 319: if (cmdpipe->pid) {
! 320: close(cmdpipe->read_fd);
! 321: close(cmdpipe->write_fd);
! 322:
! 323: kill(cmdpipe->pid, SIGTERM);
! 324: waitpid(cmdpipe->pid, &child_exit_value, 0);
! 325: }
! 326:
! 327: memset(cmdpipe, 0, sizeof(struct packet_command_pipe_t));
! 328: }
! 329:
! 330:
! 331: /* Start building the command string for the "send-probe" command */
! 332: static
! 333: void construct_base_command(
! 334: struct mtr_ctl *ctl,
! 335: char *command,
! 336: int buffer_size,
! 337: int command_token,
! 338: ip_t * address,
! 339: ip_t * localaddress)
! 340: {
! 341: char ip_string[INET6_ADDRSTRLEN];
! 342: char local_ip_string[INET6_ADDRSTRLEN];
! 343: const char *ip_type;
! 344: const char *local_ip_type;
! 345: const char *protocol = NULL;
! 346:
! 347: /* Conver the remote IP address to a string */
! 348: if (inet_ntop(ctl->af, address, ip_string, INET6_ADDRSTRLEN) == NULL) {
! 349:
! 350: display_close(ctl);
! 351: error(EXIT_FAILURE, errno, "invalid remote IP address");
! 352: }
! 353:
! 354: if (inet_ntop(ctl->af, localaddress,
! 355: local_ip_string, INET6_ADDRSTRLEN) == NULL) {
! 356:
! 357: display_close(ctl);
! 358: error(EXIT_FAILURE, errno, "invalid local IP address");
! 359: }
! 360:
! 361: if (ctl->af == AF_INET6) {
! 362: ip_type = "ip-6";
! 363: local_ip_type = "local-ip-6";
! 364: } else {
! 365: ip_type = "ip-4";
! 366: local_ip_type = "local-ip-4";
! 367: }
! 368:
! 369: if (ctl->mtrtype == IPPROTO_ICMP) {
! 370: protocol = "icmp";
! 371: } else if (ctl->mtrtype == IPPROTO_UDP) {
! 372: protocol = "udp";
! 373: } else if (ctl->mtrtype == IPPROTO_TCP) {
! 374: protocol = "tcp";
! 375: #ifdef HAS_SCTP
! 376: } else if (ctl->mtrtype == IPPROTO_SCTP) {
! 377: protocol = "sctp";
! 378: #endif
! 379: } else {
! 380: display_close(ctl);
! 381: error(EXIT_FAILURE, 0,
! 382: "protocol unsupported by mtr-packet interface");
! 383: }
! 384:
! 385: snprintf(command, buffer_size,
! 386: "%d send-probe %s %s %s %s protocol %s",
! 387: command_token,
! 388: ip_type, ip_string, local_ip_type, local_ip_string, protocol);
! 389: }
! 390:
! 391:
! 392: /* Append an argument to the "send-probe" command string */
! 393: static
! 394: void append_command_argument(
! 395: char *command,
! 396: int buffer_size,
! 397: char *name,
! 398: int value)
! 399: {
! 400: char argument[COMMAND_BUFFER_SIZE];
! 401: int remaining_size;
! 402:
! 403: remaining_size = buffer_size - strlen(command) - 1;
! 404:
! 405: snprintf(argument, buffer_size, " %s %d", name, value);
! 406: strncat(command, argument, remaining_size);
! 407: }
! 408:
! 409:
! 410: /* Request a new probe from the "mtr-packet" child process */
! 411: void send_probe_command(
! 412: struct mtr_ctl *ctl,
! 413: struct packet_command_pipe_t *cmdpipe,
! 414: ip_t * address,
! 415: ip_t * localaddress,
! 416: int packet_size,
! 417: int sequence,
! 418: int time_to_live)
! 419: {
! 420: char command[COMMAND_BUFFER_SIZE];
! 421: int remaining_size;
! 422: int timeout;
! 423:
! 424: construct_base_command(ctl, command, COMMAND_BUFFER_SIZE, sequence,
! 425: address, localaddress);
! 426:
! 427: append_command_argument(command, COMMAND_BUFFER_SIZE, "size",
! 428: packet_size);
! 429:
! 430: append_command_argument(command, COMMAND_BUFFER_SIZE, "bit-pattern",
! 431: ctl->bitpattern);
! 432:
! 433: append_command_argument(command, COMMAND_BUFFER_SIZE, "tos", ctl->tos);
! 434:
! 435: append_command_argument(command, COMMAND_BUFFER_SIZE, "ttl",
! 436: time_to_live);
! 437:
! 438: timeout = ctl->probe_timeout / 1000000;
! 439: append_command_argument(command, COMMAND_BUFFER_SIZE, "timeout",
! 440: timeout);
! 441:
! 442: if (ctl->remoteport) {
! 443: append_command_argument(command, COMMAND_BUFFER_SIZE, "port",
! 444: ctl->remoteport);
! 445: }
! 446:
! 447: if (ctl->localport) {
! 448: append_command_argument(command, COMMAND_BUFFER_SIZE, "local-port",
! 449: ctl->localport);
! 450: }
! 451: #ifdef SO_MARK
! 452: if (ctl->mark) {
! 453: append_command_argument(command, COMMAND_BUFFER_SIZE, "mark",
! 454: ctl->mark);
! 455: }
! 456: #endif
! 457:
! 458: remaining_size = COMMAND_BUFFER_SIZE - strlen(command) - 1;
! 459: strncat(command, "\n", remaining_size);
! 460:
! 461: /* Send a probe using the mtr-packet subprocess */
! 462: if (write(cmdpipe->write_fd, command, strlen(command)) == -1) {
! 463: display_close(ctl);
! 464: error(EXIT_FAILURE, errno,
! 465: "mtr-packet command pipe write failure");
! 466: }
! 467: }
! 468:
! 469:
! 470: /*
! 471: Parse a comma separated field of mpls values, filling out the mplslen
! 472: structure with mpls labels.
! 473: */
! 474: static
! 475: void parse_mpls_values(
! 476: struct mplslen *mpls,
! 477: char *value_str)
! 478: {
! 479: char *next_value = value_str;
! 480: char *end_of_value;
! 481: int value;
! 482: int label_count = 0;
! 483: int label_field = 0;
! 484:
! 485: while (*next_value) {
! 486: value = strtol(next_value, &end_of_value, 10);
! 487:
! 488: /* Failure to advance means an invalid numeric value */
! 489: if (end_of_value == next_value) {
! 490: return;
! 491: }
! 492:
! 493: /* If the next character is not a comma or a NUL, we have
! 494: an invalid string */
! 495: if (*end_of_value == ',') {
! 496: next_value = end_of_value + 1;
! 497: } else if (*end_of_value == 0) {
! 498: next_value = end_of_value;
! 499: } else {
! 500: return;
! 501: }
! 502:
! 503: /*
! 504: Store the converted value in the next field of the MPLS
! 505: structure.
! 506: */
! 507: if (label_field == 0) {
! 508: mpls->label[label_count] = value;
! 509: } else if (label_field == 1) {
! 510: mpls->exp[label_count] = value;
! 511: } else if (label_field == 2) {
! 512: mpls->s[label_count] = value;
! 513: } else if (label_field == 3) {
! 514: mpls->ttl[label_count] = value;
! 515: }
! 516:
! 517: label_field++;
! 518: if (label_field > 3) {
! 519: label_field = 0;
! 520: label_count++;
! 521: }
! 522:
! 523: /*
! 524: If we've used up all MPLS labels in the structure, return with
! 525: what we've got
! 526: */
! 527: if (label_count >= MAXLABELS) {
! 528: break;
! 529: }
! 530: }
! 531:
! 532: mpls->labels = label_count;
! 533: }
! 534:
! 535:
! 536: /*
! 537: Extract the IP address and round trip time from a reply to a probe.
! 538: Returns true if both arguments are found in the reply, false otherwise.
! 539: */
! 540: static
! 541: bool parse_reply_arguments(
! 542: struct mtr_ctl *ctl,
! 543: struct command_t *reply,
! 544: ip_t * fromaddress,
! 545: int *round_trip_time,
! 546: struct mplslen *mpls)
! 547: {
! 548: bool found_round_trip;
! 549: bool found_ip;
! 550: char *arg_name;
! 551: char *arg_value;
! 552: int i;
! 553:
! 554: *round_trip_time = 0;
! 555: memset(fromaddress, 0, sizeof(ip_t));
! 556: memset(mpls, 0, sizeof(struct mplslen));
! 557:
! 558: found_ip = false;
! 559: found_round_trip = false;
! 560:
! 561: /* Examine the reply arguments for known values */
! 562: for (i = 0; i < reply->argument_count; i++) {
! 563: arg_name = reply->argument_name[i];
! 564: arg_value = reply->argument_value[i];
! 565:
! 566: if (ctl->af == AF_INET6) {
! 567: /* IPv6 address of the responding host */
! 568: if (!strcmp(arg_name, "ip-6")) {
! 569: if (inet_pton(AF_INET6, arg_value, fromaddress)) {
! 570: found_ip = true;
! 571: }
! 572: }
! 573: } else {
! 574: /* IPv4 address of the responding host */
! 575: if (!strcmp(arg_name, "ip-4")) {
! 576: if (inet_pton(AF_INET, arg_value, fromaddress)) {
! 577: found_ip = true;
! 578: }
! 579: }
! 580: }
! 581:
! 582: /* The round trip time in microseconds */
! 583: if (!strcmp(arg_name, "round-trip-time")) {
! 584: errno = 0;
! 585: *round_trip_time = strtol(arg_value, NULL, 10);
! 586: if (!errno) {
! 587: found_round_trip = true;
! 588: }
! 589: }
! 590:
! 591: /* MPLS labels */
! 592: if (!strcmp(arg_name, "mpls")) {
! 593: parse_mpls_values(mpls, arg_value);
! 594: }
! 595: }
! 596:
! 597: return found_ip && found_round_trip;
! 598: }
! 599:
! 600:
! 601: /*
! 602: If an mtr-packet command has returned an error result,
! 603: report the error and exit.
! 604: */
! 605: static
! 606: void handle_reply_errors(
! 607: struct mtr_ctl *ctl,
! 608: struct command_t *reply)
! 609: {
! 610: char *reply_name;
! 611:
! 612: reply_name = reply->command_name;
! 613:
! 614: if (!strcmp(reply_name, "no-route")) {
! 615: display_close(ctl);
! 616: error(EXIT_FAILURE, 0, "No route to host");
! 617: }
! 618:
! 619: if (!strcmp(reply_name, "network-down")) {
! 620: display_close(ctl);
! 621: error(EXIT_FAILURE, 0, "Network down");
! 622: }
! 623:
! 624: if (!strcmp(reply_name, "probes-exhausted")) {
! 625: display_close(ctl);
! 626: error(EXIT_FAILURE, 0, "Probes exhausted");
! 627: }
! 628:
! 629: if (!strcmp(reply_name, "invalid-argument")) {
! 630: display_close(ctl);
! 631: error(EXIT_FAILURE, 0, "mtr-packet reported invalid argument");
! 632: }
! 633:
! 634: if (!strcmp(reply_name, "permission-denied")) {
! 635: display_close(ctl);
! 636: error(EXIT_FAILURE, 0, "Permission denied");
! 637: }
! 638:
! 639: if (!strcmp(reply_name, "address-in-use")) {
! 640: display_close(ctl);
! 641: error(EXIT_FAILURE, 0, "Address in use");
! 642: }
! 643:
! 644: if (!strcmp(reply_name, "address-not-available")) {
! 645: display_close(ctl);
! 646: error(EXIT_FAILURE, 0, "Address not available");
! 647: }
! 648:
! 649: if (!strcmp(reply_name, "unexpected-error")) {
! 650: display_close(ctl);
! 651: error(EXIT_FAILURE, 0, "Unexpected mtr-packet error");
! 652: }
! 653: }
! 654:
! 655:
! 656: /*
! 657: A complete mtr-packet reply line has arrived. Parse it and record
! 658: the responding IP and round trip time, if it is a reply that we
! 659: understand.
! 660: */
! 661: static
! 662: void handle_command_reply(
! 663: struct mtr_ctl *ctl,
! 664: char *reply_str,
! 665: probe_reply_func_t reply_func)
! 666: {
! 667: struct command_t reply;
! 668: ip_t fromaddress;
! 669: int seq_num;
! 670: int round_trip_time;
! 671: char *reply_name;
! 672: struct mplslen mpls;
! 673:
! 674: /* Parse the reply string */
! 675: if (parse_command(&reply, reply_str)) {
! 676: /*
! 677: If the reply isn't well structured, something is fundamentally
! 678: wrong, as we might as well exit. Even if the reply is of an
! 679: unknown type, it should still parse.
! 680: */
! 681: display_close(ctl);
! 682: error(EXIT_FAILURE, errno, "reply parse failure");
! 683: return;
! 684: }
! 685:
! 686: handle_reply_errors(ctl, &reply);
! 687:
! 688: seq_num = reply.token;
! 689: reply_name = reply.command_name;
! 690:
! 691: /* If the reply type is unknown, ignore it for future compatibility */
! 692: if (strcmp(reply_name, "reply") && strcmp(reply_name, "ttl-expired")) {
! 693: return;
! 694: }
! 695:
! 696: /*
! 697: If the reply had an IP address and a round trip time, we can
! 698: record the result.
! 699: */
! 700: if (parse_reply_arguments
! 701: (ctl, &reply, &fromaddress, &round_trip_time, &mpls)) {
! 702:
! 703: reply_func(ctl, seq_num, &mpls, (void *) &fromaddress,
! 704: round_trip_time);
! 705: }
! 706: }
! 707:
! 708:
! 709: /*
! 710: Check the command pipe for completed replies to commands
! 711: we have previously sent. Record the results of those replies.
! 712: */
! 713: static
! 714: void consume_reply_buffer(
! 715: struct mtr_ctl *ctl,
! 716: struct packet_command_pipe_t *cmdpipe,
! 717: probe_reply_func_t reply_func)
! 718: {
! 719: char *reply_buffer;
! 720: char *reply_start;
! 721: char *end_of_reply;
! 722: int used_size;
! 723: int move_size;
! 724:
! 725: reply_buffer = cmdpipe->reply_buffer;
! 726:
! 727: /* Terminate the string storing the replies */
! 728: assert(cmdpipe->reply_buffer_used < PACKET_REPLY_BUFFER_SIZE);
! 729: reply_buffer[cmdpipe->reply_buffer_used] = 0;
! 730:
! 731: reply_start = reply_buffer;
! 732:
! 733: /*
! 734: We may have multiple completed replies. Loop until we don't
! 735: have any more newlines termininating replies.
! 736: */
! 737: while (true) {
! 738: /* If no newline is found, our reply isn't yet complete */
! 739: end_of_reply = index(reply_start, '\n');
! 740: if (end_of_reply == NULL) {
! 741: /* No complete replies remaining */
! 742: break;
! 743: }
! 744:
! 745: /*
! 746: Terminate the reply string at the newline, which
! 747: is necessary in the case where we are able to read
! 748: mulitple replies arriving simultaneously.
! 749: */
! 750: *end_of_reply = 0;
! 751:
! 752: /* Parse and record the reply results */
! 753: handle_command_reply(ctl, reply_start, reply_func);
! 754:
! 755: reply_start = end_of_reply + 1;
! 756: }
! 757:
! 758: /*
! 759: After replies have been processed, free the space used
! 760: by the replies, and move any remaining partial reply text
! 761: to the start of the reply buffer.
! 762: */
! 763: used_size = reply_start - reply_buffer;
! 764: move_size = cmdpipe->reply_buffer_used - used_size;
! 765: memmove(reply_buffer, reply_start, move_size);
! 766: cmdpipe->reply_buffer_used -= used_size;
! 767:
! 768: if (cmdpipe->reply_buffer_used >= PACKET_REPLY_BUFFER_SIZE - 1) {
! 769: /*
! 770: We've overflowed the reply buffer without a complete reply.
! 771: There's not much we can do about it but discard the data
! 772: we've got and hope new data coming in fits.
! 773: */
! 774: cmdpipe->reply_buffer_used = 0;
! 775: }
! 776: }
! 777:
! 778:
! 779: /*
! 780: Read as much as we can from the reply pipe from the child process, and
! 781: process as many replies as are available.
! 782: */
! 783: void handle_command_replies(
! 784: struct mtr_ctl *ctl,
! 785: struct packet_command_pipe_t *cmdpipe,
! 786: probe_reply_func_t reply_func)
! 787: {
! 788: int read_count;
! 789: int buffer_remaining;
! 790: char *reply_buffer;
! 791: char *read_buffer;
! 792:
! 793: reply_buffer = cmdpipe->reply_buffer;
! 794:
! 795: /*
! 796: Read the available reply text, up to the the remaining
! 797: buffer space. (Minus one for the terminating NUL.)
! 798: */
! 799: read_buffer = &reply_buffer[cmdpipe->reply_buffer_used];
! 800: buffer_remaining =
! 801: PACKET_REPLY_BUFFER_SIZE - cmdpipe->reply_buffer_used;
! 802: read_count = read(cmdpipe->read_fd, read_buffer, buffer_remaining - 1);
! 803:
! 804: if (read_count < 0) {
! 805: /*
! 806: EAGAIN simply indicates that there is no data currently
! 807: available on our non-blocking pipe.
! 808: */
! 809: if (errno == EAGAIN) {
! 810: return;
! 811: }
! 812:
! 813: display_close(ctl);
! 814: error(EXIT_FAILURE, errno, "command reply read failure");
! 815: return;
! 816: }
! 817:
! 818: if (read_count == 0) {
! 819: display_close(ctl);
! 820:
! 821: errno = EPIPE;
! 822: error(EXIT_FAILURE, EPIPE, "unexpected packet generator exit");
! 823: }
! 824:
! 825: cmdpipe->reply_buffer_used += read_count;
! 826:
! 827: /* Handle any replies completed by this read */
! 828: consume_reply_buffer(ctl, cmdpipe, reply_func);
! 829: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cmdpipe.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr / ui