├── .gitignore
├── CMakeLists.txt
├── LICENSE
├── README.md
├── epoll.c
├── epoll.h
├── hook.c
├── hook.h
├── libcolorthis.c
├── main.c
├── pty.c
├── pty.h
└── test
    └── target
        ├── c
            └── main.c
        └── go
            ├── go.mod
            ├── go.sum
            └── main.go


/.gitignore:
--------------------------------------------------------------------------------
 1 | # This file is used to ignore files which are generated
 2 | # ----------------------------------------------------------------------------
 3 | 
 4 | *~
 5 | *.autosave
 6 | *.a
 7 | *.core
 8 | *.moc
 9 | *.o
10 | *.obj
11 | *.orig
12 | *.rej
13 | *.so
14 | *.so.*
15 | *_pch.h.cpp
16 | *_resource.rc
17 | *.qm
18 | .#*
19 | *.*#
20 | core
21 | !core/
22 | tags
23 | .DS_Store
24 | .directory
25 | *.debug
26 | Makefile*
27 | *.prl
28 | *.app
29 | moc_*.cpp
30 | ui_*.h
31 | qrc_*.cpp
32 | Thumbs.db
33 | *.res
34 | *.rc
35 | *.user
36 | /.qmake.cache
37 | /.qmake.stash
38 | 
39 | # qtcreator generated files
40 | *.pro.user*
41 | 
42 | # xemacs temporary files
43 | *.flc
44 | 
45 | # Vim temporary files
46 | .*.swp
47 | 
48 | # Visual Studio generated files
49 | *.ib_pdb_index
50 | *.idb
51 | *.ilk
52 | *.pdb
53 | *.sln
54 | *.suo
55 | *.vcproj
56 | *vcproj.*.*.user
57 | *.ncb
58 | *.sdf
59 | *.opensdf
60 | *.vcxproj
61 | *vcxproj.*
62 | 
63 | # MinGW generated files
64 | *.Debug
65 | *.Release
66 | 
67 | # Python byte code
68 | *.pyc
69 | 
70 | # Binaries
71 | # --------
72 | *.dll
73 | *.exe
74 | 
75 | isatty
76 | build
77 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.9)
 2 | 
 3 | project(ColorThis)
 4 | 
 5 | add_library(LibColorThis SHARED libcolorthis.c)
 6 | target_link_libraries(LibColorThis dl)
 7 | 
 8 | add_executable(${PROJECT_NAME}
 9 |     main.c
10 |     hook.c hook.h
11 |     pty.c pty.h
12 |     epoll.c epoll.h
13 | )
14 | 
15 | install(TARGETS ColorThis LibColorThis
16 |   RUNTIME DESTINATION bin
17 |   LIBRARY DESTINATION lib
18 | )
19 | 
20 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright 2019 Sasasu
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
8 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ColorThis
 2 | 
 3 | Tell the program I just want you to print the color.
 4 | 
 5 | ## Quick start
 6 | 
 7 | ### Prerequisites
 8 | 
 9 | the compile depends is
10 | 
11 | ```
12 | cmake make gcc
13 | ```
14 | 
15 | no runtime depends
16 | 
17 | ### Installation
18 | 
19 | 1. Download ColorThis use `git clone git@github.com:Sasasu/ColorThis.git`
20 | 2. Compile
21 | 
22 | ```shell
23 | cmake -DCMAKE_INSTALL_PREFIX=/usr .
24 | make
25 | sudo make install
26 | ```
27 | 
28 | ## Usage
29 | 
30 | type ColorThis in your terminal, you will get like this
31 | 
32 | ```shell
33 | $ ColorThis
34 | Usage: ColorThis <option> [application]
35 | where options are
36 |         -stdin:   make stdin is a tty
37 |         -stdout:  make stdout is a tty
38 |         -stderr:  make stderr is a tty
39 |         -hook:    hook libc's isatty function
40 |                   NOTE: may not work well
41 | where application like
42 |                   ls / </dev/null 2>/dev/null
43 | ```
44 | 
45 | this command shows full function
46 | 
47 | ```
48 | $ ColorThis -stdin -stdout -stderr $SOME_FRIENDLLY_GO_APP $COMMAND 2> colorfull_err_log.log < input_from_terminal.txt | tee colorfull_log.log
49 | ```
50 | 
51 | ## How it works
52 | 
53 | if `-hook` is enabled, ColorThis will inject self to `LD_PRELOAD` and patch `isatty` function in libc.
54 | 
55 | but if the application call syscall directly or is fully static link this method will not work.
56 | 
57 | if `-hook` is not enabled, ColorThis will creat at most 3 ptys, catch all signs, creat a new session, fork and exec the new executable file.
58 | 
59 | ColorThis act like a terminal, exec the new executable file then attach some new tty to this session, these tty forward anything to the real tty.
60 | 
61 | ## License
62 | 
63 | MIT
64 | 


--------------------------------------------------------------------------------
/epoll.c:
--------------------------------------------------------------------------------
  1 | #include <assert.h>
  2 | #include <errno.h>
  3 | #include <stdbool.h>
  4 | #include <stdio.h>
  5 | #include <stdlib.h>
  6 | #include <unistd.h>
  7 | 
  8 | #include <sys/epoll.h>
  9 | 
 10 | #include "epoll.h"
 11 | #include "pty.h"
 12 | 
 13 | /*
 14 | if $IN_FD can epoll, when $IN_FD ready, read from $IN_FD and write to $OUT_FD
 15 | if $IN_FD can not epoll, when $OUT_FD ready, read from $IN_FD to $OUT_FD
 16 | if read EOF from $IN_FD, close $OUT_FD and remove from poll
 17 |  */
 18 | 
 19 | #define MAX_EVENT 3
 20 | 
 21 | extern bool FAKE_FD[3]; // in main.c
 22 | 
 23 | int fd_sum = 0;
 24 | 
 25 | static int epollfd = 0;
 26 | static struct epoll_event ev, events[MAX_EVENT];
 27 | 
 28 | void set_nonblocking(int fd) {
 29 |   int flags;
 30 | 
 31 |   if ((flags = fcntl(fd, F_GETFL, 0)) < 0)
 32 |     flags = 0;
 33 |   if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
 34 |     perror("set nonblock");
 35 |     exit(1);
 36 |   }
 37 | }
 38 | 
 39 | int epoll_init() {
 40 |   epollfd = epoll_create1(EPOLL_CLOEXEC);
 41 |   if (epollfd < 0) {
 42 |     perror("epoll");
 43 |     exit(1);
 44 |   }
 45 | 
 46 |   // for stdin
 47 |   if (FAKE_FD[STDIN_FILENO] == true) {
 48 |     assert(PTYS[STDIN_FILENO] != 0 && PTYS[STDIN_FILENO] != -1);
 49 |     ev.events = EPOLLIN;
 50 |     ev.data.fd = STDIN_FILENO;
 51 |     // try add STDIN_FILENO into epoll, if failed try to add ptys into epoll
 52 |     if (epoll_ctl(epollfd, EPOLL_CTL_ADD, STDIN_FILENO, &ev) < 0) {
 53 |       ev.events = EPOLLIN;
 54 |       ev.data.fd = PTYS[STDIN_FILENO];
 55 |       if (epoll_ctl(epollfd, EPOLL_CTL_ADD, PTYS[STDIN_FILENO], &ev) < 0) {
 56 |         perror("epoll add");
 57 |         exit(1);
 58 |       } else {
 59 |         // set in pty no blocking
 60 |         fd_sum++;
 61 |         set_nonblocking(PTYS[STDIN_FILENO]);
 62 |       }
 63 |     } else {
 64 |       // STDIN_FILENO added into epoll, set STDIN_FILENO NOBLOCKING
 65 |       fd_sum++;
 66 |       set_nonblocking(STDIN_FILENO);
 67 |     }
 68 |   }
 69 | 
 70 |   // for stdout and stderr
 71 |   for (int i = 1; i < 3; i++) {
 72 |     if (FAKE_FD[i] != true)
 73 |       continue;
 74 |     assert(PTYS[i] != 0 && PTYS[i] != -1);
 75 |     // in this case, pty should can be epoll
 76 |     ev.events = EPOLLIN;
 77 |     ev.data.fd = PTYS[i];
 78 |     if (epoll_ctl(epollfd, EPOLL_CTL_ADD, PTYS[i], &ev) < 0) {
 79 |       perror("epoll add");
 80 |       exit(1);
 81 |     } else {
 82 |       fd_sum++;
 83 |       set_nonblocking(PTYS[i]);
 84 |     }
 85 |   }
 86 | 
 87 |   return 0;
 88 | }
 89 | 
 90 | void fd_action(int fd) {
 91 |   static char BUFFER[1024 * 1024 * 8]; // 8MiB
 92 |   ssize_t n;
 93 |   int read_fd, write_fd;
 94 | 
 95 |   if (fd == STDIN_FILENO) {
 96 |     read_fd = STDIN_FILENO;
 97 |     write_fd = PTYS[STDIN_FILENO];
 98 |   } else if (fd == PTYS[STDIN_FILENO]) {
 99 |     read_fd = STDIN_FILENO;
100 |     write_fd = PTYS[STDIN_FILENO];
101 |   } else if (fd == PTYS[STDOUT_FILENO]) {
102 |     read_fd = PTYS[STDOUT_FILENO];
103 |     write_fd = STDOUT_FILENO;
104 |   } else if (fd == PTYS[STDERR_FILENO]) {
105 |     read_fd = PTYS[STDERR_FILENO];
106 |     write_fd = STDERR_FILENO;
107 |   } else {
108 |     fprintf(stderr, "error");
109 |     exit(1);
110 |   }
111 | 
112 |   n = read(read_fd, BUFFER, sizeof(BUFFER));
113 |   if (n < 0 || n == 0) {
114 |     ev.events = EPOLLOUT;
115 |     ev.data.fd = fd;
116 |     epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, &ev);
117 |     fd_sum--;
118 |   } else {
119 |     if (n != write(write_fd, BUFFER, (size_t)n)) {
120 |       perror("write");
121 |       exit(1);
122 |     }
123 |   }
124 | }
125 | 
126 | void start_loop() {
127 |   while (fd_sum != 0) {
128 |     int nfds = epoll_wait(epollfd, events, MAX_EVENT, -1);
129 |     if (nfds == -1) {
130 |       if (errno == EINTR)
131 |         continue;
132 |       perror("epoll_wait");
133 |       exit(1);
134 |     }
135 |     for (size_t n = 0; n < (size_t)nfds; n++) {
136 |       fd_action(events[n].data.fd);
137 |     }
138 |   }
139 | }
140 | 


--------------------------------------------------------------------------------
/epoll.h:
--------------------------------------------------------------------------------
 1 | #ifndef EPOLL_H
 2 | #define EPOLL_H
 3 | 
 4 | extern int epoll_init();
 5 | extern void start_loop();
 6 | 
 7 | extern int fd_sum;
 8 | 
 9 | #endif // EPOLL_H
10 | 


--------------------------------------------------------------------------------
/hook.c:
--------------------------------------------------------------------------------
 1 | #include <stdbool.h>
 2 | #include <stdio.h>
 3 | #include <stdlib.h>
 4 | #include <string.h>
 5 | #include <unistd.h>
 6 | 
 7 | extern bool FAKE_FD[3]; // in main.c
 8 | static char PRELOAD[2048] = "libLibColorThis.so";
 9 | 
10 | __attribute__((noreturn)) void hook_exec(char *path, char *arg[]) {
11 |   if (FAKE_FD[STDIN_FILENO] == true)
12 |     setenv("FAKE_STDIN", "1", 0);
13 |   if (FAKE_FD[STDOUT_FILENO] == true)
14 |     setenv("FAKE_STDOUT", "1", 0);
15 |   if (FAKE_FD[STDERR_FILENO] == true)
16 |     setenv("FAKE_STDERR", "1", 0);
17 | 
18 |   char *old_preload = getenv("LD_PRELOAD");
19 |   if (old_preload != NULL && strlen(old_preload) != 0) {
20 |     size_t old_len = strlen(PRELOAD);
21 |     PRELOAD[old_len] = ':';
22 |     PRELOAD[old_len + 1] = '\0';
23 |     strcat(PRELOAD + old_len + 1, old_preload);
24 |   }
25 | 
26 |   setenv("LD_PRELOAD", PRELOAD, 1);
27 |   execvp(path, arg);
28 |   perror("exec");
29 |   exit(1);
30 | }
31 | 


--------------------------------------------------------------------------------
/hook.h:
--------------------------------------------------------------------------------
1 | #ifndef HOOK_H
2 | #define HOOK_H
3 | 
4 | extern void hook_exec(char *path, char *arg[]);
5 | 
6 | #endif // HOOK_H
7 | 


--------------------------------------------------------------------------------
/libcolorthis.c:
--------------------------------------------------------------------------------
 1 | #include <dlfcn.h>
 2 | #include <stdbool.h>
 3 | #include <stdio.h>
 4 | #include <stdlib.h>
 5 | #include <unistd.h>
 6 | 
 7 | static int (*orig_isatty)(int) = NULL;
 8 | static bool FAKE_FD[3] = {false, false, false};
 9 | 
10 | int isatty(int fd) {
11 |   if (fd == STDIN_FILENO)
12 |     return FAKE_FD[STDIN_FILENO] ? true : orig_isatty(fd);
13 |   if (fd == STDOUT_FILENO)
14 |     return FAKE_FD[STDOUT_FILENO] ? true : orig_isatty(fd);
15 |   if (fd == STDERR_FILENO)
16 |     return FAKE_FD[STDERR_FILENO] ? true : orig_isatty(fd);
17 | 
18 |   return orig_isatty(fd);
19 | }
20 | 
21 | __attribute__((constructor)) static void setup(void) {
22 |   if (getenv("FAKE_STDIN") != NULL)
23 |     FAKE_FD[STDIN_FILENO] = true;
24 |   if (getenv("FAKE_STDOUT") != NULL)
25 |     FAKE_FD[STDOUT_FILENO] = true;
26 |   if (getenv("FAKE_STDERR") != NULL)
27 |     FAKE_FD[STDERR_FILENO] = true;
28 | 
29 |   void *libc = dlopen("libc.so.6", RTLD_LAZY);
30 |   if (libc == NULL) {
31 |     fprintf(stderr, "dlopen(): %s", dlerror());
32 |     exit(1);
33 |   }
34 | 
35 |   orig_isatty = (int (*)(int))dlsym(libc, "isatty");
36 |   if (orig_isatty == NULL) {
37 |     fprintf(stderr, "dlsym(): %s", dlerror());
38 |     exit(1);
39 |   }
40 | }
41 | 


--------------------------------------------------------------------------------
/main.c:
--------------------------------------------------------------------------------
 1 | #include <stdbool.h>
 2 | #include <stdio.h>
 3 | #include <stdlib.h>
 4 | #include <string.h>
 5 | #include <unistd.h>
 6 | 
 7 | #include <sys/types.h>
 8 | #include <sys/wait.h>
 9 | 
10 | #include "epoll.h"
11 | #include "hook.h"
12 | #include "pty.h"
13 | 
14 | bool FAKE_FD[3] = {false, false, false};
15 | static pid_t pid;
16 | 
17 | void showhelp(char *name) {
18 |   printf("Usage: %s <option> [application]\n", name);
19 |   printf("where options are\n");
20 |   printf("\t-stdin:   make stdin is a tty\n");
21 |   printf("\t-stdout:  make stdout is a tty\n");
22 |   printf("\t-stderr:  make stderr is a tty\n");
23 |   printf("\t-hook:    hook libc's isatty function\n");
24 |   printf("\t          NOTE: may not work well\n");
25 |   printf("where application like\n");
26 |   printf("\t          ls / </dev/null 2>/dev/null\n");
27 | }
28 | 
29 | void setup_sig(void);
30 | 
31 | int main(int argc, char *argv[]) {
32 |   int i;
33 |   bool use_hook = false;
34 | 
35 |   if (argc == 1) {
36 |     showhelp(argv[0]);
37 |     exit(1);
38 |   }
39 | 
40 |   for (i = 1; i < argc; i++) {
41 |     if (!strcmp(argv[i], "-stdin")) {
42 |       set_ter(STDIN_FILENO, ~ICANON & ~ECHO);
43 |       FAKE_FD[STDIN_FILENO] = true;
44 |     } else if (!strcmp(argv[i], "-stdout"))
45 |       FAKE_FD[STDOUT_FILENO] = true;
46 |     else if (!strcmp(argv[i], "-stderr"))
47 |       FAKE_FD[STDERR_FILENO] = true;
48 |     else if (!strcmp(argv[i], "-hook"))
49 |       use_hook = true;
50 |     else
51 |       break;
52 |   }
53 | 
54 |   if (use_hook) {
55 |     hook_exec(argv[i], argv + i);
56 |     return 0;
57 |   }
58 | 
59 |   pid = pty_fork_exec(argv[i], argv + i);
60 | 
61 |   setup_sig();
62 |   epoll_init();
63 |   start_loop();
64 | 
65 |   return waitpid(pid, NULL, 0);
66 | }
67 | 
68 | void sig_handler(int signo) {
69 |   switch (signo) {
70 |   case SIGCHLD:
71 |     exit(waitpid(pid, NULL, 0));
72 |   default:
73 |     kill(pid, signo);
74 |   }
75 | }
76 | 
77 | static struct sigaction sa;
78 | void setup_sig(void) {
79 |   sa.sa_flags = SA_RESTART;
80 |   sa.sa_handler = &sig_handler;
81 |   sigfillset(&sa.sa_mask);
82 |   if (sigaction(SIGCHLD, &sa, NULL) == -1 || // sub process exit
83 |       sigaction(SIGINT, &sa, NULL) == -1     // C-c
84 |   ) {
85 |     perror("handle signal");
86 |     exit(1);
87 |   }
88 | }
89 | 


--------------------------------------------------------------------------------
/pty.c:
--------------------------------------------------------------------------------
  1 | #include <stdbool.h>
  2 | #include <stdio.h>
  3 | #include <stdlib.h>
  4 | #include <string.h>
  5 | #include <unistd.h>
  6 | 
  7 | #include "pty.h"
  8 | 
  9 | extern int posix_openpt(int); // posix_openpt in libc
 10 | extern int grantpt(int);      // grantt in libc
 11 | extern int unlockpt(int);     // unlockpt in libc
 12 | extern char *ptsname(int);    // ptsname in libc
 13 | 
 14 | // 0 => don't use
 15 | // -1 => use this pty
 16 | int PTYS[3] = {0, 0, 0};
 17 | 
 18 | int ptym_open(char *ptyname) {
 19 |   int psfd = posix_openpt(O_RDWR);
 20 |   char *pty;
 21 | 
 22 |   if (psfd < 0)
 23 |     goto err_ptym;
 24 |   if (grantpt(psfd) < 0)
 25 |     goto err_ptym;
 26 |   if (unlockpt(psfd) < 0)
 27 |     goto err_ptym;
 28 |   if ((pty = ptsname(psfd)) == NULL)
 29 |     goto err_ptym;
 30 | 
 31 |   strcpy(ptyname, pty);
 32 |   return psfd;
 33 | 
 34 | err_ptym:
 35 |   perror(ptyname);
 36 |   return -1;
 37 | }
 38 | 
 39 | int ptys_open(char *ptyname) {
 40 |   int fd = open(ptyname, O_RDWR);
 41 |   if (fd < 0)
 42 |     goto err_ptys;
 43 | 
 44 |   return fd;
 45 | 
 46 | err_ptys:
 47 |   perror(ptyname);
 48 |   return -1;
 49 | }
 50 | 
 51 | pid_t pty_fork(int ptys[]) {
 52 |   pid_t pid;
 53 |   char pty_names[3][20];
 54 | 
 55 |   for (size_t i = 0; i < 3; i++) {
 56 |     if (ptys[i] == 0)
 57 |       continue;
 58 |     ptys[i] = ptym_open(pty_names[i]);
 59 |     if (i == STDIN_FILENO) {
 60 |       set_ter(ptys[STDIN_FILENO], ~ICANON & ~ECHO);
 61 |     }
 62 |     if(i == STDERR_FILENO){
 63 |         set_ter(ptys[STDERR_FILENO], ~ICANON);
 64 |     }
 65 |   }
 66 | 
 67 |   if ((pid = fork()) < 0) {
 68 |     perror("fork");
 69 |     return -1;
 70 |   } else if (pid == 0) { // child
 71 |     if (setsid() < 0) {
 72 |       perror("setsid");
 73 |       return -1;
 74 |     }
 75 |     for (size_t i = 0; i < 3; i++) {
 76 |       if (ptys[i] == 0)
 77 |         continue;
 78 | 
 79 |       int tmp_fd = ptys[i];
 80 |       if ((ptys[i] = ptys_open(pty_names[i])) < 0) {
 81 |         return -1;
 82 |       }
 83 |       close(tmp_fd);
 84 | 
 85 |       if (dup2(ptys[i], (int)i) != (int)i) {
 86 |         perror("dup2");
 87 |         return -1;
 88 |       }
 89 |       close(ptys[i]);
 90 |     }
 91 | 
 92 |     return 0;
 93 |   }
 94 |   // parent
 95 |   return pid;
 96 | }
 97 | 
 98 | extern bool FAKE_FD[3]; // in main.c
 99 | 
100 | int pty_fork_exec(char *path, char *arg[]) {
101 |   pid_t pid;
102 |   for (size_t i = 0; i < 3; i++) {
103 |     if (FAKE_FD[i] == true) {
104 |       PTYS[i] = -1;
105 |     }
106 |   }
107 | 
108 |   if ((pid = pty_fork(PTYS)) < 0) {
109 |     return -1;
110 |   } else if (pid == 0) {
111 |     execvp(path, arg);
112 |   }
113 |   return pid;
114 | }
115 | 
116 | void set_ter(int fd, tcflag_t flag) {
117 |   if (!isatty(fd))
118 |     return;
119 |   struct termios t;
120 |   tcgetattr(fd, &t);
121 |   t.c_lflag &= flag;
122 |   tcsetattr(fd, TCSANOW, &t);
123 | }
124 | 


--------------------------------------------------------------------------------
/pty.h:
--------------------------------------------------------------------------------
 1 | #ifndef PTY_H
 2 | #define PTY_H
 3 | #include <fcntl.h>
 4 | #include <termios.h>
 5 | 
 6 | extern int PTYS[3];
 7 | 
 8 | extern pid_t pty_fork(int ptys[]);
 9 | extern pid_t pty_fork_exec(char *path, char *arg[]);
10 | extern void set_ter(int fd, tcflag_t flag);
11 | 
12 | #endif // PTY_H
13 | 


--------------------------------------------------------------------------------
/test/target/c/main.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <unistd.h>
 3 | 
 4 | typedef struct {
 5 |   char *name;
 6 |   int fd;
 7 | } T;
 8 | 
 9 | int main() {
10 |   T t[3] = {
11 |       {.name = "STDIN", .fd = STDIN_FILENO},
12 |       {.name = "STDOUT", .fd = STDOUT_FILENO},
13 |       {.name = "STDERR", .fd = STDERR_FILENO},
14 |   };
15 | 
16 |   int all_is_tty = 0;
17 | 
18 |   for (int i = 0; i < 3; i++) {
19 |     if (isatty(t[i].fd)) {
20 |       printf("%s is a tty\n", t[i].name);
21 |     } else {
22 |       all_is_tty = 1;
23 |       printf("%s is not tty\n", t[i].name);
24 |     }
25 |   }
26 | 
27 |   return all_is_tty;
28 | }
29 | 


--------------------------------------------------------------------------------
/test/target/go/go.mod:
--------------------------------------------------------------------------------
1 | module isatty
2 | 
3 | go 1.12
4 | 
5 | require golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b
6 | 


--------------------------------------------------------------------------------
/test/target/go/go.sum:
--------------------------------------------------------------------------------
1 | golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b h1:ag/x1USPSsqHud38I9BAC88qdNLDHHtQ4mlgQIZPPNA=
2 | golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
3 | 


--------------------------------------------------------------------------------
/test/target/go/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"os"
 6 | 
 7 | 	"golang.org/x/sys/unix"
 8 | )
 9 | 
10 | type T struct {
11 | 	name string
12 | 	fd   uintptr
13 | }
14 | 
15 | func isatty(fd uintptr) bool {
16 | 	_, err := unix.IoctlGetTermios(int(fd), unix.TCGETS)
17 | 	return err == nil
18 | }
19 | 
20 | func main() {
21 | 	t := [3]T{
22 | 		T{"STDIN", os.Stdin.Fd()},
23 | 		T{"STDOUT", os.Stdout.Fd()},
24 | 		T{"STDERR", os.Stderr.Fd()},
25 | 	}
26 | 
27 | 	var all_is_tty = true
28 | 
29 | 	for _, v := range t {
30 | 		if isatty(v.fd) {
31 | 			fmt.Println(v.name, "is a TTY")
32 | 		} else {
33 | 			all_is_tty = false
34 | 			fmt.Println(v.name, "not a TTY")
35 | 		}
36 | 	}
37 | 
38 | 	if !all_is_tty {
39 | 		os.Exit(1)
40 | 	}
41 | }
42 | 


--------------------------------------------------------------------------------