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: src/usr.sbin/dconschat/dconschat.c,v 1.6 2004/05/26 22:59:54 brooks Exp $
  36  * $DragonFly: src/usr.sbin/dconschat/dconschat.c,v 1.1 2004/09/23 06:38:29 simokawa Exp $
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/types.h>
  41 #include <sys/uio.h>
  42 #include <unistd.h>
  43 #include <fcntl.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <termios.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 #ifdef __DragonFly__
  59 #include <dev/misc/dcons/dcons.h>
  60 #include <bus/firewire/firewire.h>
  61 #include <bus/firewire/iec13213.h>
  62 #else
  63 #include <dev/dcons/dcons.h>
  64 #include <dev/firewire/firewire.h>
  65 #include <dev/firewire/iec13213.h>
  66 #endif
  67
  68 #include <kvm.h>
  69 #include <nlist.h>
  70
  71 #include <sys/errno.h>
  72
  73 #define DCONS_POLL_HZ           100
  74 #define DCONS_POLL_OFFLINE      2       /* sec */
  75
  76 #define RETRY 3
  77
  78 #ifdef CSRVAL_VENDOR_PRIVATE
  79 #define USE_CROM 1
  80 #else
  81 #define USE_CROM 0
  82 #endif
  83
  84 int verbose = 0;
  85 int tc_set = 0;
  86 int poll_hz = DCONS_POLL_HZ;
  87
  88 #define IS_CONSOLE(p)   ((p)->port == 0)
  89 #define IS_GDB(p)       ((p)->port == 1)
  90
  91 static struct dcons_state {
  92         int fd;
  93         kvm_t *kd;
  94         int kq;
  95         off_t paddr;
  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                 struct dcons_ch o;
 112                 struct dcons_ch i;
 113                 u_int32_t optr;
 114                 u_int32_t iptr;
 115                 int s;
 116                 int infd;
 117                 int outfd;
 118                 struct addrinfo *res;
 119                 int skip_read;
 120         } port[DCONS_NPORT];
 121         struct timespec to;
 122         struct timespec zero;
 123         struct termios tsave;
 124 } sc;
 125
 126 static int
 127 dread(struct dcons_state *dc, void *buf, size_t n, off_t offset)
 128 {
 129         switch (dc->type) {
 130         case TYPE_FW:
 131                 return (pread(dc->fd, buf, n, offset));
 132         case TYPE_KVM:
 133                 return (kvm_read(dc->kd, offset, buf, n));
 134         }
 135         return (-1);
 136 }
 137
 138 static int
 139 dwrite(struct dcons_state *dc, void *buf, size_t n, off_t offset)
 140 {
 141         if ((dc->flags & F_RD_ONLY) != 0)
 142                 return (n);
 143
 144         switch (dc->type) {
 145         case TYPE_FW:
 146                 return (pwrite(dc->fd, buf, n, offset));
 147         case TYPE_KVM:
 148                 return (kvm_write(dc->kd, offset, buf, n));
 149         }
 150         return (-1);
 151 }
 152
 153 static void
 154 dconschat_cleanup(int sig)
 155 {
 156         struct dcons_state *dc;
 157
 158         dc = &sc;
 159         if (tc_set != 0)
 160                 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave);
 161
 162         if (sig > 0)
 163                 printf("\n[dconschat exiting with signal %d ...]\n", sig);
 164         else
 165                 printf("\n[dconschat exiting...]\n");
 166         exit(0);
 167 }
 168
 169 #if USE_CROM
 170 static int
 171 dconschat_get_crom(struct dcons_state *dc)
 172 {
 173         off_t addr;
 174         int i, state = 0;
 175         u_int32_t buf, hi = 0, lo = 0;
 176         struct csrreg *reg;
 177
 178         reg = (struct csrreg *)&buf;
 179         addr = 0xffff;
 180         addr = (addr << 32) | 0xf0000400;
 181         for (i = 20; i < 0x400; i += 4) {
 182                 if (dread(dc, &buf, 4, addr + i) < 0) {
 183                         if (verbose)
 184                                 warn("crom read faild");
 185                         return (-1);
 186                 }
 187                 buf = ntohl(buf);
 188                 if (verbose)
 189                         printf("%d %02x %06x\n", state, reg->key, reg->val);
 190                 switch (state) {
 191                 case 0:
 192                         if (reg->key == CSRKEY_SPEC &&
 193                                         reg->val == CSRVAL_VENDOR_PRIVATE)
 194                                 state = 1;
 195                         break;
 196                 case 1:
 197                         if (reg->key == CSRKEY_VER &&
 198                                         reg->val == DCONS_CSR_VAL_VER)
 199                                 state = 2;
 200                         break;
 201                 case 2:
 202                         if (reg->key == DCONS_CSR_KEY_HI)
 203                                 hi = reg->val;
 204                         else if (reg->key == DCONS_CSR_KEY_LO) {
 205                                 lo = reg->val;
 206                                 goto out;
 207                         }
 208                         break;
 209                 }
 210         }
 211         /* not found */
 212         return (-1);
 213 out:
 214         if (verbose)
 215                 printf("addr: %06x %06x\n", hi, lo);
 216         dc->paddr = ((off_t)hi << 24) | lo;
 217         return (0);
 218 }
 219 #endif
 220
 221 static void
 222 dconschat_ready(struct dcons_state *dc, int ready, const char *reason)
 223 {
 224         static char oldreason[64] = "";
 225         int old;
 226
 227         old = (dc->flags & F_READY) ? 1 : 0;
 228
 229         if (ready) {
 230                 dc->flags |= F_READY;
 231                 if (ready != old)
 232                         printf("[dcons connected]\r\n");
 233                 oldreason[0] = 0;
 234         } else {
 235                 dc->flags &= ~F_READY;
 236                 if (strncmp(oldreason, reason, sizeof(oldreason)) != 0) {
 237                         printf("[dcons disconnected (%s)]\r\n", reason);
 238                         strlcpy(oldreason, reason, sizeof(oldreason));
 239                 }
 240         }
 241 }
 242
 243 static int
 244 dconschat_fetch_header(struct dcons_state *dc)
 245 {
 246         char ebuf[64];
 247         struct dcons_buf dbuf;
 248         int j;
 249
 250 #if USE_CROM
 251         if (dc->paddr == 0 && (dc->flags & F_USE_CROM) != 0) {
 252                 if (dconschat_get_crom(dc)) {
 253                         dconschat_ready(dc, 0, "get crom failed");
 254                         return (-1);
 255                 }
 256         }
 257 #endif
 258
 259         if (dread(dc, &dbuf, DCONS_HEADER_SIZE, dc->paddr) < 0) {
 260                 dconschat_ready(dc, 0, "read header failed");
 261                 return (-1);
 262         }
 263         if (dbuf.magic != htonl(DCONS_MAGIC)) {
 264                 if ((dc->flags & F_USE_CROM) !=0)
 265                         dc->paddr = 0;
 266                 snprintf(ebuf, sizeof(ebuf), "wrong magic 0x%08x", dbuf.magic);
 267                 dconschat_ready(dc, 0, ebuf);
 268                 return (-1);
 269         }
 270         if (ntohl(dbuf.version) != DCONS_VERSION) {
 271                 snprintf(ebuf, sizeof(ebuf),
 272                     "wrong version %d,%d",
 273                     ntohl(dbuf.version), DCONS_VERSION);
 274                 /* XXX exit? */
 275                 dconschat_ready(dc, 0, ebuf);
 276                 return (-1);
 277         }
 278
 279         for (j = 0; j < DCONS_NPORT; j++) {
 280                 struct dcons_ch *o, *i;
 281                 off_t newbuf;
 282                 int new = 0;
 283
 284                 o = &dc->port[j].o;
 285                 newbuf = dc->paddr + ntohl(dbuf.ooffset[j]);
 286                 o->size = ntohl(dbuf.osize[j]);
 287
 288                 if (newbuf != o->buf) {
 289                         /* buffer address has changes */
 290                         new = 1;
 291                         o->gen = ntohl(dbuf.optr[j]) >> DCONS_GEN_SHIFT;
 292                         o->pos = ntohl(dbuf.optr[j]) & DCONS_POS_MASK;
 293                         o->buf = newbuf;
 294                 }
 295
 296                 i = &dc->port[j].i;
 297                 i->size = ntohl(dbuf.isize[j]);
 298                 i->gen = ntohl(dbuf.iptr[j]) >> DCONS_GEN_SHIFT;
 299                 i->pos = ntohl(dbuf.iptr[j]) & DCONS_POS_MASK;
 300                 i->buf = dc->paddr + ntohl(dbuf.ioffset[j]);
 301
 302                 if (verbose) {
 303                         printf("port %d   size offset   gen   pos\n", j);
 304                         printf("output: %5d %6d %5d %5d\n"
 305                                 "input : %5d %6d %5d %5d\n",
 306                         o->size, ntohl(dbuf.ooffset[j]), o->gen, o->pos,
 307                         i->size, ntohl(dbuf.ioffset[j]), i->gen, i->pos);
 308                 }
 309
 310                 if (IS_CONSOLE(&dc->port[j]) && new &&
 311                     (dc->flags & F_REPLAY) !=0) {
 312                         if (o->gen > 0)
 313                                 o->gen --;
 314                         else
 315                                 o->pos = 0;
 316                 }
 317         }
 318         dconschat_ready(dc, 1, NULL);
 319         return(0);
 320 }
 321
 322 static int
 323 dconschat_get_ptr (struct dcons_state *dc) {
 324         int dlen, i;
 325         u_int32_t ptr[DCONS_NPORT*2+1];
 326         static int retry = RETRY;
 327
 328 again:
 329         dlen = dread(dc, &ptr, sizeof(ptr),
 330                 dc->paddr + __offsetof(struct dcons_buf, magic));
 331
 332         if (dlen < 0) {
 333                 if (errno == ETIMEDOUT)
 334                         if (retry -- > 0)
 335                                 goto again;
 336                 dconschat_ready(dc, 0, "get ptr failed");
 337                 return(-1);
 338         }
 339         if (ptr[0] != htonl(DCONS_MAGIC)) {
 340                 dconschat_ready(dc, 0, "wrong magic");
 341                 return(-1);
 342         }
 343         retry = RETRY;
 344         for (i = 0; i < DCONS_NPORT; i ++) {
 345                 dc->port[i].optr = ntohl(ptr[i + 1]);
 346                 dc->port[i].iptr = ntohl(ptr[DCONS_NPORT + i + 1]);
 347         }
 348         return(0);
 349 }
 350
 351 #define MAX_XFER 2048
 352 static int
 353 dconschat_read_dcons(struct dcons_state *dc, int port, char *buf, int len)
 354 {
 355         struct dcons_ch *ch;
 356         u_int32_t ptr, pos, gen, next_gen;
 357         int rlen, dlen, lost;
 358         int retry = RETRY;
 359
 360         ch = &dc->port[port].o;
 361         ptr = dc->port[port].optr;
 362         gen = ptr >> DCONS_GEN_SHIFT;
 363         pos = ptr & DCONS_POS_MASK;
 364         if (gen == ch->gen && pos == ch->pos)
 365                 return (-1);
 366
 367         next_gen = DCONS_NEXT_GEN(ch->gen);
 368         /* XXX sanity check */
 369         if (gen == ch->gen) {
 370                 if (pos > ch->pos)
 371                         goto ok;
 372                 lost = ch->size * DCONS_GEN_MASK - ch->pos;
 373                 ch->pos = 0;
 374         } else if (gen == next_gen) {
 375                 if (pos <= ch->pos)
 376                         goto ok;
 377                 lost = pos - ch->pos;
 378                 ch->pos = pos;
 379         } else {
 380                 lost = gen - ch->gen;
 381                 if (lost < 0)
 382                         lost += DCONS_GEN_MASK;
 383                 if (verbose)
 384                         printf("[genskip %d]", lost);
 385                 lost = lost * ch->size - ch->pos;
 386                 ch->pos = 0;
 387                 ch->gen = gen;
 388         }
 389         /* generation skipped !! */
 390         /* XXX discard */
 391         if (verbose)
 392                 printf("[lost %d]", lost);
 393 ok:
 394         if (gen == ch->gen)
 395                 rlen = pos - ch->pos;
 396         else
 397                 rlen = ch->size - ch->pos;
 398
 399         if (rlen > MAX_XFER)
 400                 rlen = MAX_XFER;
 401         if (rlen > len)
 402                 rlen = len;
 403
 404 #if 1
 405         if (verbose)
 406                 printf("[%d]", rlen); fflush(stdout);
 407 #endif
 408
 409 again:
 410         dlen = dread(dc, buf, rlen, ch->buf + ch->pos);
 411         if (dlen < 0) {
 412                 if (errno == ETIMEDOUT)
 413                         if (retry -- > 0)
 414                                 goto again;
 415                 dconschat_ready(dc, 0, "read buffer failed");
 416                 return(-1);
 417         }
 418         if (dlen != rlen)
 419                 warnx("dlen(%d) != rlen(%d)\n", dlen, rlen);
 420         ch->pos += dlen;
 421         if (ch->pos >= ch->size) {
 422                 ch->gen = next_gen;
 423                 ch->pos = 0;
 424                 if (verbose)
 425                         printf("read_dcons: gen=%d", ch->gen);
 426         }
 427         return (dlen);
 428 }
 429
 430 static int
 431 dconschat_write_dcons(struct dcons_state *dc, int port, char *buf, int blen)
 432 {
 433         struct dcons_ch *ch;
 434         u_int32_t ptr;
 435         int len, wlen;
 436         int retry = RETRY;
 437
 438         ch = &dc->port[port].i;
 439         ptr = dc->port[port].iptr;
 440
 441         /* the others may advance the pointer sync with it */
 442         ch->gen = ptr >> DCONS_GEN_SHIFT;
 443         ch->pos = ptr & DCONS_POS_MASK;
 444
 445         while(blen > 0) {
 446                 wlen = MIN(blen, (int)(ch->size - ch->pos));
 447                 wlen = MIN(wlen, MAX_XFER);
 448                 len = dwrite(dc, buf, wlen, ch->buf + ch->pos);
 449                 if (len < 0) {
 450                         if (errno == ETIMEDOUT)
 451                                 if (retry -- > 0)
 452                                         continue; /* try again */
 453                         dconschat_ready(dc, 0, "write buffer failed");
 454                         return(-1);
 455                 }
 456                 ch->pos += len;
 457                 buf += len;
 458                 blen -= len;
 459                 if (ch->pos >= ch->size) {
 460                         ch->gen = DCONS_NEXT_GEN(ch->gen);
 461                         ch->pos = 0;
 462                         if (verbose)
 463                                 printf("write_dcons: gen=%d", ch->gen);
 464
 465                 }
 466         }
 467
 468         ptr = DCONS_MAKE_PTR(ch);
 469         dc->port[port].iptr = ptr;
 470
 471         if (verbose > 2)
 472                 printf("(iptr: 0x%x)", ptr);
 473 again:
 474         len = dwrite(dc, &ptr, sizeof(u_int32_t),
 475                 dc->paddr + __offsetof(struct dcons_buf, iptr[port]));
 476         if (len < 0) {
 477                 if (errno == ETIMEDOUT)
 478                         if (retry -- > 0)
 479                                 goto again;
 480                 dconschat_ready(dc, 0, "write ptr failed");
 481                 return(-1);
 482         }
 483         return(0);
 484 }
 485
 486 static int
 487 dconschat_write_socket(int fd, char *buf, int len)
 488 {
 489         write(fd, buf, len);
 490         if (verbose > 1) {
 491                 buf[len] = 0;
 492                 printf("[%s]", buf);
 493         }
 494         return (0);
 495 }
 496
 497 static void
 498 dconschat_init_socket(struct dcons_state *dc, int port, char *host, int sport)
 499 {
 500         struct addrinfo hints, *res;
 501         int on = 1, error;
 502         char service[10];
 503         struct kevent kev;
 504         struct dcons_port *p;
 505
 506         p = &dc->port[port];
 507         p->port = port;
 508         p->infd = p->outfd = -1;
 509
 510         if (sport < 0)
 511                 return;
 512
 513         if (sport == 0) {
 514
 515                 /* Use stdin and stdout */
 516                 p->infd = STDIN_FILENO;
 517                 p->outfd = STDOUT_FILENO;
 518                 p->s = -1;
 519                 if (tc_set == 0 &&
 520                     tcgetattr(STDIN_FILENO, &dc->tsave) == 0) {
 521                         struct termios traw;
 522
 523                         traw = dc->tsave;
 524                         cfmakeraw(&traw);
 525                         tcsetattr(STDIN_FILENO, TCSADRAIN, &traw);
 526                         tc_set = 1;
 527                 }
 528                 EV_SET(&kev, p->infd, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1,
 529                     (void *)p);
 530                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 531                 return;
 532         }
 533
 534         memset(&hints, 0, sizeof(hints));
 535         hints.ai_flags = AI_PASSIVE;
 536 #if 1   /* gdb can talk v4 only */
 537         hints.ai_family = PF_INET;
 538 #else
 539         hints.ai_family = PF_UNSPEC;
 540 #endif
 541         hints.ai_socktype = SOCK_STREAM;
 542         hints.ai_protocol = 0;
 543
 544         if (verbose)
 545                 printf("%s:%d for port %d\n",
 546                         host == NULL ? "*" : host, sport, port);
 547         snprintf(service, sizeof(service), "%d", sport);
 548         error = getaddrinfo(host, service,  &hints, &res);
 549         if (error)
 550                 errx(1, "tcp/%s: %s\n", service, gai_strerror(error));
 551         p->res = res;
 552         p->s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 553         if (p->s < 0)
 554                 err(1, "socket");
 555         setsockopt(p->s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
 556
 557         if (bind(p->s, p->res->ai_addr, p->res->ai_addrlen) < 0) {
 558                 err(1, "bind");
 559         }
 560         if (listen(p->s, 1) < 0)
 561                 err(1, "listen");
 562         EV_SET(&kev, p->s, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, (void *)p);
 563         error = kevent(dc->kq, &kev, 1, NULL, 0, &dc->to);
 564         if (error < 0)
 565                 err(1, "kevent");
 566         return;
 567 }
 568
 569 static int
 570 dconschat_accept_socket(struct dcons_state *dc, struct dcons_port *p)
 571 {
 572         int foo, ns, flags;
 573         struct kevent kev;
 574
 575         /* accept connection */
 576         foo = p->res->ai_addrlen;
 577         ns = accept(p->s, p->res->ai_addr, &foo);
 578         if (ns < 0)
 579                 err(1, "accept");
 580         if (verbose)
 581                 printf("port%d accepted\n", p->port);
 582
 583         flags = fcntl(ns, F_GETFL, 0);
 584         flags |= O_NDELAY;
 585         fcntl(ns, F_SETFL, flags);
 586 #if 1
 587         if (IS_CONSOLE(p) && (dc->flags & F_TELNET) != 0) {
 588                 char sga[] = {IAC, WILL, TELOPT_SGA};
 589                 char linemode[] = {IAC, DONT, TELOPT_LINEMODE};
 590                 char echo[] = {IAC, WILL, TELOPT_ECHO};
 591                 char bin[] = {IAC, DO, TELOPT_BINARY};
 592
 593                 write(ns, sga, sizeof(sga));
 594                 write(ns, linemode, sizeof(linemode));
 595                 write(ns, echo, sizeof(echo));
 596                 write(ns, bin, sizeof(bin));
 597                 p->skip_read = 0;
 598         }
 599 #endif
 600
 601         p->infd = p->outfd = ns;
 602         EV_SET(&kev, ns, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1, (void *)p);
 603         kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 604         return(0);
 605 }
 606
 607 static int
 608 dconschat_read_filter(struct dcons_state *dc, struct dcons_port *p,
 609     u_char *sp, int slen, u_char *dp, int *dlen)
 610 {
 611         static u_char abreak[3] = {13 /* CR */, 126 /* ~ */, 2 /* ^B */};
 612
 613         while (slen > 0) {
 614                 if (IS_CONSOLE(p)) {
 615                         if ((dc->flags & F_TELNET) != 0) {
 616                                 /* XXX Telent workarounds */
 617                                 if (p->skip_read -- > 0) {
 618                                         sp ++;
 619                                         slen --;
 620                                         continue;
 621                                 }
 622                                 if (*sp == IAC) {
 623                                         if (verbose)
 624                                                 printf("(IAC)");
 625                                         p->skip_read = 2;
 626                                         sp ++;
 627                                         slen --;
 628                                         continue;
 629                                 }
 630                                 if (*sp == 0) {
 631                                         if (verbose)
 632                                                 printf("(0 stripped)");
 633                                         sp ++;
 634                                         slen --;
 635                                         continue;
 636                                 }
 637                         }
 638                         switch (dc->escape_state) {
 639                         case STATE1:
 640                                 if (*sp == KEY_TILDE)
 641                                         dc->escape_state = STATE2;
 642                                 else
 643                                         dc->escape_state = STATE0;
 644                                 break;
 645                         case STATE2:
 646                                 dc->escape_state = STATE0;
 647                                 if (*sp == '.')
 648                                         dconschat_cleanup(0);
 649                         }
 650                         if (*sp == KEY_CR)
 651                                 dc->escape_state = STATE1;
 652                 } else if (IS_GDB(p)) {
 653                         /* GDB: ^C -> CR+~+^B */
 654                         if (*sp == 0x3 && (dc->flags & F_ALT_BREAK) != 0) {
 655                                 bcopy(abreak, dp, 3);
 656                                 dp += 3;
 657                                 sp ++;
 658                                 *dlen += 3;
 659                                 /* discard rest of the packet */
 660                                 slen = 0;
 661                                 break;
 662                         }
 663                 }
 664                 *dp++ = *sp++;
 665                 (*dlen) ++;
 666                 slen --;
 667         }
 668         return (*dlen);
 669
 670 }
 671
 672 static int
 673 dconschat_read_socket(struct dcons_state *dc, struct dcons_port *p)
 674 {
 675         struct kevent kev;
 676         int len, wlen;
 677         char rbuf[MAX_XFER], wbuf[MAX_XFER+2];
 678
 679         if ((len = read(p->infd, rbuf, sizeof(rbuf))) > 0) {
 680                 wlen = 0;
 681                 dconschat_read_filter(dc, p, rbuf, len, wbuf, &wlen);
 682                 /* XXX discard if not ready*/
 683                 if (wlen > 0 && (dc->flags & F_READY) != 0) {
 684                         dconschat_write_dcons(dc, p->port, wbuf, wlen);
 685                         if (verbose > 1) {
 686                                 wbuf[wlen] = 0;
 687                                 printf("(%s)\n", wbuf);
 688                         }
 689                         if (verbose) {
 690                                 printf("(%d)", wlen);
 691                                 fflush(stdout);
 692                         }
 693                 }
 694         } else {
 695                 if (verbose) {
 696                         if (len == 0)
 697                                 warnx("port%d: closed", p->port);
 698                         else
 699                                 warn("port%d: read", p->port);
 700                 }
 701                 EV_SET(&kev, p->infd, EVFILT_READ,
 702                         EV_DELETE, 0, 0, NULL);
 703                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 704                 close(p->infd);
 705                 close(p->outfd);
 706                 /* XXX exit for pipe case XXX */
 707                 EV_SET(&kev, p->s, EVFILT_READ,
 708                                 EV_ADD | EV_ONESHOT, 0, 0, (void *) p);
 709                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 710                 p->infd = p->outfd = -1;
 711         }
 712         return(0);
 713 }
 714 #define NEVENT 5
 715 static int
 716 dconschat_proc_socket(struct dcons_state *dc)
 717 {
 718         struct kevent elist[NEVENT], *e;
 719         int i, n;
 720         struct dcons_port *p;
 721
 722         n = kevent(dc->kq, NULL, 0, elist, NEVENT, &dc->to);
 723         for (i = 0; i < n; i ++) {
 724                 e = &elist[i];
 725                 p = (struct dcons_port *)e->udata;
 726                 if (e->ident == (uintptr_t)p->s) {
 727                         dconschat_accept_socket(dc, p);
 728                 } else {
 729                         dconschat_read_socket(dc, p);
 730                 }
 731         }
 732         return(0);
 733 }
 734
 735 static int
 736 dconschat_proc_dcons(struct dcons_state *dc)
 737 {
 738         int port, len, error;
 739         char buf[MAX_XFER];
 740         struct dcons_port *p;
 741
 742         error = dconschat_get_ptr(dc);
 743         if (error) {
 744                 /* XXX we should stop write operation too. */
 745                 return error;
 746         }
 747         for (port = 0; port < DCONS_NPORT; port ++) {
 748                 p = &dc->port[port];
 749                 if (p->infd < 0)
 750                         continue;
 751                 while ((len = dconschat_read_dcons(dc, port, buf,
 752                     sizeof(buf))) > 0) {
 753                         dconschat_write_socket(p->outfd, buf, len);
 754                         dconschat_get_ptr(dc);
 755                 }
 756                 if ((dc->flags & F_ONE_SHOT) != 0 && len <= 0)
 757                         dconschat_cleanup(0);
 758         }
 759         return 0;
 760 }
 761
 762 static int
 763 dconschat_start_session(struct dcons_state *dc)
 764 {
 765         int counter = 0;
 766
 767         while (1) {
 768                 if ((dc->flags & F_READY) == 0 &&
 769                         (++counter % (poll_hz * DCONS_POLL_OFFLINE)) == 0)
 770                         dconschat_fetch_header(dc);
 771                 if ((dc->flags & F_READY) != 0)
 772                         dconschat_proc_dcons(dc);
 773                 dconschat_proc_socket(dc);
 774         }
 775         return (0);
 776 }
 777
 778 static void
 779 usage(void)
 780 {
 781         fprintf(stderr,
 782             "usage: dconschat [-brvwRT1] [-h hz] [-C port] [-G port]\n"
 783             "\t\t\t[-M core] [-N system]\n"
 784             "\t\t\t[-u unit] [-a address] [-t target_eui64]\n"
 785             "\t-b       translate ctrl-C to CR+~+ctrl-B on gdb port\n"
 786             "\t-v       verbose\n"
 787             "\t-w       listen on wildcard address rather than localhost\n"
 788             "\t-r       replay old buffer on connection\n"
 789             "\t-R       read-only\n"
 790             "\t-T       enable Telnet protocol workaround on console port\n"
 791             "\t-1       one shot: read buffer and exit\n"
 792             "\t-h       polling rate\n"
 793             "\t-C       port number for console port\n"
 794             "\t-G       port number for gdb port\n"
 795             "\t(for KVM)\n"
 796             "\t-M       core file\n"
 797             "\t-N       system file\n"
 798             "\t(for FireWire)\n"
 799             "\t-u       specify unit number of the bus\n"
 800             "\t-t       EUI64 of target host (must be specified)\n"
 801             "\t-a       physical address of dcons buffer on target host\n"
 802         );
 803         exit(0);
 804 }
 805 int
 806 main(int argc, char **argv)
 807 {
 808         struct dcons_state *dc;
 809         struct fw_eui64 eui;
 810         struct eui64 target;
 811         char devicename[256], *core = NULL, *sysfile = NULL;
 812         int i, ch, error;
 813         int unit=0, wildcard=0;
 814         int port[DCONS_NPORT];
 815
 816         bzero(&sc, sizeof(sc));
 817         dc = &sc;
 818         dc->flags |= USE_CROM ? F_USE_CROM : 0;
 819
 820         /* defualt ports */
 821         port[0] = 0;    /* stdin/out for console */
 822         port[1] = -1;   /* disable gdb port */
 823
 824         while ((ch = getopt(argc, argv, "a:bh:rt:u:vwC:G:M:N:RT1")) != -1) {
 825                 switch(ch) {
 826                 case 'a':
 827                         dc->paddr = strtoull(optarg, NULL, 0);
 828                         dc->flags &= ~F_USE_CROM;
 829                         break;
 830                 case 'b':
 831                         dc->flags |= F_ALT_BREAK;
 832                         break;
 833                 case 'h':
 834                         poll_hz = strtoul(optarg, NULL, 0);
 835                         if (poll_hz == 0)
 836                                 poll_hz = DCONS_POLL_HZ;
 837                         break;
 838                 case 'r':
 839                         dc->flags |= F_REPLAY;
 840                         break;
 841                 case 't':
 842                         if (eui64_hostton(optarg, &target) != 0 &&
 843                             eui64_aton(optarg, &target) != 0)
 844                                 errx(1, "invalid target: %s", optarg);
 845                         eui.hi = ntohl(*(u_int32_t*)&(target.octet[0]));
 846                         eui.lo = ntohl(*(u_int32_t*)&(target.octet[4]));
 847                         dc->type = TYPE_FW;
 848                         break;
 849                 case 'u':
 850                         unit = strtol(optarg, NULL, 0);
 851                         break;
 852                 case 'v':
 853                         verbose ++;
 854                         break;
 855                 case 'w':
 856                         wildcard = 1;
 857                         break;
 858                 case 'C':
 859                         port[0] = strtol(optarg, NULL, 0);
 860                         break;
 861                 case 'G':
 862                         port[1] = strtol(optarg, NULL, 0);
 863                         break;
 864                 case 'M':
 865                         core = optarg;
 866                         break;
 867                 case 'N':
 868                         sysfile = optarg;
 869                         break;
 870                 case 'R':
 871                         dc->flags |= F_RD_ONLY;
 872                         break;
 873                 case 'T':
 874                         dc->flags |= F_TELNET;
 875                         break;
 876                 case '1':
 877                         dc->flags |= F_ONE_SHOT | F_REPLAY;
 878                         break;
 879                 default:
 880                         usage();
 881                 }
 882         }
 883         if (dc->paddr == 0 && (dc->flags & F_USE_CROM) == 0) {
 884                 warnx("no address specified");
 885                 usage();
 886         }
 887
 888         if (port[0] < 0 && port[1] < 0) {
 889                 warnx("no port specified");
 890                 usage();
 891         }
 892
 893         /* set signal handler */
 894         signal(SIGHUP, dconschat_cleanup);
 895         signal(SIGINT, dconschat_cleanup);
 896         signal(SIGPIPE, dconschat_cleanup);
 897         signal(SIGTERM, dconschat_cleanup);
 898
 899         /* init firewire */
 900         switch (dc->type) {
 901         case TYPE_FW:
 902 #define MAXDEV 10
 903                 for (i = 0; i < MAXDEV; i ++) {
 904                         snprintf(devicename, sizeof(devicename),
 905                             "/dev/fwmem%d.%d", unit, i);
 906                         dc->fd = open(devicename, O_RDWR);
 907                         if (dc->fd >= 0)
 908                                 goto found;
 909                 }
 910                 err(1, "open");
 911 found:
 912                 error = ioctl(dc->fd, FW_SDEUI64, &eui);
 913                 if (error)
 914                         err(1, "ioctl");
 915                 break;
 916         case TYPE_KVM:
 917         {
 918                 struct nlist nl[] = {{.n_name = "dcons_buf"}, {.n_name = ""}};
 919                 void *dcons_buf;
 920
 921                 dc->kd = kvm_open(sysfile, core, NULL,
 922                     (dc->flags & F_RD_ONLY) ? O_RDONLY : O_RDWR, "dconschat");
 923                 if (dc->kd == NULL)
 924                         errx(1, "kvm_open");
 925
 926                 if (kvm_nlist(dc->kd, nl) < 0)
 927                         errx(1, "kvm_nlist: %s", kvm_geterr(dc->kd));
 928
 929                 if (kvm_read(dc->kd, nl[0].n_value, &dcons_buf,
 930                     sizeof(void *)) < 0)
 931                         errx(1, "kvm_read: %s", kvm_geterr(dc->kd));
 932                 dc->paddr = (uintptr_t)dcons_buf;
 933                 if (verbose)
 934                         printf("dcons_buf: 0x%x\n", (uint)dc->paddr);
 935                 break;
 936         }
 937         }
 938         dconschat_fetch_header(dc);
 939
 940         /* iniit sockets */
 941         dc->kq = kqueue();
 942         if (poll_hz == 1) {
 943                 dc->to.tv_sec = 1;
 944                 dc->to.tv_nsec = 0;
 945         } else {
 946                 dc->to.tv_sec = 0;
 947                 dc->to.tv_nsec = 1000 * 1000 * 1000 / poll_hz;
 948         }
 949         dc->zero.tv_sec = 0;
 950         dc->zero.tv_nsec = 0;
 951         for (i = 0; i < DCONS_NPORT; i++)
 952                 dconschat_init_socket(dc, i,
 953                     wildcard ? NULL : __DECONST(char *, "localhost"), port[i]);
 954
 955         dconschat_start_session(dc);
 956
 957         for (i = 0; i < DCONS_NPORT; i++) {
 958                 freeaddrinfo(dc->port[i].res);
 959         }
 960         return (0);
 961 }