usr.sbin/dconschat/dconschat.c

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