int canonical(struct termios *saved) { //Restaura la configuración original del usuario. return( tcsetattr( 0, TCSADRAIN, saved ) ); }
int openComm(void) { #if 1 struct termios ti; char *device = CUST_BT_SERIAL_PORT; bt_prompt_trace(MOD_BT, "[UART] openComm"); bt_android_log("[UART] openComm"); if (commPort >= 0) //modified by autumn { bt_prompt_trace(MOD_BT, "[UART] openComm already opened"); bt_android_log("[UART][ERR] commPort=%d already opened.", commPort); bt_android_log("[BT][UART] + close uart=%d", commPort); close(commPort); bt_android_log("[BT][UART] - close uart"); } bt_android_log("[BT][UART] + open uart"); commPort = open(device, O_RDWR | O_NOCTTY | O_NONBLOCK); // Modified by SH bt_android_log("[BT][UART] - open uart"); if (commPort < 0) { bt_prompt_trace(MOD_BT, "[UART]Can't open serial port: %s (%d)\n", strerror(errno), errno); bt_android_log("[UART][ERR] Can't open serial port: %s (%d)\n", strerror(errno), errno); return -1; } #ifndef __MTK_STP_SUPPORTED__ //fcntl(commPort, F_SETFL, FASYNC); // Added by SH tcflush(commPort, TCIOFLUSH); if (tcgetattr(commPort, &ti) < 0) { bt_prompt_trace(MOD_BT, "[UART]Can't get port settings: %s (%d)\n", strerror(errno), errno); bt_android_log("[UART][ERR] Can't get port settings: %s (%d)\n", strerror(errno), errno); bt_android_log("[UART][ERR] Close commPort"); close(commPort); commPort = -1; return -1; } cfmakeraw(&ti); ti.c_cflag |= CLOCAL; ti.c_cflag &= ~CRTSCTS; #if !defined(__ANDROID_EMULATOR__) /* Emulator does not support flow control */ ti.c_iflag &= ~(IXON | IXOFF | IXANY | 0x80000000); #endif if (tcsetattr(commPort, TCSANOW, &ti) < 0) { bt_prompt_trace(MOD_BT, "[UART] Can't change port settings: %s (%d)\n", strerror(errno), errno); bt_android_log("[UART][ERR] Can't change port settings: %s (%d)\n", strerror(errno), errno); bt_android_log("[UART][ERR] Close commPort"); close(commPort); commPort = -1; return -1; } if( set_speed(commPort, &ti, 115200) < 0){ bt_android_log("[UART][ERR] set_speed failed"); close(commPort); commPort = -1; return -1; } tcflush(commPort, TCIOFLUSH); #endif /* ifndef __MTK_STP_SUPPORTED__ */ bt_prompt_trace(MOD_BT, "[UART] Opening UART successfully : %d", commPort); bt_android_log("[UART] Opening UART successfully : %d", commPort); return 0; #else char portName[20]; sprintf(portName, "/dev/ttyS%d", 2/*readUartSetting()*/); bt_prompt_trace(MOD_BT, "Opening UART port : %s", portName); /* Open UART port */ if (-1 == (commPort = open(portName, O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK)) ) { bt_prompt_trace(MOD_BT, "[Failed] Opening UART port "); return 0; } else { struct termios options; //fcntl(commPort, F_SETOWN, getpid()); fcntl(commPort, F_SETFL, FASYNC); /* Get default com port setting */ if( -1 == tcgetattr(commPort, &options) ) { bt_prompt_trace(MOD_BT, "[Failed] tcgetattr UART port failed"); close(commPort); return 0; } /* Set baud rate to 115200 */ cfsetispeed(&options, B115200); cfsetospeed(&options, B115200); options.c_cflag |= (CLOCAL | CREAD); options.c_cflag &= ~PARENB; /* No parity */ options.c_cflag &= ~CSTOPB; /* 1 stop bit */ options.c_cflag &= ~CSIZE; /* Mask the character size bits */ options.c_cflag |= CS8; /* Select 8 data bits */ /* Disable RTS & CTS */ options.c_cflag &= ~CRTSCTS; tcflush(commPort, TCIFLUSH); /* Set new com port setting */ if( -1 == tcsetattr(commPort, TCSANOW, &options) ) { bt_prompt_trace(MOD_BT, "[Failed] tcsetattr UART port failed"); close(commPort); return 0; } return 1; } #endif }
static int daemon_accept(int fd) { is_daemon = 1; int pid = read_int(fd); LOGD("remote pid: %d", pid); int atty = read_int(fd); LOGD("remote atty: %d", atty); daemon_from_uid = read_int(fd); LOGD("remote uid: %d", daemon_from_uid); daemon_from_pid = read_int(fd); LOGD("remote req pid: %d", daemon_from_pid); struct ucred credentials; int ucred_length = sizeof(struct ucred); /* fill in the user data structure */ if(getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &credentials, &ucred_length)) { LOGE("could obtain credentials from unix domain socket"); exit(-1); } // if the credentials on the other side of the wire are NOT root, // we can't trust anything being sent. if (credentials.uid != 0) { daemon_from_uid = credentials.uid; pid = credentials.pid; daemon_from_pid = credentials.pid; } int mount_storage = read_int(fd); int argc = read_int(fd); if (argc < 0 || argc > 512) { LOGE("unable to allocate args: %d", argc); exit(-1); } LOGD("remote args: %d", argc); char** argv = (char**)malloc(sizeof(char*) * (argc + 1)); argv[argc] = NULL; int i; for (i = 0; i < argc; i++) { argv[i] = read_string(fd); } char errfile[PATH_MAX]; char outfile[PATH_MAX]; char infile[PATH_MAX]; sprintf(outfile, "%s/%d.stdout", REQUESTOR_DAEMON_PATH, pid); sprintf(errfile, "%s/%d.stderr", REQUESTOR_DAEMON_PATH, pid); sprintf(infile, "%s/%d.stdin", REQUESTOR_DAEMON_PATH, pid); if (mkfifo(outfile, 0660) != 0) { PLOGE("mkfifo %s", outfile); exit(-1); } if (mkfifo(errfile, 0660) != 0) { PLOGE("mkfifo %s", errfile); exit(-1); } if (mkfifo(infile, 0660) != 0) { PLOGE("mkfifo %s", infile); exit(-1); } chown(outfile, daemon_from_uid, 0); chown(infile, daemon_from_uid, 0); chown(errfile, daemon_from_uid, 0); chmod(outfile, 0660); chmod(infile, 0660); chmod(errfile, 0660); // ack write_int(fd, 1); int ptm = -1; char* devname = NULL; if (atty) { ptm = open("/dev/ptmx", O_RDWR); if (ptm <= 0) { PLOGE("ptm"); exit(-1); } if(grantpt(ptm) || unlockpt(ptm) || ((devname = (char*) ptsname(ptm)) == 0)) { PLOGE("ptm setup"); close(ptm); exit(-1); } LOGD("devname: %s", devname); } int outfd = open(outfile, O_WRONLY); if (outfd <= 0) { PLOGE("outfd daemon %s", outfile); goto done; } int errfd = open(errfile, O_WRONLY); if (errfd <= 0) { PLOGE("errfd daemon %s", errfile); goto done; } int infd = open(infile, O_RDONLY); if (infd <= 0) { PLOGE("infd daemon %s", infile); goto done; } int code; // now fork and run main, watch for the child pid exit, and send that // across the control channel as the response. int child = fork(); if (child < 0) { code = child; goto done; } // if this is the child, open the fifo streams // and dup2 them with stdin/stdout, and run main, which execs // the target. if (child == 0) { close(fd); if (devname != NULL) { int pts = open(devname, O_RDWR); if(pts < 0) { PLOGE("pts"); exit(-1); } struct termios slave_orig_term_settings; // Saved terminal settings tcgetattr(pts, &slave_orig_term_settings); struct termios new_term_settings; new_term_settings = slave_orig_term_settings; cfmakeraw(&new_term_settings); // WHY DOESN'T THIS WORK, FUUUUU new_term_settings.c_lflag &= ~(ECHO); tcsetattr(pts, TCSANOW, &new_term_settings); setsid(); ioctl(pts, TIOCSCTTY, 1); close(infd); close(outfd); close(errfd); close(ptm); errfd = pts; infd = pts; outfd = pts; } #ifdef SUPERUSER_EMBEDEDED if (mount_storage) { mount_emulated_storage(multiuser_get_user_id(daemon_from_uid)); } #endif return run_daemon_child(infd, outfd, errfd, argc, argv); } if (devname != NULL) { // pump ptm across the socket pump_async(infd, ptm); pump(ptm, outfd); } else { close(infd); close(outfd); close(errfd); } // wait for the child to exit, and send the exit code // across the wire. int status; LOGD("waiting for child exit"); if (waitpid(child, &status, 0) > 0) { code = WEXITSTATUS(status); } else { code = -1; } done: write(fd, &code, sizeof(int)); close(fd); LOGD("child exited"); return code; }
int close_serial_port(void){ tcsetattr(ComFd, TCSANOW, &ComTio_Bk); return close(ComFd); }
NFCSTATUS phDal4Nfc_uart_open_and_configure(pphDal4Nfc_sConfig_t pConfig, void ** pLinkHandle) { int nComStatus; NFCSTATUS nfcret = NFCSTATUS_SUCCESS; int ret; DAL_ASSERT_STR(gComPortContext.nOpened==0, "Trying to open but already done!"); srand(time(NULL)); /* open communication port handle */ gComPortContext.nHandle = open(pConfig->deviceNode, O_RDWR | O_NOCTTY); if (gComPortContext.nHandle < 0) { *pLinkHandle = NULL; return PHNFCSTVAL(CID_NFC_DAL, NFCSTATUS_INVALID_DEVICE); } gComPortContext.nOpened = 1; *pLinkHandle = (void*)gComPortContext.nHandle; /* * Now configure the com port */ ret = tcgetattr(gComPortContext.nHandle, &gComPortContext.nIoConfigBackup); /* save the old io config */ if (ret == -1) { /* tcgetattr failed -- it is likely that the provided port is invalid */ *pLinkHandle = NULL; return PHNFCSTVAL(CID_NFC_DAL, NFCSTATUS_INVALID_DEVICE); } ret = fcntl(gComPortContext.nHandle, F_SETFL, 0); /* Makes the read blocking (default). */ DAL_ASSERT_STR(ret != -1, "fcntl failed"); /* Configures the io */ memset((void *)&gComPortContext.nIoConfig, (int)0, (size_t)sizeof(struct termios)); /* BAUDRATE: Set bps rate. You could also use cfsetispeed and cfsetospeed. CRTSCTS : output hardware flow control (only used if the cable has all necessary lines. See sect. 7 of Serial-HOWTO) CS8 : 8n1 (8bit,no parity,1 stopbit) CLOCAL : local connection, no modem contol CREAD : enable receiving characters */ gComPortContext.nIoConfig.c_cflag = DAL_BAUD_RATE | CS8 | CLOCAL | CREAD; /* Control mode flags */ gComPortContext.nIoConfig.c_iflag = IGNPAR; /* Input mode flags : IGNPAR Ignore parity errors */ gComPortContext.nIoConfig.c_oflag = 0; /* Output mode flags */ gComPortContext.nIoConfig.c_lflag = 0; /* Local mode flags. Read mode : non canonical, no echo */ gComPortContext.nIoConfig.c_cc[VTIME] = 0; /* Control characters. No inter-character timer */ gComPortContext.nIoConfig.c_cc[VMIN] = 1; /* Control characters. Read is blocking until X characters are read */ /* TCSANOW Make changes now without waiting for data to complete TCSADRAIN Wait until everything has been transmitted TCSAFLUSH Flush input and output buffers and make the change */ ret = tcsetattr(gComPortContext.nHandle, TCSANOW, &gComPortContext.nIoConfig); DAL_ASSERT_STR(ret != -1, "tcsetattr failed"); /* On linux the DTR signal is set by default. That causes a problem for pn544 chip because this signal is connected to "reset". So we clear it. (on windows it is cleared by default). */ ret = ioctl(gComPortContext.nHandle, TIOCMGET, &nComStatus); DAL_ASSERT_STR(ret != -1, "ioctl TIOCMGET failed"); nComStatus &= ~TIOCM_DTR; ret = ioctl(gComPortContext.nHandle, TIOCMSET, &nComStatus); DAL_ASSERT_STR(ret != -1, "ioctl TIOCMSET failed"); DAL_DEBUG("Com port status=%d\n", nComStatus); usleep(10000); /* Mandatory sleep so that the DTR line is ready before continuing */ return nfcret; }
//--------------------------------------------------------------------------- void OpenComms(void) { #if ( LIN == 1 ) speed_t BAUD; #endif const char *device = CommPortString.c_str(); fd = open(device, O_RDWR | O_NOCTTY | O_NDELAY); if (fd == -1) { LoggingFile.mLogFile << "failed to open port:" << endl; ShowMessage(device); CloseComms(); return; } if (!isatty(fd)) { LoggingFile.mLogFile << "not a tty:" << endl; ShowMessage(device); CloseComms(); return; } if (tcgetattr(fd, &config) < 0) { LoggingFile.mLogFile << "failed to get port info" << endl; CloseComms(); return; } // // Input flags - Turn off input processing // convert break to null byte, no CR to NL translation, // no NL to CR translation, don't mark parity errors or breaks // no input parity check, don't strip high bit off, // no XON/XOFF software flow control // config.c_iflag &= ~(IGNBRK | BRKINT | ICRNL | INLCR | PARMRK | INPCK | ISTRIP | IXON); // // Output flags - Turn off output processing // no CR to NL translation, no NL to CR-NL translation, // no NL to CR translation, no column 0 CR suppression, // no Ctrl-D suppression, no fill characters, no case mapping, // no local output processing // // config.c_oflag &= ~(OCRNL | ONLCR | ONLRET | // ONOCR | ONOEOT| OFILL | OLCUC | OPOST); config.c_oflag = 0; // // No line processing: // echo off, echo newline off, canonical mode off, // extended input processing off, signal chars off // config.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN | ISIG); // // Turn off character processing // clear current char size mask, no parity checking, // no output processing, force 8 bit input // config.c_cflag &= ~(CSIZE | PARENB | CSTOPB); config.c_cflag |= CS8; // // One input byte is enough to return from read() // Inter-character timer off // config.c_cc[VMIN] = 1; config.c_cc[VTIME] = 0; // // Communication speed (simple version, using the predefined // constants) // #if ( LIN == 1 ) switch (CommPortSpeed) { case 1152000: BAUD = 1152000; break; case 1000000: BAUD = 1000000; break; case 921600: BAUD = 921600; break; case 576000: BAUD = 576000; break; case 500000: BAUD = 500000; break; case 460800: BAUD = 460800; break; case 230400: BAUD = B230400; break; case 115200: BAUD = B115200; break; case 57600: BAUD = B57600; break; case 38400: BAUD = B38400; break; case 19200: BAUD = B19200; break; case 9600: BAUD = B9600; break; case 4800: BAUD = B4800; break; case 2400: BAUD = B2400; break; case 1800: BAUD = B1800; break; case 1200: BAUD = B1200; break; case 600: BAUD = B600; break; case 300: BAUD = B300; break; case 200: BAUD = B200; break; case 150: BAUD = B150; break; case 134: BAUD = B134; break; case 110: BAUD = B110; break; case 75: BAUD = B75; break; case 50: BAUD = B50; break; default: BAUD = B19200; break; } //end of switch CommPortSpeed if (cfsetispeed(&config, BAUD) < 0 || cfsetospeed(&config, BAUD) < 0) { #else if (cfsetispeed(&config, CommPortSpeed) < 0 || cfsetospeed(&config, CommPortSpeed) < 0) { #endif LoggingFile.mLogFile << "failed to set port speed" << endl; CloseComms(); return; } // // Finally, apply the configuration // if (tcsetattr(fd, TCSAFLUSH, &config) < 0) { LoggingFile.mLogFile << "failed to configure port" << endl; CloseComms(); return; } LoggingFile.mLogFile << "Opened port " << device << endl; } //--------------------------------------------------------------------------- void CloseComms(void) { if (fd != -1) { close(fd); fd = -1; LoggingFile.mLogFile << "Closed port" << endl; } } //--------------------------------------------------------------------------- void SendToComPort(unsigned long ResponseLength, unsigned char *Buffer) { if (fd != -1) { int written = write(fd, Buffer, ResponseLength); if (written != ResponseLength) { LoggingFile.mLogFile << "serial write failed (" << ResponseLength << ", " << written << ")" << endl; } } } //--------------------------------------------------------------------------- void ReceiveFromComPort(void) { unsigned long dwBytesTransferred = 0; char Byte = 0x00; if (fd != -1) { // Loop for waiting for the data. while (read(fd, &Byte, 1) == 1) { HandleMsgByte(Byte); } } }
static void restore(void) { tcsetattr(STDIN_FILENO, TCSANOW, &term); }
void disable_raw() { /* Don't even check the return value as it's too late. */ if (rawmode && tcsetattr(STDIN_FILENO,TCSAFLUSH,&orig_termios) != -1) rawmode = 0; }
int16 XSERDPort::open(uint16 config) { // Don't open NULL name devices if (device_name == NULL) return openErr; // Init variables io_killed = false; quitting = false; // Open port, according to the syntax of the path if (device_name[0] == '|') { // Open a process via ptys if (!open_pty()) goto open_error; } else if (!strcmp(device_name, "midi")) { // MIDI: not yet implemented return openErr; } else { // Device special file fd = ::open(device_name, O_RDWR); if (fd < 0) goto open_error; #if defined(__linux__) // Parallel port? struct stat st; if (fstat(fd, &st) == 0) if (S_ISCHR(st.st_mode)) protocol = ((MAJOR(st.st_rdev) == LP_MAJOR) ? parallel : serial); #elif defined(__FreeBSD__) || defined(__NetBSD__) // Parallel port? struct stat st; if (fstat(fd, &st) == 0) if (S_ISCHR(st.st_mode)) protocol = (((st.st_rdev >> 16) == 16) ? parallel : serial); #endif } // Configure port for raw mode if (protocol == serial || protocol == pty) { if (tcgetattr(fd, &mode) < 0) goto open_error; cfmakeraw(&mode); mode.c_cflag |= HUPCL; mode.c_cc[VMIN] = 1; mode.c_cc[VTIME] = 0; tcsetattr(fd, TCSAFLUSH, &mode); } configure(config); // Start input/output threads input_thread_cancel = false; output_thread_cancel = false; if (sem_init(&input_signal, 0, 0) < 0) goto open_error; if (sem_init(&output_signal, 0, 0) < 0) goto open_error; input_thread_active = (pthread_create(&input_thread, &thread_attr, input_func, this) == 0); output_thread_active = (pthread_create(&output_thread, &thread_attr, output_func, this) == 0); if (!input_thread_active || !output_thread_active) goto open_error; return noErr; open_error: if (input_thread_active) { input_thread_cancel = true; #ifdef HAVE_PTHREAD_CANCEL pthread_cancel(input_thread); #endif pthread_join(input_thread, NULL); sem_destroy(&input_signal); input_thread_active = false; } if (output_thread_active) { output_thread_cancel = true; #ifdef HAVE_PTHREAD_CANCEL pthread_cancel(output_thread); #endif pthread_join(output_thread, NULL); sem_destroy(&output_signal); output_thread_active = false; } if (fd > 0) { ::close(fd); fd = -1; } return openErr; }
void TurtlebotTeleop::keyLoop() { char c; // get the console in raw mode tcgetattr(kfd, &cooked); memcpy(&raw, &cooked, sizeof(struct termios)); raw.c_lflag &=~ (ICANON | ECHO); // Setting a new line, then end of file raw.c_cc[VEOL] = 1; raw.c_cc[VEOF] = 2; tcsetattr(kfd, TCSANOW, &raw); puts("Reading from keyboard"); puts("---------------------------"); puts("Use arrow keys to move the turtlebot."); while (ros::ok()) { // get the next event from the keyboard if(read(kfd, &c, 1) < 0) { perror("read():"); exit(-1); } linear_=angular_=0; ROS_DEBUG("value: 0x%02X\n", c); switch(c) { case KEYCODE_L: ROS_DEBUG("LEFT"); angular_ = 1.0; break; case KEYCODE_R: ROS_DEBUG("RIGHT"); angular_ = -1.0; break; case KEYCODE_U: ROS_DEBUG("UP"); linear_ = 0.5; break; case KEYCODE_D: ROS_DEBUG("DOWN"); linear_ = -0.5; break; case KEYCODE_Q: ROS_DEBUG("QUIT"); linear_ = 0.0; angular_ = 0.0; break; } boost::mutex::scoped_lock lock(publish_mutex_); if (ros::Time::now() > last_publish_ + ros::Duration(1.0)) { first_publish_ = ros::Time::now(); } last_publish_ = ros::Time::now(); publish(angular_, linear_); if(c==KEYCODE_Q) quit(SIGINT); } return; }
void quit(int sig) { tcsetattr(kfd, TCSANOW, &cooked); ros::shutdown(); exit(0); }
/*! Sets the baud rate of the serial port. Note that not all rates are applicable on all platforms. The following table shows translations of the various baud rate constants on Windows(including NT/2000) and POSIX platforms. Speeds marked with an * are speeds that are usable on both Windows and POSIX. \note BAUD76800 may not be supported on all POSIX systems. SGI/IRIX systems do not support BAUD1800. \verbatim RATE Windows Speed POSIX Speed ----------- ------------- ----------- BAUD50 110 50 BAUD75 110 75 *BAUD110 110 110 BAUD134 110 134.5 BAUD150 110 150 BAUD200 110 200 *BAUD300 300 300 *BAUD600 600 600 *BAUD1200 1200 1200 BAUD1800 1200 1800 *BAUD2400 2400 2400 *BAUD4800 4800 4800 *BAUD9600 9600 9600 BAUD14400 14400 9600 *BAUD19200 19200 19200 *BAUD38400 38400 38400 BAUD56000 56000 38400 *BAUD57600 57600 57600 BAUD76800 57600 76800 *BAUD115200 115200 115200 BAUD128000 128000 115200 BAUD256000 256000 115200 \endverbatim */ void QextSerialPort::setBaudRate(BaudRateType baudRate) { QMutexLocker lock(mutex); if (Settings.BaudRate!=baudRate) { switch (baudRate) { case BAUD14400: Settings.BaudRate=BAUD9600; break; case BAUD56000: Settings.BaudRate=BAUD38400; break; case BAUD76800: #ifndef B76800 Settings.BaudRate=BAUD57600; #else Settings.BaudRate=baudRate; #endif break; case BAUD128000: case BAUD256000: Settings.BaudRate=BAUD115200; break; default: Settings.BaudRate=baudRate; break; } } if (isOpen()) { switch (baudRate) { /*50 baud*/ case BAUD50: TTY_PORTABILITY_WARNING("QextSerialPort Portability Warning: Windows does not support 50 baud operation."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B50; #else cfsetispeed(&Posix_CommConfig, B50); cfsetospeed(&Posix_CommConfig, B50); #endif break; /*75 baud*/ case BAUD75: TTY_PORTABILITY_WARNING("QextSerialPort Portability Warning: Windows does not support 75 baud operation."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B75; #else cfsetispeed(&Posix_CommConfig, B75); cfsetospeed(&Posix_CommConfig, B75); #endif break; /*110 baud*/ case BAUD110: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B110; #else cfsetispeed(&Posix_CommConfig, B110); cfsetospeed(&Posix_CommConfig, B110); #endif break; /*134.5 baud*/ case BAUD134: TTY_PORTABILITY_WARNING("QextSerialPort Portability Warning: Windows does not support 134.5 baud operation."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B134; #else cfsetispeed(&Posix_CommConfig, B134); cfsetospeed(&Posix_CommConfig, B134); #endif break; /*150 baud*/ case BAUD150: TTY_PORTABILITY_WARNING("QextSerialPort Portability Warning: Windows does not support 150 baud operation."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B150; #else cfsetispeed(&Posix_CommConfig, B150); cfsetospeed(&Posix_CommConfig, B150); #endif break; /*200 baud*/ case BAUD200: TTY_PORTABILITY_WARNING("QextSerialPort Portability Warning: Windows does not support 200 baud operation."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B200; #else cfsetispeed(&Posix_CommConfig, B200); cfsetospeed(&Posix_CommConfig, B200); #endif break; /*300 baud*/ case BAUD300: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B300; #else cfsetispeed(&Posix_CommConfig, B300); cfsetospeed(&Posix_CommConfig, B300); #endif break; /*600 baud*/ case BAUD600: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B600; #else cfsetispeed(&Posix_CommConfig, B600); cfsetospeed(&Posix_CommConfig, B600); #endif break; /*1200 baud*/ case BAUD1200: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B1200; #else cfsetispeed(&Posix_CommConfig, B1200); cfsetospeed(&Posix_CommConfig, B1200); #endif break; /*1800 baud*/ case BAUD1800: TTY_PORTABILITY_WARNING("QextSerialPort Portability Warning: Windows and IRIX do not support 1800 baud operation."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B1800; #else cfsetispeed(&Posix_CommConfig, B1800); cfsetospeed(&Posix_CommConfig, B1800); #endif break; /*2400 baud*/ case BAUD2400: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B2400; #else cfsetispeed(&Posix_CommConfig, B2400); cfsetospeed(&Posix_CommConfig, B2400); #endif break; /*4800 baud*/ case BAUD4800: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B4800; #else cfsetispeed(&Posix_CommConfig, B4800); cfsetospeed(&Posix_CommConfig, B4800); #endif break; /*9600 baud*/ case BAUD9600: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B9600; #else cfsetispeed(&Posix_CommConfig, B9600); cfsetospeed(&Posix_CommConfig, B9600); #endif break; /*14400 baud*/ case BAUD14400: TTY_WARNING("QextSerialPort: POSIX does not support 14400 baud operation. Switching to 9600 baud."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B9600; #else cfsetispeed(&Posix_CommConfig, B9600); cfsetospeed(&Posix_CommConfig, B9600); #endif break; /*19200 baud*/ case BAUD19200: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B19200; #else cfsetispeed(&Posix_CommConfig, B19200); cfsetospeed(&Posix_CommConfig, B19200); #endif break; /*38400 baud*/ case BAUD38400: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B38400; #else cfsetispeed(&Posix_CommConfig, B38400); cfsetospeed(&Posix_CommConfig, B38400); #endif break; /*56000 baud*/ case BAUD56000: TTY_WARNING("QextSerialPort: POSIX does not support 56000 baud operation. Switching to 38400 baud."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B38400; #else cfsetispeed(&Posix_CommConfig, B38400); cfsetospeed(&Posix_CommConfig, B38400); #endif break; /*57600 baud*/ case BAUD57600: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B57600; #else cfsetispeed(&Posix_CommConfig, B57600); cfsetospeed(&Posix_CommConfig, B57600); #endif break; /*76800 baud*/ case BAUD76800: TTY_PORTABILITY_WARNING("QextSerialPort Portability Warning: Windows and some POSIX systems do not support 76800 baud operation."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); #ifdef B76800 Posix_CommConfig.c_cflag|=B76800; #else TTY_WARNING("QextSerialPort: QextSerialPort was compiled without 76800 baud support. Switching to 57600 baud."); Posix_CommConfig.c_cflag|=B57600; #endif //B76800 #else //CBAUD #ifdef B76800 cfsetispeed(&Posix_CommConfig, B76800); cfsetospeed(&Posix_CommConfig, B76800); #else TTY_WARNING("QextSerialPort: QextSerialPort was compiled without 76800 baud support. Switching to 57600 baud."); cfsetispeed(&Posix_CommConfig, B57600); cfsetospeed(&Posix_CommConfig, B57600); #endif //B76800 #endif //CBAUD break; /*115200 baud*/ case BAUD115200: #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B115200; #else cfsetispeed(&Posix_CommConfig, B115200); cfsetospeed(&Posix_CommConfig, B115200); #endif break; /*128000 baud*/ case BAUD128000: TTY_WARNING("QextSerialPort: POSIX does not support 128000 baud operation. Switching to 115200 baud."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B115200; #else cfsetispeed(&Posix_CommConfig, B115200); cfsetospeed(&Posix_CommConfig, B115200); #endif break; /*256000 baud*/ case BAUD256000: TTY_WARNING("QextSerialPort: POSIX does not support 256000 baud operation. Switching to 115200 baud."); #ifdef CBAUD Posix_CommConfig.c_cflag&=(~CBAUD); Posix_CommConfig.c_cflag|=B115200; #else cfsetispeed(&Posix_CommConfig, B115200); cfsetospeed(&Posix_CommConfig, B115200); #endif break; } tcsetattr(fd, TCSAFLUSH, &Posix_CommConfig); } }
/*! Sets the parity associated with the serial port. The possible values of parity are: \verbatim PAR_SPACE Space Parity PAR_MARK Mark Parity PAR_NONE No Parity PAR_EVEN Even Parity PAR_ODD Odd Parity \endverbatim \note This function is subject to the following limitations: \par POSIX systems do not support mark parity. \par POSIX systems support space parity only if tricked into doing so, and only with fewer than 8 data bits. Use space parity very carefully with POSIX systems. */ void QextSerialPort::setParity(ParityType parity) { QMutexLocker lock(mutex); if (Settings.Parity!=parity) { if (parity==PAR_MARK || (parity==PAR_SPACE && Settings.DataBits==DATA_8)) { } else { Settings.Parity=parity; } } if (isOpen()) { switch (parity) { /*space parity*/ case PAR_SPACE: if (Settings.DataBits==DATA_8) { TTY_PORTABILITY_WARNING("QextSerialPort: Space parity is only supported in POSIX with 7 or fewer data bits"); } else { /*space parity not directly supported - add an extra data bit to simulate it*/ Posix_CommConfig.c_cflag&=~(PARENB|CSIZE); switch(Settings.DataBits) { case DATA_5: Settings.DataBits=DATA_6; Posix_CommConfig.c_cflag|=CS6; break; case DATA_6: Settings.DataBits=DATA_7; Posix_CommConfig.c_cflag|=CS7; break; case DATA_7: Settings.DataBits=DATA_8; Posix_CommConfig.c_cflag|=CS8; break; case DATA_8: break; } tcsetattr(fd, TCSAFLUSH, &Posix_CommConfig); } break; /*mark parity - WINDOWS ONLY*/ case PAR_MARK: TTY_WARNING("QextSerialPort: Mark parity is not supported by POSIX."); break; /*no parity*/ case PAR_NONE: Posix_CommConfig.c_cflag&=(~PARENB); tcsetattr(fd, TCSAFLUSH, &Posix_CommConfig); break; /*even parity*/ case PAR_EVEN: Posix_CommConfig.c_cflag&=(~PARODD); Posix_CommConfig.c_cflag|=PARENB; tcsetattr(fd, TCSAFLUSH, &Posix_CommConfig); break; /*odd parity*/ case PAR_ODD: Posix_CommConfig.c_cflag|=(PARENB|PARODD); tcsetattr(fd, TCSAFLUSH, &Posix_CommConfig); break; } } }
/*! Sets the number of data bits used by the serial port. Possible values of dataBits are: \verbatim DATA_5 5 data bits DATA_6 6 data bits DATA_7 7 data bits DATA_8 8 data bits \endverbatim \note This function is subject to the following restrictions: \par 5 data bits cannot be used with 2 stop bits. \par 8 data bits cannot be used with space parity on POSIX systems. */ void QextSerialPort::setDataBits(DataBitsType dataBits) { QMutexLocker lock(mutex); if (Settings.DataBits!=dataBits) { if ((Settings.StopBits==STOP_2 && dataBits==DATA_5) || (Settings.StopBits==STOP_1_5 && dataBits!=DATA_5) || (Settings.Parity==PAR_SPACE && dataBits==DATA_8)) { } else { Settings.DataBits=dataBits; } } if (isOpen()) { switch(dataBits) { /*5 data bits*/ case DATA_5: if (Settings.StopBits==STOP_2) { TTY_WARNING("QextSerialPort: 5 Data bits cannot be used with 2 stop bits."); } else { Settings.DataBits=dataBits; Posix_CommConfig.c_cflag&=(~CSIZE); Posix_CommConfig.c_cflag|=CS5; tcsetattr(fd, TCSAFLUSH, &Posix_CommConfig); } break; /*6 data bits*/ case DATA_6: if (Settings.StopBits==STOP_1_5) { TTY_WARNING("QextSerialPort: 6 Data bits cannot be used with 1.5 stop bits."); } else { Settings.DataBits=dataBits; Posix_CommConfig.c_cflag&=(~CSIZE); Posix_CommConfig.c_cflag|=CS6; tcsetattr(fd, TCSAFLUSH, &Posix_CommConfig); } break; /*7 data bits*/ case DATA_7: if (Settings.StopBits==STOP_1_5) { TTY_WARNING("QextSerialPort: 7 Data bits cannot be used with 1.5 stop bits."); } else { Settings.DataBits=dataBits; Posix_CommConfig.c_cflag&=(~CSIZE); Posix_CommConfig.c_cflag|=CS7; tcsetattr(fd, TCSAFLUSH, &Posix_CommConfig); } break; /*8 data bits*/ case DATA_8: if (Settings.StopBits==STOP_1_5) { TTY_WARNING("QextSerialPort: 8 Data bits cannot be used with 1.5 stop bits."); } else { Settings.DataBits=dataBits; Posix_CommConfig.c_cflag&=(~CSIZE); Posix_CommConfig.c_cflag|=CS8; tcsetattr(fd, TCSAFLUSH, &Posix_CommConfig); } break; } } }
static void /* Reset terminal mode on program exit */ ttyReset(void) { if (tcsetattr(STDIN_FILENO, TCSANOW, &ttyOrig) == -1) errExit("tcsetattr"); }
int16 XSERDPort::control(uint32 pb, uint32 dce, uint16 code) { switch (code) { case 1: // KillIO io_killed = true; if (protocol == serial) tcflush(fd, TCIOFLUSH); while (read_pending || write_pending) usleep(10000); io_killed = false; return noErr; case kSERDConfiguration: if (configure(ReadMacInt16(pb + csParam))) return noErr; else return paramErr; case kSERDInputBuffer: return noErr; // Not supported under Unix case kSERDSerHShake: set_handshake(pb + csParam, false); return noErr; case kSERDSetBreak: if (protocol == serial) tcsendbreak(fd, 0); return noErr; case kSERDClearBreak: return noErr; case kSERDBaudRate: { if (protocol != serial) return noErr; uint16 rate = ReadMacInt16(pb + csParam); speed_t baud_rate; if (rate <= 50) { rate = 50; baud_rate = B50; } else if (rate <= 75) { rate = 75; baud_rate = B75; } else if (rate <= 110) { rate = 110; baud_rate = B110; } else if (rate <= 134) { rate = 134; baud_rate = B134; } else if (rate <= 150) { rate = 150; baud_rate = B150; } else if (rate <= 200) { rate = 200; baud_rate = B200; } else if (rate <= 300) { rate = 300; baud_rate = B300; } else if (rate <= 600) { rate = 600; baud_rate = B600; } else if (rate <= 1200) { rate = 1200; baud_rate = B1200; } else if (rate <= 1800) { rate = 1800; baud_rate = B1800; } else if (rate <= 2400) { rate = 2400; baud_rate = B2400; } else if (rate <= 4800) { rate = 4800; baud_rate = B4800; } else if (rate <= 9600) { rate = 9600; baud_rate = B9600; } else if (rate <= 19200) { rate = 19200; baud_rate = B19200; } else if (rate <= 38400) { rate = 38400; baud_rate = B38400; } else if (rate <= 57600) { rate = 57600; baud_rate = B57600; } else { // Just for safety in case someone wants a rate between 57600 and 65535 rate = 57600; baud_rate = B57600; } WriteMacInt16(pb + csParam, rate); cfsetispeed(&mode, baud_rate); cfsetospeed(&mode, baud_rate); tcsetattr(fd, TCSANOW, &mode); return noErr; } case kSERDHandshake: case kSERDHandshakeRS232: set_handshake(pb + csParam, true); return noErr; case kSERDMiscOptions: if (protocol != serial) return noErr; if (ReadMacInt8(pb + csParam) & kOptionPreserveDTR) mode.c_cflag &= ~HUPCL; else mode.c_cflag |= HUPCL; tcsetattr(fd, TCSANOW, &mode); return noErr; case kSERDAssertDTR: { if (protocol != serial) return noErr; unsigned int status = TIOCM_DTR; ioctl(fd, TIOCMBIS, &status); return noErr; } case kSERDNegateDTR: { if (protocol != serial) return noErr; unsigned int status = TIOCM_DTR; ioctl(fd, TIOCMBIC, &status); return noErr; } case kSERDSetPEChar: case kSERDSetPEAltChar: return noErr; // Not supported under Unix case kSERDResetChannel: if (protocol == serial) tcflush(fd, TCIOFLUSH); return noErr; case kSERDAssertRTS: { if (protocol != serial) return noErr; unsigned int status = TIOCM_RTS; ioctl(fd, TIOCMBIS, &status); return noErr; } case kSERDNegateRTS: { if (protocol != serial) return noErr; unsigned int status = TIOCM_RTS; ioctl(fd, TIOCMBIC, &status); return noErr; } case kSERD115KBaud: if (protocol != serial) return noErr; cfsetispeed(&mode, B115200); cfsetospeed(&mode, B115200); tcsetattr(fd, TCSANOW, &mode); return noErr; case kSERD230KBaud: case kSERDSetHighSpeed: if (protocol != serial) return noErr; cfsetispeed(&mode, B230400); cfsetospeed(&mode, B230400); tcsetattr(fd, TCSANOW, &mode); return noErr; default: printf("WARNING: SerialControl(): unimplemented control code %d\n", code); return controlErr; } }
int pty_allocate(int *ptyfd, int *ttyfd, char *namebuf, int namebuflen) { #if defined(HAVE_OPENPTY) || defined(BSD4_4) /* openpty(3) exists in OSF/1 and some other os'es */ char *name; int i; i = openpty(ptyfd, ttyfd, NULL, NULL, NULL); if (i < 0) { error("openpty: %.100s", strerror(errno)); return 0; } name = ttyname(*ttyfd); if (!name) fatal("openpty returns device for which ttyname fails."); strlcpy(namebuf, name, namebuflen); /* possible truncation */ return 1; #else /* HAVE_OPENPTY */ #ifdef HAVE__GETPTY /* * _getpty(3) exists in SGI Irix 4.x, 5.x & 6.x -- it generates more * pty's automagically when needed */ char *slave; slave = _getpty(ptyfd, O_RDWR, 0622, 0); if (slave == NULL) { error("_getpty: %.100s", strerror(errno)); return 0; } strlcpy(namebuf, slave, namebuflen); /* Open the slave side. */ *ttyfd = open(namebuf, O_RDWR | O_NOCTTY); if (*ttyfd < 0) { error("%.200s: %.100s", namebuf, strerror(errno)); close(*ptyfd); return 0; } return 1; #else /* HAVE__GETPTY */ #if defined(HAVE_DEV_PTMX) /* * This code is used e.g. on Solaris 2.x. (Note that Solaris 2.3 * also has bsd-style ptys, but they simply do not work.) */ int ptm; char *pts; mysig_t old_signal; ptm = open("/dev/ptmx", O_RDWR | O_NOCTTY); if (ptm < 0) { error("/dev/ptmx: %.100s", strerror(errno)); return 0; } old_signal = mysignal(SIGCHLD, SIG_DFL); if (grantpt(ptm) < 0) { error("grantpt: %.100s", strerror(errno)); return 0; } mysignal(SIGCHLD, old_signal); if (unlockpt(ptm) < 0) { error("unlockpt: %.100s", strerror(errno)); return 0; } pts = ptsname(ptm); if (pts == NULL) error("Slave pty side name could not be obtained."); strlcpy(namebuf, pts, namebuflen); *ptyfd = ptm; /* Open the slave side. */ *ttyfd = open(namebuf, O_RDWR | O_NOCTTY); if (*ttyfd < 0) { error("%.100s: %.100s", namebuf, strerror(errno)); close(*ptyfd); return 0; } #ifndef HAVE_CYGWIN /* * Push the appropriate streams modules, as described in Solaris pts(7). * HP-UX pts(7) doesn't have ttcompat module. */ if (ioctl(*ttyfd, I_PUSH, "ptem") < 0) error("ioctl I_PUSH ptem: %.100s", strerror(errno)); if (ioctl(*ttyfd, I_PUSH, "ldterm") < 0) error("ioctl I_PUSH ldterm: %.100s", strerror(errno)); #ifndef __hpux if (ioctl(*ttyfd, I_PUSH, "ttcompat") < 0) error("ioctl I_PUSH ttcompat: %.100s", strerror(errno)); #endif #endif return 1; #else /* HAVE_DEV_PTMX */ #ifdef HAVE_DEV_PTS_AND_PTC /* AIX-style pty code. */ const char *name; *ptyfd = open("/dev/ptc", O_RDWR | O_NOCTTY); if (*ptyfd < 0) { error("Could not open /dev/ptc: %.100s", strerror(errno)); return 0; } name = ttyname(*ptyfd); if (!name) fatal("Open of /dev/ptc returns device for which ttyname fails."); strlcpy(namebuf, name, namebuflen); *ttyfd = open(name, O_RDWR | O_NOCTTY); if (*ttyfd < 0) { error("Could not open pty slave side %.100s: %.100s", name, strerror(errno)); close(*ptyfd); return 0; } return 1; #else /* HAVE_DEV_PTS_AND_PTC */ #ifdef _UNICOS char buf[64]; int i; int highpty; #ifdef _SC_CRAY_NPTY highpty = sysconf(_SC_CRAY_NPTY); if (highpty == -1) highpty = 128; #else highpty = 128; #endif for (i = 0; i < highpty; i++) { snprintf(buf, sizeof(buf), "/dev/pty/%03d", i); *ptyfd = open(buf, O_RDWR|O_NOCTTY); if (*ptyfd < 0) continue; snprintf(namebuf, namebuflen, "/dev/ttyp%03d", i); /* Open the slave side. */ *ttyfd = open(namebuf, O_RDWR|O_NOCTTY); if (*ttyfd < 0) { error("%.100s: %.100s", namebuf, strerror(errno)); close(*ptyfd); return 0; } return 1; } return 0; #else /* BSD-style pty code. */ char buf[64]; int i; const char *ptymajors = "pqrstuvwxyzabcdefghijklmnoABCDEFGHIJKLMNOPQRSTUVWXYZ"; const char *ptyminors = "0123456789abcdef"; int num_minors = strlen(ptyminors); int num_ptys = strlen(ptymajors) * num_minors; struct termios tio; for (i = 0; i < num_ptys; i++) { snprintf(buf, sizeof buf, "/dev/pty%c%c", ptymajors[i / num_minors], ptyminors[i % num_minors]); snprintf(namebuf, namebuflen, "/dev/tty%c%c", ptymajors[i / num_minors], ptyminors[i % num_minors]); *ptyfd = open(buf, O_RDWR | O_NOCTTY); if (*ptyfd < 0) { /* Try SCO style naming */ snprintf(buf, sizeof buf, "/dev/ptyp%d", i); snprintf(namebuf, namebuflen, "/dev/ttyp%d", i); *ptyfd = open(buf, O_RDWR | O_NOCTTY); if (*ptyfd < 0) continue; } /* Open the slave side. */ *ttyfd = open(namebuf, O_RDWR | O_NOCTTY); if (*ttyfd < 0) { error("%.100s: %.100s", namebuf, strerror(errno)); close(*ptyfd); return 0; } /* set tty modes to a sane state for broken clients */ if (tcgetattr(*ptyfd, &tio) < 0) log("Getting tty modes for pty failed: %.100s", strerror(errno)); else { tio.c_lflag |= (ECHO | ISIG | ICANON); tio.c_oflag |= (OPOST | ONLCR); tio.c_iflag |= ICRNL; /* Set the new modes for the terminal. */ if (tcsetattr(*ptyfd, TCSANOW, &tio) < 0) log("Setting tty modes for pty failed: %.100s", strerror(errno)); } return 1; } return 0; #endif /* CRAY */ #endif /* HAVE_DEV_PTS_AND_PTC */ #endif /* HAVE_DEV_PTMX */ #endif /* HAVE__GETPTY */ #endif /* HAVE_OPENPTY */ }
bool XSERDPort::configure(uint16 config) { D(bug(" configure %04x\n", config)); if (protocol != serial) return true; // Set number of stop bits switch (config & 0xc000) { case stop10: mode.c_cflag &= ~CSTOPB; break; case stop20: mode.c_cflag |= CSTOPB; break; default: return false; } // Set parity mode switch (config & 0x3000) { case noParity: mode.c_iflag &= ~INPCK; mode.c_oflag &= ~PARENB; break; case oddParity: mode.c_iflag |= INPCK; mode.c_oflag |= PARENB; mode.c_oflag |= PARODD; break; case evenParity: mode.c_iflag |= INPCK; mode.c_oflag |= PARENB; mode.c_oflag &= ~PARODD; break; default: return false; } // Set number of data bits switch (config & 0x0c00) { case data5: mode.c_cflag = mode.c_cflag & ~CSIZE | CS5; break; case data6: mode.c_cflag = mode.c_cflag & ~CSIZE | CS6; break; case data7: mode.c_cflag = mode.c_cflag & ~CSIZE | CS7; break; case data8: mode.c_cflag = mode.c_cflag & ~CSIZE | CS8; break; } // Set baud rate speed_t baud_rate; switch (config & 0x03ff) { case baud150: baud_rate = B150; break; case baud300: baud_rate = B300; break; case baud600: baud_rate = B600; break; case baud1200: baud_rate = B1200; break; case baud1800: baud_rate = B1800; break; case baud2400: baud_rate = B2400; break; case baud4800: baud_rate = B4800; break; case baud9600: baud_rate = B9600; break; case baud19200: baud_rate = B19200; break; case baud38400: baud_rate = B38400; break; case baud57600: baud_rate = B57600; break; default: return false; } cfsetispeed(&mode, baud_rate); cfsetospeed(&mode, baud_rate); tcsetattr(fd, TCSANOW, &mode); return true; }
int main(int argc, char *argv[]) { int o; unsigned short old_rows; struct slab_info *slab_list = NULL; int run_once = 0, retval = EXIT_SUCCESS; static const struct option longopts[] = { { "delay", required_argument, NULL, 'd' }, { "sort", required_argument, NULL, 's' }, { "once", no_argument, NULL, 'o' }, { "help", no_argument, NULL, 'h' }, { "version", no_argument, NULL, 'V' }, { NULL, 0, NULL, 0 } }; #ifdef HAVE_PROGRAM_INVOCATION_NAME program_invocation_name = program_invocation_short_name; #endif setlocale (LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); atexit(close_stdout); sort_func = DEF_SORT_FUNC; while ((o = getopt_long(argc, argv, "d:s:ohV", longopts, NULL)) != -1) { switch (o) { case 'd': errno = 0; delay = strtol_or_err(optarg, _("illegal delay")); if (delay < 1) xerrx(EXIT_FAILURE, _("delay must be positive integer")); break; case 's': sort_func = (int (*)(const struct slab_info*, const struct slab_info *)) set_sort_func(optarg[0]); break; case 'o': run_once=1; delay = 0; break; case 'V': printf(PROCPS_NG_VERSION); return EXIT_SUCCESS; case 'h': usage(stdout); default: usage(stderr); } } if (tcgetattr(STDIN_FILENO, &saved_tty) == -1) xwarn(_("terminal setting retrieval")); old_rows = rows; term_size(0); if (!run_once) { initscr(); resizeterm(rows, cols); signal(SIGWINCH, term_size); } signal(SIGINT, sigint_handler); do { struct slab_info *curr; struct slab_stat stats; struct timeval tv; fd_set readfds; char c; int i; memset(&stats, 0, sizeof(struct slab_stat)); if (get_slabinfo(&slab_list, &stats)) { retval = EXIT_FAILURE; break; } if (!run_once && old_rows != rows) { resizeterm(rows, cols); old_rows = rows; } move(0, 0); print_line(" %-35s: %d / %d (%.1f%%)\n" " %-35s: %d / %d (%.1f%%)\n" " %-35s: %d / %d (%.1f%%)\n" " %-35s: %.2fK / %.2fK (%.1f%%)\n" " %-35s: %.2fK / %.2fK / %.2fK\n\n", /* Translation Hint: Next five strings must not * exceed 35 length in characters. */ /* xgettext:no-c-format */ _("Active / Total Objects (% used)"), stats.nr_active_objs, stats.nr_objs, 100.0 * stats.nr_active_objs / stats.nr_objs, /* xgettext:no-c-format */ _("Active / Total Slabs (% used)"), stats.nr_active_slabs, stats.nr_slabs, 100.0 * stats.nr_active_slabs / stats.nr_slabs, /* xgettext:no-c-format */ _("Active / Total Caches (% used)"), stats.nr_active_caches, stats.nr_caches, 100.0 * stats.nr_active_caches / stats.nr_caches, /* xgettext:no-c-format */ _("Active / Total Size (% used)"), stats.active_size / 1024.0, stats.total_size / 1024.0, 100.0 * stats.active_size / stats.total_size, _("Minimum / Average / Maximum Object"), stats.min_obj_size / 1024.0, stats.avg_obj_size / 1024.0, stats.max_obj_size / 1024.0); slab_list = slabsort(slab_list); attron(A_REVERSE); /* Translation Hint: Please keep alignment of the * following intact. */ print_line("%-78s\n", _(" OBJS ACTIVE USE OBJ SIZE SLABS OBJ/SLAB CACHE SIZE NAME")); attroff(A_REVERSE); curr = slab_list; for (i = 0; i < rows - 8 && curr->next; i++) { print_line("%6u %6u %3u%% %7.2fK %6u %8u %9uK %-23s\n", curr->nr_objs, curr->nr_active_objs, curr->use, curr->obj_size / 1024.0, curr->nr_slabs, curr->objs_per_slab, (unsigned)(curr->cache_size / 1024), curr->name); curr = curr->next; } put_slabinfo(slab_list); if (!run_once) { refresh(); FD_ZERO(&readfds); FD_SET(STDIN_FILENO, &readfds); tv.tv_sec = delay; tv.tv_usec = 0; if (select(STDOUT_FILENO, &readfds, NULL, NULL, &tv) > 0) { if (read(STDIN_FILENO, &c, 1) != 1) break; parse_input(c); } } } while (delay); tcsetattr(STDIN_FILENO, TCSAFLUSH, &saved_tty); free_slabinfo(slab_list); if (!run_once) endwin(); return retval; }
int openpty (int *amaster, int *aslave, char *name, struct termios const *termp, struct winsize const *winp) { int master; char *slave_name; int slave; # if HAVE__GETPTY /* IRIX */ slave_name = _getpty (&master, O_RDWR, 0622, 0); if (slave_name == NULL) return -1; # else /* AIX 5.1, HP-UX 11, Solaris 10, mingw */ # if HAVE_POSIX_OPENPT /* Solaris 10 */ master = posix_openpt (O_RDWR | O_NOCTTY); if (master < 0) return -1; # else /* AIX 5.1, HP-UX 11, Solaris 9, mingw */ # ifdef _AIX /* AIX */ master = open ("/dev/ptc", O_RDWR | O_NOCTTY); if (master < 0) return -1; # else /* HP-UX 11, Solaris 9, mingw */ /* HP-UX, Solaris have /dev/ptmx. HP-UX also has /dev/ptym/clone, but this should not be needed. Linux also has /dev/ptmx, but Linux already has openpty(). MacOS X also has /dev/ptmx, but MacOS X already has openpty(). OSF/1 also has /dev/ptmx and /dev/ptmx_bsd, but OSF/1 already has openpty(). */ master = open ("/dev/ptmx", O_RDWR | O_NOCTTY); if (master < 0) return -1; # endif # endif /* If all this does not work, we could try to open, one by one: - On MacOS X: /dev/pty[p-w][0-9a-f] - On *BSD: /dev/pty[p-sP-S][0-9a-v] - On AIX: /dev/ptyp[0-9a-f] - On HP-UX: /dev/pty[p-r][0-9a-f] - On OSF/1: /dev/pty[p-q][0-9a-f] - On Solaris: /dev/pty[p-r][0-9a-f] */ # endif /* This call does not require a dependency to the 'grantpt' module, because AIX, HP-UX, IRIX, Solaris all have the grantpt() function. */ if (grantpt (master)) goto fail; /* This call does not require a dependency to the 'unlockpt' module, because AIX, HP-UX, IRIX, Solaris all have the unlockpt() function. */ if (unlockpt (master)) goto fail; # if !HAVE__GETPTY /* !IRIX */ slave_name = ptsname (master); if (slave_name == NULL) goto fail; # endif slave = open (slave_name, O_RDWR | O_NOCTTY); if (slave == -1) goto fail; # if defined __sun || defined __hpux /* Solaris, HP-UX */ if (ioctl (slave, I_PUSH, "ptem") < 0 || ioctl (slave, I_PUSH, "ldterm") < 0 # if defined __sun || ioctl (slave, I_PUSH, "ttcompat") < 0 # endif ) { close (slave); goto fail; } # endif /* XXX Should we ignore errors here? */ if (termp) tcsetattr (slave, TCSAFLUSH, termp); if (winp) ioctl (slave, TIOCSWINSZ, winp); *amaster = master; *aslave = slave; if (name != NULL) strcpy (name, slave_name); return 0; fail: close (master); return -1; }
int main(int argc, char **argv) { int vfd, afd, c; int filefd; const char *videodev = "/dev/dvb/adapter0/video0"; const char *audiodev = "/dev/dvb/adapter0/audio0"; if (((tcgetpgrp(STDIN_FILENO) == getpid()) || (getppid() != (pid_t)1)) && (tcgetattr(STDIN_FILENO, &term) == 0)) { struct termios newterm; memcpy(&newterm, &term, sizeof(struct termios)); newterm.c_iflag = 0; newterm.c_lflag &= ~(ICANON | ECHO); newterm.c_cc[VMIN] = 0; newterm.c_cc[VTIME] = 0; atexit(restore); tcsetattr(STDIN_FILENO, TCSANOW, &newterm); } opterr = 0; while ((c = getopt(argc, argv, "+daA")) != -1) { switch (c) { case 'd': dolby++; break; case 'a': audio++; break; case 'A': audio++; black++; break; case '?': fprintf(stderr, "usage: test_av_play [-d] [-a] [-A] mpeg_A+V_PES_file\n"); return 1; default: break; } } argv += optind; argc -= optind; if (getenv("VIDEO")) videodev = getenv("VIDEO"); if (getenv("AUDIO")) audiodev = getenv("AUDIO"); printf("using video device '%s'\n", videodev); printf("using audio device '%s'\n", audiodev); putchar('\n'); printf("Freeze by pressing `z'\n"); printf("Stop by pressing `s'\n"); printf("Continue by pressing `c'\n"); printf("Start by pressing `p'\n"); printf("FastForward by pressing `f'\n"); printf("Mute by pressing `m'\n"); printf("UnMute by pressing `u'\n"); printf("MP2/AC3 by pressing `d'\n"); printf("SlowMotion by pressing `l'\n"); printf("Quit by pressing `q'\n"); putchar('\n'); errno = ENOENT; if (!argv[0] || (filefd = open(argv[0], O_RDONLY)) < 0) { perror("File open:"); return -1; } if ((vfd = open(videodev,O_RDWR|O_NONBLOCK)) < 0) { perror("VIDEO DEVICE: "); return -1; } if ((afd = open(audiodev,O_RDWR|O_NONBLOCK)) < 0) { perror("AUDIO DEVICE: "); return -1; } play_file_av(filefd, vfd, afd); close(vfd); close(afd); close(filefd); return 0; }
/* Restore terminal settings * @param Old settings */ void BarTermRestore (struct termios *termOrig) { tcsetattr (fileno (stdin), TCSANOW, termOrig); }
int microcom_main(int argc, char **argv) { struct pollfd pfd[2]; #define sfd (pfd[1].fd) char *device_lock_file = NULL; const char *s; const char *opt_s = "9600"; unsigned speed; int len; int exitcode = 1; struct termios tio0, tiosfd, tio; getopt32(argv, "s:", &opt_s); argc -= optind; argv += optind; if (!argv[0]) bb_show_usage(); speed = xatou(opt_s); // try to create lock file in /var/lock s = bb_basename(argv[0]); if (!s[0]) { errno = ENODEV; bb_perror_msg_and_die("can't lock device"); } device_lock_file = xasprintf("/var/lock/LCK..%s", s); sfd = open(device_lock_file, O_CREAT | O_WRONLY | O_TRUNC | O_EXCL, 0644); if (sfd < 0) { if (ENABLE_FEATURE_CLEAN_UP) free(device_lock_file); device_lock_file = NULL; if (errno == EEXIST) bb_perror_msg_and_die("can't lock device"); // We don't abort on other errors: /var/lock can be // non-writable or non-existent } else { // %4d to make mgetty happy. It treats 4-bytes lock files as binary, // not text, PID. Making 5+ char file. Brrr... s = xasprintf("%4d\n", getpid()); write(sfd, s, strlen(s)); if (ENABLE_FEATURE_CLEAN_UP) free((char*)s); close(sfd); } // open device sfd = open(argv[0], O_RDWR); if (sfd < 0) { bb_perror_msg("can't open device"); goto unlock_and_exit; } // put stdin to "raw mode", handle one character at a time tcgetattr(STDIN_FILENO, &tio0); tio = tio0; tio.c_lflag &= ~(ICANON|ECHO); tio.c_iflag &= ~(IXON|ICRNL); tio.c_oflag &= ~(ONLCR); tio.c_cc[VMIN] = 1; tio.c_cc[VTIME] = 0; if (tcsetattr(STDIN_FILENO, TCSANOW, &tio)) { bb_perror_msg("can't tcsetattr for %s", "stdin"); goto unlock_and_exit; } /* same thing for modem (plus: set baud rate) - TODO: make CLI option */ tcgetattr(sfd, &tiosfd); tio = tiosfd; tio.c_lflag &= ~(ICANON|ECHO); tio.c_iflag &= ~(IXON|ICRNL); tio.c_oflag &= ~(ONLCR); tio.c_cc[VMIN] = 1; tio.c_cc[VTIME] = 0; cfsetispeed(&tio, tty_value_to_baud(speed)); cfsetospeed(&tio, tty_value_to_baud(speed)); if (tcsetattr(sfd, TCSANOW, &tio)) { bb_perror_msg("can't tcsetattr for %s", "device"); goto unlock_and_exit; } // disable SIGINT signal(SIGINT, SIG_IGN); // drain stdin tcflush(STDIN_FILENO, TCIFLUSH); printf("connected to '%s' (%d bps), exit with ctrl-X...\r\n", argv[0], speed); // main loop: check with poll(), then read/write bytes across pfd[0].fd = STDIN_FILENO; pfd[0].events = POLLIN; /*pfd[1].fd = sfd;*/ pfd[1].events = POLLIN; while (1) { int i; safe_poll(pfd, 2, -1); for (i = 0; i < 2; ++i) { if (pfd[i].revents & POLLIN) { len = read(pfd[i].fd, bb_common_bufsiz1, COMMON_BUFSIZE); if (len > 0) { if (!i && 24 == bb_common_bufsiz1[0]) goto done; // ^X exits write(pfd[1-i].fd, bb_common_bufsiz1, len); } } } } done: tcsetattr(sfd, TCSANOW, &tiosfd); tcsetattr(STDIN_FILENO, TCSANOW, &tio0); tcflush(STDIN_FILENO, TCIFLUSH); if (ENABLE_FEATURE_CLEAN_UP) close(sfd); exitcode = 0; unlock_and_exit: // delete lock file if (device_lock_file) { unlink(device_lock_file); if (ENABLE_FEATURE_CLEAN_UP) free(device_lock_file); } return exitcode; }
int rlSerial::openDevice(const char *devicename, int speed, int block, int rtscts, int bits, int stopbits, int parity) { #ifdef RLUNIX struct termios buf; if(fd != -1) return -1; fd = open(devicename, O_RDWR | O_NOCTTY | O_NDELAY); if(fd < 0) { return -1; } //signal(SIGINT, sighandler); if(tcgetattr(fd, &save_termios) < 0) { return -1; } buf = save_termios; buf.c_cflag = speed | CLOCAL | CREAD; if(rtscts == 1) buf.c_cflag |= CRTSCTS; if(bits == 7) buf.c_cflag |= CS7; else buf.c_cflag |= CS8; if(stopbits == 2) buf.c_cflag |= CSTOPB; if(parity == rlSerial::ODD) buf.c_cflag |= (PARENB | PARODD); if(parity == rlSerial::EVEN) buf.c_cflag |= PARENB; buf.c_lflag = IEXTEN; //ICANON; buf.c_oflag = OPOST; buf.c_cc[VMIN] = 1; buf.c_cc[VTIME] = 0; #ifndef PVMAC buf.c_line = 0; #endif buf.c_iflag = IGNBRK | IGNPAR | IXANY; if(tcsetattr(fd, TCSAFLUSH, &buf) < 0) { return -1; } //if(tcsetattr(fd, TCSANOW, &buf) < 0) { return -1; } ttystate = RAW; ttysavefd = fd; if(block == 1) fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NONBLOCK); tcflush(fd,TCIOFLUSH); #endif #ifdef __VMS // Please set com parameters at DCL level struct dsc$descriptor_s dsc; int status; dsc.dsc$w_length = strlen(devicename); dsc.dsc$a_pointer = (char *) devicename; dsc.dsc$b_class = DSC$K_CLASS_S; dsc.dsc$b_dtype = DSC$K_DTYPE_T; status = SYS$ASSIGN(&dsc,&vms_channel,0,0); if(status != SS$_NORMAL) return -1; #endif #ifdef RLWIN32 DWORD ccsize; COMMCONFIG cc; int baudrate,ret; char devname[100]; if(strlen(devicename) > 80) return -1; sprintf(devname,"\\\\.\\%s",devicename); // Aenderung: allow more than 4 COM ports hdl = CreateFile( devname, // devicename, // pointer to name of the file GENERIC_READ | GENERIC_WRITE, // access (read-write) mode 0, // share mode 0, // pointer to security attributes OPEN_EXISTING, // how to create 0, // not overlapped I/O 0 // handle to file with attributes to copy ); if(hdl == INVALID_HANDLE_VALUE) { printf("CreateFile(%s) failed\n",devicename); return -1; } baudrate = CBR_9600; if(speed == B50 ) baudrate = 50; if(speed == B75 ) baudrate = 75; if(speed == B110 ) baudrate = CBR_110; if(speed == B134 ) baudrate = 134; if(speed == B150 ) baudrate = 150; if(speed == B200 ) baudrate = 200; if(speed == B300 ) baudrate = CBR_300; if(speed == B600 ) baudrate = CBR_600; if(speed == B1200 ) baudrate = CBR_1200; if(speed == B1800 ) baudrate = 1800; if(speed == B2400 ) baudrate = CBR_2400; if(speed == B4800 ) baudrate = CBR_4800; if(speed == B9600 ) baudrate = CBR_9600; if(speed == B19200 ) baudrate = CBR_19200; if(speed == B38400 ) baudrate = CBR_38400; if(speed == B57600 ) baudrate = CBR_57600; if(speed == B115200 ) baudrate = CBR_115200; if(speed == B230400 ) baudrate = 230400; if(speed == B460800 ) baudrate = 460800; if(speed == B500000 ) baudrate = 500000; if(speed == B576000 ) baudrate = 576000; if(speed == B921600 ) baudrate = 921600; if(speed == B1000000) baudrate = 1000000; if(speed == B1152000) baudrate = 1152000; if(speed == B1500000) baudrate = 1500000; if(speed == B2000000) baudrate = 2000000; if(speed == B2500000) baudrate = 2500000; if(speed == B3000000) baudrate = 3000000; if(speed == B3500000) baudrate = 3500000; if(speed == B4000000) baudrate = 4000000; ccsize = sizeof(cc); GetCommConfig(hdl,&cc,&ccsize); //cc.dwSize = sizeof(cc); // size of structure //cc.wVersion = 1; // version of structure //cc.wReserved = 0; // reserved // DCB dcb; // device-control block cc.dcb.DCBlength = sizeof(DCB); // sizeof(DCB) cc.dcb.BaudRate = baudrate; // current baud rate cc.dcb.fBinary = 1; // binary mode, no EOF check cc.dcb.fParity = 1; // enable parity checking cc.dcb.fOutxCtsFlow = 0; // CTS output flow control if(rtscts == 1) cc.dcb.fOutxCtsFlow = 1; cc.dcb.fOutxDsrFlow = 0; // DSR output flow control cc.dcb.fDtrControl = DTR_CONTROL_DISABLE; // DTR flow control type cc.dcb.fDsrSensitivity = 0; // DSR sensitivity cc.dcb.fTXContinueOnXoff = 1; // XOFF continues Tx //cc.dcb.fOutX = 0; // XON/XOFF out flow control //cc.dcb.fInX = 0; // XON/XOFF in flow control //cc.dcb.fErrorChar = 0; // enable error replacement cc.dcb.fNull = 0; // enable null stripping cc.dcb.fRtsControl = RTS_CONTROL_DISABLE; if(rtscts == 1) cc.dcb.fRtsControl = RTS_CONTROL_HANDSHAKE; // RTS flow control cc.dcb.fAbortOnError = 0; // abort reads/writes on error //cc.dcb.fDummy2 = 0; // reserved //cc.dcb.wReserved = 0; // not currently used //cc.dcb.XonLim = 0; // transmit XON threshold //cc.dcb.XoffLim = 0; // transmit XOFF threshold cc.dcb.ByteSize = bits; // number of bits/byte, 4-8 cc.dcb.Parity = 0; // 0-4=no,odd,even,mark,space if(parity == rlSerial::ODD) cc.dcb.Parity = 1; if(parity == rlSerial::EVEN) cc.dcb.Parity = 2; cc.dcb.StopBits = ONESTOPBIT; // 0,1,2 = 1, 1.5, 2 if(stopbits==2) cc.dcb.StopBits = TWOSTOPBITS; //cc.dcb.XonChar = 0; // Tx and Rx XON character //cc.dcb.XoffChar = 0; // Tx and Rx XOFF character //cc.dcb.ErrorChar = 0; // error replacement character //cc.dcb.EofChar = 0; // end of input character //cc.dcb.EvtChar = 0; // received event character //cc.dcb.wReserved1 = 0; // reserved; do not use cc.dwProviderSubType = PST_RS232; // type of provider-specific data //cc.dwProviderOffset = 0; // offset of provider-specific data //cc.dwProviderSize = 0; // size of provider-specific data //cc.wcProviderData[0] = 0; // provider-specific data ret = SetCommConfig(hdl,&cc,sizeof(cc)); if(ret == 0) { printf("SetCommConfig ret=%d devicename=%s LastError=%ld\n",ret,devicename,GetLastError()); return -1; } if(block) return 0; #endif #ifdef RM3 RmEntryStruct CatEntry; /* Struktur der Deiviceinformationen */ int iStatus; /* Rckgabewert */ RmIOStatusStruct DrvSts; /* Struktur der Rckgabewerte fr RmIO - Funktion */ RmBytParmStruct PBlock; /* Parameterstruktur fr RmIO - Funktion */ static UCD_BYT_PORT Ucd_byt_drv; /* Struktur zum Setzen der UCD - Werte */ ushort uTimeBd; /* Timing - Wert der �ertragungsgeschwindigkeit */ uint uMode; /* Portsteuerungsparameter */ unsigned char cByte; /* Byte - Parameter */ /* Timing = 748800 / Baudrate; */ /**************************************************/ char byt_com[32]; /* COM1=0x3F8 COM2=0x2F8 - Port Adresse */ if (strcmp(devicename,"COM1") == 0) { strcpy(byt_com,"BYT_COM1"); com = 0x3f8; } else if(strcmp(devicename,"COM2") == 0) { strcpy(byt_com,"BYT_COM2"); com = 0x2f8; } else { printf("Error: devicename=%s unknown\n",devicename); return -1; } //printf("Open COM port - inside\n"); /* * Device und Unit - Id auslesen */ if( RmGetEntry( RM_WAIT, byt_com, &CatEntry ) != RM_OK ) /* RM_CONTINUE */ { printf( "Error: %s device not found\n", byt_com); return -1; } device = (int) ((ushort) CatEntry.ide); unit = (int) CatEntry.id; /* * Ger� reservieren */ if( RmIO( BYT_RESERVE, (unsigned)(device), (unsigned)(unit), 0u, 0u, &DrvSts, &PBlock ) < 0 ) { printf( "Error: Unable to reserve %s device\n", byt_com); return -1; } /* * Baudrate ausrechnen */ baudrate = 9600; if(speed == B50 ) baudrate = 50; if(speed == B75 ) baudrate = 75; if(speed == B110 ) baudrate = 110; if(speed == B134 ) baudrate = 134; if(speed == B150 ) baudrate = 150; if(speed == B200 ) baudrate = 200; if(speed == B300 ) baudrate = 300; if(speed == B600 ) baudrate = 600; if(speed == B1200 ) baudrate = 1200; if(speed == B1800 ) baudrate = 1800; if(speed == B2400 ) baudrate = 2400; if(speed == B4800 ) baudrate = 4800; if(speed == B9600 ) baudrate = 9600; if(speed == B19200 ) baudrate = 19200; if(speed == B38400 ) baudrate = 38400; if(speed == B57600 ) baudrate = 57600; if(speed == B115200 ) baudrate = 115200; if(speed == B230400 ) baudrate = 230400; if(speed == B460800 ) baudrate = 460800; if(speed == B500000 ) baudrate = 500000; if(speed == B576000 ) baudrate = 576000; if(speed == B921600 ) baudrate = 921600; if(speed == B1000000) baudrate = 1000000; if(speed == B1152000) baudrate = 1152000; if(speed == B1500000) baudrate = 1500000; if(speed == B2000000) baudrate = 2000000; if(speed == B2500000) baudrate = 2500000; if(speed == B3000000) baudrate = 3000000; if(speed == B3500000) baudrate = 3500000; if(speed == B4000000) baudrate = 4000000; uTimeBd = 748800 / baudrate; /* * Portsteuerungsparameter setzen */ uMode = 0x1000 | DATA_8 | STOP_1 | NOPARITY; /* * UCD des seriellen Ports auslesen */ PBlock.string = 0; PBlock.strlen = 0; PBlock.buffer = (char *)&Ucd_byt_drv; PBlock.timlen = sizeof(UCD_BYT_PORT); PBlock.status = 0; iStatus = RmIO( BYT_CREATE_NEW, (unsigned)(device), (unsigned)(unit), 0u, 0u, &DrvSts, &PBlock ); /* * Modus �dern */ Ucd_byt_drv.mobyte[5] |= (ushort) (uMode & 0xFFu); /* * Timeout setzen */ Ucd_byt_drv.header.timout = timeout; /* * Werte zuweisen */ PBlock.string = (char*) &Ucd_byt_drv; PBlock.strlen = sizeof(UCD_BYT_PORT); PBlock.buffer = 0; PBlock.timlen = 0; PBlock.status = 0; iStatus = RmIO( BYT_CREATE_NEW, (unsigned)(device), (unsigned)(unit), 0u, 0u, &DrvSts, &PBlock ); /* * Register 0 und 1 zum Schreiben freigeben */ cByte = inbyte( com + 0x03 ); outbyte( com + 0x03, (unsigned char)(cByte | 0x80) ); /* * Baudrate setzen */ outbyte( com + 0x00, (ushort) LOW (uTimeBd) ); outbyte( com + 0x01, (ushort) HIGH (uTimeBd) ); /* * Register 0 und 1 sperren */ outbyte( com + 0x03, cByte ); if( iStatus ) printf( "BYT_CREATE_NEW (set ucb): Error status = %X\n", iStatus ); #endif return 0; }
static void term_exit(void) { tcsetattr(0, TCSANOW, &oldtty); }
int OpenSerialPort() { int fileDescriptor = -1; struct termios options; // Open the serial port read/write, with no controlling terminal, and don't wait for a connection. // The O_NONBLOCK flag also causes subsequent I/O on the device to be non-blocking. // See open(2) ("man 2 open") for details. fileDescriptor = open("/dev/tty.iap", O_RDWR | O_NOCTTY | O_NONBLOCK); if (fileDescriptor == -1) { printf("Error opening serial port %s - %s(%d).\n", "/dev/tty.iap", strerror(errno), errno); goto error; } // Note that open() follows POSIX semantics: multiple open() calls to the same file will succeed // unless the TIOCEXCL ioctl is issued. This will prevent additional opens except by root-owned // processes. // See tty(4) ("man 4 tty") and ioctl(2) ("man 2 ioctl") for details. if (ioctl(fileDescriptor, TIOCEXCL) == -1) { printf("Error setting TIOCEXCL on %s - %s(%d).\n", "/dev/tty.iap", strerror(errno), errno); goto error; } // Now that the device is open, clear the O_NONBLOCK flag so subsequent I/O will block. // See fcntl(2) ("man 2 fcntl") for details. if (fcntl(fileDescriptor, F_SETFL, 0) == -1) { printf("Error clearing O_NONBLOCK %s - %s(%d).\n", "/dev/tty.iap", strerror(errno), errno); goto error; } // Get the current options and save them so we can restore the default settings later. if (tcgetattr(fileDescriptor, &gOriginalTTYAttrs) == -1) { printf("Error getting tty attributes %s - %s(%d).\n", "/dev/tty.iap", strerror(errno), errno); goto error; } // The serial port attributes such as timeouts and baud rate are set by modifying the termios // structure and then calling tcsetattr() to cause the changes to take effect. Note that the // changes will not become effective without the tcsetattr() call. // See tcsetattr(4) ("man 4 tcsetattr") for details. options = gOriginalTTYAttrs; // Print the current input and output baud rates. // See tcsetattr(4) ("man 4 tcsetattr") for details. printf("Current input baud rate is %d\n", (int) cfgetispeed(&options)); printf("Current output baud rate is %d\n", (int) cfgetospeed(&options)); // Set raw input (non-canonical) mode, with reads blocking until either a single character // has been received or a one second timeout expires. // See tcsetattr(4) ("man 4 tcsetattr") and termios(4) ("man 4 termios") for details. cfmakeraw(&options); options.c_cc[VMIN] = 1; options.c_cc[VTIME] = 10; // The baud rate, word length, and handshake options can be set as follows: cfsetspeed(&options, B9600); // Set 19200 baud options.c_cflag |= (CS8); // RTS flow control of input printf("Input baud rate changed to %d\n", (int) cfgetispeed(&options)); printf("Output baud rate changed to %d\n", (int) cfgetospeed(&options)); // Cause the new options to take effect immediately. if (tcsetattr(fileDescriptor, TCSANOW, &options) == -1) { printf("Error setting tty attributes %s - %s(%d).\n", "/dev/tty.iap", strerror(errno), errno); goto error; } // Success return fileDescriptor; // Failure "/dev/tty.iap" error: if (fileDescriptor != -1) { close(fileDescriptor); } return -1; }
static VeiFlockOfBirds *open_serial(char *name, VeDeviceInstance *i) { struct termios t; VeiFlockOfBirds *b; char *c; b = calloc(1,sizeof(VeiFlockOfBirds)); assert(b != NULL); if (c = veDeviceInstOption(i,"line")) b->line = veDupString(c); else { veError(MODULE,"serial source not specified in fob input definition"); return NULL; } if (c = veDeviceInstOption(i,"raw")) b->raw = atoi(c); if (c = veDeviceInstOption(i,"speed")) b->speed = str_to_bps(c); else b->speed = str_to_bps(DEFAULT_FOB_SPEED); if (b->speed < 0) return NULL; b->fd = open(b->line, O_RDWR|O_NOCTTY); if (b->fd < 0) { veError(MODULE, "could not open serial line %s: %s", b->line, strerror(errno)); return NULL; } /* setup serial line, terminal mumbo-jumbo */ if (tcgetattr(b->fd,&t)) { veError(MODULE, "could not get serial attributes for %s: %s", b->line, strerror(errno)); return NULL; } /* this is "non-portable" or "portability-hostile" but I can't figure out which of the many flags was mussing up data from the receiver, so we'll just trash them all. This also seems to kill the slow-startup bug */ t.c_iflag = 0; t.c_oflag = 0; t.c_cflag = 0; t.c_lflag = 0; t.c_cflag |= (CLOCAL|CREAD|CS8); t.c_cc[VMIN] = 1; t.c_cc[VTIME] = 0; cfsetispeed(&t,b->speed); cfsetospeed(&t,b->speed); /* setup flow control */ if (c = veDeviceInstOption(i, "flow")) { if (strcmp(c, "xonxoff") == 0) { t.c_iflag |= (IXON|IXOFF); #if defined(__sgi) t.c_cflag &= ~CNEW_RTSCTS; #elif defined(__sun) || defined(__linux) t.c_cflag &= ~CRTSCTS; #endif } else if (strcmp(c, "rtscts") == 0) { /* Hmm... RTS/CTS is not standard...great... */ #if defined(__sgi) t.c_cflag |= CNEW_RTSCTS; #elif defined(__sun) || defined(__linux) t.c_cflag |= CRTSCTS; #else veError(MODULE, "RTS/CTS not supported on this platform"); return NULL; #endif } } else { t.c_iflag &= ~(IXON|IXOFF|IXANY); #if defined(__sgi) t.c_cflag &= ~CNEW_RTSCTS; #elif defined(__sun) || defined(__linux) t.c_cflag &= ~CRTSCTS; #endif } if (tcsetattr(b->fd,TCSAFLUSH,&t)) { veError(MODULE, "could not set serial attributes for %s: %s", b->line, strerror(errno)); return NULL; } /* try to sync things up in case it is already running */ sync_bird(b->fd); /* build NULL frame */ veFrameIdentity(&b->frame); if (c = veDeviceInstOption(i, "loc")) parseVector3(name,c,&b->frame.loc); if (c = veDeviceInstOption(i, "dir")) parseVector3(name,c,&b->frame.dir); if (c = veDeviceInstOption(i, "up")) parseVector3(name,c,&b->frame.up); return b; }
MonoBoolean ves_icall_System_ConsoleDriver_TtySetup (MonoString *keypad, MonoString *teardown, MonoArray **control_chars, int **size) { int dims; MONO_ARCH_SAVE_REGS; dims = terminal_get_dimensions (); if (dims == -1){ int cols = 0, rows = 0; const char *str = g_getenv ("COLUMNS"); if (str != NULL) cols = atoi (str); str = g_getenv ("LINES"); if (str != NULL) rows = atoi (str); if (cols != 0 && rows != 0) cols_and_lines = (cols << 16) | rows; else cols_and_lines = -1; } else { cols_and_lines = dims; } *size = &cols_and_lines; /* 17 is the number of entries set in set_control_chars() above. * NCCS is the total size, but, by now, we only care about those 17 values*/ mono_gc_wbarrier_generic_store (control_chars, (MonoObject*) mono_array_new (mono_domain_get (), mono_defaults.byte_class, 17)); if (tcgetattr (STDIN_FILENO, &initial_attr) == -1) return FALSE; mono_attr = initial_attr; mono_attr.c_lflag &= ~(ICANON); mono_attr.c_iflag &= ~(IXON|IXOFF); mono_attr.c_cc [VMIN] = 1; mono_attr.c_cc [VTIME] = 0; #ifdef VDSUSP /* Disable C-y being used as a suspend character on OSX */ mono_attr.c_cc [VDSUSP] = 255; #endif if (tcsetattr (STDIN_FILENO, TCSANOW, &mono_attr) == -1) return FALSE; set_control_chars (*control_chars, mono_attr.c_cc); /* If initialized from another appdomain... */ if (setup_finished) return TRUE; keypad_xmit_str = keypad != NULL ? mono_string_to_utf8 (keypad) : NULL; console_set_signal_handlers (); setup_finished = TRUE; if (!atexit_called) { if (teardown != NULL) teardown_str = mono_string_to_utf8 (teardown); atexit (tty_teardown); } return TRUE; }
int main(int argc, char *argv[]) { int len, cmd_finished, stop, i,try; int clientSocket, serial_fd, remotePort, status = 0; struct hostent *hostPtr = NULL; struct sockaddr_in serverName = { 0 }; unsigned char buffer[BUFFER_SIZE]; unsigned char buffer2[BUFFER_SIZE]; char *remoteHost = NULL; char *serial_device; struct termios oldtio,newtio; char *s; char *hex_filename; FILE *hexfile; if (2 != argc) { fprintf(stderr, "Usage: %s <serial_device>\n", argv[0]); exit(1); }; serial_device = argv[1]; /* Open modem device for reading and writing and not as controlling tty because we don't want to get killed if linenoise sends CTRL-C. */ serial_fd = open(serial_device, O_RDWR | O_NOCTTY ); if (serial_fd <0) {perror(serial_device); exit(-1); } tcgetattr(serial_fd,&oldtio); /* save current port settings */ bzero(&newtio, sizeof(newtio)); /* BAUDRATE: Set bps rate. You could also use cfsetispeed and cfsetospeed. CRTSCTS : output hardware flow control (only used if the cable has all necessary lines. See sect. 7 of Serial-HOWTO) CS8 : 8n1 (8bit,no parity,1 stopbit) CLOCAL : local connection, no modem contol CREAD : enable receiving characters */ newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD; /* IGNPAR : ignore bytes with parity errors ICRNL : map CR to NL (otherwise a CR input on the other computer will not terminate input) otherwise make device raw (no other input processing) */ newtio.c_iflag = IGNPAR; /* Raw output. */ newtio.c_oflag = 0; /* set input mode (non-canonical, no echo,...) disable all echo functionality, and don't send signals to calling program */ newtio.c_lflag = 0; newtio.c_cc[VTIME] = 50; /* time out after 5 seconds */ newtio.c_cc[VMIN] = 0; /* non-blocking read */ /* now clean the modem line and activate the settings for the port */ tcflush(serial_fd, TCIFLUSH); tcsetattr(serial_fd,TCSANOW,&newtio); printf("Sending break\n"); /* Send a break to reset device into ISP mode */ tcsendbreak(serial_fd,3); tcflush(serial_fd, TCIFLUSH); usleep(1000000); tcflush(serial_fd, TCIFLUSH); usleep(1000000); /* Send an uppercase U to negotiate baud rate */ buffer[0] = 'U'; buffer[1] = 0; /* Send U to serial line */ if (write_all(serial_fd, buffer, 1) == -1) { perror("sendall"); printf("We only sent %d bytes because of the error!\n", len); }; len = read_cmd(serial_fd, buffer); buffer[len] = 0; printf("Read %d characters:\n\t", len, buffer[0]); for (i=0; i<len; i++) printf("%02x ", buffer[i]); printf("\n"); tcflush(serial_fd, TCIFLUSH); /* Send U to serial line to check that we are in sync */ buffer[0] = 'U'; if (write_all(serial_fd, buffer, 1) == -1) { perror("sendall"); printf("We only sent %d bytes because of the error!\n", len); }; len = read_cmd(serial_fd, buffer); printf("Read %d characters:\n\t", len); for (i=0; i<len; i++) printf("%02x ", buffer[i]); printf("\n"); buffer[len] = 0; if (buffer[0] == 'U') printf("Baud rate successfully negotiated\n"); else { printf("buffer[0] = %02x\n", buffer[0] ); printf("Error: Could not negotiate baud rate!\n"); exit(20); }; s=":0100000310EC"; printf("Manuf. ID \t= "); if (0 != send_string(serial_fd,s,buffer2) ) { exit(20); ; }; printf("%s\n",buffer2); if (0 != strncmp(buffer2, "15", 2)) { fprintf(stderr, "ERROR: Device not recognized\n"); exit(20); }; s=":0100000311EB"; printf("Device ID \t= "); if (0 != send_string(serial_fd,s,buffer2)) { exit(20); ; }; printf("%s\n",buffer2); if (0 != strncmp(buffer2, "DD", 2)) { fprintf(stderr, "ERROR: Device not recognized\n"); exit(20); }; s=":0100000312EA"; printf("Derivative ID \t= "); if (0 != send_string(serial_fd,s,buffer2)) { exit(20); ; }; printf("%s\n",buffer2); if (0 != strncmp(buffer2, "09", 2)) { fprintf(stderr, "ERROR: Device not recognized\n"); exit(20); }; /* Read configuration data */ s=":0100000300FC"; printf("UCFG1 \t= "); if (0 != send_string(serial_fd,s, buffer2)) { exit(-20); ; }; printf("%s\n",buffer2); s=":0100000302FA"; printf("Boot Vector \t= "); if (0 != send_string(serial_fd,s,buffer2)) { exit(-20); ; }; printf("%s\n",buffer2); s=":0100000303F9"; printf("Status Byte \t= "); if (0 != send_string(serial_fd,s,buffer2)) { exit(-20); ; }; printf("%s\n",buffer2); s=":00000001FF"; printf("Version ID \t= "); if (0 != send_string(serial_fd,s, buffer2)) { exit(-20); ; }; printf("%s\n",buffer2); really_write_sector(serial_fd, 0); really_write_sector(serial_fd, 1); really_write_sector(serial_fd, 2); really_write_sector(serial_fd, 3); really_write_sector(serial_fd, 4); really_write_sector(serial_fd, 5); really_write_sector(serial_fd, 6); // The configuration bytes are defined and set in bin2c.c !!! /* Write Configuration Byte UCFG1 */ sprintf(buffer, ":0200000200%02X", scart_UCFG1); checksum(buffer); if (0 != send_string(serial_fd, buffer, buffer2)) { return(20); ; }; /* Read UCFG1 */ s=":0100000300FC"; printf("UCFG1 \t= "); if (0 != send_string(serial_fd,s, buffer2)) { exit(-20); ; }; printf("%s\n",buffer2); /* Write Boot Vector Byte */ sprintf(buffer, ":0200000202%02X", scart_bootvec); checksum(buffer); if (0 != send_string(serial_fd, buffer, buffer2)) { return(20); ; }; s=":0100000302FA"; printf("Boot Vector \t= "); if (0 != send_string(serial_fd,s,buffer2)) { exit(-20); ; }; printf("%s\n",buffer2); /* Write Boot Status Byte */ sprintf(buffer, ":0200000203%02X", scart_bootstat); checksum(buffer); if (0 != send_string(serial_fd, buffer, buffer2)) { return(20); ; }; s=":0100000303F9"; printf("Status Byte \t= "); if (0 != send_string(serial_fd,s,buffer2)) { exit(-20); ; }; printf("%s\n",buffer2); /* Reset the device */ printf("\nResetting device\n"); s=":00000008F8"; write_all(serial_fd, s, strlen(s)); /* This should be the echo of our RESET command */ read_cmd(serial_fd, buffer); printf("%s\n", buffer); /* Restore old serial port settings */ tcsetattr(serial_fd,TCSANOW,&oldtio); return 0; }
//TODO: use more efficient setvar() which takes a pointer to malloced "VAR=VAL" //string. hush naturally has it, and ash has setvareq(). //Here we can simply store "VAR=" at buffer start and store read data directly //after "=", then pass buffer to setvar() to consume. const char* FAST_FUNC shell_builtin_read(void FAST_FUNC (*setvar)(const char *name, const char *val), char **argv, const char *ifs, int read_flags, const char *opt_n, const char *opt_p, const char *opt_t, const char *opt_u ) { unsigned err; unsigned end_ms; /* -t TIMEOUT */ int fd; /* -u FD */ int nchars; /* -n NUM */ char **pp; char *buffer; struct termios tty, old_tty; const char *retval; int bufpos; /* need to be able to hold -1 */ int startword; smallint backslash; errno = err = 0; pp = argv; while (*pp) { if (!is_well_formed_var_name(*pp, '\0')) { /* Mimic bash message */ bb_error_msg("read: '%s': not a valid identifier", *pp); return (const char *)(uintptr_t)1; } pp++; } nchars = 0; /* if != 0, -n is in effect */ if (opt_n) { nchars = bb_strtou(opt_n, NULL, 10); if (nchars < 0 || errno) return "invalid count"; /* note: "-n 0": off (bash 3.2 does this too) */ } end_ms = 0; if (opt_t) { end_ms = bb_strtou(opt_t, NULL, 10); if (errno || end_ms > UINT_MAX / 2048) return "invalid timeout"; end_ms *= 1000; #if 0 /* even bash has no -t N.NNN support */ ts.tv_sec = bb_strtou(opt_t, &p, 10); ts.tv_usec = 0; /* EINVAL means number is ok, but not terminated by NUL */ if (*p == '.' && errno == EINVAL) { char *p2; if (*++p) { int scale; ts.tv_usec = bb_strtou(p, &p2, 10); if (errno) return "invalid timeout"; scale = p2 - p; /* normalize to usec */ if (scale > 6) return "invalid timeout"; while (scale++ < 6) ts.tv_usec *= 10; } } else if (ts.tv_sec < 0 || errno) { return "invalid timeout"; } if (!(ts.tv_sec | ts.tv_usec)) { /* both are 0? */ return "invalid timeout"; } #endif /* if 0 */ } fd = STDIN_FILENO; if (opt_u) { fd = bb_strtou(opt_u, NULL, 10); if (fd < 0 || errno) return "invalid file descriptor"; } if (opt_p && isatty(fd)) { fputs(opt_p, stderr); fflush_all(); } if (ifs == NULL) ifs = defifs; if (nchars || (read_flags & BUILTIN_READ_SILENT)) { tcgetattr(fd, &tty); old_tty = tty; if (nchars) { tty.c_lflag &= ~ICANON; // Setting it to more than 1 breaks poll(): // it blocks even if there's data. !?? //tty.c_cc[VMIN] = nchars < 256 ? nchars : 255; /* reads would block only if < 1 char is available */ tty.c_cc[VMIN] = 1; /* no timeout (reads block forever) */ tty.c_cc[VTIME] = 0; } if (read_flags & BUILTIN_READ_SILENT) { tty.c_lflag &= ~(ECHO | ECHOK | ECHONL); } /* This forces execution of "restoring" tcgetattr later */ read_flags |= BUILTIN_READ_SILENT; /* if tcgetattr failed, tcsetattr will fail too. * Ignoring, it's harmless. */ tcsetattr(fd, TCSANOW, &tty); } retval = (const char *)(uintptr_t)0; startword = 1; backslash = 0; if (end_ms) /* NB: end_ms stays nonzero: */ end_ms = ((unsigned)monotonic_ms() + end_ms) | 1; buffer = NULL; bufpos = 0; do { char c; struct pollfd pfd[1]; int timeout; if ((bufpos & 0xff) == 0) buffer = xrealloc(buffer, bufpos + 0x101); timeout = -1; if (end_ms) { timeout = end_ms - (unsigned)monotonic_ms(); if (timeout <= 0) { /* already late? */ retval = (const char *)(uintptr_t)1; goto ret; } } /* We must poll even if timeout is -1: * we want to be interrupted if signal arrives, * regardless of SA_RESTART-ness of that signal! */ errno = 0; pfd[0].fd = fd; pfd[0].events = POLLIN; if (poll(pfd, 1, timeout) != 1) { /* timed out, or EINTR */ err = errno; retval = (const char *)(uintptr_t)1; goto ret; } if (read(fd, &buffer[bufpos], 1) != 1) { err = errno; retval = (const char *)(uintptr_t)1; break; } c = buffer[bufpos]; if (c == '\0') continue; if (backslash) { backslash = 0; if (c != '\n') goto put; continue; } if (!(read_flags & BUILTIN_READ_RAW) && c == '\\') { backslash = 1; continue; } if (c == '\n') break; /* $IFS splitting. NOT done if we run "read" * without variable names (bash compat). * Thus, "read" and "read REPLY" are not the same. */ if (argv[0]) { /* http://www.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05 */ const char *is_ifs = strchr(ifs, c); if (startword && is_ifs) { if (isspace(c)) continue; /* it is a non-space ifs char */ startword--; if (startword == 1) /* first one? */ continue; /* yes, it is not next word yet */ } startword = 0; if (argv[1] != NULL && is_ifs) { buffer[bufpos] = '\0'; bufpos = 0; setvar(*argv, buffer); argv++; /* can we skip one non-space ifs char? (2: yes) */ startword = isspace(c) ? 2 : 1; continue; } } put: bufpos++; } while (--nchars); if (argv[0]) { /* Remove trailing space $IFS chars */ while (--bufpos >= 0 && isspace(buffer[bufpos]) && strchr(ifs, buffer[bufpos]) != NULL) continue; buffer[bufpos + 1] = '\0'; /* Use the remainder as a value for the next variable */ setvar(*argv, buffer); /* Set the rest to "" */ while (*++argv) setvar(*argv, ""); } else { /* Note: no $IFS removal */ buffer[bufpos] = '\0'; setvar("REPLY", buffer); } ret: free(buffer); if (read_flags & BUILTIN_READ_SILENT) tcsetattr(fd, TCSANOW, &old_tty); errno = err; return retval; }