/*------------------------------------------------------------------
*
* Module: pttest.c
*
* Purpose: Test for pseudo terminal.
*
* Input:
*
* Outputs:
*
* Description: The protocol name is an acronym for Keep it Simple Stupid.
* You would expect it to be simple but this caused a lot
* of effort on Linux. The problem is that writes to a pseudo
* terminal eventually block if nothing at the other end
* is removing the data. This causes the application to
* hang and stop receiving after a while.
*
* This is an attempt to demonstrate the problem in a small
* test case and, hopefully, find a solution.
*
*
* Instructions:
* First compile like this:
*
*
* Run it, noting the name of pseudo terminal,
* typically /dev/pts/1.
*
* In another window, type:
*
* cat /dev/pts/1
*
* This should run "forever" as long as something is
* reading from the slave side of the pseudo terminal.
*
* If nothing is removing the data, this runs for a while
* and then blocks on the write.
* For this particular application we just want to discard
* excess data if no one is listening.
*
*
* Failed experiments:
*
* Notice that ??? always returns 0 for amount of data
* in the queue.
* Define TEST1 to make the device non-blocking.
* Write fails entirely.
*
* Define TEST2 to use a different method.
* Also fails in the same way.
*
*
*---------------------------------------------------------------*/
#include <stdio.h>
#include <unistd.h>
#define __USE_XOPEN2KXSI 1
#define __USE_XOPEN 1
//#define __USE_POSIX 1
#include <stdlib.h>
#include <ctype.h>
#include <fcntl.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/errno.h>
#include <assert.h>
#include <string.h>
//#include "direwolf.h"
//#include "tq.h"
//#include "ax25_pad.h"
//#include "textcolor.h"
//#include "kiss.h"
//#include "xmit.h"
static MYFDTYPE pt_master_fd = -1; /* File descriptor for my end. */
static MYFDTYPE pt_slave_fd = -1; /* File descriptor for pseudo terminal */
/* for use by application. */
static int msg_number;
static int total_bytes;
/*-------------------------------------------------------------------
*
* Name: kiss_init
*
* Purpose: Set up a pseudo terminal acting as a virtual KISS TNC.
*
*
* Inputs: mc->nullmodem - name of device for our end of nullmodem.
*
* Outputs:
*
* Description: (1) Create a pseudo terminal for the client to use.
* (2) Start a new thread to listen for commands from client app
* so the main application doesn't block while we wait.
*
*
*--------------------------------------------------------------------*/
static int kiss_open_pt (void);
main (int argc, char *argv)
{
pt_master_fd = kiss_open_pt ();
printf ("msg total qcount\n");
msg_number = 0;
total_bytes = 0;
#endif
}
/*
* Returns fd for master side of pseudo terminal or MYFDERROR for error.
*/
static int kiss_open_pt (void)
{
int fd;
char *slave_device;
struct termios ts;
int e;
int flags;
fd = posix_openpt(O_RDWR|O_NOCTTY);
if (fd == -1
|| grantpt (fd) == -1
|| unlockpt (fd) == -1
|| (slave_device = ptsname (fd)) == NULL) {
text_color_set(DW_COLOR_ERROR);
printf ("ERROR - Could not create pseudo terminal.\n");
return (-1);
}
e = tcgetattr (fd, &ts);
if (e != 0) {
printf ("Can't get pseudo terminal attributes, err=%d\n", e);
perror ("pt tcgetattr");
}
cfmakeraw (&ts);
ts.c_cc[VMIN] = 1; /* wait for at least one character */
ts.c_cc[VTIME] = 0; /* no fancy timing. */
e = tcsetattr (fd, TCSANOW, &ts);
if (e != 0) {
text_color_set(DW_COLOR_ERROR);
printf ("Can't set pseudo terminal attributes, err=%d\n", e);
perror ("pt tcsetattr");
}
/*
* After running for a while on Linux, the write eventually
* blocks if no one is reading from the other side of
* the pseudo terminal. We get stuck on the kiss data
* write and reception stops.
*
* I tried using ioctl(,TIOCOUTQ,) to see how much was in
* the queue but that always returned zero. (Ubuntu)
*
* Let's try using non-blocking writes and see if we get
* the EWOULDBLOCK status instead of hanging.
*/
#if TEST1
// this is worse. all writes fail. errno = ? bad file descriptor
flags = fcntl(fd, F_GETFL, 0);
e = fcntl (fd, F_SETFL, flags | O_NONBLOCK);
if (e != 0) {
printf ("Can't set pseudo terminal to nonblocking, fcntl returns %d, errno = %d\n", e, errno);
perror ("pt fcntl");
}
#endif
#if TEST2
// same
flags = 1;
e = ioctl (fd, FIONBIO, &flags);
if (e != 0) {
printf ("Can't set pseudo terminal to nonblocking, ioctl returns %d, errno = %d\n", e, errno);
perror ("pt ioctl");
}
#endif
printf("Virtual KISS TNC is available on %s\n", slave_device);
// Sample code shows this. Why would we open it here?
// pt_slave_fd = open(slave_device, O_RDWR|O_NOCTTY);
return (fd);
}
/*-------------------------------------------------------------------
*
* Name: kiss_send_rec_packet
*
* Purpose: Send a received packet to the client app.
*
* Inputs: chan - Channel number where packet was received.
* 0 = first, 1 = second if any.
*
* pp - Identifier for packet object.
*
* fbuf - Address of raw received frame buffer.
* flen - Length of raw received frame.
* Not including the FCS.
*
*
* Description: Send message to client.
* We really don't care if anyone is listening or not.
* I don't even know if we can find out.
*
*
*--------------------------------------------------------------------*/
void kiss_send_rec_packet (void)
{
char kiss_buff[100];
int kiss_len;
int q_count = 123;
int j;
strcpy (kiss_buff, "The quick brown fox jumps over the lazy dog.\n");
kiss_len = strlen(kiss_buff);
if (pt_master_fd != MYFDERROR) {
int err;
msg_number++;
total_bytes += kiss_len;
//#if DEBUG
printf ("%3d %5d %5d\n", msg_number, total_bytes, q_count);
//#endif
err = write (pt_master_fd, kiss_buff, kiss_len);
if (err == -1 && errno == EWOULDBLOCK) {
//#if DEBUG
printf ("Discarding message because write would block.\n");
//#endif
}
else if (err != kiss_len)
{
printf ("\nError sending message on pseudo terminal. len=%d, write returned %d, errno = %d\n\n",
kiss_len, err, errno);
perror ("pt write");
}
}
//#endif
}
/* end pttest.c */