github
/
abduco
mirror of https://github.com/martanne/abduco
1
0
Fork 1
Code Issues Releases Wiki Activity

Compare commits

base: github:master
Branches Tags
github:master
github:coverity_scan
github:gh-pages
github:v0.6
github:v0.5
github:v0.4
github:v0.3
github:v0.2
github:v0.1
..
compare: github:v0.1
Branches Tags
github:master
github:coverity_scan
github:gh-pages
github:v0.6
github:v0.5
github:v0.4
github:v0.3
github:v0.2
github:v0.1

No commits in common. "master" and "v0.1" have entirely different histories.
master ... v0.1

24 changed files with 423 additions and 1505 deletions
Show Stats Expand all files Collapse all files

11
.builds/alpine.yml
View File

@ -1,11 +0,0 @@
image: alpine/edge
sources:
- https://github.com/martanne/abduco
tasks:
- build: |
cd abduco
./configure
make
- test: |
cd abduco
./testsuite.sh

11
.builds/debian.yml
View File

@ -1,11 +0,0 @@
image: debian/stable
sources:
- https://github.com/martanne/abduco
tasks:
- build: |
cd abduco
./configure
make
- test: |
cd abduco
./testsuite.sh

11
.builds/freebsd.yml
View File

@ -1,11 +0,0 @@
image: freebsd/latest
sources:
- https://github.com/martanne/abduco
tasks:
- build: |
cd abduco
./configure
make
- test: |
cd abduco
./testsuite.sh

11
.builds/openbsd.yml
View File

@ -1,11 +0,0 @@
image: openbsd/latest
sources:
- https://github.com/martanne/abduco
tasks:
- build: |
cd abduco
./configure
make
- test: |
cd abduco
./testsuite.sh

46
.github/workflows/coverity-scan.yml vendored
View File

@ -1,46 +0,0 @@
name: Coverity Scan
env:
PROJECT: abduco
on:
schedule:
- cron: '0 0 * * 0' # once a week
jobs:
scan:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Download Coverity Build Tool
run: |
wget -q https://scan.coverity.com/download/cxx/linux64 --post-data "token=$TOKEN&project=martanne/${PROJECT}" -O cov-analysis-linux64.tar.gz
mkdir cov-analysis-linux64
tar xzf cov-analysis-linux64.tar.gz --strip 1 -C cov-analysis-linux64
env:
TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
- name: Configure
run: ./configure
- name: Build with cov-build
run: |
export PATH=$(pwd)/cov-analysis-linux64/bin:$PATH
cov-build --dir cov-int make
- name: Submit the result to Coverity Scan
run: |
tar czvf ${PROJECT}.tgz cov-int
curl \
--form project=martanne/${PROJECT} \
--form token=$TOKEN \
--form email=mat@brain-dump.org \
--form file=@${PROJECT}.tgz \
--form version=trunk \
--form description="`./${PROJECT} -v`" \
https://scan.coverity.com/builds?project=martanne/${PROJECT}
env:
TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}

24
.github/workflows/macos.yml vendored
View File

@ -1,24 +0,0 @@
name: macOS
on: [push, pull_request]
jobs:
build:
strategy:
matrix:
os:
- macos-10.15
runs-on: ${{ matrix.os }}
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Build
run: |
./configure
make
- name: Test
run: |
./testsuite.sh

44
.github/workflows/man.yml vendored
View File

@ -1,44 +0,0 @@
name: Manual
env:
PROJECT: abduco
on:
push:
paths:
- '*.1'
jobs:
man:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v2
- name: Dependency
run: sudo apt install mandoc
- name: Manual generation
run: |
mkdir man
sed -e "s/VERSION/$(git describe --always)/" ${PROJECT}.1 | \
mandoc -W warning -T utf8 -T html -O man=%N.%S.html -O style=mandoc.css 1> \
"man/${PROJECT}.1.html" || true
wget 'https://cvsweb.bsd.lv/~checkout~/mandoc/mandoc.css?rev=1.46&content-type=text/plain' -O man/mandoc.css
ln -sf "${PROJECT}.1.html" man/index.html
- name: Upload
env:
DEPLOY_TOKEN: ${{ secrets.GIT_DEPLOY_TOKEN }}
run: |
git clone --depth=1 --single-branch --branch gh-pages "https://x-access-token:${DEPLOY_TOKEN}@github.com/${GITHUB_REPOSITORY}.git" /tmp/gh-pages
git config --global user.name "${GITHUB_ACTOR}"
git config --global user.email "${GITHUB_ACTOR}@users.noreply.github.com"
mkdir -p /tmp/gh-pages/man
rm -f /tmp/gh-pages/man/*
cp -av man/*.html /tmp/gh-pages/man/
cp -av man/*.css /tmp/gh-pages/man/
cd /tmp/gh-pages
git add -A && git commit --allow-empty -am "Publishing from ${GITHUB_REPOSITORY} ${GITHUB_SHA}"
git push origin gh-pages

16
.gitignore vendored
View File

@ -1,9 +1,7 @@
/config.h # normal ignores
/config.mk .*
/abduco *.[ao]
*.css *.lo
*.gcda *.so
*.gcno tags
*.gcov !.gitignore
*.html
*.o

4
LICENSE
View File

@ -1,6 +1,4 @@
ISC License Copyright (c) 2013-2014 Marc André Tanner <mat at brain-dump.org>
Copyright (c) 2013-2018 Marc André Tanner <mat at brain-dump.org>
Permission to use, copy, modify, and/or distribute this software for any Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above purpose with or without fee is hereby granted, provided that the above

70
Makefile
View File

@ -1,67 +1,61 @@
-include config.mk include config.mk
VERSION = 0.6 SRC += abduco.c
OBJ = ${SRC:.c=.o}
CFLAGS_STD ?= -std=c99 -D_POSIX_C_SOURCE=200809L -D_XOPEN_SOURCE=700 -DNDEBUG all: clean options abduco
CFLAGS_STD += -DVERSION=\"${VERSION}\"
LDFLAGS_STD ?= -lc -lutil options:
@echo abduco build options:
STRIP ?= strip @echo "CFLAGS = ${CFLAGS}"
INSTALL ?= install @echo "LDFLAGS = ${LDFLAGS}"
@echo "CC = ${CC}"
PREFIX ?= /usr/local
SHAREDIR ?= ${PREFIX}/share
SRC = abduco.c
all: abduco
config.h: config.h:
cp config.def.h config.h cp config.def.h config.h
config.mk: .c.o:
@touch $@ @echo CC $<
@${CC} -c ${CFLAGS} $<
abduco: config.h config.mk *.c ${OBJ}: config.h config.mk
${CC} ${CFLAGS} ${CFLAGS_STD} ${CFLAGS_AUTO} ${CFLAGS_EXTRA} ${SRC} ${LDFLAGS} ${LDFLAGS_STD} ${LDFLAGS_AUTO} -o $@
abduco: ${OBJ}
@echo CC -o $@
@${CC} -o $@ ${OBJ} ${LDFLAGS}
debug: clean debug: clean
make CFLAGS_EXTRA='${CFLAGS_DEBUG}' @make CFLAGS='${DEBUG_CFLAGS}'
clean: clean:
@echo cleaning @echo cleaning
@rm -f abduco abduco-*.tar.gz @rm -f abduco ${OBJ} abduco-${VERSION}.tar.gz
dist: clean dist: clean
@echo creating dist tarball @echo creating dist tarball
@git archive --prefix=abduco-${VERSION}/ -o abduco-${VERSION}.tar.gz HEAD @mkdir -p abduco-${VERSION}
@cp -R LICENSE Makefile README testsuite.sh config.def.h config.mk \
${SRC} debug.c client.c server.c forkpty-aix.c abduco.1 abduco-${VERSION}
@tar -cf abduco-${VERSION}.tar abduco-${VERSION}
@gzip abduco-${VERSION}.tar
@rm -rf abduco-${VERSION}
installdirs: install: abduco
@${INSTALL} -d ${DESTDIR}${PREFIX}/bin \ @echo stripping executable
${DESTDIR}${MANPREFIX}/man1 @strip -s abduco
install: abduco installdirs
@echo installing executable file to ${DESTDIR}${PREFIX}/bin @echo installing executable file to ${DESTDIR}${PREFIX}/bin
@${INSTALL} -m 0755 abduco ${DESTDIR}${PREFIX}/bin @mkdir -p ${DESTDIR}${PREFIX}/bin
@cp -f abduco ${DESTDIR}${PREFIX}/bin
@chmod 755 ${DESTDIR}${PREFIX}/bin/abduco
@echo installing manual page to ${DESTDIR}${MANPREFIX}/man1 @echo installing manual page to ${DESTDIR}${MANPREFIX}/man1
@mkdir -p ${DESTDIR}${MANPREFIX}/man1 @mkdir -p ${DESTDIR}${MANPREFIX}/man1
@sed "s/VERSION/${VERSION}/g" < abduco.1 > ${DESTDIR}${MANPREFIX}/man1/abduco.1 @sed "s/VERSION/${VERSION}/g" < abduco.1 > ${DESTDIR}${MANPREFIX}/man1/abduco.1
@chmod 644 ${DESTDIR}${MANPREFIX}/man1/abduco.1 @chmod 644 ${DESTDIR}${MANPREFIX}/man1/abduco.1
install-strip: install
${STRIP} ${DESTDIR}${PREFIX}/bin/abduco
install-completion:
@echo installing zsh completion file to ${DESTDIR}${SHAREDIR}/zsh/site-functions
@install -Dm644 contrib/abduco.zsh ${DESTDIR}${SHAREDIR}/zsh/site-functions/_abduco
uninstall: uninstall:
@echo removing executable file from ${DESTDIR}${PREFIX}/bin @echo removing executable file from ${DESTDIR}${PREFIX}/bin
@rm -f ${DESTDIR}${PREFIX}/bin/abduco @rm -f ${DESTDIR}${PREFIX}/bin/abduco
@echo removing manual page from ${DESTDIR}${MANPREFIX}/man1 @echo removing manual page from ${DESTDIR}${MANPREFIX}/man1
@rm -f ${DESTDIR}${MANPREFIX}/man1/abduco.1 @rm -f ${DESTDIR}${MANPREFIX}/man1/abduco.1
@echo removing zsh completion file from ${DESTDIR}${SHAREDIR}/zsh/site-functions
@rm -f ${DESTDIR}${SHAREDIR}/zsh/site-functions/_abduco
.PHONY: all clean dist install installdirs install-strip install-completion uninstall debug .PHONY: all options clean dist install uninstall debug

8
README Normal file
View File

@ -0,0 +1,8 @@
abduco
======
abduco provides the session management and attach/detach functionality
of screen(1) and tmux(1) together with dvtm(1) it is a nearly complete
replacement of the before mentioned tools.
See http://www.brain-dump.org/projects/abduco for the latest version.

185
README.md
View File

@ -1,185 +0,0 @@
# abduco a tool for session {at,de}tach support
[abduco](https://www.brain-dump.org/projects/abduco) provides
session management i.e. it allows programs to be run independently
from their controlling terminal. That is programs can be detached -
run in the background - and then later reattached. Together with
[dvtm](https://www.brain-dump.org/projects/dvtm) it provides a
simpler and cleaner alternative to tmux or screen.
![abduco+dvtm demo](https://raw.githubusercontent.com/martanne/abduco/gh-pages/screencast.gif#center)
abduco is in many ways very similar to [dtach](http://dtach.sf.net)
but is a completely independent implementation which is actively maintained,
contains no legacy code, provides a few additional features, has a
cleaner, more robust implementation and is distributed under the
[ISC license](https://raw.githubusercontent.com/martanne/abduco/master/LICENSE)
## News
* [abduco-0.6](https://www.brain-dump.org/projects/abduco/abduco-0.6.tar.gz)
[released](https://lists.suckless.org/dev/1603/28589.html) (24.03.2016)
* [abduco-0.5](https://www.brain-dump.org/projects/abduco/abduco-0.5.tar.gz)
[released](https://lists.suckless.org/dev/1601/28094.html) (09.01.2016)
* [abduco-0.4](https://www.brain-dump.org/projects/abduco/abduco-0.4.tar.gz)
[released](https://lists.suckless.org/dev/1503/26027.html) (18.03.2015)
* [abduco-0.3](https://www.brain-dump.org/projects/abduco/abduco-0.3.tar.gz)
[released](https://lists.suckless.org/dev/1502/25557.html) (19.02.2015)
* [abduco-0.2](https://www.brain-dump.org/projects/abduco/abduco-0.2.tar.gz)
[released](https://lists.suckless.org/dev/1411/24447.html) (15.11.2014)
* [abduco-0.1](https://www.brain-dump.org/projects/abduco/abduco-0.1.tar.gz)
[released](https://lists.suckless.org/dev/1407/22703.html) (05.07.2014)
* [Initial announcement](https://lists.suckless.org/dev/1403/20372.html)
on the suckless development mailing list (08.03.2014)
## Download
Either download the latest [source tarball](https://github.com/martanne/abduco/releases),
compile and install it
./configure && make && sudo make install
or use one of the distribution provided
[binary packages](https://repology.org/project/abduco/packages).
## Quickstart
In order to create a new session `abduco` requires a session name
as well as an command which will be run. If no command is given
the environment variable `$ABDUCO_CMD` is examined and if not set
`dvtm` is executed. Therefore assuming `dvtm` is located somewhere
in `$PATH` a new session named *demo* is created with:
$ abduco -c demo
An arbitrary application can be started as follows:
$ abduco -c session-name your-application
`CTRL-\` detaches from the active session. This detach key can be
changed by means of the `-e` command line option, `-e ^q` would
for example set it to `CTRL-q`.
To get an overview of existing session run `abduco` without any
arguments.
$ abduco
Active sessions (on host debbook)
* Thu 2015-03-12 12:05:20 demo-active
+ Thu 2015-03-12 12:04:50 demo-finished
Thu 2015-03-12 12:03:30 demo
A leading asterisk `*` indicates that at least one client is
connected. A leading plus `+` denotes that the session terminated,
attaching to it will print its exit status.
A session can be reattached by using the `-a` command line option
in combination with the session name which was used during session
creation.
$ abduco -a demo
If you encounter problems with incomplete redraws or other
incompatibilities it is recommended to run your applications
within [dvtm](https://github.com/martanne/dvtm) under abduco:
$ abduco -c demo dvtm your-application
Check out the manual page for further information and all available
command line options.
## Improvements over dtach
* **session list**, available by executing `abduco` without any arguments,
indicating whether clients are connected or the command has already
terminated.
* the **session exit status** of the command being run is always kept and
reported either upon command termination or on reconnection
e.g. the following works:
$ abduco -n demo true && abduco -a demo
abduco: demo: session terminated with exit status 0
* **read only sessions** if the `-r` command line argument is used when
attaching to a session, then all keyboard input is ignored and the
client is a passive observer only.
Note that this is not a security feature, but only a convenient way to
avoid accidental keyboard input.
If you want to make your abduco session available to another user
in a read only fashion, use [socat](http://www.dest-unreach.org/socat/)
to proxy the abduco socket in a unidirectional (from the abduco server
to the client, but not vice versa) way.
Start your to be shared session, make sure only you have access to
the `private` directory:
$ abduco -c /tmp/abduco/private/session
Then proxy the socket in unidirectional mode `-u` to a directory
where the desired observers have sufficient access rights:
$ socat -u unix-connect:/tmp/abduco/private/session unix-listen:/tmp/abduco/public/read-only &
Now the observers can connect to the read-only side of the socket:
$ abduco -a /tmp/abduco/public/read-only
communication in the other direction will not be possible and keyboard
input will hence be discarded.
* **better resize handling** on shared sessions, resize request are only
processed if they are initiated by the most recently connected, non
read only client.
* **socket recreation** by sending the `SIGUSR1` signal to the server
process. In case the unix domain socket was removed by accident it
can be recreated. The simplest way to find out the server process
id is to look for abduco processes which are reparented to the init
process.
$ pgrep -P 1 abduco
After finding the correct PID the socket can be recreated with
$ kill -USR1 $PID
If the abduco binary itself has also been deleted, but a session is
still running, use the following command to bring back the session:
$ /proc/$PID/exe
* **improved socket permissions** the session sockets are by default either
stored in `$HOME/.abduco` or `/tmp/abduco/$USER` in both cases it is
made sure that only the owner has access to the respective directory.
## Development
You can always fetch the current code base from the git repository
located at [Github](https://github.com/martanne/abduco/) or
[Sourcehut](https://git.sr.ht/~martanne/abduco).
If you have comments, suggestions, ideas, a bug report, a patch or something
else related to abduco then write to the
[suckless developer mailing list](https://suckless.org/community)
or contact me directly.
### Debugging
The protocol content exchanged between client and server can be dumped
to temporary files as follows:
$ make debug
$ ./abduco -n debug [command-to-debug] 2> server-log
$ ./abduco -a debug 2> client-log
If you want to run client and server with one command (e.g. using the `-c`
option) then within `gdb` the option `set follow-fork-mode {child,parent}`
might be useful. Similarly to get a syscall trace `strace -o abduco -ff
[abduco-cmd]` proved to be handy.
## License
abduco is licensed under the [ISC license](https://raw.githubusercontent.com/martanne/abduco/master/LICENSE)

337
abduco.1
View File

@ -1,226 +1,119 @@
.Dd March 18, 2018 .TH ABDUCO 1 abduco\-VERSION
.Dt ABDUCO 1 .nh
.Os abduco VERSION .SH NAME
. abduco
.Sh NAME .SH SYNOPSIS
.Nm abduco .B abduco
.Nd terminal session manager .RB [ \-e
. .IR detachkey ]
.Sh SYNOPSIS .RB \-c
.Nm .RB name
.Fl a .RB command
.Op options ... .RI [ args \ ... "" ]
.Cm name .br
. .B abduco
.Nm .RB [ \-r ]
.Fl A .RB [ \-e
.Op options ... .IR detachkey ]
.Cm name .RB \-n
.Cm command Op args ... .RB name
. .RB command
.Nm .RI [ args \ ... "" ]
.Fl c .br
.Op options ... .B abduco
.Cm name .RB [ \-e
.Cm command Op args ... .IR detachkey ]
. .RB \-A
.Nm .RB name
.Fl n .RB command
.Op options ... .RI [ args \ ... "" ]
.Cm name .br
.Cm command Op args ... .B abduco
. .RB [ \-r ]
.Sh DESCRIPTION .RB [ \-e
. .IR detachkey ]
.Nm .RB \-a
disassociates a given application from its controlling .RB name
terminal, thereby providing roughly the same session attach/detach support as .br
.Xr screen 1 , .SH DESCRIPTION
.Xr tmux 1 , .B abduco
or provides a way to disconnect a given application from its controlling
.Xr dtach 1 . terminal, thus it provides roughly the same session attach/detach support as
.Pp .BR screen(1) , " tmux(1)" " or" " dtach(1)".
A session comprises of an
.Nm If the
server process which spawns a user .BR command
command in its own pseudo terminal to execute is not specified, the environment variable
.Pq see Xr pty 7 . .BR $ABDUCO_CMD
Each session is given a name represented by a unix domain socket
.Pq see Xr unix 7
stored in the local file system.
.Nm
clients can connect to it and their standard input output streams
are relayed to the command supervised by the server.
.Pp
.Nm
operates on the raw I/O byte stream without interpreting any terminal
escape sequences.
As a consequence the terminal state is not preserved across sessions.
If this functionality is desired, it should be provided by another
utility such as
.Xr dvtm 1 .
.
.Ss ACTIONS
.
If no command line arguments are given, all currently active sessions are
listed sorted by their respective creation date.
Lines starting with an asterisk
.Pq *
indicate that at least one client is currently connected.
A plus sign
.Pq +
signals that the command terminated while no client was connected.
Attaching to the session will print its exit status.
The next column shows the PID of the server process, followed by the session
.Ic name .
.Pp
.Nm
provides different actions of which one must be provided.
.
.Bl -tag -width indent
.It Fl a
Attach to an existing session.
.It Fl A
Try to connect to an existing session, upon failure create said session and attach immediately to it.
.It Fl c
Create a new session and attach immediately to it.
.It Fl n
Create a new session but do not attach to it.
.El
.
.Ss OPTIONS
.
Additionally the following options can be provided to further tweak
the behavior.
.Bl -tag -width indent
.It Fl e Ar detachkey
Set the key to detach.
Defaults to
.Aq Ctrl+\e
which is specified as ^\\ i.e. Ctrl is represented as a caret
.Pq ^ .
.It Fl f
Force creation of session when there is an already terminated session of the same name,
after showing its exit status.
.It Fl l
Attach with the lowest priority, meaning this client will be the last to control the size.
.It Fl p
Pass through content of standard input to the session.
Implies the
.Fl q
and
.Fl l
options.
.It Fl q
Be quiet, do not print informative messages.
.It Fl r
Read-only session, user input is ignored.
.It Fl v
Print version information and exit.
.El
.
.Sh SIGNALS
.
.Bl -tag -width indent
.It Dv SIGWINCH
Whenever the primary client resizes its terminal the server process will deliver a
.Ev SIGWINCH
signal to the supervised process.
.It Dv SIGUSR1
If for some reason the unix domain socket representing a session is deleted, sending
.Ev SIGUSR1
to the server process will recreate it.
.It Dv SIGTERM
Detaches a client.
.El
.
.Sh ENVIRONMENT
.
.Bl -tag -width indent
.It Ev ABDUCO_CMD
If
.Ic command
is not specified, the environment variable
.Ev $ABDUCO_CMD
is examined, if it is not set is examined, if it is not set
.Xr dvtm 1 .BR dvtm(1)
is executed. is executed.
.It Ev ABDUCO_SESSION
The current session name available to the supervised command. By default all session related information is stored in
.It Ev ABDUCO_SOCKET .B $HOME/.abduco
The absolute path of the session socket available to the supervised command.
.El
.Pp
See the
.Sx FILES
section for environment variables used in determining the location
of unix domain sockets representing sessions.
.Sh FILES
.
All session related information is stored in the following directories (first
to succeed is used):
.Bl -bullet
.It
.Ev $ABDUCO_SOCKET_DIR/abduco
.It
.Ev $HOME/.abduco
.It
.Ev $TMPDIR/abduco/$USER
.It
.Ev /tmp/abduco/$USER
.El
.
.Pp
However, if a given session
.Ic name
represents either a relative or absolute path it is used unmodified.
.
.
.Sh EXAMPLES
.
Start a new session (assuming
.Xr dvtm 1
is in
.Ev $PATH )
with with
.Pp .BR $TMPDIR/.abduco
.Dl $ abduco -c my-session as a fallback and
.Pp .BR /tmp/.abduco
as a last resort.
However if a given session name represents either a relative or absolute path
it is used unmodified.
If for some reason the
.BR unix(7)
domain socket representing a session is deleted, sending
.BR SIGUSR1
to the server process will recreate it.
.SH OPTIONS
If no command line arguments are given all currently active sessions are
printed sorted by their respective creation date. Lines starting with an
asterik
.BR *
indicate that at least one client is connected.
A plus sign
.BR +
indicates that the command terminated while no client was connected, attach
to get its exit status.
.TP
.B \-v
Print version information to standard output and exit.
.TP
.B \-r
Readonly session, i.e. user input is ignored.
.TP
.BI \-e \ detachkey
Set the key to detach which by default is set to CTRL+\\ i.e. ^\\ to detachkey.
.TP
.BI \-c
Create a new session and attach immediately to it.
.TP
.BI \-n
Create a new session but do not attach to it.
.TP
.BI \-A
Try to connect to an existing session, upon failure create said session and attach immediately to it.
.TP
.BI \-a
Attach to an existing session.
.SH EXAMPLE
Start a new session (assuming
.BR dvtm(1)
is in
.BR $PATH )
with
.nf
.B abduco -c my-session
.fi
do some work, then detach by pressing do some work, then detach by pressing
.Aq Ctrl+\e , .B CTRL+\e
list existing session by running and later reattach with
.Nm .nf
without any arguments and later reattach with
.Pp .B abduco -a my-session
.Dl $ abduco -a my-session
.Pp .fi
Alternatively, we can also explicitly specify the command to run. .SH AUTHOR
.Pp abduco is written by Marc André Tanner <mat at brain-dump.org>
.Dl $ abduco -c my-session /bin/sh
.Pp
Attach with a
.Aq Ctrl+z
as detach key.
.Pp
.Dl $ abduco -e ^z -a my-session
.Pp
Send a command to an existing session.
.Pp
.Dl $ echo make | abduco -a my-session
.Pp
Or in a slightly more interactive fashion.
.Pp
.Dl $ abduco -p my-session
.Dl make
.Dl ^D
.
.Sh SEE ALSO
.Xr dvtm 1 ,
.Xr dtach 1 ,
.Xr tmux 1 ,
.Xr screen 1
.
.Sh AUTHORS
.Nm
is written by
.An Marc André Tanner Aq mat at brain-dump.org

423
abduco.c
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2018 Marc André Tanner <mat at brain-dump.org> * Copyright (c) 2013-2014 Marc André Tanner <mat at brain-dump.org>
* *
* Permission to use, copy, modify, and/or distribute this software for any * Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above * purpose with or without fee is hereby granted, provided that the above
@ -13,9 +13,9 @@
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/ */
#define _GNU_SOURCE
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <inttypes.h>
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdlib.h> #include <stdlib.h>
@ -29,8 +29,6 @@
#include <termios.h> #include <termios.h>
#include <time.h> #include <time.h>
#include <unistd.h> #include <unistd.h>
#include <pwd.h>
#include <sys/select.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <sys/types.h> #include <sys/types.h>
@ -39,7 +37,7 @@
#include <sys/un.h> #include <sys/un.h>
#if defined(__linux__) || defined(__CYGWIN__) #if defined(__linux__) || defined(__CYGWIN__)
# include <pty.h> # include <pty.h>
#elif defined(__FreeBSD__) || defined(__DragonFly__) #elif defined(__FreeBSD__)
# include <libutil.h> # include <libutil.h>
#elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__) #elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
# include <util.h> # include <util.h>
@ -54,10 +52,8 @@
#include "config.h" #include "config.h"
#if defined(_AIX) #ifdef _AIX
# include "forkpty-aix.c" # include "forkpty-aix.c"
#elif defined(__sun)
# include "forkpty-sunos.c"
#endif #endif
#define countof(arr) (sizeof(arr) / sizeof((arr)[0])) #define countof(arr) (sizeof(arr) / sizeof((arr)[0]))
@ -67,21 +63,18 @@ enum PacketType {
MSG_ATTACH = 1, MSG_ATTACH = 1,
MSG_DETACH = 2, MSG_DETACH = 2,
MSG_RESIZE = 3, MSG_RESIZE = 3,
MSG_EXIT = 4, MSG_REDRAW = 4,
MSG_PID = 5, MSG_EXIT = 5,
}; };
typedef struct { typedef struct {
uint32_t type; unsigned int type;
uint32_t len; size_t len;
union { union {
char msg[4096 - 2*sizeof(uint32_t)]; char msg[BUFSIZ];
struct { struct winsize ws;
uint16_t rows; int i;
uint16_t cols; bool b;
} ws;
uint32_t i;
uint64_t l;
} u; } u;
} Packet; } Packet;
@ -95,10 +88,7 @@ struct Client {
STATE_DISCONNECTED, STATE_DISCONNECTED,
} state; } state;
bool need_resize; bool need_resize;
enum { bool readonly;
CLIENT_READONLY = 1 << 0,
CLIENT_LOWPRIORITY = 1 << 1,
} flags;
Client *next; Client *next;
}; };
@ -114,20 +104,19 @@ typedef struct {
volatile sig_atomic_t running; volatile sig_atomic_t running;
const char *name; const char *name;
const char *session_name; const char *session_name;
char host[255];
bool read_pty; bool read_pty;
} Server; } Server;
static Server server = { .running = true, .exit_status = -1, .host = "@localhost" }; static Server server = { .running = true, .exit_status = -1 };
static Client client; static Client client;
static struct termios orig_term, cur_term; static struct termios orig_term, cur_term;
static bool has_term, alternate_buffer, quiet, passthrough; bool has_term;
static struct sockaddr_un sockaddr = { static struct sockaddr_un sockaddr = {
.sun_family = AF_UNIX, .sun_family = AF_UNIX,
}; };
static bool set_socket_name(struct sockaddr_un *sockaddr, const char *name); static int create_socket(const char *name);
static void die(const char *s); static void die(const char *s);
static void info(const char *str, ...); static void info(const char *str, ...);
@ -181,8 +170,6 @@ static ssize_t read_all(int fd, char *buf, size_t len) {
static bool send_packet(int socket, Packet *pkt) { static bool send_packet(int socket, Packet *pkt) {
size_t size = packet_size(pkt); size_t size = packet_size(pkt);
if (size > sizeof(*pkt))
return false;
return write_all(socket, (char *)pkt, size) == size; return write_all(socket, (char *)pkt, size) == size;
} }
@ -190,10 +177,6 @@ static bool recv_packet(int socket, Packet *pkt) {
ssize_t len = read_all(socket, (char*)pkt, packet_header_size()); ssize_t len = read_all(socket, (char*)pkt, packet_header_size());
if (len <= 0 || len != packet_header_size()) if (len <= 0 || len != packet_header_size())
return false; return false;
if (pkt->len > sizeof(pkt->u.msg)) {
pkt->len = 0;
return false;
}
if (pkt->len > 0) { if (pkt->len > 0) {
len = read_all(socket, pkt->u.msg, pkt->len); len = read_all(socket, pkt->u.msg, pkt->len);
if (len <= 0 || len != pkt->len) if (len <= 0 || len != pkt->len)
@ -208,12 +191,13 @@ static bool recv_packet(int socket, Packet *pkt) {
static void info(const char *str, ...) { static void info(const char *str, ...) {
va_list ap; va_list ap;
va_start(ap, str); va_start(ap, str);
if (str && !quiet) { fprintf(stderr, "\e[999H");
if (str) {
fprintf(stderr, "%s: %s: ", server.name, server.session_name); fprintf(stderr, "%s: %s: ", server.name, server.session_name);
vfprintf(stderr, str, ap); vfprintf(stderr, str, ap);
fprintf(stderr, "\r\n"); fprintf(stderr, "\r\n");
fflush(stderr);
} }
fflush(stderr);
va_end(ap); va_end(ap);
} }
@ -222,172 +206,62 @@ static void die(const char *s) {
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
static void usage(void) { static void usage() {
fprintf(stderr, "usage: abduco [-a|-A|-c|-n] [-p] [-r] [-q] [-l] [-f] [-e detachkey] name command\n"); fprintf(stderr, "usage: abduco [-a|-A|-c|-n] [-r] [-e detachkey] name command\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
static bool xsnprintf(char *buf, size_t size, const char *fmt, ...) { static int create_socket_dir() {
va_list ap; size_t maxlen = sizeof(sockaddr.sun_path);
if (size > INT_MAX) char *dirs[] = { getenv("HOME"), getenv("TMPDIR"), "/tmp" };
return false; int socketfd = socket(AF_LOCAL, SOCK_STREAM, 0);
va_start(ap, fmt);
int n = vsnprintf(buf, size, fmt, ap);
va_end(ap);
if (n == -1)
return false;
if (n >= size) {
errno = ENAMETOOLONG;
return false;
}
return true;
}
static int session_connect(const char *name) {
int fd;
struct stat sb;
if (!set_socket_name(&sockaddr, name) || (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
return -1;
socklen_t socklen = offsetof(struct sockaddr_un, sun_path) + strlen(sockaddr.sun_path) + 1;
if (connect(fd, (struct sockaddr*)&sockaddr, socklen) == -1) {
if (errno == ECONNREFUSED && stat(sockaddr.sun_path, &sb) == 0 && S_ISSOCK(sb.st_mode))
unlink(sockaddr.sun_path);
close(fd);
return -1;
}
return fd;
}
static pid_t session_exists(const char *name) {
Packet pkt;
pid_t pid = 0;
if ((server.socket = session_connect(name)) == -1)
return pid;
if (client_recv_packet(&pkt) && pkt.type == MSG_PID)
pid = pkt.u.l;
close(server.socket);
return pid;
}
static bool session_alive(const char *name) {
struct stat sb;
return session_exists(name) &&
stat(sockaddr.sun_path, &sb) == 0 &&
S_ISSOCK(sb.st_mode) && (sb.st_mode & S_IXGRP) == 0;
}
static bool create_socket_dir(struct sockaddr_un *sockaddr) {
sockaddr->sun_path[0] = '\0';
int socketfd = socket(AF_UNIX, SOCK_STREAM, 0);
if (socketfd == -1) if (socketfd == -1)
return false; return -1;
for (unsigned int i = 0; i < countof(dirs); i++) {
const size_t maxlen = sizeof(sockaddr->sun_path); char *dir = dirs[i];
uid_t uid = getuid(); if (!dir)
struct passwd *pw = getpwuid(uid);
for (unsigned int i = 0; i < countof(socket_dirs); i++) {
struct stat sb;
struct Dir *dir = &socket_dirs[i];
bool ishome = false;
if (dir->env) {
dir->path = getenv(dir->env);
ishome = !strcmp(dir->env, "HOME");
if (ishome && (!dir->path || !dir->path[0]) && pw)
dir->path = pw->pw_dir;
}
if (!dir->path || !dir->path[0])
continue; continue;
if (!xsnprintf(sockaddr->sun_path, maxlen, "%s/%s%s/", dir->path, ishome ? "." : "", server.name)) int len = snprintf(sockaddr.sun_path, maxlen, "%s/.%s/", dir, server.name);
if (len < 0 || (size_t)len >= maxlen)
continue; continue;
mode_t mask = umask(0); if (mkdir(sockaddr.sun_path, 0750) == -1 && errno != EEXIST)
int r = mkdir(sockaddr->sun_path, dir->personal ? S_IRWXU : S_IRWXU|S_IRWXG|S_IRWXO|S_ISVTX);
umask(mask);
if (r != 0 && errno != EEXIST)
continue; continue;
if (lstat(sockaddr->sun_path, &sb) != 0) int len2 = snprintf(sockaddr.sun_path, maxlen, "%s/.%s/.abduco-%d", dir, server.name, getpid());
if (len2 < 0 || (size_t)len2 >= maxlen)
continue; continue;
if (!S_ISDIR(sb.st_mode)) { socklen_t socklen = offsetof(struct sockaddr_un, sun_path) + strlen(sockaddr.sun_path) + 1;
errno = ENOTDIR; if (bind(socketfd, (struct sockaddr*)&sockaddr, socklen) == -1)
continue; continue;
} unlink(sockaddr.sun_path);
size_t dirlen = strlen(sockaddr->sun_path);
if (!dir->personal) {
/* create subdirectory only accessible to user */
if (pw && !xsnprintf(sockaddr->sun_path+dirlen, maxlen-dirlen, "%s/", pw->pw_name))
continue;
if (!pw && !xsnprintf(sockaddr->sun_path+dirlen, maxlen-dirlen, "%d/", uid))
continue;
if (mkdir(sockaddr->sun_path, S_IRWXU) != 0 && errno != EEXIST)
continue;
if (lstat(sockaddr->sun_path, &sb) != 0)
continue;
if (!S_ISDIR(sb.st_mode)) {
errno = ENOTDIR;
continue;
}
dirlen = strlen(sockaddr->sun_path);
}
if (sb.st_uid != uid || sb.st_mode & (S_IRWXG|S_IRWXO)) {
errno = EACCES;
continue;
}
if (!xsnprintf(sockaddr->sun_path+dirlen, maxlen-dirlen, ".abduco-%d", getpid()))
continue;
socklen_t socklen = offsetof(struct sockaddr_un, sun_path) + strlen(sockaddr->sun_path) + 1;
if (bind(socketfd, (struct sockaddr*)sockaddr, socklen) == -1)
continue;
unlink(sockaddr->sun_path);
close(socketfd); close(socketfd);
sockaddr->sun_path[dirlen] = '\0'; sockaddr.sun_path[len] = '\0';
return true; return len;
} }
close(socketfd); close(socketfd);
return false; return -1;
} }
static bool set_socket_name(struct sockaddr_un *sockaddr, const char *name) { static int create_socket(const char *name) {
const size_t maxlen = sizeof(sockaddr->sun_path); size_t maxlen = sizeof(sockaddr.sun_path);
const char *session_name = NULL;
char buf[maxlen];
if (name[0] == '/') { if (name[0] == '/') {
if (strlen(name) >= maxlen) { strncpy(sockaddr.sun_path, name, maxlen);
errno = ENAMETOOLONG; if (sockaddr.sun_path[maxlen-1])
return false; return -1;
}
strncpy(sockaddr->sun_path, name, maxlen);
} else if (name[0] == '.' && (name[1] == '.' || name[1] == '/')) { } else if (name[0] == '.' && (name[1] == '.' || name[1] == '/')) {
char *cwd = getcwd(buf, sizeof buf); char buf[maxlen], *cwd = getcwd(buf, sizeof buf);
if (!cwd) if (!cwd)
return false; return -1;
if (!xsnprintf(sockaddr->sun_path, maxlen, "%s/%s", cwd, name)) int len = snprintf(sockaddr.sun_path, maxlen, "%s/%s", cwd, name);
return false; if (len < 0 || (size_t)len >= maxlen)
return -1;
} else { } else {
if (!create_socket_dir(sockaddr)) int len = create_socket_dir(), rem = strlen(name);
return false; if (len == -1 || maxlen - len - rem <= 0)
if (strlen(sockaddr->sun_path) + strlen(name) + strlen(server.host) >= maxlen) { return -1;
errno = ENAMETOOLONG; strncat(sockaddr.sun_path, name, maxlen - len - 1);
return false;
}
session_name = name;
strncat(sockaddr->sun_path, name, maxlen - strlen(sockaddr->sun_path) - 1);
strncat(sockaddr->sun_path, server.host, maxlen - strlen(sockaddr->sun_path) - 1);
} }
return socket(AF_LOCAL, SOCK_STREAM, 0);
if (!session_name) {
strncpy(buf, sockaddr->sun_path, sizeof buf);
session_name = basename(buf);
}
setenv("ABDUCO_SESSION", session_name, 1);
setenv("ABDUCO_SOCKET", sockaddr->sun_path, 1);
return true;
} }
static bool create_session(const char *name, char * const argv[]) { static bool create_session(const char *name, char * const argv[]) {
@ -405,11 +279,6 @@ static bool create_session(const char *name, char * const argv[]) {
char errormsg[255]; char errormsg[255];
struct sigaction sa; struct sigaction sa;
if (session_exists(name)) {
errno = EADDRINUSE;
return false;
}
if (pipe(client_pipe) == -1) if (pipe(client_pipe) == -1)
return false; return false;
if ((server.socket = server_create_socket(name)) == -1) if ((server.socket = server_create_socket(name)) == -1)
@ -435,11 +304,10 @@ static bool create_session(const char *name, char * const argv[]) {
case 0: /* child = user application process */ case 0: /* child = user application process */
close(server.socket); close(server.socket);
close(server_pipe[0]); close(server_pipe[0]);
if (fcntl(client_pipe[1], F_SETFD, FD_CLOEXEC) == 0 && fcntl(client_pipe[1], F_SETFD, FD_CLOEXEC);
fcntl(server_pipe[1], F_SETFD, FD_CLOEXEC) == 0) fcntl(server_pipe[1], F_SETFD, FD_CLOEXEC);
execvp(argv[0], argv); execvp(argv[0], argv);
snprintf(errormsg, sizeof(errormsg), "server-execvp: %s: %s\n", snprintf(errormsg, sizeof(errormsg), "server-execvp: %s\n", strerror(errno));
argv[0], strerror(errno));
write_all(client_pipe[1], errormsg, strlen(errormsg)); write_all(client_pipe[1], errormsg, strlen(errormsg));
write_all(server_pipe[1], errormsg, strlen(errormsg)); write_all(server_pipe[1], errormsg, strlen(errormsg));
close(client_pipe[1]); close(client_pipe[1]);
@ -463,16 +331,12 @@ static bool create_session(const char *name, char * const argv[]) {
sa.sa_handler = SIG_IGN; sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, NULL); sigaction(SIGPIPE, &sa, NULL);
sigaction(SIGHUP, &sa, NULL); sigaction(SIGHUP, &sa, NULL);
if (chdir("/") == -1) chdir("/");
_exit(EXIT_FAILURE);
#ifdef NDEBUG #ifdef NDEBUG
int fd = open("/dev/null", O_RDWR); int fd = open("/dev/null", O_RDWR);
if (fd != -1) { dup2(fd, 0);
dup2(fd, STDIN_FILENO); dup2(fd, 1);
dup2(fd, STDOUT_FILENO); dup2(fd, 2);
dup2(fd, STDERR_FILENO);
close(fd);
}
#endif /* NDEBUG */ #endif /* NDEBUG */
close(client_pipe[1]); close(client_pipe[1]);
close(server_pipe[1]); close(server_pipe[1]);
@ -501,7 +365,8 @@ static bool create_session(const char *name, char * const argv[]) {
return false; return false;
default: /* parent = client process */ default: /* parent = client process */
close(client_pipe[1]); close(client_pipe[1]);
while (waitpid(pid, NULL, 0) == -1 && errno == EINTR); int status;
wait(&status); /* wait for first fork */
ssize_t len = read_all(client_pipe[0], errormsg, sizeof(errormsg)); ssize_t len = read_all(client_pipe[0], errormsg, sizeof(errormsg));
if (len > 0) { if (len > 0) {
write_all(STDERR_FILENO, errormsg, len); write_all(STDERR_FILENO, errormsg, len);
@ -513,10 +378,13 @@ static bool create_session(const char *name, char * const argv[]) {
return true; return true;
} }
static bool attach_session(const char *name, const bool terminate) { static bool attach_session(const char *name) {
if (server.socket > 0) if (server.socket > 0)
close(server.socket); close(server.socket);
if ((server.socket = session_connect(name)) == -1) if ((server.socket = create_socket(name)) == -1)
return false;
socklen_t socklen = offsetof(struct sockaddr_un, sun_path) + strlen(sockaddr.sun_path) + 1;
if (connect(server.socket, (struct sockaddr*)&sockaddr, socklen) == -1)
return false; return false;
if (server_set_socket_non_blocking(server.socket) == -1) if (server_set_socket_non_blocking(server.socket) == -1)
return false; return false;
@ -528,8 +396,19 @@ static bool attach_session(const char *name, const bool terminate) {
sigaction(SIGWINCH, &sa, NULL); sigaction(SIGWINCH, &sa, NULL);
sa.sa_handler = SIG_IGN; sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, NULL); sigaction(SIGPIPE, &sa, NULL);
atexit(client_restore_terminal);
cur_term = orig_term;
cur_term.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON|IXOFF);
cur_term.c_oflag &= ~(OPOST);
cur_term.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
cur_term.c_cflag &= ~(CSIZE|PARENB);
cur_term.c_cflag |= CS8;
cur_term.c_cc[VLNEXT] = _POSIX_VDISABLE;
cur_term.c_cc[VMIN] = 1;
cur_term.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSADRAIN, &cur_term);
client_setup_terminal();
int status = client_mainloop(); int status = client_mainloop();
client_restore_terminal(); client_restore_terminal();
if (status == -1) { if (status == -1) {
@ -538,15 +417,14 @@ static bool attach_session(const char *name, const bool terminate) {
info("exited due to I/O errors"); info("exited due to I/O errors");
} else { } else {
info("session terminated with exit status %d", status); info("session terminated with exit status %d", status);
if (terminate) exit(status);
exit(status);
} }
return terminate; return true;
} }
static int session_filter(const struct dirent *d) { static int session_filter(const struct dirent *d) {
return strstr(d->d_name, server.host) != NULL; return d->d_name[0] != '.';
} }
static int session_comparator(const struct dirent **a, const struct dirent **b) { static int session_comparator(const struct dirent **a, const struct dirent **b) {
@ -558,33 +436,25 @@ static int session_comparator(const struct dirent **a, const struct dirent **b)
return sa.st_atime < sb.st_atime ? -1 : 1; return sa.st_atime < sb.st_atime ? -1 : 1;
} }
static int list_session(void) { static int list_session() {
if (!create_socket_dir(&sockaddr)) if (create_socket_dir() == -1)
return 1; return 1;
if (chdir(sockaddr.sun_path) == -1) chdir(sockaddr.sun_path);
die("list-session");
struct dirent **namelist; struct dirent **namelist;
int n = scandir(sockaddr.sun_path, &namelist, session_filter, session_comparator); int n = scandir(sockaddr.sun_path, &namelist, session_filter, session_comparator);
if (n < 0) if (n < 0)
return 1; return 1;
printf("Active sessions (on host %s)\n", server.host+1); puts("Active sessions");
while (n--) { while (n--) {
struct stat sb; char buf[255]; struct stat sb; char buf[255];
if (stat(namelist[n]->d_name, &sb) == 0 && S_ISSOCK(sb.st_mode)) { if (stat(namelist[n]->d_name, &sb) == 0 && S_ISSOCK(sb.st_mode)) {
pid_t pid = 0; strftime(buf, sizeof(buf), "%a%t %F %T", localtime(&sb.st_atime));
strftime(buf, sizeof(buf), "%a%t %F %T", localtime(&sb.st_mtime));
char status = ' '; char status = ' ';
char *local = strstr(namelist[n]->d_name, server.host);
if (local) {
*local = '\0'; /* truncate hostname if we are local */
if (!(pid = session_exists(namelist[n]->d_name)))
continue;
}
if (sb.st_mode & S_IXUSR) if (sb.st_mode & S_IXUSR)
status = '*'; status = '*';
else if (sb.st_mode & S_IXGRP) else if (sb.st_mode & S_IXGRP)
status = '+'; status = '+';
printf("%c %s\t%jd\t%s\n", status, buf, (intmax_t)pid, namelist[n]->d_name); printf("%c %s\t%s\n", status, buf, namelist[n]->d_name);
} }
free(namelist[n]); free(namelist[n]);
} }
@ -593,83 +463,58 @@ static int list_session(void) {
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
int opt;
bool force = false;
char **cmd = NULL, action = '\0'; char **cmd = NULL, action = '\0';
char *default_cmd[4] = { "/bin/sh", "-c", getenv("ABDUCO_CMD"), NULL };
if (!default_cmd[2]) {
default_cmd[0] = ABDUCO_CMD;
default_cmd[1] = NULL;
}
server.name = basename(argv[0]); server.name = basename(argv[0]);
gethostname(server.host+1, sizeof(server.host) - 1); if (argc == 1)
exit(list_session());
while ((opt = getopt(argc, argv, "aAclne:fpqrv")) != -1) { for (int arg = 1; arg < argc; arg++) {
switch (opt) { if (argv[arg][0] != '-') {
if (!server.session_name) {
server.session_name = argv[arg];
continue;
} else if (!cmd) {
cmd = &argv[arg];
break;
}
}
if (server.session_name)
usage();
switch (argv[arg][1]) {
case 'a': case 'a':
case 'A': case 'A':
case 'c': case 'c':
case 'n': case 'n':
action = opt; action = argv[arg][1];
break; break;
case 'e': case 'e':
if (!optarg) if (arg + 1 >= argc)
usage(); usage();
if (optarg[0] == '^' && optarg[1]) char *esc = argv[++arg];
optarg[0] = CTRL(optarg[1]); if (esc[0] == '^' && esc[1])
KEY_DETACH = optarg[0]; *esc = CTRL(esc[1]);
break; KEY_DETACH = *esc;
case 'f':
force = true;
break;
case 'p':
passthrough = true;
break;
case 'q':
quiet = true;
break; break;
case 'r': case 'r':
client.flags |= CLIENT_READONLY; client.readonly = true;
break;
case 'l':
client.flags |= CLIENT_LOWPRIORITY;
break; break;
case 'v': case 'v':
puts("abduco-"VERSION" © 2013-2018 Marc André Tanner"); puts("abduco-"VERSION" © 2013-2014 Marc André Tanner");
exit(EXIT_SUCCESS); exit(EXIT_SUCCESS);
default: default:
usage(); usage();
} }
} }
/* collect the session name if trailing args */ if (!cmd) {
if (optind < argc) cmd = (char*[]){ getenv("ABDUCO_CMD"), NULL };
server.session_name = argv[optind]; if (!cmd[0])
cmd[0] = "dvtm";
/* if yet more trailing arguments, they must be the command */
if (optind + 1 < argc)
cmd = &argv[optind + 1];
else
cmd = default_cmd;
if (server.session_name && !isatty(STDIN_FILENO))
passthrough = true;
if (passthrough) {
if (!action)
action = 'a';
quiet = true;
client.flags |= CLIENT_LOWPRIORITY;
} }
if (!action && !server.session_name) if (!action || !server.session_name || ((action == 'c' || action == 'A') && client.readonly))
exit(list_session());
if (!action || !server.session_name)
usage(); usage();
if (!passthrough && tcgetattr(STDIN_FILENO, &orig_term) != -1) { if (tcgetattr(STDIN_FILENO, &orig_term) != -1) {
server.term = orig_term; server.term = orig_term;
has_term = true; has_term = true;
} }
@ -681,37 +526,23 @@ int main(int argc, char *argv[]) {
server.read_pty = (action == 'n'); server.read_pty = (action == 'n');
redo:
switch (action) { switch (action) {
redo:
case 'n': case 'n':
case 'c': case 'c':
if (force) {
if (session_alive(server.session_name)) {
info("session exists and has not yet terminated");
return 1;
}
if (session_exists(server.session_name))
attach_session(server.session_name, false);
}
if (!create_session(server.session_name, cmd)) if (!create_session(server.session_name, cmd))
die("create-session"); die("create-session");
if (action == 'n') if (action == 'n')
break; break;
/* fall through */
case 'a': case 'a':
if (!attach_session(server.session_name, true))
die("attach-session");
break;
case 'A': case 'A':
if (session_alive(server.session_name)) { if (!attach_session(server.session_name)) {
if (!attach_session(server.session_name, true)) if (action == 'A') {
die("attach-session"); action = 'c';
} else if (!attach_session(server.session_name, !force)) { goto redo;
force = false; }
action = 'c'; die("attach-session");
goto redo;
} }
break;
} }
return 0; return 0;

65
client.c
View File

@ -21,52 +21,23 @@ static bool client_recv_packet(Packet *pkt) {
return false; return false;
} }
static void client_restore_terminal(void) { static void client_show_cursor() {
if (!has_term) printf("\e[?25h");
return; fflush(stdout);
tcsetattr(STDIN_FILENO, TCSAFLUSH, &orig_term);
if (alternate_buffer) {
printf("\033[?25h\033[?1049l");
fflush(stdout);
alternate_buffer = false;
}
} }
static void client_setup_terminal(void) { static void client_restore_terminal() {
if (!has_term) if (has_term)
return; tcsetattr(STDIN_FILENO, TCSADRAIN, &orig_term);
atexit(client_restore_terminal); client_show_cursor();
cur_term = orig_term;
cur_term.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON|IXOFF);
cur_term.c_oflag &= ~(OPOST);
cur_term.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
cur_term.c_cflag &= ~(CSIZE|PARENB);
cur_term.c_cflag |= CS8;
cur_term.c_cc[VLNEXT] = _POSIX_VDISABLE;
cur_term.c_cc[VMIN] = 1;
cur_term.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSANOW, &cur_term);
if (!alternate_buffer) {
printf("\033[?1049h\033[H");
fflush(stdout);
alternate_buffer = true;
}
} }
static int client_mainloop(void) { static int client_mainloop() {
sigset_t emptyset, blockset;
sigemptyset(&emptyset);
sigemptyset(&blockset);
sigaddset(&blockset, SIGWINCH);
sigprocmask(SIG_BLOCK, &blockset, NULL);
client.need_resize = true; client.need_resize = true;
Packet pkt = { Packet pkt = {
.type = MSG_ATTACH, .type = MSG_ATTACH,
.u.i = client.flags, .u = { .b = client.readonly },
.len = sizeof(pkt.u.i), .len = sizeof(pkt.u.b),
}; };
client_send_packet(&pkt); client_send_packet(&pkt);
@ -81,15 +52,15 @@ static int client_mainloop(void) {
if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) != -1) { if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) != -1) {
Packet pkt = { Packet pkt = {
.type = MSG_RESIZE, .type = MSG_RESIZE,
.u = { .ws = { .rows = ws.ws_row, .cols = ws.ws_col } }, .u = { .ws = ws },
.len = sizeof(pkt.u.ws), .len = sizeof(ws),
}; };
if (client_send_packet(&pkt)) if (client_send_packet(&pkt))
client.need_resize = false; client.need_resize = false;
} }
} }
if (pselect(server.socket+1, &fds, NULL, NULL, NULL, &emptyset) == -1) { if (select(server.socket + 1, &fds, NULL, NULL, NULL) == -1) {
if (errno == EINTR) if (errno == EINTR)
continue; continue;
die("client-mainloop"); die("client-mainloop");
@ -100,8 +71,7 @@ static int client_mainloop(void) {
if (client_recv_packet(&pkt)) { if (client_recv_packet(&pkt)) {
switch (pkt.type) { switch (pkt.type) {
case MSG_CONTENT: case MSG_CONTENT:
if (!passthrough) write_all(STDOUT_FILENO, pkt.u.msg, pkt.len);
write_all(STDOUT_FILENO, pkt.u.msg, pkt.len);
break; break;
case MSG_RESIZE: case MSG_RESIZE:
client.need_resize = true; client.need_resize = true;
@ -122,7 +92,7 @@ static int client_mainloop(void) {
if (len > 0) { if (len > 0) {
debug("client-stdin: %c\n", pkt.u.msg[0]); debug("client-stdin: %c\n", pkt.u.msg[0]);
pkt.len = len; pkt.len = len;
if (KEY_REDRAW && pkt.u.msg[0] == KEY_REDRAW) { if (pkt.u.msg[0] == KEY_REDRAW) {
client.need_resize = true; client.need_resize = true;
} else if (pkt.u.msg[0] == KEY_DETACH) { } else if (pkt.u.msg[0] == KEY_DETACH) {
pkt.type = MSG_DETACH; pkt.type = MSG_DETACH;
@ -130,12 +100,9 @@ static int client_mainloop(void) {
client_send_packet(&pkt); client_send_packet(&pkt);
close(server.socket); close(server.socket);
return -1; return -1;
} else if (!(client.flags & CLIENT_READONLY)) { } else if (!client.readonly) {
client_send_packet(&pkt); client_send_packet(&pkt);
} }
} else if (len == 0) {
debug("client-stdin: EOF\n");
return -1;
} }
} }
} }

17
config.def.h
View File

@ -1,19 +1,2 @@
/* default command to execute if non is given and $ABDUCO_CMD is unset */
#define ABDUCO_CMD "dvtm"
/* default detach key, can be overriden at run time using -e option */
static char KEY_DETACH = CTRL('\\'); static char KEY_DETACH = CTRL('\\');
/* redraw key to send a SIGWINCH signal to underlying process
* (set to 0 to disable the redraw key) */
static char KEY_REDRAW = 0; static char KEY_REDRAW = 0;
/* Where to place the "abduco" directory storing all session socket files.
* The first directory to succeed is used. */
static struct Dir {
char *path; /* fixed (absolute) path to a directory */
char *env; /* environment variable to use if (set) */
bool personal; /* if false a user owned sub directory will be created */
} socket_dirs[] = {
{ .env = "ABDUCO_SOCKET_DIR", false },
{ .env = "HOME", true },
{ .env = "TMPDIR", false },
{ .path = "/tmp", false },
};

17
config.mk Normal file
View File

@ -0,0 +1,17 @@
# abduco version
VERSION = 0.1
# Customize below to fit your system
PREFIX = /usr/local
MANPREFIX = ${PREFIX}/share/man
INCS = -I.
LIBS = -lc -lutil
CFLAGS += -std=c99 -Os ${INCS} -DVERSION=\"${VERSION}\" -DNDEBUG
LDFLAGS += ${LIBS}
DEBUG_CFLAGS = ${CFLAGS} -UNDEBUG -O0 -g -ggdb -Wall
CC = cc

244
configure vendored
View File

@ -1,244 +0,0 @@
#!/bin/sh
# Based on the configure script from musl libc, MIT licensed
usage () {
cat <<EOF
Usage: $0 [OPTION]... [VAR=VALUE]...
To assign environment variables (e.g., CC, CFLAGS...), specify them as
VAR=VALUE. See below for descriptions of some of the useful variables.
Defaults for the options are specified in brackets.
Configuration:
--srcdir=DIR source directory [detected]
Installation directories:
--prefix=PREFIX main installation prefix [/usr/local]
--exec-prefix=EPREFIX installation prefix for executable files [PREFIX]
Fine tuning of the installation directories:
--bindir=DIR user executables [EPREFIX/bin]
--sharedir=DIR share directories [PREFIX/share]
--docdir=DIR misc. documentation [PREFIX/share/doc]
--mandir=DIR man pages [PREFIX/share/man]
Some influential environment variables:
CC C compiler command [detected]
CFLAGS C compiler flags [-Os -pipe ...]
LDFLAGS Linker flags
Use these variables to override the choices made by configure.
EOF
exit 0
}
# Helper functions
quote () {
tr '\n' ' ' <<EOF | grep '^[-[:alnum:]_=,./:]* $' >/dev/null 2>&1 && { echo "$1" ; return 0 ; }
$1
EOF
printf %s\\n "$1" | sed -e "s/'/'\\\\''/g" -e "1s/^/'/" -e "\$s/\$/'/" -e "s#^'\([-[:alnum:]_,./:]*\)=\(.*\)\$#\1='\2#"
}
echo () { printf "%s\n" "$*" ; }
fail () { echo "$*" ; exit 1 ; }
fnmatch () { eval "case \"\$2\" in $1) return 0 ;; *) return 1 ;; esac" ; }
cmdexists () { type "$1" >/dev/null 2>&1 ; }
trycc () { test -z "$CC" && cmdexists "$1" && CC=$1 ; }
stripdir () {
while eval "fnmatch '*/' \"\${$1}\"" ; do eval "$1=\${$1%/}" ; done
}
trycppif () {
printf "checking preprocessor condition %s... " "$1"
echo "typedef int x;" > "$tmpc"
echo "#if $1" >> "$tmpc"
echo "#error yes" >> "$tmpc"
echo "#endif" >> "$tmpc"
if $CC $2 -c -o "$tmpo" "$tmpc" >/dev/null 2>&1 ; then
printf "false\n"
return 1
else
printf "true\n"
return 0
fi
}
tryflag () {
printf "checking whether compiler accepts %s... " "$2"
echo "typedef int x;" > "$tmpc"
if $CC $CFLAGS_TRY $2 -c -o "$tmpo" "$tmpc" >/dev/null 2>&1 ; then
printf "yes\n"
eval "$1=\"\${$1} \$2\""
eval "$1=\${$1# }"
return 0
else
printf "no\n"
return 1
fi
}
tryldflag () {
printf "checking whether linker accepts %s... " "$2"
echo "typedef int x;" > "$tmpc"
if $CC $LDFLAGS_TRY -nostdlib -shared "$2" -o "$tmpo" "$tmpc" >/dev/null 2>&1 ; then
printf "yes\n"
eval "$1=\"\${$1} \$2\""
eval "$1=\${$1# }"
return 0
else
printf "no\n"
return 1
fi
}
# Beginning of actual script
CFLAGS_AUTO=
CFLAGS_TRY=
LDFLAGS_AUTO=
LDFLAGS_TRY=
SRCDIR=
PREFIX=/usr/local
EXEC_PREFIX='$(PREFIX)'
BINDIR='$(EXEC_PREFIX)/bin'
MANDIR='$(PREFIX)/share/man'
for arg ; do
case "$arg" in
--help|-h) usage ;;
--srcdir=*) SRCDIR=${arg#*=} ;;
--prefix=*) PREFIX=${arg#*=} ;;
--exec-prefix=*) EXEC_PREFIX=${arg#*=} ;;
--bindir=*) BINDIR=${arg#*=} ;;
--sharedir=*) SHAREDIR=${arg#*=} ;;
--docdir=*) DOCDIR=${arg#*=} ;;
--mandir=*) MANDIR=${arg#*=} ;;
--enable-*|--disable-*|--with-*|--without-*|--*dir=*|--build=*) ;;
-* ) echo "$0: unknown option $arg" ;;
CC=*) CC=${arg#*=} ;;
CFLAGS=*) CFLAGS=${arg#*=} ;;
CPPFLAGS=*) CPPFLAGS=${arg#*=} ;;
LDFLAGS=*) LDFLAGS=${arg#*=} ;;
*=*) ;;
*) ;;
esac
done
for i in SRCDIR PREFIX EXEC_PREFIX BINDIR MANDIR ; do
stripdir $i
done
#
# Get the source dir for out-of-tree builds
#
if test -z "$SRCDIR" ; then
SRCDIR="${0%/configure}"
stripdir SRCDIR
fi
abs_builddir="$(pwd)" || fail "$0: cannot determine working directory"
abs_srcdir="$(cd $SRCDIR && pwd)" || fail "$0: invalid source directory $SRCDIR"
test "$abs_srcdir" = "$abs_builddir" && SRCDIR=.
test "$SRCDIR" != "." -a -f Makefile -a ! -h Makefile && fail "$0: Makefile already exists in the working directory"
#
# Get a temp filename we can use
#
i=0
set -C
while : ; do i=$(($i+1))
tmpc="./conf$$-$PPID-$i.c"
tmpo="./conf$$-$PPID-$i.o"
2>|/dev/null > "$tmpc" && break
test "$i" -gt 50 && fail "$0: cannot create temporary file $tmpc"
done
set +C
trap 'rm -f "$tmpc" "$tmpo"' EXIT INT QUIT TERM HUP
#
# Find a C compiler to use
#
printf "checking for C compiler... "
trycc cc
trycc gcc
trycc clang
printf "%s\n" "$CC"
test -n "$CC" || { echo "$0: cannot find a C compiler" ; exit 1 ; }
printf "checking whether C compiler works... "
echo "typedef int x;" > "$tmpc"
if output=$($CC $CPPFLAGS $CFLAGS -c -o "$tmpo" "$tmpc" 2>&1) ; then
printf "yes\n"
else
printf "no; compiler output follows:\n%s\n" "$output"
exit 1
fi
#
# Figure out options to force errors on unknown flags.
#
tryflag CFLAGS_TRY -Werror=unknown-warning-option
tryflag CFLAGS_TRY -Werror=unused-command-line-argument
tryldflag LDFLAGS_TRY -Werror=unknown-warning-option
tryldflag LDFLAGS_TRY -Werror=unused-command-line-argument
CFLAGS_STD="-std=c99 -D_POSIX_C_SOURCE=200809L -D_XOPEN_SOURCE=700 -DNDEBUG -D_FORTIFY_SOURCE=2"
LDFLAGS_STD="-lc -lutil"
OS=$(uname)
case "$OS" in
FreeBSD) CFLAGS_STD="$CFLAGS_STD -D_BSD_SOURCE -D__BSD_VISIBLE=1" ;;
*BSD) CFLAGS_STD="$CFLAGS_STD -D_BSD_SOURCE" ;;
Darwin) CFLAGS_STD="$CFLAGS_STD -D_DARWIN_C_SOURCE" ;;
AIX) CFLAGS_STD="$CFLAGS_STD -D_ALL_SOURCE" ;;
esac
tryflag CFLAGS -pipe
# Try flags to optimize binary size
tryflag CFLAGS -Os
tryflag CFLAGS -ffunction-sections
tryflag CFLAGS -fdata-sections
tryldflag LDFLAGS_AUTO -Wl,--gc-sections
# Try hardening flags
tryflag CFLAGS -fPIE
tryflag CFLAGS_AUTO -fstack-protector-all
tryldflag LDFLAGS -Wl,-z,now
tryldflag LDFLAGS -Wl,-z,relro
tryldflag LDFLAGS_AUTO -pie
printf "creating config.mk... "
cmdline=$(quote "$0")
for i ; do cmdline="$cmdline $(quote "$i")" ; done
exec 3>&1 1>config.mk
cat << EOF
# This version of config.mk was generated by:
# $cmdline
# Any changes made here will be lost if configure is re-run
SRCDIR = $SRCDIR
PREFIX = $PREFIX
EXEC_PREFIX = $EXEC_PREFIX
BINDIR = $BINDIR
MANPREFIX = $MANDIR
CC = $CC
CFLAGS = $CFLAGS
LDFLAGS = $LDFLAGS
CFLAGS_STD = $CFLAGS_STD
LDFLAGS_STD = $LDFLAGS_STD
CFLAGS_AUTO = $CFLAGS_AUTO
LDFLAGS_AUTO = $LDFLAGS_AUTO
CFLAGS_DEBUG = -U_FORTIFY_SOURCE -UNDEBUG -O0 -g -ggdb -Wall -Wextra -pedantic -Wno-unused-parameter -Wno-sign-compare
EOF
exec 1>&3 3>&-
printf "done\n"
test "$SRCDIR" = "." || ln -sf $SRCDIR/Makefile .

35
contrib/abduco.zsh
View File

@ -1,35 +0,0 @@
#compdef abduco
typeset -A opt_args
_abduco_sessions() {
declare -a sessions
sessions=( $(abduco | sed '1d;s/.*\t[0-9][0-9]*\t//') )
_describe -t session 'session' sessions
}
_abduco_firstarg() {
if (( $+opt_args[-a] || $+opt_args[-A] )); then
_abduco_sessions
elif (( $+opt_args[-c] || $+opt_args[-n] )); then
_guard "^-*" 'session name'
elif [[ -z $words[CURRENT] ]]; then
compadd "$@" -S '' -- -
fi
}
_arguments -s \
'(-a -A -c -n -f)-a[attach to an existing session]' \
'(-a -A -c -n)-A[attach to a session, create if does not exist]' \
'(-a -A -c -n -l)-c[create a new session and attach to it]' \
'(-a -A -c -n -l)-n[create a new session but do not attach to it]' \
'-e[set the detachkey (default: ^\\)]:detachkey' \
'(-a)-f[force create the session]' \
'(-q)-p[pass-through mode]' \
'-q[be quiet]' \
'-r[read-only session, ignore user input]' \
'(-c -n)-l[attach with the lowest priority]' \
'(-)-v[show version information and exit]' \
'1: :_abduco_firstarg' \
'2:command:_path_commands' \
'*:: :{ shift $((CURRENT-3)) words; _precommand; }'

20
debug.c
View File

@ -16,8 +16,8 @@ static void print_packet(const char *prefix, Packet *pkt) {
[MSG_ATTACH] = "ATTACH", [MSG_ATTACH] = "ATTACH",
[MSG_DETACH] = "DETACH", [MSG_DETACH] = "DETACH",
[MSG_RESIZE] = "RESIZE", [MSG_RESIZE] = "RESIZE",
[MSG_REDRAW] = "REDRAW",
[MSG_EXIT] = "EXIT", [MSG_EXIT] = "EXIT",
[MSG_PID] = "PID",
}; };
const char *type = "UNKNOWN"; const char *type = "UNKNOWN";
if (pkt->type < countof(msgtype) && msgtype[pkt->type]) if (pkt->type < countof(msgtype) && msgtype[pkt->type])
@ -26,24 +26,14 @@ static void print_packet(const char *prefix, Packet *pkt) {
fprintf(stderr, "%s: %s ", prefix, type); fprintf(stderr, "%s: %s ", prefix, type);
switch (pkt->type) { switch (pkt->type) {
case MSG_CONTENT: case MSG_CONTENT:
fwrite(pkt->u.msg, pkt->len, 1, stderr); for (size_t i = 0; i < pkt->len && i < sizeof(pkt->u.msg); i++)
fprintf(stderr, "%c", pkt->u.msg[i]);
break; break;
case MSG_RESIZE: case MSG_RESIZE:
fprintf(stderr, "%"PRIu16"x%"PRIu16, pkt->u.ws.cols, pkt->u.ws.rows); fprintf(stderr, "%dx%d", pkt->u.ws.ws_col, pkt->u.ws.ws_row);
break;
case MSG_ATTACH:
fprintf(stderr, "readonly: %d low-priority: %d",
pkt->u.i & CLIENT_READONLY,
pkt->u.i & CLIENT_LOWPRIORITY);
break;
case MSG_EXIT:
fprintf(stderr, "status: %"PRIu32, pkt->u.i);
break;
case MSG_PID:
fprintf(stderr, "pid: %"PRIu32, pkt->u.i);
break; break;
default: default:
fprintf(stderr, "len: %"PRIu32, pkt->len); fprintf(stderr, "len: %zu", pkt->len);
break; break;
} }
fprintf(stderr, "\n"); fprintf(stderr, "\n");

35
forkpty-aix.c
View File

@ -17,13 +17,23 @@
#include <sys/types.h> #include <sys/types.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#include <fcntl.h> #include <fcntl.h>
#include <stdlib.h> #include <stdlib.h>
#include <stropts.h> #include <stropts.h>
#include <unistd.h> #include <unistd.h>
#include <paths.h> #include <paths.h>
pid_t forkpty(int *master, char *name, struct termios *tio, struct winsize *ws) /* Fatal errors. */
#ifdef NDEBUG
#define debug(format, args...)
#else
#define debug eprint
#endif
#define fatal(msg) debug("%s: %s", __func__, msg);
pid_t
forkpty(int *master, char *name, struct termios *tio, struct winsize *ws)
{ {
int slave, fd; int slave, fd;
char *path; char *path;
@ -31,7 +41,7 @@ pid_t forkpty(int *master, char *name, struct termios *tio, struct winsize *ws)
struct termios tio2; struct termios tio2;
if ((*master = open("/dev/ptc", O_RDWR|O_NOCTTY)) == -1) if ((*master = open("/dev/ptc", O_RDWR|O_NOCTTY)) == -1)
return -1; return (-1);
if ((path = ttyname(*master)) == NULL) if ((path = ttyname(*master)) == NULL)
goto out; goto out;
@ -50,47 +60,48 @@ pid_t forkpty(int *master, char *name, struct termios *tio, struct winsize *ws)
close(fd); close(fd);
} }
setsid(); if (setsid() < 0)
fatal("setsid");
fd = open(_PATH_TTY, O_RDWR|O_NOCTTY); fd = open(_PATH_TTY, O_RDWR|O_NOCTTY);
if (fd >= 0) if (fd >= 0)
return -1; fatal("open succeeded (failed to disconnect)");
fd = open(path, O_RDWR); fd = open(path, O_RDWR);
if (fd < 0) if (fd < 0)
return -1; fatal("open failed");
close(fd); close(fd);
fd = open("/dev/tty", O_WRONLY); fd = open("/dev/tty", O_WRONLY);
if (fd < 0) if (fd < 0)
return -1; fatal("open failed");
close(fd); close(fd);
if (tcgetattr(slave, &tio2) != 0) if (tcgetattr(slave, &tio2) != 0)
return -1; fatal("tcgetattr failed");
if (tio != NULL) if (tio != NULL)
memcpy(tio2.c_cc, tio->c_cc, sizeof tio2.c_cc); memcpy(tio2.c_cc, tio->c_cc, sizeof tio2.c_cc);
tio2.c_cc[VERASE] = '\177'; tio2.c_cc[VERASE] = '\177';
if (tcsetattr(slave, TCSAFLUSH, &tio2) == -1) if (tcsetattr(slave, TCSAFLUSH, &tio2) == -1)
return -1; fatal("tcsetattr failed");
if (ioctl(slave, TIOCSWINSZ, ws) == -1) if (ioctl(slave, TIOCSWINSZ, ws) == -1)
return -1; fatal("ioctl failed");
dup2(slave, 0); dup2(slave, 0);
dup2(slave, 1); dup2(slave, 1);
dup2(slave, 2); dup2(slave, 2);
if (slave > 2) if (slave > 2)
close(slave); close(slave);
return 0; return (0);
} }
close(slave); close(slave);
return pid; return (pid);
out: out:
if (*master != -1) if (*master != -1)
close(*master); close(*master);
if (slave != -1) if (slave != -1)
close(slave); close(slave);
return -1; return (-1);
} }

88
forkpty-sunos.c
View File

@ -1,88 +0,0 @@
/*
* Copyright (c) 2008 Nicholas Marriott <nicm@users.sourceforge.net>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <sys/types.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <stdlib.h>
#include <strings.h>
#include <stropts.h>
#include <unistd.h>
#ifndef TTY_NAME_MAX
#define TTY_NAME_MAX TTYNAME_MAX
#endif
pid_t forkpty(int *master, char *name, struct termios *tio, struct winsize *ws)
{
int slave;
char *path;
pid_t pid;
if ((*master = open("/dev/ptmx", O_RDWR|O_NOCTTY)) == -1)
return -1;
if (grantpt(*master) != 0)
goto out;
if (unlockpt(*master) != 0)
goto out;
if ((path = ptsname(*master)) == NULL)
goto out;
if (name != NULL)
strlcpy(name, path, TTY_NAME_MAX);
if ((slave = open(path, O_RDWR|O_NOCTTY)) == -1)
goto out;
switch (pid = fork()) {
case -1:
goto out;
case 0:
close(*master);
setsid();
#ifdef TIOCSCTTY
if (ioctl(slave, TIOCSCTTY, NULL) == -1)
return -1;
#endif
if (ioctl(slave, I_PUSH, "ptem") == -1)
return -1;
if (ioctl(slave, I_PUSH, "ldterm") == -1)
return -1;
if (tio != NULL && tcsetattr(slave, TCSAFLUSH, tio) == -1)
return -1;
if (ioctl(slave, TIOCSWINSZ, ws) == -1)
return -1;
dup2(slave, 0);
dup2(slave, 1);
dup2(slave, 2);
if (slave > 2)
close(slave);
return 0;
}
close(slave);
return pid;
out:
if (*master != -1)
close(*master);
if (slave != -1)
close(slave);
return -1;
}

127
server.c
View File

@ -18,54 +18,36 @@ static void client_free(Client *c) {
free(c); free(c);
} }
static void server_sink_client() { static int server_mark_socket_exec(bool exec, bool usr) {
if (!server.clients || !server.clients->next)
return;
Client *target = server.clients;
server.clients = target->next;
Client *dst = server.clients;
while (dst->next)
dst = dst->next;
target->next = NULL;
dst->next = target;
}
static void server_mark_socket_exec(bool exec, bool usr) {
struct stat sb; struct stat sb;
if (stat(sockaddr.sun_path, &sb) == -1) if (stat(sockaddr.sun_path, &sb) == -1)
return; return -1;
mode_t mode = sb.st_mode; mode_t mode = sb.st_mode;
mode_t flag = usr ? S_IXUSR : S_IXGRP; mode_t flag = usr ? S_IXUSR : S_IXGRP;
if (exec) if (exec)
mode |= flag; mode |= flag;
else else
mode &= ~flag; mode &= ~flag;
chmod(sockaddr.sun_path, mode); return chmod(sockaddr.sun_path, mode);
} }
static int server_create_socket(const char *name) { static int server_create_socket(const char *name) {
if (!set_socket_name(&sockaddr, name)) int socket = create_socket(name);
return -1; if (socket == -1)
int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd == -1)
return -1; return -1;
socklen_t socklen = offsetof(struct sockaddr_un, sun_path) + strlen(sockaddr.sun_path) + 1; socklen_t socklen = offsetof(struct sockaddr_un, sun_path) + strlen(sockaddr.sun_path) + 1;
mode_t mask = umask(S_IXUSR|S_IRWXG|S_IRWXO); mode_t mode = S_IRUSR|S_IWUSR;
int r = bind(fd, (struct sockaddr*)&sockaddr, socklen); fchmod(socket, mode);
umask(mask); if (bind(socket, (struct sockaddr*)&sockaddr, socklen) == -1)
if (r == -1) {
close(fd);
return -1; return -1;
} if (fchmod(socket, mode) == -1 && chmod(sockaddr.sun_path, mode) == -1)
goto error;
if (listen(fd, 5) == -1) { if (listen(socket, 5) == -1)
unlink(sockaddr.sun_path); goto error;
close(fd); return socket;
return -1; error:
} unlink(sockaddr.sun_path);
return -1;
return fd;
} }
static int server_set_socket_non_blocking(int sock) { static int server_set_socket_non_blocking(int sock) {
@ -75,14 +57,30 @@ static int server_set_socket_non_blocking(int sock) {
return fcntl(sock, F_SETFL, flags | O_NONBLOCK); return fcntl(sock, F_SETFL, flags | O_NONBLOCK);
} }
static Client *server_accept_client() {
int newfd = accept(server.socket, NULL, NULL);
if (newfd == -1)
return NULL;
Client *c = client_malloc(newfd);
if (!c)
return NULL;
if (!server.clients)
server_mark_socket_exec(true, true);
server_set_socket_non_blocking(newfd);
c->socket = newfd;
c->state = STATE_CONNECTED;
c->next = server.clients;
server.clients = c;
server.read_pty = true;
return c;
}
static bool server_read_pty(Packet *pkt) { static bool server_read_pty(Packet *pkt) {
pkt->type = MSG_CONTENT; pkt->type = MSG_CONTENT;
ssize_t len = read(server.pty, pkt->u.msg, sizeof(pkt->u.msg)); ssize_t len = read(server.pty, pkt->u.msg, sizeof(pkt->u.msg));
if (len > 0) if (len != -1)
pkt->len = len; pkt->len = len;
else if (len == 0) else if (errno != EAGAIN && errno != EINTR)
server.running = false;
else if (len == -1 && errno != EAGAIN && errno != EINTR && errno != EWOULDBLOCK)
server.running = false; server.running = false;
print_packet("server-read-pty:", pkt); print_packet("server-read-pty:", pkt);
return len > 0; return len > 0;
@ -136,35 +134,6 @@ static void server_sigterm_handler(int sig) {
exit(EXIT_FAILURE); /* invoke atexit handler */ exit(EXIT_FAILURE); /* invoke atexit handler */
} }
static Client *server_accept_client(void) {
int newfd = accept(server.socket, NULL, NULL);
if (newfd == -1 || server_set_socket_non_blocking(newfd) == -1)
goto error;
Client *c = client_malloc(newfd);
if (!c)
goto error;
if (!server.clients)
server_mark_socket_exec(true, true);
c->socket = newfd;
c->state = STATE_CONNECTED;
c->next = server.clients;
server.clients = c;
server.read_pty = true;
Packet pkt = {
.type = MSG_PID,
.len = sizeof pkt.u.l,
.u.l = getpid(),
};
server_send_packet(c, &pkt);
return c;
error:
if (newfd != -1)
close(newfd);
return NULL;
}
static void server_sigusr1_handler(int sig) { static void server_sigusr1_handler(int sig) {
int socket = server_create_socket(server.session_name); int socket = server_create_socket(server.session_name);
if (socket != -1) { if (socket != -1) {
@ -174,11 +143,11 @@ static void server_sigusr1_handler(int sig) {
} }
} }
static void server_atexit_handler(void) { static void server_atexit_handler() {
unlink(sockaddr.sun_path); unlink(sockaddr.sun_path);
} }
static void server_mainloop(void) { static void server_mainloop() {
atexit(server_atexit_handler); atexit(server_atexit_handler);
fd_set new_readfds, new_writefds; fd_set new_readfds, new_writefds;
FD_ZERO(&new_readfds); FD_ZERO(&new_readfds);
@ -223,25 +192,19 @@ static void server_mainloop(void) {
server_write_pty(&client_packet); server_write_pty(&client_packet);
break; break;
case MSG_ATTACH: case MSG_ATTACH:
c->flags = client_packet.u.i; c->readonly = client_packet.u.b;
if (c->flags & CLIENT_LOWPRIORITY)
server_sink_client();
break; break;
case MSG_RESIZE: case MSG_RESIZE:
c->state = STATE_ATTACHED; c->state = STATE_ATTACHED;
if (!(c->flags & CLIENT_READONLY) && c == server.clients) { case MSG_REDRAW:
if (!c->readonly && (client_packet.type == MSG_REDRAW || c == server.clients)) {
debug("server-ioct: TIOCSWINSZ\n"); debug("server-ioct: TIOCSWINSZ\n");
struct winsize ws = { 0 }; ioctl(server.pty, TIOCSWINSZ, &client_packet.u.ws);
ws.ws_row = client_packet.u.ws.rows;
ws.ws_col = client_packet.u.ws.cols;
ioctl(server.pty, TIOCSWINSZ, &ws);
} }
kill(-server.pid, SIGWINCH); kill(-server.pid, SIGWINCH);
break; break;
case MSG_EXIT:
exit_packet_delivered = true;
/* fall through */
case MSG_DETACH: case MSG_DETACH:
case MSG_EXIT:
c->state = STATE_DISCONNECTED; c->state = STATE_DISCONNECTED;
break; break;
default: /* ignore package */ default: /* ignore package */
@ -277,7 +240,9 @@ static void server_mainloop(void) {
.u.i = server.exit_status, .u.i = server.exit_status,
.len = sizeof(pkt.u.i), .len = sizeof(pkt.u.i),
}; };
if (!server_send_packet(c, &pkt)) if (server_send_packet(c, &pkt))
exit_packet_delivered = true;
else
FD_SET_MAX(c->socket, &new_writefds, new_fdmax); FD_SET_MAX(c->socket, &new_writefds, new_fdmax);
} else { } else {
FD_SET_MAX(c->socket, &new_writefds, new_fdmax); FD_SET_MAX(c->socket, &new_writefds, new_fdmax);

77
testsuite.sh
View File

@ -1,4 +1,4 @@
#!/bin/sh #!/bin/bash
ABDUCO="./abduco" ABDUCO="./abduco"
# set detach key explicitly in case it was changed in config.h # set detach key explicitly in case it was changed in config.h
@ -7,9 +7,6 @@ ABDUCO_OPTS="-e ^\\"
[ ! -z "$1" ] && ABDUCO="$1" [ ! -z "$1" ] && ABDUCO="$1"
[ ! -x "$ABDUCO" ] && echo "usage: $0 /path/to/abduco" && exit 1 [ ! -x "$ABDUCO" ] && echo "usage: $0 /path/to/abduco" && exit 1
TESTS_OK=0
TESTS_RUN=0
detach() { detach() {
sleep 1 sleep 1
printf "" printf ""
@ -30,30 +27,12 @@ dvtm_session() {
dvtm_cmd ' ' dvtm_cmd ' '
dvtm_cmd ' ' dvtm_cmd ' '
sleep 1 sleep 1
dvtm_cmd 'qq' dvtm_cmd 'q'
}
expected_abduco_prolog() {
printf "[?1049h"
} }
# $1 => session-name, $2 => exit status # $1 => session-name, $2 => exit status
expected_abduco_epilog() { expected_abduco_output() {
echo "[?25h[?1049labduco: $1: session terminated with exit status $2" echo "[?25habduco: $1: session terminated with exit status $2"
}
# $1 => session-name, $2 => cmd to run
expected_abduco_attached_output() {
expected_abduco_prolog
$2
expected_abduco_epilog "$1" $?
}
# $1 => session-name, $2 => cmd to run
expected_abduco_detached_output() {
expected_abduco_prolog
$2 >/dev/null 2>&1
expected_abduco_epilog "$1" $?
} }
check_environment() { check_environment() {
@ -64,7 +43,7 @@ check_environment() {
test_non_existing_command() { test_non_existing_command() {
check_environment || return 1; check_environment || return 1;
$ABDUCO -c test ./non-existing-command >/dev/null 2>&1 $ABDUCO -c test ./non-existing-command &> /dev/null
check_environment || return 1; check_environment || return 1;
} }
@ -77,14 +56,12 @@ run_test_attached() {
local output="$name.out" local output="$name.out"
local output_expected="$name.expected" local output_expected="$name.expected"
TESTS_RUN=$((TESTS_RUN + 1))
echo -n "Running test attached: $name " echo -n "Running test attached: $name "
expected_abduco_attached_output "$name" "$cmd" > "$output_expected" 2>&1 $cmd &> "$output_expected"
expected_abduco_output "$name" $? >> "$output_expected"
if $ABDUCO -c "$name" $cmd 2>&1 | sed 's/.$//' > "$output" && sleep 1 && $ABDUCO -c "$name" $cmd 2>&1 | head -n -1 | sed 's/.$//' > "$output"
diff -u "$output_expected" "$output" && check_environment; then if diff -u "$output_expected" "$output" && check_environment; then
rm "$output" "$output_expected" rm "$output" "$output_expected"
TESTS_OK=$((TESTS_OK + 1))
echo "OK" echo "OK"
return 0 return 0
else else
@ -102,15 +79,14 @@ run_test_detached() {
local output="$name.out" local output="$name.out"
local output_expected="$name.expected" local output_expected="$name.expected"
TESTS_RUN=$((TESTS_RUN + 1))
echo -n "Running test detached: $name " echo -n "Running test detached: $name "
expected_abduco_detached_output "$name" "$cmd" > "$output_expected" 2>&1 $cmd &> /dev/null
expected_abduco_output "$name" $? > "$output_expected"
if $ABDUCO -n "$name" $cmd >/dev/null 2>&1 && sleep 1 && if $ABDUCO -n "$name" $cmd &> /dev/null && sleep 1 &&
$ABDUCO -a "$name" 2>&1 | sed 's/.$//' > "$output" && $ABDUCO -a "$name" 2>&1 | head -n -1 | sed 's/.$//' > "$output" &&
diff -u "$output_expected" "$output" && check_environment; then diff -u "$output_expected" "$output" && check_environment; then
rm "$output" "$output_expected" rm "$output" "$output_expected"
TESTS_OK=$((TESTS_OK + 1))
echo "OK" echo "OK"
return 0 return 0
else else
@ -128,16 +104,14 @@ run_test_attached_detached() {
local output="$name.out" local output="$name.out"
local output_expected="$name.expected" local output_expected="$name.expected"
TESTS_RUN=$((TESTS_RUN + 1))
echo -n "Running test: $name " echo -n "Running test: $name "
$cmd >/dev/null 2>&1 $cmd &> /dev/null
expected_abduco_epilog "$name" $? > "$output_expected" 2>&1 expected_abduco_output "$name" $? > "$output_expected"
if detach | $ABDUCO $ABDUCO_OPTS -c "$name" $cmd >/dev/null 2>&1 && sleep 3 && if detach | $ABDUCO $ABDUCO_OPTS -c "$name" $cmd &> /dev/null && sleep 3 &&
$ABDUCO -a "$name" 2>&1 | tail -1 | sed 's/.$//' > "$output" && $ABDUCO -a "$name" 2>&1 | head -n -1 | tail -1 | sed 's/.$//' > "$output" &&
diff -u "$output_expected" "$output" && check_environment; then diff -u "$output_expected" "$output" && check_environment; then
rm "$output" "$output_expected" rm "$output" "$output_expected"
TESTS_OK=$((TESTS_OK + 1))
echo "OK" echo "OK"
return 0 return 0
else else
@ -148,21 +122,22 @@ run_test_attached_detached() {
run_test_dvtm() { run_test_dvtm() {
echo -n "Running dvtm test: " echo -n "Running dvtm test: "
if ! which dvtm >/dev/null 2>&1; then if ! which dvtm &> /dev/null; then
echo "SKIPPED" echo "SKIPPED"
return 0; return 0;
fi fi
TESTS_RUN=$((TESTS_RUN + 1))
local name="dvtm" local name="dvtm"
local output="$name.out" local output="$name.out"
local output_expected="$name.expected" local output_expected="$name.expected"
: > "$output_expected" echo exit | dvtm &> /dev/null
if dvtm_session | $ABDUCO -c "$name" > "$output" 2>&1 && expected_abduco_output "$name" $? > "$output_expected"
local len=`wc -c "$output_expected" | awk '{ print $1 }'`
len=$((len+1))
if dvtm_session | $ABDUCO -c "$name" 2>&1 | head -n -1 | tail -c $len | sed 's/.$//' > "$output" &&
diff -u "$output_expected" "$output" && check_environment; then diff -u "$output_expected" "$output" && check_environment; then
rm "$output" "$output_expected" rm "$output" "$output_expected"
TESTS_OK=$((TESTS_OK + 1))
echo "OK" echo "OK"
return 0 return 0
else else
@ -173,8 +148,8 @@ run_test_dvtm() {
test_non_existing_command || echo "Execution of non existing command FAILED" test_non_existing_command || echo "Execution of non existing command FAILED"
run_test_attached "awk" "awk 'BEGIN {for(i=1;i<=1000;i++) print i}'" run_test_attached "seq" "seq 1 1000"
run_test_detached "awk" "awk 'BEGIN {for(i=1;i<=1000;i++) print i}'" run_test_detached "seq" "seq 1 1000"
run_test_attached "false" "false" run_test_attached "false" "false"
run_test_detached "false" "false" run_test_detached "false" "false"
@ -211,5 +186,3 @@ run_test_attached_detached "attach-detach" "./long-running.sh"
rm ./long-running.sh rm ./long-running.sh
run_test_dvtm run_test_dvtm
[ $TESTS_OK -eq $TESTS_RUN ]