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);
 407                 fflush(stdout);
 408         }
 409 #endif
 410
 411 again:
 412         dlen = dread(dc, buf, rlen, ch->buf + ch->pos);
 413         if (dlen < 0) {
 414                 if (errno == ETIMEDOUT)
 415                         if (retry -- > 0)
 416                                 goto again;
 417                 dconschat_ready(dc, 0, "read buffer failed");
 418                 return(-1);
 419         }
 420         if (dlen != rlen)
 421                 warnx("dlen(%d) != rlen(%d)\n", dlen, rlen);
 422         ch->pos += dlen;
 423         if (ch->pos >= ch->size) {
 424                 ch->gen = next_gen;
 425                 ch->pos = 0;
 426                 if (verbose)
 427                         printf("read_dcons: gen=%d", ch->gen);
 428         }
 429         return (dlen);
 430 }
 431
 432 static int
 433 dconschat_write_dcons(struct dcons_state *dc, int port, char *buf, int blen)
 434 {
 435         struct dcons_ch *ch;
 436         u_int32_t ptr;
 437         int len, wlen;
 438         int retry = RETRY;
 439
 440         ch = &dc->port[port].i;
 441         ptr = dc->port[port].iptr;
 442
 443         /* the others may advance the pointer sync with it */
 444         ch->gen = ptr >> DCONS_GEN_SHIFT;
 445         ch->pos = ptr & DCONS_POS_MASK;
 446
 447         while(blen > 0) {
 448                 wlen = MIN(blen, (int)(ch->size - ch->pos));
 449                 wlen = MIN(wlen, MAX_XFER);
 450                 len = dwrite(dc, buf, wlen, ch->buf + ch->pos);
 451                 if (len < 0) {
 452                         if (errno == ETIMEDOUT)
 453                                 if (retry -- > 0)
 454                                         continue; /* try again */
 455                         dconschat_ready(dc, 0, "write buffer failed");
 456                         return(-1);
 457                 }
 458                 ch->pos += len;
 459                 buf += len;
 460                 blen -= len;
 461                 if (ch->pos >= ch->size) {
 462                         ch->gen = DCONS_NEXT_GEN(ch->gen);
 463                         ch->pos = 0;
 464                         if (verbose)
 465                                 printf("write_dcons: gen=%d", ch->gen);
 466
 467                 }
 468         }
 469
 470         ptr = DCONS_MAKE_PTR(ch);
 471         dc->port[port].iptr = ptr;
 472
 473         if (verbose > 2)
 474                 printf("(iptr: 0x%x)", ptr);
 475 again:
 476         len = dwrite(dc, &ptr, sizeof(u_int32_t),
 477                 dc->paddr + __offsetof(struct dcons_buf, iptr[port]));
 478         if (len < 0) {
 479                 if (errno == ETIMEDOUT)
 480                         if (retry -- > 0)
 481                                 goto again;
 482                 dconschat_ready(dc, 0, "write ptr failed");
 483                 return(-1);
 484         }
 485         return(0);
 486 }
 487
 488 static int
 489 dconschat_write_socket(int fd, char *buf, int len)
 490 {
 491         write(fd, buf, len);
 492         if (verbose > 1) {
 493                 buf[len] = 0;
 494                 printf("[%s]", buf);
 495         }
 496         return (0);
 497 }
 498
 499 static void
 500 dconschat_init_socket(struct dcons_state *dc, int port, char *host, int sport)
 501 {
 502         struct addrinfo hints, *res;
 503         int on = 1, error;
 504         char service[10];
 505         struct kevent kev;
 506         struct dcons_port *p;
 507
 508         p = &dc->port[port];
 509         p->port = port;
 510         p->infd = p->outfd = -1;
 511
 512         if (sport < 0)
 513                 return;
 514
 515         if (sport == 0) {
 516
 517                 /* Use stdin and stdout */
 518                 p->infd = STDIN_FILENO;
 519                 p->outfd = STDOUT_FILENO;
 520                 p->s = -1;
 521                 if (tc_set == 0 &&
 522                     tcgetattr(STDIN_FILENO, &dc->tsave) == 0) {
 523                         struct termios traw;
 524
 525                         traw = dc->tsave;
 526                         cfmakeraw(&traw);
 527                         tcsetattr(STDIN_FILENO, TCSADRAIN, &traw);
 528                         tc_set = 1;
 529                 }
 530                 EV_SET(&kev, p->infd, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1,
 531                     (void *)p);
 532                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 533                 return;
 534         }
 535
 536         memset(&hints, 0, sizeof(hints));
 537         hints.ai_flags = AI_PASSIVE;
 538 #if 1   /* gdb can talk v4 only */
 539         hints.ai_family = PF_INET;
 540 #else
 541         hints.ai_family = PF_UNSPEC;
 542 #endif
 543         hints.ai_socktype = SOCK_STREAM;
 544         hints.ai_protocol = 0;
 545
 546         if (verbose)
 547                 printf("%s:%d for port %d\n",
 548                         host == NULL ? "*" : host, sport, port);
 549         snprintf(service, sizeof(service), "%d", sport);
 550         error = getaddrinfo(host, service,  &hints, &res);
 551         if (error)
 552                 errx(1, "tcp/%s: %s\n", service, gai_strerror(error));
 553         p->res = res;
 554         p->s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 555         if (p->s < 0)
 556                 err(1, "socket");
 557         setsockopt(p->s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
 558
 559         if (bind(p->s, p->res->ai_addr, p->res->ai_addrlen) < 0) {
 560                 err(1, "bind");
 561         }
 562         if (listen(p->s, 1) < 0)
 563                 err(1, "listen");
 564         EV_SET(&kev, p->s, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, (void *)p);
 565         error = kevent(dc->kq, &kev, 1, NULL, 0, &dc->to);
 566         if (error < 0)
 567                 err(1, "kevent");
 568         return;
 569 }
 570
 571 static int
 572 dconschat_accept_socket(struct dcons_state *dc, struct dcons_port *p)
 573 {
 574         int foo, ns, flags;
 575         struct kevent kev;
 576
 577         /* accept connection */
 578         foo = p->res->ai_addrlen;
 579         ns = accept(p->s, p->res->ai_addr, &foo);
 580         if (ns < 0)
 581                 err(1, "accept");
 582         if (verbose)
 583                 printf("port%d accepted\n", p->port);
 584
 585         flags = fcntl(ns, F_GETFL, 0);
 586         flags |= O_NDELAY;
 587         fcntl(ns, F_SETFL, flags);
 588 #if 1
 589         if (IS_CONSOLE(p) && (dc->flags & F_TELNET) != 0) {
 590                 char sga[] = {IAC, WILL, TELOPT_SGA};
 591                 char linemode[] = {IAC, DONT, TELOPT_LINEMODE};
 592                 char echo[] = {IAC, WILL, TELOPT_ECHO};
 593                 char bin[] = {IAC, DO, TELOPT_BINARY};
 594
 595                 write(ns, sga, sizeof(sga));
 596                 write(ns, linemode, sizeof(linemode));
 597                 write(ns, echo, sizeof(echo));
 598                 write(ns, bin, sizeof(bin));
 599                 p->skip_read = 0;
 600         }
 601 #endif
 602
 603         p->infd = p->outfd = ns;
 604         EV_SET(&kev, ns, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1, (void *)p);
 605         kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 606         return(0);
 607 }
 608
 609 static int
 610 dconschat_read_filter(struct dcons_state *dc, struct dcons_port *p,
 611     u_char *sp, int slen, u_char *dp, int *dlen)
 612 {
 613         static u_char abreak[3] = {13 /* CR */, 126 /* ~ */, 2 /* ^B */};
 614
 615         while (slen > 0) {
 616                 if (IS_CONSOLE(p)) {
 617                         if ((dc->flags & F_TELNET) != 0) {
 618                                 /* XXX Telent workarounds */
 619                                 if (p->skip_read -- > 0) {
 620                                         sp ++;
 621                                         slen --;
 622                                         continue;
 623                                 }
 624                                 if (*sp == IAC) {
 625                                         if (verbose)
 626                                                 printf("(IAC)");
 627                                         p->skip_read = 2;
 628                                         sp ++;
 629                                         slen --;
 630                                         continue;
 631                                 }
 632                                 if (*sp == 0) {
 633                                         if (verbose)
 634                                                 printf("(0 stripped)");
 635                                         sp ++;
 636                                         slen --;
 637                                         continue;
 638                                 }
 639                         }
 640                         switch (dc->escape_state) {
 641                         case STATE1:
 642                                 if (*sp == KEY_TILDE)
 643                                         dc->escape_state = STATE2;
 644                                 else
 645                                         dc->escape_state = STATE0;
 646                                 break;
 647                         case STATE2:
 648                                 dc->escape_state = STATE0;
 649                                 if (*sp == '.')
 650                                         dconschat_cleanup(0);
 651                         }
 652                         if (*sp == KEY_CR)
 653                                 dc->escape_state = STATE1;
 654                 } else if (IS_GDB(p)) {
 655                         /* GDB: ^C -> CR+~+^B */
 656                         if (*sp == 0x3 && (dc->flags & F_ALT_BREAK) != 0) {
 657                                 bcopy(abreak, dp, 3);
 658                                 dp += 3;
 659                                 sp ++;
 660                                 *dlen += 3;
 661                                 /* discard rest of the packet */
 662                                 slen = 0;
 663                                 break;
 664                         }
 665                 }
 666                 *dp++ = *sp++;
 667                 (*dlen) ++;
 668                 slen --;
 669         }
 670         return (*dlen);
 671
 672 }
 673
 674 static int
 675 dconschat_read_socket(struct dcons_state *dc, struct dcons_port *p)
 676 {
 677         struct kevent kev;
 678         int len, wlen;
 679         char rbuf[MAX_XFER], wbuf[MAX_XFER+2];
 680
 681         if ((len = read(p->infd, rbuf, sizeof(rbuf))) > 0) {
 682                 wlen = 0;
 683                 dconschat_read_filter(dc, p, rbuf, len, wbuf, &wlen);
 684                 /* XXX discard if not ready*/
 685                 if (wlen > 0 && (dc->flags & F_READY) != 0) {
 686                         dconschat_write_dcons(dc, p->port, wbuf, wlen);
 687                         if (verbose > 1) {
 688                                 wbuf[wlen] = 0;
 689                                 printf("(%s)\n", wbuf);
 690                         }
 691                         if (verbose) {
 692                                 printf("(%d)", wlen);
 693                                 fflush(stdout);
 694                         }
 695                 }
 696         } else {
 697                 if (verbose) {
 698                         if (len == 0)
 699                                 warnx("port%d: closed", p->port);
 700                         else
 701                                 warn("port%d: read", p->port);
 702                 }
 703                 EV_SET(&kev, p->infd, EVFILT_READ,
 704                         EV_DELETE, 0, 0, NULL);
 705                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 706                 close(p->infd);
 707                 close(p->outfd);
 708                 /* XXX exit for pipe case XXX */
 709                 EV_SET(&kev, p->s, EVFILT_READ,
 710                                 EV_ADD | EV_ONESHOT, 0, 0, (void *) p);
 711                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 712                 p->infd = p->outfd = -1;
 713         }
 714         return(0);
 715 }
 716 #define NEVENT 5
 717 static int
 718 dconschat_proc_socket(struct dcons_state *dc)
 719 {
 720         struct kevent elist[NEVENT], *e;
 721         int i, n;
 722         struct dcons_port *p;
 723
 724         n = kevent(dc->kq, NULL, 0, elist, NEVENT, &dc->to);
 725         for (i = 0; i < n; i ++) {
 726                 e = &elist[i];
 727                 p = (struct dcons_port *)e->udata;
 728                 if (e->ident == (uintptr_t)p->s) {
 729                         dconschat_accept_socket(dc, p);
 730                 } else {
 731                         dconschat_read_socket(dc, p);
 732                 }
 733         }
 734         return(0);
 735 }
 736
 737 static int
 738 dconschat_proc_dcons(struct dcons_state *dc)
 739 {
 740         int port, len, error;
 741         char buf[MAX_XFER];
 742         struct dcons_port *p;
 743
 744         error = dconschat_get_ptr(dc);
 745         if (error) {
 746                 /* XXX we should stop write operation too. */
 747                 return error;
 748         }
 749         for (port = 0; port < DCONS_NPORT; port ++) {
 750                 p = &dc->port[port];
 751                 if (p->infd < 0)
 752                         continue;
 753                 while ((len = dconschat_read_dcons(dc, port, buf,
 754                     sizeof(buf))) > 0) {
 755                         dconschat_write_socket(p->outfd, buf, len);
 756                         dconschat_get_ptr(dc);
 757                 }
 758                 if ((dc->flags & F_ONE_SHOT) != 0 && len <= 0)
 759                         dconschat_cleanup(0);
 760         }
 761         return 0;
 762 }
 763
 764 static int
 765 dconschat_start_session(struct dcons_state *dc)
 766 {
 767         int counter = 0;
 768
 769         while (1) {
 770                 if ((dc->flags & F_READY) == 0 &&
 771                         (++counter % (poll_hz * DCONS_POLL_OFFLINE)) == 0)
 772                         dconschat_fetch_header(dc);
 773                 if ((dc->flags & F_READY) != 0)
 774                         dconschat_proc_dcons(dc);
 775                 dconschat_proc_socket(dc);
 776         }
 777         return (0);
 778 }
 779
 780 static void
 781 usage(void)
 782 {
 783         fprintf(stderr,
 784             "usage: dconschat [-brvwRT1] [-h hz] [-C port] [-G port]\n"
 785             "\t\t\t[-M core] [-N system]\n"
 786             "\t\t\t[-u unit] [-a address] [-t target_eui64]\n"
 787             "\t-b       translate ctrl-C to CR+~+ctrl-B on gdb port\n"
 788             "\t-v       verbose\n"
 789             "\t-w       listen on wildcard address rather than localhost\n"
 790             "\t-r       replay old buffer on connection\n"
 791             "\t-R       read-only\n"
 792             "\t-T       enable Telnet protocol workaround on console port\n"
 793             "\t-1       one shot: read buffer and exit\n"
 794             "\t-h       polling rate\n"
 795             "\t-C       port number for console port\n"
 796             "\t-G       port number for gdb port\n"
 797             "\t(for KVM)\n"
 798             "\t-M       core file\n"
 799             "\t-N       system file\n"
 800             "\t(for FireWire)\n"
 801             "\t-u       specify unit number of the bus\n"
 802             "\t-t       EUI64 of target host (must be specified)\n"
 803             "\t-a       physical address of dcons buffer on target host\n"
 804         );
 805         exit(0);
 806 }
 807 int
 808 main(int argc, char **argv)
 809 {
 810         struct dcons_state *dc;
 811         struct fw_eui64 eui;
 812         struct eui64 target;
 813         char devicename[256], *core = NULL, *sysfile = NULL;
 814         int i, ch, error;
 815         int unit=0, wildcard=0;
 816         int port[DCONS_NPORT];
 817
 818         bzero(&sc, sizeof(sc));
 819         dc = &sc;
 820         dc->flags |= USE_CROM ? F_USE_CROM : 0;
 821
 822         /* defualt ports */
 823         port[0] = 0;    /* stdin/out for console */
 824         port[1] = -1;   /* disable gdb port */
 825
 826         while ((ch = getopt(argc, argv, "a:bh:rt:u:vwC:G:M:N:RT1")) != -1) {
 827                 switch(ch) {
 828                 case 'a':
 829                         dc->paddr = strtoull(optarg, NULL, 0);
 830                         dc->flags &= ~F_USE_CROM;
 831                         break;
 832                 case 'b':
 833                         dc->flags |= F_ALT_BREAK;
 834                         break;
 835                 case 'h':
 836                         poll_hz = strtoul(optarg, NULL, 0);
 837                         if (poll_hz == 0)
 838                                 poll_hz = DCONS_POLL_HZ;
 839                         break;
 840                 case 'r':
 841                         dc->flags |= F_REPLAY;
 842                         break;
 843                 case 't':
 844                         if (eui64_hostton(optarg, &target) != 0 &&
 845                             eui64_aton(optarg, &target) != 0)
 846                                 errx(1, "invalid target: %s", optarg);
 847                         eui.hi = ntohl(*(u_int32_t*)&(target.octet[0]));
 848                         eui.lo = ntohl(*(u_int32_t*)&(target.octet[4]));
 849                         dc->type = TYPE_FW;
 850                         break;
 851                 case 'u':
 852                         unit = strtol(optarg, NULL, 0);
 853                         break;
 854                 case 'v':
 855                         verbose ++;
 856                         break;
 857                 case 'w':
 858                         wildcard = 1;
 859                         break;
 860                 case 'C':
 861                         port[0] = strtol(optarg, NULL, 0);
 862                         break;
 863                 case 'G':
 864                         port[1] = strtol(optarg, NULL, 0);
 865                         break;
 866                 case 'M':
 867                         core = optarg;
 868                         break;
 869                 case 'N':
 870                         sysfile = optarg;
 871                         break;
 872                 case 'R':
 873                         dc->flags |= F_RD_ONLY;
 874                         break;
 875                 case 'T':
 876                         dc->flags |= F_TELNET;
 877                         break;
 878                 case '1':
 879                         dc->flags |= F_ONE_SHOT | F_REPLAY;
 880                         break;
 881                 default:
 882                         usage();
 883                 }
 884         }
 885         if (dc->paddr == 0 && (dc->flags & F_USE_CROM) == 0) {
 886                 warnx("no address specified");
 887                 usage();
 888         }
 889
 890         if (port[0] < 0 && port[1] < 0) {
 891                 warnx("no port specified");
 892                 usage();
 893         }
 894
 895         /* set signal handler */
 896         signal(SIGHUP, dconschat_cleanup);
 897         signal(SIGINT, dconschat_cleanup);
 898         signal(SIGPIPE, dconschat_cleanup);
 899         signal(SIGTERM, dconschat_cleanup);
 900
 901         /* init firewire */
 902         switch (dc->type) {
 903         case TYPE_FW:
 904 #define MAXDEV 10
 905                 for (i = 0; i < MAXDEV; i ++) {
 906                         snprintf(devicename, sizeof(devicename),
 907                             "/dev/fwmem%d.%d", unit, i);
 908                         dc->fd = open(devicename, O_RDWR);
 909                         if (dc->fd >= 0)
 910                                 goto found;
 911                 }
 912                 err(1, "open");
 913 found:
 914                 error = ioctl(dc->fd, FW_SDEUI64, &eui);
 915                 if (error)
 916                         err(1, "ioctl");
 917                 break;
 918         case TYPE_KVM:
 919         {
 920                 struct nlist nl[] = {{.n_name = "dcons_buf"}, {.n_name = ""}};
 921                 void *dcons_buf;
 922
 923                 dc->kd = kvm_open(sysfile, core, NULL,
 924                     (dc->flags & F_RD_ONLY) ? O_RDONLY : O_RDWR, "dconschat");
 925                 if (dc->kd == NULL)
 926                         errx(1, "kvm_open");
 927
 928                 if (kvm_nlist(dc->kd, nl) < 0)
 929                         errx(1, "kvm_nlist: %s", kvm_geterr(dc->kd));
 930
 931                 if (kvm_read(dc->kd, nl[0].n_value, &dcons_buf,
 932                     sizeof(void *)) < 0)
 933                         errx(1, "kvm_read: %s", kvm_geterr(dc->kd));
 934                 dc->paddr = (uintptr_t)dcons_buf;
 935                 if (verbose)
 936                         printf("dcons_buf: 0x%x\n", (uint)dc->paddr);
 937                 break;
 938         }
 939         }
 940         dconschat_fetch_header(dc);
 941
 942         /* iniit sockets */
 943         dc->kq = kqueue();
 944         if (poll_hz == 1) {
 945                 dc->to.tv_sec = 1;
 946                 dc->to.tv_nsec = 0;
 947         } else {
 948                 dc->to.tv_sec = 0;
 949                 dc->to.tv_nsec = 1000 * 1000 * 1000 / poll_hz;
 950         }
 951         dc->zero.tv_sec = 0;
 952         dc->zero.tv_nsec = 0;
 953         for (i = 0; i < DCONS_NPORT; i++)
 954                 dconschat_init_socket(dc, i,
 955                     wildcard ? NULL : __DECONST(char *, "localhost"), port[i]);
 956
 957         dconschat_start_session(dc);
 958
 959         for (i = 0; i < DCONS_NPORT; i++) {
 960                 freeaddrinfo(dc->port[i].res);
 961         }
 962         return (0);
 963 }