1 /****************************************************************************
2 * Copyright (c) 1998-2009,2010 Free Software Foundation, Inc. *
4 * Permission is hereby granted, free of charge, to any person obtaining a *
5 * copy of this software and associated documentation files (the *
6 * "Software"), to deal in the Software without restriction, including *
7 * without limitation the rights to use, copy, modify, merge, publish, *
8 * distribute, distribute with modifications, sublicense, and/or sell *
9 * copies of the Software, and to permit persons to whom the Software is *
10 * furnished to do so, subject to the following conditions: *
12 * The above copyright notice and this permission notice shall be included *
13 * in all copies or substantial portions of the Software. *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
18 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
23 * Except as contained in this notice, the name(s) of the above copyright *
24 * holders shall not be used in advertising or otherwise to promote the *
25 * sale, use or other dealings in this Software without prior written *
27 ****************************************************************************/
30 * Author: Thomas E. Dickey (1998-on)
32 * $Id: ditto.c,v 1.40 2010/11/14 01:06:47 tom Exp $
34 * The program illustrates how to set up multiple screens from a single
37 * If openpty() is supported, the command line parameters are titles for
38 * the windows showing each screen's data.
40 * If openpty() is not supported, you must invoke the program by specifying
41 * another terminal on the same machine by specifying its device, e.g.,
44 #include <test.priv.h>
52 #include USE_OPENPTY_HEADER
57 #define THIS_FIFO(n) ((n) % MAX_FIFO)
58 #define NEXT_FIFO(n) THIS_FIFO((n) + 1)
61 unsigned long sequence
;
68 unsigned long sequence
;
72 * Data "owned" for a single screen. Each screen is divided into windows that
73 * show the text read from each terminal. Input from a given screen will also
74 * be read into one window per screen.
79 SCREEN
*screen
; /* this screen - curses internal data */
80 int which1
; /* this screen's index in DITTO[] array */
81 int length
; /* length of windows[] and peeks[] */
82 char **titles
; /* per-window titles */
83 WINDOW
**windows
; /* display data from each screen */
84 PEEK
*peeks
; /* indices for each screen's fifo */
85 FIFO fifo
; /* fifo for this screen */
92 * Structure used to pass multiple parameters via the use_screen()
93 * single-parameter interface.
96 int source
; /* which screen did character come from */
97 int target
; /* which screen is character going to */
98 DITTO
*ditto
; /* data for all screens */
102 failed(const char *s
)
105 ExitProgram(EXIT_FAILURE
);
111 fprintf(stderr
, "usage: ditto [terminal1 ...]\n");
112 ExitProgram(EXIT_FAILURE
);
115 /* Add to the head of the fifo, checking for overflow. */
117 put_fifo(FIFO
* fifo
, int value
)
119 int next
= NEXT_FIFO(fifo
->head
);
120 if (next
== fifo
->tail
)
121 fifo
->tail
= NEXT_FIFO(fifo
->tail
);
122 fifo
->data
[next
] = value
;
127 /* Get data from the tail (oldest part) of the fifo, returning -1 if no data.
128 * Since each screen can peek into the fifo, we do not update the tail index,
129 * but modify the peek-index.
131 * FIXME - test/workaround for case where fifo gets more than a buffer
135 peek_fifo(FIFO
* fifo
, PEEK
* peek
)
138 if (peek
->sequence
< fifo
->sequence
) {
139 result
= fifo
->data
[THIS_FIFO(peek
->sequence
)];
152 char slave_name
[1024];
153 char s_option
[sizeof(slave_name
) + 80];
155 if (openpty(&amaster
, &aslave
, slave_name
, 0, 0) != 0
156 || strlen(slave_name
) > sizeof(slave_name
) - 1)
158 if (strrchr(slave_name
, '/') == 0) {
162 sprintf(s_option
, "-S%s/%d", slave_name
, aslave
);
164 execlp("xterm", "xterm", s_option
, "-title", path
, (char *) 0);
167 fp
= fdopen(amaster
, "r+");
173 if (stat(path
, &sb
) < 0)
175 if ((sb
.st_mode
& S_IFMT
) != S_IFCHR
) {
179 fp
= fopen(path
, "r+");
182 printf("opened %s\n", path
);
191 SCREEN
*sp GCC_UNUSED
,
195 DITTO
*target
= (DITTO
*) arg
;
201 scrollok(stdscr
, TRUE
);
204 target
->windows
= typeCalloc(WINDOW
*, (size_t) target
->length
);
205 target
->peeks
= typeCalloc(PEEK
, (size_t) target
->length
);
207 high
= (LINES
- 2) / target
->length
;
209 for (k
= 0; k
< target
->length
; ++k
) {
210 WINDOW
*outer
= newwin(high
, wide
, 1 + (high
* k
), 1);
211 WINDOW
*inner
= derwin(outer
, high
- 2, wide
- 2, 1, 1);
214 MvWAddStr(outer
, 0, 2, target
->titles
[k
]);
217 scrollok(inner
, TRUE
);
220 nodelay(inner
, TRUE
);
223 target
->windows
[k
] = inner
;
229 open_screen(DITTO
* target
, char **source
, int length
, int which1
)
233 target
->output
= open_tty(source
[which1
]);
235 target
->input
= stdin
;
236 target
->output
= stdout
;
239 target
->which1
= which1
;
240 target
->titles
= source
;
241 target
->length
= length
;
242 target
->fifo
.head
= -1;
243 target
->screen
= newterm((char *) 0, /* assume $TERM is the same */
247 if (target
->screen
== 0)
250 (void) USING_SCREEN(target
->screen
, init_screen
, target
);
256 SCREEN
*sp GCC_UNUSED
,
258 void *arg GCC_UNUSED
)
268 * Read data from the 'source' screen.
273 SCREEN
*sp GCC_UNUSED
,
277 DDATA
*data
= (DDATA
*) arg
;
278 DITTO
*ditto
= &(data
->ditto
[data
->source
]);
279 WINDOW
*win
= ditto
->windows
[data
->source
];
280 int ch
= wgetch(win
);
282 if (ch
> 0 && ch
< 256)
283 put_fifo(&(ditto
->fifo
), ch
);
291 * Write all of the data that's in fifos for the 'target' screen.
296 SCREEN
*sp GCC_UNUSED
,
298 void *arg GCC_UNUSED
)
300 DDATA
*data
= (DDATA
*) arg
;
301 DITTO
*ditto
= &(data
->ditto
[data
->target
]);
302 bool changed
= FALSE
;
305 for (which
= 0; which
< ditto
->length
; ++which
) {
306 WINDOW
*win
= ditto
->windows
[which
];
307 FIFO
*fifo
= &(data
->ditto
[which
].fifo
);
308 PEEK
*peek
= &(ditto
->peeks
[which
]);
311 while ((ch
= peek_fifo(fifo
, peek
)) > 0) {
314 waddch(win
, (chtype
) ch
);
325 show_ditto(DITTO
* data
, int count
, DDATA
* ddata
)
330 for (n
= 0; n
< count
; n
++) {
332 USING_SCREEN(data
[n
].screen
, write_screen
, (void *) ddata
);
338 handle_screen(void *arg
)
343 memset(&ddata
, 0, sizeof(ddata
));
344 ddata
.ditto
= (DITTO
*) arg
;
345 ddata
.source
= ddata
.ditto
->which1
;
346 ddata
.ditto
-= ddata
.source
; /* -> base of array */
349 ch
= read_screen(ddata
.ditto
->screen
, &ddata
);
350 if (ch
== CTRL('D')) {
351 int later
= (ddata
.source
? ddata
.source
: -1);
354 for (j
= ddata
.ditto
->length
- 1; j
> 0; --j
) {
356 pthread_cancel(ddata
.ditto
[j
].thread
);
360 pthread_cancel(ddata
.ditto
[later
].thread
);
364 show_ditto(ddata
.ditto
, ddata
.ditto
->length
, &ddata
);
371 main(int argc
, char *argv
[])
382 if ((data
= typeCalloc(DITTO
, (size_t) argc
)) == 0)
383 failed("calloc data");
387 for (j
= 0; j
< argc
; j
++) {
388 open_screen(&data
[j
], argv
, argc
, j
);
393 * For multi-threaded operation, set up a reader for each of the screens.
394 * That uses blocking I/O rather than polling for input, so no calls to
395 * napms() are needed.
397 for (j
= 0; j
< argc
; j
++) {
398 (void) pthread_create(&(data
[j
].thread
), NULL
, handle_screen
, &data
[j
]);
400 pthread_join(data
[1].thread
, NULL
);
403 * Loop, reading characters from any of the inputs and writing to all
406 for (count
= 0;; ++count
) {
409 int which
= (count
% argc
);
413 ddata
.source
= which
;
416 ch
= USING_SCREEN(data
[which
].screen
, read_screen
, &ddata
);
417 if (ch
== CTRL('D')) {
419 } else if (ch
!= ERR
) {
420 show_ditto(data
, argc
, &ddata
);
428 for (j
= argc
- 1; j
>= 0; j
--) {
429 USING_SCREEN(data
[j
].screen
, close_screen
, 0);
430 fprintf(data
[j
].output
, "**Closed\r\n");
433 * Closing before a delscreen() helps ncurses determine that there
434 * is no valid output buffer, and can remove the setbuf() data.
436 fflush(data
[j
].output
);
437 fclose(data
[j
].output
);
438 delscreen(data
[j
].screen
);
440 ExitProgram(EXIT_SUCCESS
);