我想编写一个程序来模拟串行端口上的设备。我正在尝试使用伪终端来完成此操作。我想要一个独特的过程来控制主人。此过程充当串行设备仿真器。我希望另一个进程(例如 kermit)能够使用从终端与主进程通信。由于不同的工艺要求，我没有使用任何 fork 。互联网上几乎每个伪终端示例都显示了 fork() 用于主/从。

我让它朝一个方向工作。也就是说，我可以让从进程将数据写入从伪终端，而主进程将从主伪终端读取它就好了。

问题在另一个方向。无法让master写数据，slave读数据。

我将展示无效的双向代码和有效的单向代码。

非工作双向主机:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc, char* argv[])
{
  // get the master fd
  int masterfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
  if(masterfd < 0)
  {
    perror("getpt");
    exit(1);
  }

  // grant access to the slave
  if(grantpt(masterfd) < 0)
  {
    perror("grantpt");
    exit(1);
  }

  // unlock the slave
  if(unlockpt(masterfd) < 0)
  {
    perror("unlockpt");
    exit(1);
  }

  // get the path to the slave
  char slavepath[64];
  if(ptsname_r(masterfd, slavepath, sizeof(slavepath)) < 0)
  {
    perror("ptsname_r");
    exit(1);
  }

  printf("Using %s\n", slavepath);

  char bufout = 'D';
  char bufin;

  int c;
  while(1)
  {
    printf("reading\n");
    c = read(masterfd, &bufin, 1);
    printf("read %i bytes: %c\n", c, bufin);
    if(c == -1) break;

    if(bufout == 'D') bufout = 'E';
    else if(bufout == 'E') bufout = 'D';
    printf("writing %c\n", bufout);
    c = write(masterfd, &bufout, 1);
    printf("wrote %i bytes\n", c);
    if(c == -1) break;

    sleep(1);
  }

  close(masterfd);

  return 0;
}

非工作双向从站:

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char* argv[])
{
  int fd = open("/dev/pts/15", O_RDWR | O_NOCTTY);
  if(fd < 0)
  {
    perror("open");
    exit(1);
  }

  char bufout = 'A';
  char bufin;

  int c;
  while(1)
  {
    if(bufout == 'A') bufout = 'B';
    else if(bufout == 'B') bufout = 'A';
    printf("writing %c\n", bufout);
    c = write(fd, &bufout, 1);
    if(c == -1) break;

    printf("reading\n");
    c = read(fd, &bufin, 1);
    printf("read %i bytes: %c\n", c, bufin);
    if(c == -1) break;

    sleep(1);
  }

  close(fd);
}

非工作主机的输出: (注意接收到的第一个字符来自 slave，然后其余的字符由 master 写入。换句话说，master 正在读出它写给 master pts 的相同字符并且它忽略了 slave 正在写的内容，除了第一个字符。)

Using /dev/pts/15
reading
read 1 bytes: B     [<--- FROM THE SLAVE]
writing E
wrote 1 bytes
reading
read 1 bytes: E     [<--- REST FROM THE MASTER]
writing D
wrote 1 bytes
reading
read 1 bytes: D
writing E
wrote 1 bytes
reading
read 1 bytes: E
writing D
wrote 1 bytes
reading
read 1 bytes: D
^C

非工作奴隶的输出:(永远不会收到主人正在写的东西。)

writing B
reading
^C

工作单向大师:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main(int argc, char* argv[])
{
  // get the master fd
  int masterfd = open("/dev/ptmx", O_RDWR | O_NOCTTY);
  if(masterfd < 0)
  {
    perror("getpt");
    exit(1);
  }

  // grant access to the slave
  if(grantpt(masterfd) < 0)
  {
    perror("grantpt");
    exit(1);
  }

  // unlock the slave
  if(unlockpt(masterfd) < 0)
  {
    perror("unlockpt");
    exit(1);
  }

  // get the path to the slave
  char slavepath[64];
  if(ptsname_r(masterfd, slavepath, sizeof(slavepath)) < 0)
  {
    perror("ptsname_r");
    exit(1);
  }

  printf("Using %s\n", slavepath);

  char bufout = 'D';
  char bufin;

  int c;
  while(1)
  {
    printf("reading\n");
    c = read(masterfd, &bufin, 1);
    printf("read %i bytes: %c\n", c, bufin);
    if(c == -1) break;

    sleep(1);
  }

  close(masterfd);

  return 0;
}

工作单向奴隶:

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char* argv[])
{
  int fd = open("/dev/pts/15", O_RDWR | O_NOCTTY);
  if(fd < 0)
  {
    perror("open");
    exit(1);
  }

  char bufout = 'A';
  char bufin;

  int c;
  while(1)
  {
    if(bufout == 'A') bufout = 'B';
    else if(bufout == 'B') bufout = 'A';
    printf("writing %c\n", bufout);
    c = write(fd, &bufout, 1);
    if(c == -1) break;

    sleep(1);
  }

  close(fd);
}

工作主机的输出:(读取从机成功写入的内容。)

Using /dev/pts/15
reading
read 1 bytes: B
reading
read 1 bytes: A
reading
read 1 bytes: B
reading
read 1 bytes: A
reading
read 1 bytes: B
^C

工作奴隶的输出:

writing B
writing A
writing B
writing A
writing B
^C

最佳答案

我注意到如果我们使用像 screen 或 picocom 这样的终端仿真器而不是您的从属程序，您的第一个示例就可以工作。

我认为不同之处在于不同的线路“ cooking ”设置。这是 pts 创建时的默认状态:

$ stty -F /dev/pts/2 
speed 38400 baud; line = 0;
-brkint -imaxbel

现在，在使用 screen 打开后，它变成了:

$ stty -F /dev/pts/2 
speed 9600 baud; line = 0;
kill = ^H; min = 100; time = 2;
-icrnl -imaxbel
-opost -onlcr
-isig -icanon -echo

然后我尝试在读/写操作之前在从程序中将 pts 设置为原始模式。原始模式是线路设置的组合，可以尽可能多地禁用 cooking 。

struct termios ts;

if(tcgetattr(fd, &ts))
{
  perror("tcgetattr");
  exit(1);
}

cfmakeraw(&ts);
tcsetattr (fd, TCSANOW, &ts);

看起来它可以正常工作。

大师:

$ ./pts_master 
Using /dev/pts/2
reading
read 1 bytes: B
writing E
wrote 1 bytes
reading
read 1 bytes: A
writing D
wrote 1 bytes
reading
read 1 bytes: B
writing E
wrote 1 bytes
...

奴隶:

$ ./pts_slave 
writing B
reading
read 1 bytes: E
writing A
reading
read 1 bytes: D
writing B
...

关于c - 如何使用单独的进程但不 fork 地读取/写入 Linux 伪终端？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/23459520/