usr.sbin/dconschat/dconschat.c

   1 /*
   2  * Copyright (C) 2003
   3  *      Hidetoshi Shimokawa. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *
  16  *      This product includes software developed by Hidetoshi Shimokawa.
  17  *
  18  * 4. Neither the name of the author nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $Id: dconschat.c,v 1.76 2003/10/23 06:21:13 simokawa Exp $
  35  * $FreeBSD$
  36  */
  37
  38 #include <sys/param.h>
  39 #include <sys/types.h>
  40 #include <sys/uio.h>
  41 #include <unistd.h>
  42 #include <fcntl.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <termios.h>
  46 #include <dev/dcons/dcons.h>
  47
  48 #include <sys/socket.h>
  49 #include <netinet/in.h>
  50 #include <netdb.h>
  51 #include <err.h>
  52 #include <string.h>
  53 #include <sys/eui64.h>
  54 #include <sys/event.h>
  55 #include <sys/time.h>
  56 #include <arpa/telnet.h>
  57
  58 #include <sys/ioccom.h>
  59 #include <dev/firewire/firewire.h>
  60 #include <dev/firewire/iec13213.h>
  61
  62 #include <kvm.h>
  63 #include <nlist.h>
  64
  65 #include <sys/errno.h>
  66
  67 #define DCONS_POLL_HZ           100
  68 #define DCONS_POLL_OFFLINE      2       /* sec */
  69
  70 #define RETRY 3
  71
  72 #ifdef CSRVAL_VENDOR_PRIVATE
  73 #define USE_CROM 1
  74 #else
  75 #define USE_CROM 0
  76 #endif
  77
  78 int verbose = 0;
  79 int tc_set = 0;
  80 int poll_hz = DCONS_POLL_HZ;
  81 static u_char abreak[3] = {13 /* CR */, 126 /* ~ */, 2 /* ^B */};
  82
  83 #define IS_CONSOLE(p)   ((p)->port == DCONS_CON)
  84 #define IS_GDB(p)       ((p)->port == DCONS_GDB)
  85
  86 static struct dcons_state {
  87         int fd;
  88         kvm_t *kd;
  89         int kq;
  90         off_t paddr;
  91         off_t reset;
  92 #define F_READY         (1 << 1)
  93 #define F_RD_ONLY       (1 << 2)
  94 #define F_ALT_BREAK     (1 << 3)
  95 #define F_TELNET        (1 << 4)
  96 #define F_USE_CROM      (1 << 5)
  97 #define F_ONE_SHOT      (1 << 6)
  98 #define F_REPLAY        (1 << 7)
  99         int flags;
 100         enum {
 101                 TYPE_KVM,
 102                 TYPE_FW
 103         } type;
 104         int escape_state;
 105         struct dcons_port {
 106                 int port;
 107                 int sport;
 108                 struct dcons_ch o;
 109                 struct dcons_ch i;
 110                 u_int32_t optr;
 111                 u_int32_t iptr;
 112                 int s;
 113                 int infd;
 114                 int outfd;
 115                 struct addrinfo *res;
 116                 int skip_read;
 117         } port[DCONS_NPORT];
 118         struct timespec to;
 119         struct timespec zero;
 120         struct termios tsave;
 121         struct termios traw;
 122         char escape;
 123 } sc;
 124
 125 static int dconschat_write_dcons(struct dcons_state *, int, char *, int);
 126
 127 static int
 128 dread(struct dcons_state *dc, void *buf, size_t n, off_t offset)
 129 {
 130         switch (dc->type) {
 131         case TYPE_FW:
 132                 return (pread(dc->fd, buf, n, offset));
 133         case TYPE_KVM:
 134                 return (kvm_read(dc->kd, offset, buf, n));
 135         }
 136         return (-1);
 137 }
 138
 139 static int
 140 dwrite(struct dcons_state *dc, void *buf, size_t n, off_t offset)
 141 {
 142         if ((dc->flags & F_RD_ONLY) != 0)
 143                 return (n);
 144
 145         switch (dc->type) {
 146         case TYPE_FW:
 147                 return (pwrite(dc->fd, buf, n, offset));
 148         case TYPE_KVM:
 149                 return (kvm_write(dc->kd, offset, buf, n));
 150         }
 151         return (-1);
 152 }
 153
 154 static void
 155 dconschat_reset_target(struct dcons_state *dc, struct dcons_port *p)
 156 {
 157         char buf[PAGE_SIZE];
 158         if (dc->reset == 0)
 159                 return;
 160
 161         snprintf(buf, PAGE_SIZE, "\r\n[dconschat reset target(addr=0x%zx)...]\r\n", dc->reset);
 162         write(p->outfd, buf, strlen(buf));
 163         bzero(&buf[0], PAGE_SIZE);
 164         dwrite(dc, (void *)buf, PAGE_SIZE, dc->reset);
 165 }
 166
 167
 168 static void
 169 dconschat_suspend(struct dcons_state *dc, struct dcons_port *p)
 170 {
 171         if (p->sport != 0)
 172                 return;
 173
 174         if (tc_set)
 175                 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave);
 176
 177         printf("\n[dconschat suspend]\n");
 178         kill(getpid(), SIGTSTP);
 179
 180         if (tc_set)
 181                 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw);
 182 }
 183
 184 static void
 185 dconschat_sigchld(int s)
 186 {
 187         struct kevent kev;
 188         struct dcons_port *p;
 189         char buf[256];
 190
 191         p = &sc.port[DCONS_CON];
 192
 193         snprintf(buf, 256, "\r\n[child exit]\r\n");
 194         write(p->outfd, buf, strlen(buf));
 195
 196         if (tc_set)
 197                 tcsetattr(STDIN_FILENO, TCSADRAIN, &sc.traw);
 198
 199         EV_SET(&kev, p->infd, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1, (void *)p);
 200         kevent(sc.kq, &kev, 1, NULL, 0, &sc.zero);
 201 }
 202
 203 static void
 204 dconschat_fork_gdb(struct dcons_state *dc, struct dcons_port *p)
 205 {
 206         pid_t pid;
 207         char buf[256], com[256];
 208         struct kevent kev;
 209
 210         pid = fork();
 211         if (pid < 0) {
 212                 snprintf(buf, 256, "\r\n[%s: fork failed]\r\n", __FUNCTION__);
 213                 write(p->outfd, buf, strlen(buf));
 214         }
 215
 216
 217         if (pid == 0) {
 218                 /* child */
 219                 if (tc_set)
 220                         tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave);
 221
 222                 snprintf(com, sizeof(buf), "kgdb -r :%d kernel",
 223                         dc->port[DCONS_GDB].sport);
 224                 snprintf(buf, 256, "\n[fork %s]\n", com);
 225                 write(p->outfd, buf, strlen(buf));
 226
 227                 execl("/bin/sh", "/bin/sh", "-c", com, 0);
 228
 229                 snprintf(buf, 256, "\n[fork failed]\n");
 230                 write(p->outfd, buf, strlen(buf));
 231
 232                 if (tc_set)
 233                         tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw);
 234
 235                 exit(0);
 236         } else {
 237                 signal(SIGCHLD, dconschat_sigchld);
 238                 EV_SET(&kev, p->infd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
 239                 kevent(sc.kq, &kev, 1, NULL, 0, &sc.zero);
 240         }
 241 }
 242
 243
 244 static void
 245 dconschat_cleanup(int sig)
 246 {
 247         struct dcons_state *dc;
 248         int status;
 249
 250         dc = &sc;
 251         if (tc_set != 0)
 252                 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave);
 253
 254         if (sig > 0)
 255                 printf("\n[dconschat exiting with signal %d ...]\n", sig);
 256         else
 257                 printf("\n[dconschat exiting...]\n");
 258         wait(&status);
 259         exit(0);
 260 }
 261
 262 #if USE_CROM
 263 static int
 264 dconschat_get_crom(struct dcons_state *dc)
 265 {
 266         off_t addr;
 267         int i, state = 0;
 268         u_int32_t buf, hi = 0, lo = 0, reset_hi = 0, reset_lo = 0;
 269         struct csrreg *reg;
 270
 271         reg = (struct csrreg *)&buf;
 272         addr = 0xffff;
 273         addr = (addr << 32) | 0xf0000400;
 274         for (i = 20; i < 0x400; i += 4) {
 275                 if (dread(dc, &buf, 4, addr + i) < 0) {
 276                         if (verbose)
 277                                 warn("crom read faild");
 278                         goto out;
 279                 }
 280                 buf = ntohl(buf);
 281                 if (verbose)
 282                         printf("%d %02x %06x\n", state, reg->key, reg->val);
 283                 switch (state) {
 284                 case 0:
 285                         if (reg->key == CSRKEY_SPEC &&
 286                                         reg->val == CSRVAL_VENDOR_PRIVATE)
 287                                 state = 1;
 288                         break;
 289                 case 1:
 290                         if (reg->key == CSRKEY_VER &&
 291                                         reg->val == DCONS_CSR_VAL_VER)
 292                                 state = 2;
 293                         break;
 294                 case 2:
 295                         switch (reg->key) {
 296                         case DCONS_CSR_KEY_HI:
 297                                 hi = reg->val;
 298                                 break;
 299                         case DCONS_CSR_KEY_LO:
 300                                 lo = reg->val;
 301                                 break;
 302                         case DCONS_CSR_KEY_RESET_HI:
 303                                 reset_hi = reg->val;
 304                                 break;
 305                         case DCONS_CSR_KEY_RESET_LO:
 306                                 reset_lo = reg->val;
 307                                 goto out;
 308                                 break;
 309                         case 0x81:
 310                                 break;
 311                         default:
 312                                 state = 0;
 313                         }
 314                         break;
 315                 }
 316         }
 317 out:
 318         if (verbose)
 319                 printf("addr: %06x %06x\n", hi, lo);
 320         dc->paddr = ((off_t)hi << 24) | lo;
 321         dc->reset = ((off_t)reset_hi << 24) | reset_lo;
 322         if (dc->paddr == 0)
 323                 return (-1);
 324         return (0);
 325 }
 326 #endif
 327
 328 static void
 329 dconschat_ready(struct dcons_state *dc, int ready, char *reason)
 330 {
 331         static char oldreason[64] = "";
 332         int old;
 333
 334         old = (dc->flags & F_READY) ? 1 : 0;
 335
 336         if (ready) {
 337                 dc->flags |= F_READY;
 338                 if (ready != old)
 339                         printf("[dcons connected]\r\n");
 340                 oldreason[0] = 0;
 341         } else {
 342                 dc->flags &= ~F_READY;
 343                 if (strncmp(oldreason, reason, sizeof(oldreason)) != 0) {
 344                         printf("[dcons disconnected (%s)]\r\n", reason);
 345                         strlcpy(oldreason, reason, sizeof(oldreason));
 346                 }
 347         }
 348 }
 349
 350 static int
 351 dconschat_fetch_header(struct dcons_state *dc)
 352 {
 353         char ebuf[64];
 354         struct dcons_buf dbuf;
 355         int j;
 356
 357 #if USE_CROM
 358         if (dc->paddr == 0 && (dc->flags & F_USE_CROM) != 0) {
 359                 if (dconschat_get_crom(dc)) {
 360                         dconschat_ready(dc, 0, "get crom failed");
 361                         return (-1);
 362                 }
 363         }
 364 #endif
 365
 366         if (dread(dc, &dbuf, DCONS_HEADER_SIZE, dc->paddr) < 0) {
 367                 dconschat_ready(dc, 0, "read header failed");
 368                 return (-1);
 369         }
 370         if (dbuf.magic != htonl(DCONS_MAGIC)) {
 371                 if ((dc->flags & F_USE_CROM) !=0)
 372                         dc->paddr = 0;
 373                 snprintf(ebuf, sizeof(ebuf), "wrong magic 0x%08x", dbuf.magic);
 374                 dconschat_ready(dc, 0, ebuf);
 375                 return (-1);
 376         }
 377         if (ntohl(dbuf.version) != DCONS_VERSION) {
 378                 snprintf(ebuf, sizeof(ebuf),
 379 #if __FreeBSD_version < 500000
 380                     "wrong version %ld,%d",
 381 #else
 382                     "wrong version %d,%d",
 383 #endif
 384                     ntohl(dbuf.version), DCONS_VERSION);
 385                 /* XXX exit? */
 386                 dconschat_ready(dc, 0, ebuf);
 387                 return (-1);
 388         }
 389
 390         for (j = 0; j < DCONS_NPORT; j++) {
 391                 struct dcons_ch *o, *i;
 392                 off_t newbuf;
 393                 int new = 0;
 394
 395                 o = &dc->port[j].o;
 396                 newbuf = dc->paddr + ntohl(dbuf.ooffset[j]);
 397                 o->size = ntohl(dbuf.osize[j]);
 398
 399                 if (newbuf != o->buf) {
 400                         /* buffer address has changes */
 401                         new = 1;
 402                         o->gen = ntohl(dbuf.optr[j]) >> DCONS_GEN_SHIFT;
 403                         o->pos = ntohl(dbuf.optr[j]) & DCONS_POS_MASK;
 404                         o->buf = newbuf;
 405                 }
 406
 407                 i = &dc->port[j].i;
 408                 i->size = ntohl(dbuf.isize[j]);
 409                 i->gen = ntohl(dbuf.iptr[j]) >> DCONS_GEN_SHIFT;
 410                 i->pos = ntohl(dbuf.iptr[j]) & DCONS_POS_MASK;
 411                 i->buf = dc->paddr + ntohl(dbuf.ioffset[j]);
 412
 413                 if (verbose) {
 414                         printf("port %d   size offset   gen   pos\n", j);
 415 #if __FreeBSD_version < 500000
 416                         printf("output: %5d %6ld %5d %5d\n"
 417                                 "input : %5d %6ld %5d %5d\n",
 418 #else
 419                         printf("output: %5d %6d %5d %5d\n"
 420                                 "input : %5d %6d %5d %5d\n",
 421 #endif
 422                         o->size, ntohl(dbuf.ooffset[j]), o->gen, o->pos,
 423                         i->size, ntohl(dbuf.ioffset[j]), i->gen, i->pos);
 424                 }
 425
 426                 if (IS_CONSOLE(&dc->port[j]) && new &&
 427                     (dc->flags & F_REPLAY) !=0) {
 428                         if (o->gen > 0)
 429                                 o->gen --;
 430                         else
 431                                 o->pos = 0;
 432                 }
 433         }
 434         dconschat_ready(dc, 1, NULL);
 435         return(0);
 436 }
 437
 438 static int
 439 dconschat_get_ptr (struct dcons_state *dc) {
 440         int dlen, i;
 441         u_int32_t ptr[DCONS_NPORT*2+1];
 442         static int retry = RETRY;
 443         char ebuf[64];
 444
 445 again:
 446         dlen = dread(dc, &ptr, sizeof(ptr),
 447                 dc->paddr + __offsetof(struct dcons_buf, magic));
 448
 449         if (dlen < 0) {
 450                 if (errno == ETIMEDOUT)
 451                         if (retry -- > 0)
 452                                 goto again;
 453                 dconschat_ready(dc, 0, "get ptr failed");
 454                 return(-1);
 455         }
 456         if (ptr[0] != htonl(DCONS_MAGIC)) {
 457                 if ((dc->flags & F_USE_CROM) !=0)
 458                         dc->paddr = 0;
 459                 snprintf(ebuf, sizeof(ebuf), "wrong magic 0x%08x", ptr[0]);
 460                 dconschat_ready(dc, 0, ebuf);
 461                 return(-1);
 462         }
 463         retry = RETRY;
 464         for (i = 0; i < DCONS_NPORT; i ++) {
 465                 dc->port[i].optr = ntohl(ptr[i + 1]);
 466                 dc->port[i].iptr = ntohl(ptr[DCONS_NPORT + i + 1]);
 467         }
 468         return(0);
 469 }
 470
 471 #define MAX_XFER 2048
 472 static int
 473 dconschat_read_dcons(struct dcons_state *dc, int port, char *buf, int len)
 474 {
 475         struct dcons_ch *ch;
 476         u_int32_t ptr, pos, gen, next_gen;
 477         int rlen, dlen, lost;
 478         int retry = RETRY;
 479
 480         ch = &dc->port[port].o;
 481         ptr = dc->port[port].optr;
 482         gen = ptr >> DCONS_GEN_SHIFT;
 483         pos = ptr & DCONS_POS_MASK;
 484         if (gen == ch->gen && pos == ch->pos)
 485                 return (-1);
 486
 487         next_gen = DCONS_NEXT_GEN(ch->gen);
 488         /* XXX sanity check */
 489         if (gen == ch->gen) {
 490                 if (pos > ch->pos)
 491                         goto ok;
 492                 lost = ch->size * DCONS_GEN_MASK - ch->pos;
 493                 ch->pos = 0;
 494         } else if (gen == next_gen) {
 495                 if (pos <= ch->pos)
 496                         goto ok;
 497                 lost = pos - ch->pos;
 498                 ch->pos = pos;
 499         } else {
 500                 lost = gen - ch->gen;
 501                 if (lost < 0)
 502                         lost += DCONS_GEN_MASK;
 503                 if (verbose)
 504                         printf("[genskip %d]", lost);
 505                 lost = lost * ch->size - ch->pos;
 506                 ch->pos = 0;
 507                 ch->gen = gen;
 508         }
 509         /* generation skipped !! */
 510         /* XXX discard */
 511         if (verbose)
 512                 printf("[lost %d]", lost);
 513 ok:
 514         if (gen == ch->gen)
 515                 rlen = pos - ch->pos;
 516         else
 517                 rlen = ch->size - ch->pos;
 518
 519         if (rlen > MAX_XFER)
 520                 rlen = MAX_XFER;
 521         if (rlen > len)
 522                 rlen = len;
 523
 524 #if 1
 525         if (verbose == 1)
 526                 printf("[%d]", rlen); fflush(stdout);
 527 #endif
 528
 529 again:
 530         dlen = dread(dc, buf, rlen, ch->buf + ch->pos);
 531         if (dlen < 0) {
 532                 if (errno == ETIMEDOUT)
 533                         if (retry -- > 0)
 534                                 goto again;
 535                 dconschat_ready(dc, 0, "read buffer failed");
 536                 return(-1);
 537         }
 538         if (dlen != rlen)
 539                 warnx("dlen(%d) != rlen(%d)\n", dlen, rlen);
 540         ch->pos += dlen;
 541         if (ch->pos >= ch->size) {
 542                 ch->gen = next_gen;
 543                 ch->pos = 0;
 544                 if (verbose)
 545                         printf("read_dcons: gen=%d", ch->gen);
 546         }
 547         return (dlen);
 548 }
 549
 550 static int
 551 dconschat_write_dcons(struct dcons_state *dc, int port, char *buf, int blen)
 552 {
 553         struct dcons_ch *ch;
 554         u_int32_t ptr;
 555         int len, wlen;
 556         int retry = RETRY;
 557
 558         ch = &dc->port[port].i;
 559         ptr = dc->port[port].iptr;
 560
 561         /* the others may advance the pointer sync with it */
 562         ch->gen = ptr >> DCONS_GEN_SHIFT;
 563         ch->pos = ptr & DCONS_POS_MASK;
 564
 565         while(blen > 0) {
 566                 wlen = MIN(blen, ch->size - ch->pos);
 567                 wlen = MIN(wlen, MAX_XFER);
 568                 len = dwrite(dc, buf, wlen, ch->buf + ch->pos);
 569                 if (len < 0) {
 570                         if (errno == ETIMEDOUT)
 571                                 if (retry -- > 0)
 572                                         continue; /* try again */
 573                         dconschat_ready(dc, 0, "write buffer failed");
 574                         return(-1);
 575                 }
 576                 ch->pos += len;
 577                 buf += len;
 578                 blen -= len;
 579                 if (ch->pos >= ch->size) {
 580                         ch->gen = DCONS_NEXT_GEN(ch->gen);
 581                         ch->pos = 0;
 582                         if (verbose)
 583                                 printf("write_dcons: gen=%d", ch->gen);
 584
 585                 }
 586         }
 587
 588         ptr = DCONS_MAKE_PTR(ch);
 589         dc->port[port].iptr = ptr;
 590
 591         if (verbose > 2)
 592                 printf("(iptr: 0x%x)", ptr);
 593 again:
 594         len = dwrite(dc, &ptr, sizeof(u_int32_t),
 595                 dc->paddr + __offsetof(struct dcons_buf, iptr[port]));
 596         if (len < 0) {
 597                 if (errno == ETIMEDOUT)
 598                         if (retry -- > 0)
 599                                 goto again;
 600                 dconschat_ready(dc, 0, "write ptr failed");
 601                 return(-1);
 602         }
 603         return(0);
 604 }
 605
 606
 607 static int
 608 dconschat_write_socket(int fd, char *buf, int len)
 609 {
 610         write(fd, buf, len);
 611         if (verbose > 1) {
 612                 buf[len] = 0;
 613                 printf("<- %s\n", buf);
 614         }
 615         return (0);
 616 }
 617
 618 static void
 619 dconschat_init_socket(struct dcons_state *dc, int port, char *host, int sport)
 620 {
 621         struct addrinfo hints, *res;
 622         int on = 1, error;
 623         char service[10];
 624         struct kevent kev;
 625         struct dcons_port *p;
 626
 627         p = &dc->port[port];
 628         p->port = port;
 629         p->sport = sport;
 630         p->infd = p->outfd = -1;
 631
 632         if (sport < 0)
 633                 return;
 634
 635         if (sport == 0) {
 636
 637                 /* Use stdin and stdout */
 638                 p->infd = STDIN_FILENO;
 639                 p->outfd = STDOUT_FILENO;
 640                 p->s = -1;
 641                 if (tc_set == 0 &&
 642                     tcgetattr(STDIN_FILENO, &dc->tsave) == 0) {
 643                         dc->traw = dc->tsave;
 644                         cfmakeraw(&dc->traw);
 645                         tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw);
 646                         tc_set = 1;
 647                 }
 648                 EV_SET(&kev, p->infd, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1,
 649                     (void *)p);
 650                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 651                 return;
 652         }
 653
 654         memset(&hints, 0, sizeof(hints));
 655         hints.ai_flags = AI_PASSIVE;
 656 #if 1   /* gdb can talk v4 only */
 657         hints.ai_family = PF_INET;
 658 #else
 659         hints.ai_family = PF_UNSPEC;
 660 #endif
 661         hints.ai_socktype = SOCK_STREAM;
 662         hints.ai_protocol = 0;
 663
 664         if (verbose)
 665                 printf("%s:%d for port %d\n",
 666                         host == NULL ? "*" : host, sport, port);
 667         snprintf(service, sizeof(service), "%d", sport);
 668         error = getaddrinfo(host, service,  &hints, &res);
 669         if (error)
 670                 errx(1, "tcp/%s: %s\n", service, gai_strerror(error));
 671         p->res = res;
 672         p->s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 673         if (p->s < 0)
 674                 err(1, "socket");
 675         setsockopt(p->s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
 676
 677         if (bind(p->s, p->res->ai_addr, p->res->ai_addrlen) < 0) {
 678                 err(1, "bind");
 679         }
 680         if (listen(p->s, 1) < 0)
 681                 err(1, "listen");
 682         EV_SET(&kev, p->s, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, (void *)p);
 683         error = kevent(dc->kq, &kev, 1, NULL, 0, &dc->to);
 684         if (error < 0)
 685                 err(1, "kevent");
 686         return;
 687 }
 688
 689 static int
 690 dconschat_accept_socket(struct dcons_state *dc, struct dcons_port *p)
 691 {
 692         socklen_t addrlen;
 693         int ns, flags;
 694         struct kevent kev;
 695
 696         /* accept connection */
 697         addrlen = p->res->ai_addrlen;
 698         ns = accept(p->s, p->res->ai_addr, &addrlen);
 699         if (ns < 0)
 700                 err(1, "accept");
 701         if (verbose)
 702                 printf("port%d accepted\n", p->port);
 703
 704         flags = fcntl(ns, F_GETFL, 0);
 705         flags |= O_NDELAY;
 706         fcntl(ns, F_SETFL, flags);
 707 #if 1
 708         if (IS_CONSOLE(p) && (dc->flags & F_TELNET) != 0) {
 709                 char sga[] = {IAC, WILL, TELOPT_SGA};
 710                 char linemode[] = {IAC, DONT, TELOPT_LINEMODE};
 711                 char echo[] = {IAC, WILL, TELOPT_ECHO};
 712                 char bin[] = {IAC, DO, TELOPT_BINARY};
 713
 714                 write(ns, sga, sizeof(sga));
 715                 write(ns, linemode, sizeof(linemode));
 716                 write(ns, echo, sizeof(echo));
 717                 write(ns, bin, sizeof(bin));
 718                 p->skip_read = 0;
 719         }
 720 #endif
 721         /* discard backlog on GDB port */
 722         if (IS_GDB(p)) {
 723                 char buf[2048];
 724                 int len;
 725
 726                 while ((len = dconschat_read_dcons(dc, DCONS_GDB, &buf[0],
 727                                  2048)) > 0)
 728                         if (verbose)
 729                                 printf("discard %d chars on GDB port\n", len);
 730         }
 731
 732         p->infd = p->outfd = ns;
 733         EV_SET(&kev, ns, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1, (void *)p);
 734         kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 735         return(0);
 736 }
 737
 738 static int
 739 dconschat_read_filter(struct dcons_state *dc, struct dcons_port *p,
 740     u_char *sp, int slen, u_char *dp, int *dlen)
 741 {
 742         int skip;
 743         char *buf;
 744
 745         while (slen > 0) {
 746                 skip = 0;
 747                 if (IS_CONSOLE(p)) {
 748                         if ((dc->flags & F_TELNET) != 0) {
 749                                 /* XXX Telnet workarounds */
 750                                 if (p->skip_read -- > 0) {
 751                                         sp ++;
 752                                         slen --;
 753                                         continue;
 754                                 }
 755                                 if (*sp == IAC) {
 756                                         if (verbose)
 757                                                 printf("(IAC)");
 758                                         p->skip_read = 2;
 759                                         sp ++;
 760                                         slen --;
 761                                         continue;
 762                                 }
 763                                 if (*sp == 0) {
 764                                         if (verbose)
 765                                                 printf("(0 stripped)");
 766                                         sp ++;
 767                                         slen --;
 768                                         continue;
 769                                 }
 770                         }
 771                         switch (dc->escape_state) {
 772                         case STATE1:
 773                                 if (*sp == dc->escape) {
 774                                         skip = 1;
 775                                         dc->escape_state = STATE2;
 776                                 } else
 777                                         dc->escape_state = STATE0;
 778                                 break;
 779                         case STATE2:
 780                                 dc->escape_state = STATE0;
 781                                 skip = 1;
 782                                 if (*sp == '.')
 783                                         dconschat_cleanup(0);
 784                                 else if (*sp == CTRL('B')) {
 785                                         bcopy(abreak, dp, 3);
 786                                         dp += 3;
 787                                         *dlen += 3;
 788                                 }
 789                                 else if (*sp == CTRL('G'))
 790                                         dconschat_fork_gdb(dc, p);
 791                                 else if ((*sp == CTRL('R'))
 792                                                 && (dc->reset != 0)) {
 793                                         dc->escape_state = STATE3;
 794                                         buf = "\r\n[Are you sure to reset target? (y/N)]";
 795                                         write(p->outfd, buf, strlen(buf));
 796                                 } else if (*sp == CTRL('Z'))
 797                                         dconschat_suspend(dc, p);
 798                                 else {
 799                                         skip = 0;
 800                                         *dp++ = dc->escape;
 801                                         (*dlen) ++;
 802                                 }
 803                                 break;
 804                         case STATE3:
 805                                 dc->escape_state = STATE0;
 806                                 skip = 1;
 807                                 if (*sp == 'y')
 808                                         dconschat_reset_target(dc, p);
 809                                 else {
 810                                         write(p->outfd, sp, 1);
 811                                         write(p->outfd, "\r\n", 2);
 812                                 }
 813                                 break;
 814                         }
 815                         if (*sp == KEY_CR)
 816                                 dc->escape_state = STATE1;
 817                 } else if (IS_GDB(p)) {
 818                         /* GDB: ^C -> CR+~+^B */
 819                         if (*sp == CTRL('C') && (dc->flags & F_ALT_BREAK) != 0) {
 820                                 bcopy(abreak, dp, 3);
 821                                 dp += 3;
 822                                 sp ++;
 823                                 *dlen += 3;
 824                                 /* discard rest of the packet */
 825                                 slen = 0;
 826                                 break;
 827                         }
 828                 }
 829                 if (!skip) {
 830                         *dp++ = *sp;
 831                         (*dlen) ++;
 832                 }
 833                 sp ++;
 834                 slen --;
 835         }
 836         return (*dlen);
 837
 838 }
 839
 840 static int
 841 dconschat_read_socket(struct dcons_state *dc, struct dcons_port *p)
 842 {
 843         struct kevent kev;
 844         int len, wlen;
 845         char rbuf[MAX_XFER], wbuf[MAX_XFER+2];
 846
 847         if ((len = read(p->infd, rbuf, sizeof(rbuf))) > 0) {
 848                 wlen = 0;
 849                 dconschat_read_filter(dc, p, rbuf, len, wbuf, &wlen);
 850                 /* XXX discard if not ready*/
 851                 if (wlen > 0 && (dc->flags & F_READY) != 0) {
 852                         dconschat_write_dcons(dc, p->port, wbuf, wlen);
 853                         if (verbose > 1) {
 854                                 wbuf[wlen] = 0;
 855                                 printf("-> %s\n", wbuf);
 856                         } else if (verbose == 1) {
 857                                 printf("(%d)", wlen);
 858                                 fflush(stdout);
 859                         }
 860                 }
 861         } else {
 862                 if (verbose) {
 863                         if (len == 0)
 864                                 warnx("port%d: closed", p->port);
 865                         else
 866                                 warn("port%d: read", p->port);
 867                 }
 868                 EV_SET(&kev, p->infd, EVFILT_READ,
 869                         EV_DELETE, 0, 0, NULL);
 870                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 871                 close(p->infd);
 872                 close(p->outfd);
 873                 /* XXX exit for pipe case XXX */
 874                 EV_SET(&kev, p->s, EVFILT_READ,
 875                                 EV_ADD | EV_ONESHOT, 0, 0, (void *) p);
 876                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 877                 p->infd = p->outfd = -1;
 878         }
 879         return(0);
 880 }
 881 #define NEVENT 5
 882 static int
 883 dconschat_proc_socket(struct dcons_state *dc)
 884 {
 885         struct kevent elist[NEVENT], *e;
 886         int i, n;
 887         struct dcons_port *p;
 888
 889         n = kevent(dc->kq, NULL, 0, elist, NEVENT, &dc->to);
 890         for (i = 0; i < n; i ++) {
 891                 e = &elist[i];
 892                 p = (struct dcons_port *)e->udata;
 893                 if (e->ident == p->s) {
 894                         dconschat_accept_socket(dc, p);
 895                 } else {
 896                         dconschat_read_socket(dc, p);
 897                 }
 898         }
 899         return(0);
 900 }
 901
 902 static int
 903 dconschat_proc_dcons(struct dcons_state *dc)
 904 {
 905         int port, len, err;
 906         char buf[MAX_XFER];
 907         struct dcons_port *p;
 908
 909         err = dconschat_get_ptr(dc);
 910         if (err) {
 911                 /* XXX we should stop write operation too. */
 912                 return err;
 913         }
 914         for (port = 0; port < DCONS_NPORT; port ++) {
 915                 p = &dc->port[port];
 916                 if (p->infd < 0)
 917                         continue;
 918                 while ((len = dconschat_read_dcons(dc, port, buf,
 919                     sizeof(buf))) > 0) {
 920                         dconschat_write_socket(p->outfd, buf, len);
 921                         if ((err = dconschat_get_ptr(dc)))
 922                                 return (err);
 923                 }
 924                 if ((dc->flags & F_ONE_SHOT) != 0 && len <= 0)
 925                         dconschat_cleanup(0);
 926         }
 927         return 0;
 928 }
 929
 930 static int
 931 dconschat_start_session(struct dcons_state *dc)
 932 {
 933         int counter = 0;
 934         int retry = 0;
 935         int retry_unit_init = MAX(1, poll_hz / 10);
 936         int retry_unit_offline = poll_hz * DCONS_POLL_OFFLINE;
 937         int retry_unit = retry_unit_init;
 938         int retry_max = retry_unit_offline / retry_unit;
 939
 940         while (1) {
 941                 if (((dc->flags & F_READY) == 0) && ++counter > retry_unit) {
 942                         counter = 0;
 943                         retry ++;
 944                         if (retry > retry_max)
 945                                 retry_unit = retry_unit_offline;
 946                         if (verbose) {
 947                                 printf("%d/%d ", retry, retry_max);
 948                                 fflush(stdout);
 949                         }
 950                         dconschat_fetch_header(dc);
 951                 }
 952                 if ((dc->flags & F_READY) != 0) {
 953                         counter = 0;
 954                         retry = 0;
 955                         retry_unit = retry_unit_init;
 956                         dconschat_proc_dcons(dc);
 957                 }
 958                 dconschat_proc_socket(dc);
 959         }
 960         return (0);
 961 }
 962
 963 static void
 964 usage(void)
 965 {
 966         fprintf(stderr,
 967             "usage: dconschat [-brvwRT1] [-h hz] [-C port] [-G port]\n"
 968             "\t\t\t[-M core] [-N system]\n"
 969             "\t\t\t[-u unit] [-a address] [-t target_eui64]\n"
 970             "\t-b       translate ctrl-C to CR+~+ctrl-B on gdb port\n"
 971             "\t-v       verbose\n"
 972             "\t-w       listen on wildcard address rather than localhost\n"
 973             "\t-r       replay old buffer on connection\n"
 974             "\t-R       read-only\n"
 975             "\t-T       enable Telnet protocol workaround on console port\n"
 976             "\t-1       one shot: read buffer and exit\n"
 977             "\t-h       polling rate\n"
 978             "\t-C       port number for console port\n"
 979             "\t-G       port number for gdb port\n"
 980             "\t(for KVM)\n"
 981             "\t-M       core file\n"
 982             "\t-N       system file\n"
 983             "\t(for FireWire)\n"
 984             "\t-u       specify unit number of the bus\n"
 985             "\t-t       EUI64 of target host (must be specified)\n"
 986             "\t-a       physical address of dcons buffer on target host\n"
 987         );
 988         exit(0);
 989 }
 990 int
 991 main(int argc, char **argv)
 992 {
 993         struct dcons_state *dc;
 994         struct fw_eui64 eui;
 995         struct eui64 target;
 996         char devname[256], *core = NULL, *system = NULL;
 997         int i, ch, error;
 998         int unit=0, wildcard=0;
 999         int port[DCONS_NPORT];
1000
1001         bzero(&sc, sizeof(sc));
1002         dc = &sc;
1003         dc->flags |= USE_CROM ? F_USE_CROM : 0;
1004
1005         /* default ports */
1006         port[0] = 0;    /* stdin/out for console */
1007         port[1] = -1;   /* disable gdb port */
1008
1009         /* default escape char */
1010         dc->escape = KEY_TILDE;
1011
1012         while ((ch = getopt(argc, argv, "a:be:h:rt:u:vwC:G:M:N:RT1")) != -1) {
1013                 switch(ch) {
1014                 case 'a':
1015                         dc->paddr = strtoull(optarg, NULL, 0);
1016                         dc->flags &= ~F_USE_CROM;
1017                         break;
1018                 case 'b':
1019                         dc->flags |= F_ALT_BREAK;
1020                         break;
1021                 case 'e':
1022                         dc->escape = optarg[0];
1023                         break;
1024                 case 'h':
1025                         poll_hz = strtoul(optarg, NULL, 0);
1026                         if (poll_hz == 0)
1027                                 poll_hz = DCONS_POLL_HZ;
1028                         break;
1029                 case 'r':
1030                         dc->flags |= F_REPLAY;
1031                         break;
1032                 case 't':
1033                         if (eui64_hostton(optarg, &target) != 0 &&
1034                             eui64_aton(optarg, &target) != 0)
1035                                 errx(1, "invalid target: %s", optarg);
1036                         eui.hi = ntohl(*(u_int32_t*)&(target.octet[0]));
1037                         eui.lo = ntohl(*(u_int32_t*)&(target.octet[4]));
1038                         dc->type = TYPE_FW;
1039                         break;
1040                 case 'u':
1041                         unit = strtol(optarg, NULL, 0);
1042                         break;
1043                 case 'v':
1044                         verbose ++;
1045                         break;
1046                 case 'w':
1047                         wildcard = 1;
1048                         break;
1049                 case 'C':
1050                         port[0] = strtol(optarg, NULL, 0);
1051                         break;
1052                 case 'G':
1053                         port[1] = strtol(optarg, NULL, 0);
1054                         break;
1055                 case 'M':
1056                         core = optarg;
1057                         break;
1058                 case 'N':
1059                         system = optarg;
1060                         break;
1061                 case 'R':
1062                         dc->flags |= F_RD_ONLY;
1063                         break;
1064                 case 'T':
1065                         dc->flags |= F_TELNET;
1066                         break;
1067                 case '1':
1068                         dc->flags |= F_ONE_SHOT | F_REPLAY;
1069                         break;
1070                 default:
1071                         usage();
1072                 }
1073         }
1074         if (dc->paddr == 0 && (dc->flags & F_USE_CROM) == 0) {
1075                 warnx("no address specified");
1076                 usage();
1077         }
1078
1079         if (port[0] < 0 && port[1] < 0) {
1080                 warnx("no port specified");
1081                 usage();
1082         }
1083
1084         /* set signal handler */
1085         signal(SIGHUP, dconschat_cleanup);
1086         signal(SIGINT, dconschat_cleanup);
1087         signal(SIGPIPE, dconschat_cleanup);
1088         signal(SIGTERM, dconschat_cleanup);
1089
1090         /* init firewire */
1091         switch (dc->type) {
1092         case TYPE_FW:
1093 #define MAXDEV 10
1094                 for (i = 0; i < MAXDEV; i ++) {
1095                         snprintf(devname, sizeof(devname),
1096                             "/dev/fwmem%d.%d", unit, i);
1097                         dc->fd = open(devname, O_RDWR);
1098                         if (dc->fd >= 0)
1099                                 goto found;
1100                 }
1101                 err(1, "open");
1102 found:
1103                 error = ioctl(dc->fd, FW_SDEUI64, &eui);
1104                 if (error)
1105                         err(1, "ioctl");
1106                 break;
1107         case TYPE_KVM:
1108         {
1109                 struct nlist nl[] = {{"dcons_buf"}, {""}};
1110                 void *dcons_buf;
1111
1112                 dc->kd = kvm_open(system, core, NULL,
1113                     (dc->flags & F_RD_ONLY) ? O_RDONLY : O_RDWR, "dconschat");
1114                 if (dc->kd == NULL)
1115                         errx(1, "kvm_open");
1116
1117                 if (kvm_nlist(dc->kd, nl) < 0)
1118                         errx(1, "kvm_nlist: %s", kvm_geterr(dc->kd));
1119
1120                 if (kvm_read(dc->kd, nl[0].n_value, &dcons_buf,
1121                     sizeof(void *)) < 0)
1122                         errx(1, "kvm_read: %s", kvm_geterr(dc->kd));
1123                 dc->paddr = (uintptr_t)dcons_buf;
1124                 if (verbose)
1125                         printf("dcons_buf: 0x%x\n", (uint)dc->paddr);
1126                 break;
1127         }
1128         }
1129         dconschat_fetch_header(dc);
1130
1131         /* init sockets */
1132         dc->kq = kqueue();
1133         if (poll_hz == 1) {
1134                 dc->to.tv_sec = 1;
1135                 dc->to.tv_nsec = 0;
1136         } else {
1137                 dc->to.tv_sec = 0;
1138                 dc->to.tv_nsec = 1000 * 1000 * 1000 / poll_hz;
1139         }
1140         dc->zero.tv_sec = 0;
1141         dc->zero.tv_nsec = 0;
1142         for (i = 0; i < DCONS_NPORT; i++)
1143                 dconschat_init_socket(dc, i,
1144                     wildcard ? NULL : "localhost", port[i]);
1145
1146         dconschat_start_session(dc);
1147
1148         for (i = 0; i < DCONS_NPORT; i++) {
1149                 freeaddrinfo(dc->port[i].res);
1150         }
1151         return (0);
1152 }