| /* |
| * Copyright 2005 Sun Microsystems, Inc. All rights reserved. |
| * Use is subject to license terms. |
| */ |
| |
| /* |
| * Copyright (c) 1983 Regents of the University of California. |
| * All rights reserved. The Berkeley software License Agreement |
| * specifies the terms and conditions for redistribution. |
| */ |
| |
| #include <sys/types.h> |
| #include <sys/param.h> |
| #include <sys/signal.h> |
| #include <sys/systm.h> |
| #include <sys/termio.h> |
| #include <sys/ttold.h> |
| #include <sys/stropts.h> |
| #include <sys/stream.h> |
| #include <sys/strsubr.h> |
| #include <sys/strsun.h> |
| #include <sys/tty.h> |
| #include <sys/kmem.h> |
| #include <sys/errno.h> |
| #include <sys/ddi.h> |
| #include <sys/sunddi.h> |
| #include <sys/esunddi.h> |
| |
| /* |
| * The default (sane) set of termios values, unless |
| * otherwise set by the user. |
| */ |
| static struct termios default_termios = { |
| BRKINT|ICRNL|IXON|IMAXBEL, /* c_iflag */ |
| OPOST|ONLCR|TAB3, /* c_oflag */ |
| B9600|CS8|CREAD, /* c_cflag */ |
| ISIG|ICANON|IEXTEN|ECHO|ECHOK|ECHOE|ECHOKE|ECHOCTL, /* c_lflag */ |
| { |
| CINTR, |
| CQUIT, |
| CERASE, |
| CKILL, |
| CEOF, |
| CEOL, |
| CEOL2, |
| CNSWTCH, |
| CSTART, |
| CSTOP, |
| CSUSP, |
| CDSUSP, |
| CRPRNT, |
| CFLUSH, |
| CWERASE, |
| CLNEXT, |
| CSTATUS, |
| CERASE2 |
| } |
| }; |
| |
| |
| static int termioval(char **, uint_t *, char *); |
| |
| void |
| ttycommon_close(tty_common_t *tc) |
| { |
| mutex_enter(&tc->t_excl); |
| tc->t_flags &= ~TS_XCLUDE; |
| tc->t_readq = NULL; |
| tc->t_writeq = NULL; |
| if (tc->t_iocpending != NULL) { |
| mblk_t *mp; |
| |
| mp = tc->t_iocpending; |
| tc->t_iocpending = NULL; |
| mutex_exit(&tc->t_excl); |
| /* |
| * We were holding an "ioctl" response pending the |
| * availability of an "mblk" to hold data to be passed up; |
| * another "ioctl" came through, which means that "ioctl" |
| * must have timed out or been aborted. |
| */ |
| freemsg(mp); |
| } else |
| mutex_exit(&tc->t_excl); |
| } |
| |
| /* |
| * A "line discipline" module's queue is full. |
| * Check whether IMAXBEL is set; if so, output a ^G, otherwise send an M_FLUSH |
| * upstream flushing all the read queues. |
| */ |
| void |
| ttycommon_qfull(tty_common_t *tc, queue_t *q) |
| { |
| mblk_t *mp; |
| |
| if (tc->t_iflag & IMAXBEL) { |
| if (canput(WR(q))) { |
| if ((mp = allocb(1, BPRI_HI)) != NULL) { |
| *mp->b_wptr++ = CTRL('g'); |
| (void) putq(WR(q), mp); |
| } |
| } |
| } else { |
| flushq(q, FLUSHDATA); |
| (void) putnextctl1(q, M_FLUSH, FLUSHR); |
| } |
| } |
| |
| /* |
| * Process an "ioctl" message sent down to us, and return a reply message, |
| * even if we don't understand the "ioctl". Our client may want to use |
| * that reply message for its own purposes if we don't understand it but |
| * they do, and may want to modify it if we both understand it but they |
| * understand it better than we do. |
| * If the "ioctl" reply requires additional data to be passed up to the |
| * caller, and we cannot allocate an mblk to hold the data, we return the |
| * amount of data to be sent, so that our caller can do a "bufcall" and try |
| * again later; otherwise, we return 0. |
| */ |
| size_t |
| ttycommon_ioctl(tty_common_t *tc, queue_t *q, mblk_t *mp, int *errorp) |
| { |
| struct iocblk *iocp; |
| size_t ioctlrespsize; |
| mblk_t *tmp; |
| |
| *errorp = 0; /* no error detected yet */ |
| |
| iocp = (struct iocblk *)mp->b_rptr; |
| |
| if (iocp->ioc_count == TRANSPARENT) { |
| *errorp = -1; /* we don't understand it, maybe they do */ |
| return (0); |
| } |
| |
| switch (iocp->ioc_cmd) { |
| |
| case TCSETSF: |
| /* |
| * Flush the driver's queue, and send an M_FLUSH upstream |
| * to flush everybody above us. |
| */ |
| flushq(RD(q), FLUSHDATA); |
| (void) putnextctl1(RD(q), M_FLUSH, FLUSHR); |
| /* FALLTHROUGH */ |
| |
| case TCSETSW: |
| case TCSETS: { |
| struct termios *cb; |
| |
| if (miocpullup(mp, sizeof (struct termios)) != 0) { |
| *errorp = -1; |
| break; |
| } |
| |
| /* |
| * The only information we look at are the iflag word, |
| * the cflag word, and the start and stop characters. |
| */ |
| cb = (struct termios *)mp->b_cont->b_rptr; |
| mutex_enter(&tc->t_excl); |
| tc->t_iflag = cb->c_iflag; |
| tc->t_cflag = cb->c_cflag; |
| tc->t_stopc = cb->c_cc[VSTOP]; |
| tc->t_startc = cb->c_cc[VSTART]; |
| mutex_exit(&tc->t_excl); |
| break; |
| } |
| |
| case TCSETAF: |
| /* |
| * Flush the driver's queue, and send an M_FLUSH upstream |
| * to flush everybody above us. |
| */ |
| flushq(RD(q), FLUSHDATA); |
| (void) putnextctl1(RD(q), M_FLUSH, FLUSHR); |
| /* FALLTHROUGH */ |
| |
| case TCSETAW: |
| case TCSETA: { |
| struct termio *cb; |
| |
| if (miocpullup(mp, sizeof (struct termio)) != 0) { |
| *errorp = -1; |
| break; |
| } |
| |
| /* |
| * The only information we look at are the iflag word |
| * and the cflag word. Don't touch the unset portions. |
| */ |
| cb = (struct termio *)mp->b_cont->b_rptr; |
| mutex_enter(&tc->t_excl); |
| tc->t_iflag = (tc->t_iflag & 0xffff0000 | cb->c_iflag); |
| tc->t_cflag = (tc->t_cflag & 0xffff0000 | cb->c_cflag); |
| mutex_exit(&tc->t_excl); |
| break; |
| } |
| |
| case TIOCSWINSZ: { |
| struct winsize *ws; |
| |
| if (miocpullup(mp, sizeof (struct winsize)) != 0) { |
| *errorp = -1; |
| break; |
| } |
| |
| /* |
| * If the window size changed, send a SIGWINCH. |
| */ |
| ws = (struct winsize *)mp->b_cont->b_rptr; |
| mutex_enter(&tc->t_excl); |
| if (bcmp(&tc->t_size, ws, sizeof (struct winsize)) != 0) { |
| tc->t_size = *ws; |
| mutex_exit(&tc->t_excl); |
| (void) putnextctl1(RD(q), M_PCSIG, SIGWINCH); |
| } else |
| mutex_exit(&tc->t_excl); |
| break; |
| } |
| |
| /* |
| * Prevent more opens. |
| */ |
| case TIOCEXCL: |
| mutex_enter(&tc->t_excl); |
| tc->t_flags |= TS_XCLUDE; |
| mutex_exit(&tc->t_excl); |
| break; |
| |
| /* |
| * Permit more opens. |
| */ |
| case TIOCNXCL: |
| mutex_enter(&tc->t_excl); |
| tc->t_flags &= ~TS_XCLUDE; |
| mutex_exit(&tc->t_excl); |
| break; |
| |
| /* |
| * Set or clear the "soft carrier" flag. |
| */ |
| case TIOCSSOFTCAR: |
| if (miocpullup(mp, sizeof (int)) != 0) { |
| *errorp = -1; |
| break; |
| } |
| |
| mutex_enter(&tc->t_excl); |
| if (*(int *)mp->b_cont->b_rptr) |
| tc->t_flags |= TS_SOFTCAR; |
| else |
| tc->t_flags &= ~TS_SOFTCAR; |
| mutex_exit(&tc->t_excl); |
| break; |
| |
| /* |
| * The permission checking has already been done at the stream |
| * head, since it has to be done in the context of the process |
| * doing the call. |
| */ |
| case TIOCSTI: { |
| mblk_t *bp; |
| |
| if (miocpullup(mp, sizeof (char)) != 0) { |
| *errorp = -1; |
| break; |
| } |
| |
| /* |
| * Simulate typing of a character at the terminal. |
| */ |
| if ((bp = allocb(1, BPRI_MED)) != NULL) { |
| if (!canput(tc->t_readq->q_next)) |
| freemsg(bp); |
| else { |
| *bp->b_wptr++ = *mp->b_cont->b_rptr; |
| putnext(tc->t_readq, bp); |
| } |
| } |
| break; |
| } |
| } |
| |
| /* |
| * Turn the ioctl message into an ioctl ACK message. |
| */ |
| iocp->ioc_count = 0; /* no data returned unless we say so */ |
| mp->b_datap->db_type = M_IOCACK; |
| |
| switch (iocp->ioc_cmd) { |
| |
| case TCSETSF: |
| case TCSETSW: |
| case TCSETS: |
| case TCSETAF: |
| case TCSETAW: |
| case TCSETA: |
| case TIOCSWINSZ: |
| case TIOCEXCL: |
| case TIOCNXCL: |
| case TIOCSSOFTCAR: |
| case TIOCSTI: |
| /* |
| * We've done all the important work on these already; |
| * just reply with an ACK. |
| */ |
| break; |
| |
| case TCGETS: { |
| struct termios *cb; |
| mblk_t *datap; |
| |
| if ((datap = allocb(sizeof (struct termios), |
| BPRI_HI)) == NULL) { |
| ioctlrespsize = sizeof (struct termios); |
| goto allocfailure; |
| } |
| cb = (struct termios *)datap->b_wptr; |
| /* |
| * The only information we supply is the cflag word. |
| * Our copy of the iflag word is just that, a copy. |
| */ |
| bzero(cb, sizeof (struct termios)); |
| cb->c_cflag = tc->t_cflag; |
| datap->b_wptr += sizeof (struct termios); |
| iocp->ioc_count = sizeof (struct termios); |
| if (mp->b_cont != NULL) |
| freemsg(mp->b_cont); |
| mp->b_cont = datap; |
| break; |
| } |
| |
| case TCGETA: { |
| struct termio *cb; |
| mblk_t *datap; |
| |
| if ((datap = allocb(sizeof (struct termio), BPRI_HI)) == NULL) { |
| ioctlrespsize = sizeof (struct termio); |
| goto allocfailure; |
| } |
| |
| cb = (struct termio *)datap->b_wptr; |
| /* |
| * The only information we supply is the cflag word. |
| * Our copy of the iflag word is just that, a copy. |
| */ |
| bzero(cb, sizeof (struct termio)); |
| cb->c_cflag = tc->t_cflag; |
| datap->b_wptr += sizeof (struct termio); |
| iocp->ioc_count = sizeof (struct termio); |
| if (mp->b_cont != NULL) |
| freemsg(mp->b_cont); |
| mp->b_cont = datap; |
| break; |
| } |
| |
| /* |
| * Get the "soft carrier" flag. |
| */ |
| case TIOCGSOFTCAR: { |
| mblk_t *datap; |
| |
| if ((datap = allocb(sizeof (int), BPRI_HI)) == NULL) { |
| ioctlrespsize = sizeof (int); |
| goto allocfailure; |
| } |
| if (tc->t_flags & TS_SOFTCAR) |
| *(int *)datap->b_wptr = 1; |
| else |
| *(int *)datap->b_wptr = 0; |
| datap->b_wptr += sizeof (int); |
| iocp->ioc_count = sizeof (int); |
| if (mp->b_cont != NULL) |
| freemsg(mp->b_cont); |
| mp->b_cont = datap; |
| break; |
| } |
| |
| case TIOCGWINSZ: { |
| mblk_t *datap; |
| |
| if ((datap = allocb(sizeof (struct winsize), |
| BPRI_HI)) == NULL) { |
| ioctlrespsize = sizeof (struct winsize); |
| goto allocfailure; |
| } |
| /* |
| * Return the current size. |
| */ |
| *(struct winsize *)datap->b_wptr = tc->t_size; |
| datap->b_wptr += sizeof (struct winsize); |
| iocp->ioc_count = sizeof (struct winsize); |
| if (mp->b_cont != NULL) |
| freemsg(mp->b_cont); |
| mp->b_cont = datap; |
| break; |
| } |
| |
| default: |
| *errorp = -1; /* we don't understand it, maybe they do */ |
| break; |
| } |
| return (0); |
| |
| allocfailure: |
| |
| mutex_enter(&tc->t_excl); |
| tmp = tc->t_iocpending; |
| tc->t_iocpending = mp; /* hold this ioctl */ |
| mutex_exit(&tc->t_excl); |
| /* |
| * We needed to allocate something to handle this "ioctl", but |
| * couldn't; save this "ioctl" and arrange to get called back when |
| * it's more likely that we can get what we need. |
| * If there's already one being saved, throw it out, since it |
| * must have timed out. |
| */ |
| if (tmp != NULL) |
| freemsg(tmp); |
| return (ioctlrespsize); |
| } |
| |
| #define NFIELDS 22 /* 18 control characters + 4 sets of modes */ |
| |
| /* |
| * Init routine run from main at boot time. |
| * Creates a property in the "options" node that is |
| * the default set of termios modes upon driver open. |
| * If the property already existed, then it was |
| * defined in the options.conf file. In this case we |
| * need to convert this string (stty -g style) to an |
| * actual termios structure and store the new property |
| * value. |
| */ |
| |
| void |
| ttyinit() |
| { |
| dev_info_t *dip; |
| struct termios new_termios; |
| struct termios *tp; |
| char *property = "ttymodes"; |
| char **modesp, *cp; |
| int i; |
| uint_t val; |
| uint_t len; |
| |
| |
| /* |
| * If the termios defaults were NOT set up by the |
| * user via the options.conf file, create it using the |
| * "sane" set of termios modes. |
| * Note that if the property had been created via the |
| * options.conf file, it would have been created as |
| * a string property. Since we would like to store |
| * a structure (termios) in this property, we need |
| * to change the property type to byte array. |
| */ |
| if (ddi_prop_lookup_string_array(DDI_DEV_T_ANY, ddi_root_node(), 0, |
| property, (char ***)&modesp, &len) != DDI_PROP_SUCCESS) { |
| |
| if ((dip = ddi_find_devinfo("options", -1, 0)) == NULL) { |
| cmn_err(CE_PANIC, |
| "ttyinit: Can't find options node!\n"); |
| } |
| /* |
| * Create the property. |
| */ |
| if (ddi_prop_update_byte_array(DDI_DEV_T_NONE, dip, |
| property, (uchar_t *)&default_termios, |
| sizeof (struct termios)) != DDI_PROP_SUCCESS) { |
| cmn_err(CE_PANIC, "ttyinit: can't create %s property\n", |
| property); |
| } |
| return; |
| } |
| |
| /* |
| * This property was already set in the options.conf |
| * file. We must convert it from a "stty -g" string |
| * to an actual termios structure. |
| */ |
| bzero(&new_termios, sizeof (struct termios)); |
| tp = &new_termios; |
| cp = *modesp; |
| for (i = 0; i < NFIELDS; i++) { |
| /* |
| * Check for bad field/string. |
| */ |
| if (termioval(&cp, &val, *modesp+strlen(*modesp)) == -1) { |
| cmn_err(CE_WARN, |
| "ttyinit: property '%s' %s\n", property, |
| "set incorrectly, using sane value"); |
| tp = &default_termios; |
| break; |
| } |
| switch (i) { |
| case 0: |
| new_termios.c_iflag = (tcflag_t)val; |
| break; |
| case 1: |
| new_termios.c_oflag = (tcflag_t)val; |
| break; |
| case 2: |
| new_termios.c_cflag = (tcflag_t)val; |
| break; |
| case 3: |
| new_termios.c_lflag = (tcflag_t)val; |
| break; |
| default: |
| new_termios.c_cc[i - 4] = (cc_t)val; |
| } |
| } |
| if ((dip = ddi_find_devinfo("options", -1, 0)) == NULL) { |
| cmn_err(CE_PANIC, "ttyinit: Can't find options node!\n"); |
| } |
| |
| /* |
| * We need to create ttymode property as a byte array |
| * since it will be interpreted as a termios struct. |
| * The property was created as a string by default. |
| * So remove the old property and add the new one - |
| * otherwise we end up with two ttymodes properties. |
| */ |
| if (e_ddi_prop_remove(DDI_DEV_T_NONE, dip, property) |
| != DDI_PROP_SUCCESS) { |
| cmn_err(CE_WARN, "ttyinit: cannot remove '%s' property\n", |
| property); |
| } |
| /* |
| * Store the new defaults. Since, this property was |
| * autoconfig'ed, we must use e_ddi_prop_update_byte_array(). |
| */ |
| if (e_ddi_prop_update_byte_array(DDI_DEV_T_NONE, dip, property, |
| (uchar_t *)tp, sizeof (struct termios)) != DDI_PROP_SUCCESS) { |
| cmn_err(CE_PANIC, "ttyinit: cannot modify '%s' property\n", |
| property); |
| } |
| ddi_prop_free(modesp); |
| } |
| |
| /* |
| * Convert hex string representation of termios field |
| * to a uint_t. Increments string pointer to the next |
| * field, and assigns value. Returns -1 if no more fields |
| * or an error. |
| */ |
| |
| static int |
| termioval(char **sp, uint_t *valp, char *ep) |
| { |
| char *s = *sp; |
| uint_t digit; |
| |
| if (s == 0) |
| return (-1); |
| *valp = 0; |
| while (s < ep) { |
| if (*s >= '0' && *s <= '9') |
| digit = *s++ - '0'; |
| else if (*s >= 'a' && *s <= 'f') |
| digit = *s++ - 'a' + 10; |
| else if (*s >= 'A' && *s <= 'F') |
| digit = *s++ - 'A' + 10; |
| else if (*s == ':' || *s == '\0') |
| break; |
| else |
| return (-1); |
| *valp = (*valp * 16) + digit; |
| } |
| /* |
| * Null string or empty field. |
| */ |
| if (s == *sp) |
| return (-1); |
| |
| if (s < ep && *s == ':') |
| s++; |
| |
| *sp = s; |
| return (0); |
| } |