usr.sbin/dconschat/dconschat.c

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