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.4
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.4" have entirely different histories.
master ... v0.4

22 changed files with 391 additions and 1083 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

8
.travis.yml Normal file
View File

@ -0,0 +1,8 @@
language: c
compiler:
- gcc
- clang
env:
- DEBUG=
- DEBUG=debug
script: make $DEBUG

4
LICENSE
View File

@ -1,6 +1,4 @@
ISC License Copyright (c) 2013-2015 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

71
Makefile
View File

@ -1,67 +1,62 @@
-include config.mk include config.mk
VERSION = 0.6
CFLAGS_STD ?= -std=c99 -D_POSIX_C_SOURCE=200809L -D_XOPEN_SOURCE=700 -DNDEBUG
CFLAGS_STD += -DVERSION=\"${VERSION}\"
LDFLAGS_STD ?= -lc -lutil
STRIP ?= strip
INSTALL ?= install
PREFIX ?= /usr/local
SHAREDIR ?= ${PREFIX}/share
SRC = abduco.c SRC = abduco.c
OBJ = ${SRC:.c=.o}
all: abduco all: clean options abduco
options:
@echo abduco build options:
@echo "CFLAGS = ${CFLAGS}"
@echo "LDFLAGS = ${LDFLAGS}"
@echo "CC = ${CC}"
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.md testsuite.sh config.def.h config.mk \
${SRC} debug.c client.c server.c forkpty-aix.c forkpty-sunos.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} 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

108
README.md
View File

@ -1,15 +1,15 @@
# abduco a tool for session {at,de}tach support # abduco a tool for session {at,de}tach support
[abduco](https://www.brain-dump.org/projects/abduco) provides [abduco](http://www.brain-dump.org/projects/abduco) provides
session management i.e. it allows programs to be run independently session management i.e. it allows programs to be run independently
from their controlling terminal. That is programs can be detached - from their controlling terminal. That is programs can be detached -
run in the background - and then later reattached. Together with run in the background - and then later reattached. Together with
[dvtm](https://www.brain-dump.org/projects/dvtm) it provides a [dvtm](http://www.brain-dump.org/projects/dvtm) it provides a
simpler and cleaner alternative to tmux or screen. simpler and cleaner alternative to tmux or screen.
![abduco+dvtm demo](https://raw.githubusercontent.com/martanne/abduco/gh-pages/screencast.gif#center) ![abduco+dvtm demo](https://raw.githubusercontent.com/martanne/abduco/gh-pages/screencast.gif)
abduco is in many ways very similar to [dtach](http://dtach.sf.net) abduco is in many ways very similar to [dtach]("http://dtach.sf.net)
but is a completely independent implementation which is actively maintained, but is a completely independent implementation which is actively maintained,
contains no legacy code, provides a few additional features, has a contains no legacy code, provides a few additional features, has a
cleaner, more robust implementation and is distributed under the cleaner, more robust implementation and is distributed under the
@ -17,30 +17,34 @@ cleaner, more robust implementation and is distributed under the
## News ## News
* [abduco-0.6](https://www.brain-dump.org/projects/abduco/abduco-0.6.tar.gz) * [abduco-0.3](http://www.brain-dump.org/projects/abduco/abduco-0.3.tar.gz)
[released](https://lists.suckless.org/dev/1603/28589.html) (24.03.2016) [released](http://lists.suckless.org/dev/1502/25557.html) (19.02.2015)
* [abduco-0.5](https://www.brain-dump.org/projects/abduco/abduco-0.5.tar.gz) * [abduco-0.2](http://www.brain-dump.org/projects/abduco/abduco-0.2.tar.gz)
[released](https://lists.suckless.org/dev/1601/28094.html) (09.01.2016) [released](http://lists.suckless.org/dev/1411/24447.html) (15.11.2014)
* [abduco-0.4](https://www.brain-dump.org/projects/abduco/abduco-0.4.tar.gz) * [abduco-0.1](http://www.brain-dump.org/projects/abduco/abduco-0.1.tar.gz)
[released](https://lists.suckless.org/dev/1503/26027.html) (18.03.2015) [released](http://lists.suckless.org/dev/1407/22703.html) (05.07.2014)
* [abduco-0.3](https://www.brain-dump.org/projects/abduco/abduco-0.3.tar.gz) * [Initial announcement](http://lists.suckless.org/dev/1403/20372.html)
[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) on the suckless development mailing list (08.03.2014)
## Download ## Download
Either download the latest [source tarball](https://github.com/martanne/abduco/releases), Either download the latest source tarball
[abduco-0.3.tar.gz](http://www.brain-dump.org/projects/abduco/abduco-0.3.tar.gz)
with sha1sum
175b2c0eaf2a8b7fb044f1454d018dac4ec31293 abduco-0.3.tar.gz
compile and install it compile and install it
./configure && make && sudo make install $EDITOR config.mk && make && sudo make install
or use one of the distribution provided or use one of the distribution provided binary packages:
[binary packages](https://repology.org/project/abduco/packages).
* [Debian](https://packages.debian.org/search?keywords=abduco)
* [Fedora](https://admin.fedoraproject.org/pkgdb/package/abduco/)
* [Gentoo](http://packages.gentoo.org/package/app-misc/abduco/)
* [Ubuntu](http://packages.ubuntu.com/search?keywords=abduco)
* [Mac OS X](http://www.braumeister.org/formula/abduco) via homebrew
## Quickstart ## Quickstart
@ -77,13 +81,7 @@ A session can be reattached by using the `-a` command line option
in combination with the session name which was used during session in combination with the session name which was used during session
creation. creation.
$ abduco -a demo 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 Check out the manual page for further information and all available
command line options. command line options.
@ -105,31 +103,6 @@ command line options.
attaching to a session, then all keyboard input is ignored and the attaching to a session, then all keyboard input is ignored and the
client is a passive observer only. 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 * **better resize handling** on shared sessions, resize request are only
processed if they are initiated by the most recently connected, non processed if they are initiated by the most recently connected, non
read only client. read only client.
@ -157,28 +130,21 @@ command line options.
## Development ## Development
You can always fetch the current code base from the git repository 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). git clone https://github.com/martanne/abduco.git
or
git clone git://repo.or.cz/abduco.git
If you have comments, suggestions, ideas, a bug report, a patch or something If you have comments, suggestions, ideas, a bug report, a patch or something
else related to abduco then write to the else related to abduco then write to the
[suckless developer mailing list](https://suckless.org/community) [suckless developer mailing list](http://suckless.org/community)
or contact me directly. or contact me directly mat[at]brain-dump.org.
### Debugging [![Build Status](https://travis-ci.org/martanne/abduco.svg?branch=master)](https://travis-ci.org/martanne/abduco)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/4285/badge.svg)](https://scan.coverity.com/projects/4285)
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 ## License

340
abduco.1
View File

@ -1,226 +1,128 @@
.Dd March 18, 2018 .TH ABDUCO 1 abduco\-VERSION
.Dt ABDUCO 1 .nh
.Os abduco VERSION .SH NAME
. abduco - terminal session manager
.Sh NAME .SH SYNOPSIS
.Nm abduco .B abduco
.Nd terminal session manager .RB [ \-e
. .IR detachkey ]
.Sh SYNOPSIS .RB [ \-r ]
.Nm .RB [ \-f ]
.Fl a .RB \-c
.Op options ... .RB name
.Cm name .RB command
. .RI [ args \ ... "" ]
.Nm .br
.Fl A .B abduco
.Op options ... .RB [ \-e
.Cm name .IR detachkey ]
.Cm command Op args ... .RB [ \-r ]
. .RB [ \-f ]
.Nm .RB \-n
.Fl c .RB name
.Op options ... .RB command
.Cm name .RI [ args \ ... "" ]
.Cm command Op args ... .br
. .B abduco
.Nm .RB [ \-e
.Fl n .IR detachkey ]
.Op options ... .RB [ \-r ]
.Cm name .RB [ \-f ]
.Cm command Op args ... .RB \-A
. .RB name
.Sh DESCRIPTION .RB command
. .RI [ args \ ... "" ]
.Nm .br
disassociates a given application from its controlling .B abduco
terminal, thereby providing roughly the same session attach/detach support as .RB [ \-e
.Xr screen 1 , .IR detachkey ]
.Xr tmux 1 , .RB [ \-r ]
or .RB \-a
.Xr dtach 1 . .RB name
.Pp .br
A session comprises of an .SH DESCRIPTION
.Nm .B abduco
server process which spawns a user provides a way to disconnect a given application from its controlling
command in its own pseudo terminal terminal, thus it provides roughly the same session attach/detach support as
.Pq see Xr pty 7 . .BR screen(1) , " tmux(1)" " or" " dtach(1)".
Each session is given a name represented by a unix domain socket
.Pq see Xr unix 7 If the
stored in the local file system. .BR command
.Nm to execute is not specified, the environment variable
clients can connect to it and their standard input output streams .BR $ABDUCO_CMD
are relayed to the command supervised by the server. is examined, if it is not set
.Pp .BR dvtm(1)
.Nm is executed.
operates on the raw I/O byte stream without interpreting any terminal
escape sequences. By default all session related information is stored in
As a consequence the terminal state is not preserved across sessions. .B $HOME/.abduco
If this functionality is desired, it should be provided by another with
utility such as .BR $TMPDIR/abduco/$USER
.Xr dvtm 1 . as a fallback and
. .BR /tmp/abduco/$USER
.Ss ACTIONS as a last resort.
.
If no command line arguments are given, all currently active sessions are However if a given session name represents either a relative or absolute path
listed sorted by their respective creation date. it is used unmodified.
Lines starting with an asterisk
.Pq * If for some reason the
indicate that at least one client is currently connected. .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 A plus sign
.Pq + .BR +
signals that the command terminated while no client was connected. indicates that the command terminated while no client was connected, attach
Attaching to the session will print its exit status. to get its exit status.
The next column shows the PID of the server process, followed by the session .TP
.Ic name . .B \-v
.Pp Print version information to standard output and exit.
.Nm .TP
provides different actions of which one must be provided. .B \-r
. Readonly session, i.e. user input is ignored.
.Bl -tag -width indent .TP
.It Fl a .BI \-e \ detachkey
Attach to an existing session. Set the key to detach which by default is set to CTRL+\\ i.e. ^\\ to detachkey.
.It Fl A .TP
Try to connect to an existing session, upon failure create said session and attach immediately to it. .BI \-f
.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, Force creation of session when there is an already terminated session of the same name,
after showing its exit status. after showing its exit status.
.It Fl l .TP
Attach with the lowest priority, meaning this client will be the last to control the size. .BI \-c
.It Fl p Create a new session and attach immediately to it.
Pass through content of standard input to the session. .TP
Implies the .BI \-n
.Fl q Create a new session but do not attach to it.
and .TP
.Fl l .BI \-A
options. Try to connect to an existing session, upon failure create said session and attach immediately to it.
.It Fl q .TP
Be quiet, do not print informative messages. .BI \-a
.It Fl r Attach to an existing session.
Read-only session, user input is ignored. .SH EXAMPLE
.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
.Xr dvtm 1
is executed.
.It Ev ABDUCO_SESSION
The current session name available to the supervised command.
.It Ev ABDUCO_SOCKET
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 Start a new session (assuming
.Xr dvtm 1 .BR dvtm(1)
is in is in
.Ev $PATH ) .BR $PATH )
with with
.Pp .nf
.Dl $ abduco -c my-session
.Pp .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

249
abduco.c
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2013-2018 Marc André Tanner <mat at brain-dump.org> * Copyright (c) 2013-2015 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
@ -15,7 +15,6 @@
*/ */
#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>
@ -67,21 +66,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 +91,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;
}; };
@ -121,7 +114,7 @@ typedef struct {
static Server server = { .running = true, .exit_status = -1, .host = "@localhost" }; static Server server = { .running = true, .exit_status = -1, .host = "@localhost" };
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; static bool has_term, alternate_buffer;
static struct sockaddr_un sockaddr = { static struct sockaddr_un sockaddr = {
.sun_family = AF_UNIX, .sun_family = AF_UNIX,
@ -208,12 +201,12 @@ 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) { 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);
} }
@ -223,7 +216,7 @@ static void die(const char *s) {
} }
static void usage(void) { static void usage(void) {
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] [-f] [-e detachkey] name command\n");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
@ -243,65 +236,28 @@ static bool xsnprintf(char *buf, size_t size, const char *fmt, ...) {
return true; 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) { static bool create_socket_dir(struct sockaddr_un *sockaddr) {
sockaddr->sun_path[0] = '\0'; sockaddr->sun_path[0] = '\0';
uid_t uid = getuid();
size_t maxlen = sizeof(sockaddr->sun_path);
char *dirs[] = { getenv("HOME"), getenv("TMPDIR"), "/tmp" };
int socketfd = socket(AF_UNIX, SOCK_STREAM, 0); int socketfd = socket(AF_UNIX, SOCK_STREAM, 0);
if (socketfd == -1) if (socketfd == -1)
return false; return false;
const size_t maxlen = sizeof(sockaddr->sun_path);
uid_t uid = getuid();
struct passwd *pw = getpwuid(uid); struct passwd *pw = getpwuid(uid);
if ((!dirs[0] || !dirs[0][0]) && pw)
dirs[0] = pw->pw_dir;
for (unsigned int i = 0; i < countof(socket_dirs); i++) { for (unsigned int i = 0; i < countof(dirs); i++) {
char *dir = dirs[i];
struct stat sb; struct stat sb;
struct Dir *dir = &socket_dirs[i]; bool ishome = (i == 0);
bool ishome = false; if (!dir)
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)) if (!xsnprintf(sockaddr->sun_path, maxlen, "%s/%s%s/", dir, ishome ? "." : "", server.name))
continue; continue;
mode_t mask = umask(0); mode_t mask = umask(0);
int r = mkdir(sockaddr->sun_path, dir->personal ? S_IRWXU : S_IRWXU|S_IRWXG|S_IRWXO|S_ISVTX); int r = mkdir(sockaddr->sun_path, ishome ? S_IRWXU : S_IRWXU|S_IRWXG|S_IRWXO|S_ISVTX);
umask(mask); umask(mask);
if (r != 0 && errno != EEXIST) if (r != 0 && errno != EEXIST)
continue; continue;
@ -313,8 +269,7 @@ static bool create_socket_dir(struct sockaddr_un *sockaddr) {
} }
size_t dirlen = strlen(sockaddr->sun_path); size_t dirlen = strlen(sockaddr->sun_path);
if (!dir->personal) { if (!ishome) {
/* create subdirectory only accessible to user */
if (pw && !xsnprintf(sockaddr->sun_path+dirlen, maxlen-dirlen, "%s/", pw->pw_name)) if (pw && !xsnprintf(sockaddr->sun_path+dirlen, maxlen-dirlen, "%s/", pw->pw_name))
continue; continue;
if (!pw && !xsnprintf(sockaddr->sun_path+dirlen, maxlen-dirlen, "%d/", uid)) if (!pw && !xsnprintf(sockaddr->sun_path+dirlen, maxlen-dirlen, "%d/", uid))
@ -352,10 +307,7 @@ static bool create_socket_dir(struct sockaddr_un *sockaddr) {
} }
static bool set_socket_name(struct sockaddr_un *sockaddr, const char *name) { static bool set_socket_name(struct sockaddr_un *sockaddr, 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) { if (strlen(name) >= maxlen) {
errno = ENAMETOOLONG; errno = ENAMETOOLONG;
@ -363,7 +315,7 @@ static bool set_socket_name(struct sockaddr_un *sockaddr, const char *name) {
} }
strncpy(sockaddr->sun_path, name, maxlen); 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 false;
if (!xsnprintf(sockaddr->sun_path, maxlen, "%s/%s", cwd, name)) if (!xsnprintf(sockaddr->sun_path, maxlen, "%s/%s", cwd, name))
@ -375,18 +327,9 @@ static bool set_socket_name(struct sockaddr_un *sockaddr, const char *name) {
errno = ENAMETOOLONG; errno = ENAMETOOLONG;
return false; return false;
} }
session_name = name;
strncat(sockaddr->sun_path, name, maxlen - strlen(sockaddr->sun_path) - 1); strncat(sockaddr->sun_path, name, maxlen - strlen(sockaddr->sun_path) - 1);
strncat(sockaddr->sun_path, server.host, maxlen - strlen(sockaddr->sun_path) - 1); strncat(sockaddr->sun_path, server.host, maxlen - strlen(sockaddr->sun_path) - 1);
} }
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; return true;
} }
@ -405,11 +348,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)
@ -463,14 +401,13 @@ 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) { if (fd != -1) {
dup2(fd, STDIN_FILENO); dup2(fd, 0);
dup2(fd, STDOUT_FILENO); dup2(fd, 1);
dup2(fd, STDERR_FILENO); dup2(fd, 2);
close(fd); close(fd);
} }
#endif /* NDEBUG */ #endif /* NDEBUG */
@ -501,7 +438,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);
@ -516,7 +454,10 @@ static bool create_session(const char *name, char * const argv[]) {
static bool attach_session(const char *name, const bool terminate) { static bool attach_session(const char *name, const bool terminate) {
if (server.socket > 0) if (server.socket > 0)
close(server.socket); close(server.socket);
if ((server.socket = session_connect(name)) == -1) if (!set_socket_name(&sockaddr, name) || (server.socket = socket(AF_UNIX, SOCK_STREAM, 0)) == -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;
@ -545,6 +486,21 @@ static bool attach_session(const char *name, const bool terminate) {
return terminate; return terminate;
} }
static bool session_exists(const char *name) {
struct stat sb;
if (!set_socket_name(&sockaddr, name))
return false;
return stat(sockaddr.sun_path, &sb) == 0 && S_ISSOCK(sb.st_mode);
}
static bool session_alive(const char *name) {
struct stat sb;
if (!set_socket_name(&sockaddr, name))
return false;
return stat(sockaddr.sun_path, &sb) == 0 && S_ISSOCK(sb.st_mode) &&
(sb.st_mode & S_IXGRP) == 0;
}
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 strstr(d->d_name, server.host) != NULL;
} }
@ -561,8 +517,7 @@ static int session_comparator(const struct dirent **a, const struct dirent **b)
static int list_session(void) { static int list_session(void) {
if (!create_socket_dir(&sockaddr)) if (!create_socket_dir(&sockaddr))
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)
@ -571,20 +526,16 @@ static int list_session(void) {
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); char *name = strstr(namelist[n]->d_name, server.host);
if (name)
*name = '\0';
printf("%c %s\t%s\n", status, buf, namelist[n]->d_name);
} }
free(namelist[n]); free(namelist[n]);
} }
@ -593,83 +544,63 @@ static int list_session(void) {
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
int opt;
bool force = false; 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); gethostname(server.host+1, sizeof(server.host) - 1);
if (argc == 1)
while ((opt = getopt(argc, argv, "aAclne:fpqrv")) != -1) { exit(list_session());
switch (opt) { for (int arg = 1; arg < argc; arg++) {
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]);
KEY_DETACH = *esc;
break; break;
case 'f': case 'f':
force = true; force = true;
break; break;
case 'p':
passthrough = true;
break;
case 'q':
quiet = true;
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-2015 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)
exit(list_session());
if (!action || !server.session_name) 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;
} }
@ -697,16 +628,14 @@ int main(int argc, char *argv[]) {
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)) if (!attach_session(server.session_name, true))
die("attach-session"); die("attach-session");
break; break;
case 'A': case 'A':
if (session_alive(server.session_name)) { if (session_alive(server.session_name) && !attach_session(server.session_name, true))
if (!attach_session(server.session_name, true))
die("attach-session"); die("attach-session");
} else if (!attach_session(server.session_name, !force)) { if (!attach_session(server.session_name, !force)) {
force = false; force = false;
action = 'c'; action = 'c';
goto redo; goto redo;

27
client.c
View File

@ -22,19 +22,16 @@ static bool client_recv_packet(Packet *pkt) {
} }
static void client_restore_terminal(void) { static void client_restore_terminal(void) {
if (!has_term) if (has_term)
return; tcsetattr(STDIN_FILENO, TCSADRAIN, &orig_term);
tcsetattr(STDIN_FILENO, TCSAFLUSH, &orig_term);
if (alternate_buffer) { if (alternate_buffer) {
printf("\033[?25h\033[?1049l"); printf("\033[?1049l");
fflush(stdout); fflush(stdout);
alternate_buffer = false; alternate_buffer = false;
} }
} }
static void client_setup_terminal(void) { static void client_setup_terminal(void) {
if (!has_term)
return;
atexit(client_restore_terminal); atexit(client_restore_terminal);
cur_term = orig_term; cur_term = orig_term;
@ -46,7 +43,7 @@ static void client_setup_terminal(void) {
cur_term.c_cc[VLNEXT] = _POSIX_VDISABLE; cur_term.c_cc[VLNEXT] = _POSIX_VDISABLE;
cur_term.c_cc[VMIN] = 1; cur_term.c_cc[VMIN] = 1;
cur_term.c_cc[VTIME] = 0; cur_term.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSANOW, &cur_term); tcsetattr(STDIN_FILENO, TCSADRAIN, &cur_term);
if (!alternate_buffer) { if (!alternate_buffer) {
printf("\033[?1049h\033[H"); printf("\033[?1049h\033[H");
@ -65,8 +62,8 @@ static int client_mainloop(void) {
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,8 +78,8 @@ 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;
@ -100,7 +97,6 @@ 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:
@ -122,7 +118,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 +126,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 },
};

19
config.mk Normal file
View File

@ -0,0 +1,19 @@
# abduco version
VERSION = 0.4
# Customize below to fit your system
PREFIX ?= /usr/local
MANPREFIX = ${PREFIX}/share/man
INCS = -I.
LIBS = -lc -lutil
CPPFLAGS = -D_POSIX_C_SOURCE=200809L -D_XOPEN_SOURCE=700
CFLAGS += -std=c99 -pedantic -Wall ${INCS} -DVERSION=\"${VERSION}\" -DNDEBUG ${CPPFLAGS}
LDFLAGS += ${LIBS}
DEBUG_CFLAGS = ${CFLAGS} -UNDEBUG -O0 -g -ggdb
CC ?= cc
STRIP ?= strip

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");

88
server.c
View File

@ -18,18 +18,6 @@ static void client_free(Client *c) {
free(c); free(c);
} }
static void server_sink_client() {
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) { 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)
@ -75,14 +63,33 @@ 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(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;
return c;
error:
if (newfd != -1)
close(newfd);
return NULL;
}
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 +143,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) {
@ -223,25 +201,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 +249,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);

52
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,7 +27,7 @@ dvtm_session() {
dvtm_cmd ' ' dvtm_cmd ' '
dvtm_cmd ' ' dvtm_cmd ' '
sleep 1 sleep 1
dvtm_cmd 'qq' dvtm_cmd 'q'
} }
expected_abduco_prolog() { expected_abduco_prolog() {
@ -39,7 +36,7 @@ expected_abduco_prolog() {
# $1 => session-name, $2 => exit status # $1 => session-name, $2 => exit status
expected_abduco_epilog() { expected_abduco_epilog() {
echo "[?25h[?1049labduco: $1: session terminated with exit status $2" echo "[?1049labduco: $1: session terminated with exit status $2"
} }
# $1 => session-name, $2 => cmd to run # $1 => session-name, $2 => cmd to run
@ -52,7 +49,7 @@ expected_abduco_attached_output() {
# $1 => session-name, $2 => cmd to run # $1 => session-name, $2 => cmd to run
expected_abduco_detached_output() { expected_abduco_detached_output() {
expected_abduco_prolog expected_abduco_prolog
$2 >/dev/null 2>&1 $2 &> /dev/null
expected_abduco_epilog "$1" $? expected_abduco_epilog "$1" $?
} }
@ -64,7 +61,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 +74,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 expected_abduco_attached_output "$name" "$cmd" &> "$output_expected"
$ABDUCO -c "$name" $cmd 2>&1 | sed 's/.$//' > "$output"
if $ABDUCO -c "$name" $cmd 2>&1 | sed 's/.$//' > "$output" && sleep 1 && if 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
@ -102,15 +97,13 @@ 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 expected_abduco_detached_output "$name" "$cmd" &> "$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 | 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 +121,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_epilog "$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 | 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 +139,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_epilog "$name" $? > "$output_expected"
local len=`wc -c "$output_expected" | awk '{ print $1 }'`
len=$((len+1))
if dvtm_session | $ABDUCO -c "$name" 2>&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 +165,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 +203,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 ]