pps-tools: moved to github
pps-tools: moved to github

Signed-off-by: Zoltan HERPAI <wigyori@uid0.hu>



git-svn-id: svn://svn.openwrt.org/openwrt/packages@42632 3c298f89-4303-0410-b956-a3cf2f4a3e73

#  
# Copyright (C) 2011 segal.ubi.pt  
#  
# This is free software, licensed under the GNU General Public License v2.  
# See /LICENSE for more information.  
#  
 
include $(TOPDIR)/rules.mk  
 
PKG_NAME:=ntripcaster  
PKG_VERSION:=0.1.5  
PKG_RELEASE:=1  
 
PKG_SOURCE:=$(PKG_NAME)$(PKG_VERSION).zip  
PKG_SOURCE_URL:=http://igs.bkg.bund.de/root_ftp/NTRIP/software/  
PKG_MD5SUM:=8c85a6c31d8c5cdf2638fe103207a1fd  
 
PKG_MAINTAINER:=Nuno Goncalves <nunojpg@gmail.com>  
 
include $(INCLUDE_DIR)/package.mk  
 
define Package/ntripcaster  
SECTION:=net  
CATEGORY:=Network  
SUBMENU:=NTRIP  
TITLE:=Standard Ntrip Broadcaster  
URL:=http://igs.bkg.bund.de/ntrip/download  
DEPENDS:=+libpthread  
endef  
 
define Package/ntripcaster/description  
BKG Standard Ntrip Broadcaster  
endef  
 
define Build/Prepare  
mkdir -p $(PKG_BUILD_DIR)  
unzip $(DL_DIR)/$(PKG_SOURCE) -d $(PKG_BUILD_DIR)  
mv $(PKG_BUILD_DIR)/$(PKG_NAME)$(PKG_VERSION)/* $(PKG_BUILD_DIR)  
chmod +x $(PKG_BUILD_DIR)/configure  
endef  
 
define Package/ntripcaster/install  
$(INSTALL_DIR) $(1)/usr/local/ntripcaster/bin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/src/ntripcaster $(1)/usr/local/ntripcaster/bin/  
$(INSTALL_DIR) $(1)/usr/local/ntripcaster/conf  
$(INSTALL_DATA) $(PKG_BUILD_DIR)/conf/ntripcaster.conf.dist $(1)/usr/local/ntripcaster/conf/  
$(INSTALL_DATA) $(PKG_BUILD_DIR)/conf/sourcetable.dat.dist $(1)/usr/local/ntripcaster/conf/  
endef  
 
$(eval $(call BuildPackage,ntripcaster))  
 
#  
# Copyright (C) 2011 segal.ubi.pt  
#  
# This is free software, licensed under the GNU General Public License v2.  
# See /LICENSE for more information.  
#  
 
include $(TOPDIR)/rules.mk  
 
PKG_NAME:=ntripclient  
PKG_VERSION:=1.5.0  
PKG_RELEASE:=2  
 
PKG_SOURCE:=$(PKG_NAME).zip  
PKG_SOURCE_URL:=http://igs.bkg.bund.de/root_ftp/NTRIP/software/  
PKG_MD5SUM:=4b357fa648d74e4e13c4b5a2a39f5624  
 
PKG_MAINTAINER:=Nuno Goncalves <nunojpg@gmail.com>  
 
include $(INCLUDE_DIR)/package.mk  
 
define Package/ntripclient  
SECTION:=net  
CATEGORY:=Network  
SUBMENU:=NTRIP  
TITLE:=Ntrip Version 2.0 Command Line Client  
URL:=http://igs.bkg.bund.de/ntrip/download  
endef  
 
define Package/ntripclient/description  
Ntrip Version 2.0 Command Line Client, reading from Ntrip Version 1.0 or 2.0 Caster  
endef  
 
define Build/Prepare  
mkdir -p $(PKG_BUILD_DIR)  
unzip $(DL_DIR)/$(PKG_SOURCE) -d $(PKG_BUILD_DIR)  
endef  
 
MAKE_FLAGS += \  
OPTS="$(TARGET_CFLAGS)"  
 
define Package/ntripclient/install  
$(INSTALL_DIR) $(1)/usr/bin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/ntripclient $(1)/usr/bin/  
endef  
 
$(eval $(call BuildPackage,ntripclient))  
 
#  
# Copyright (C) 2011 segal.ubi.pt  
#  
# This is free software, licensed under the GNU General Public License v2.  
# See /LICENSE for more information.  
#  
 
include $(TOPDIR)/rules.mk  
 
PKG_NAME:=ntripserver  
PKG_VERSION:=1.5.1  
PKG_RELEASE:=2  
 
PKG_SOURCE:=$(PKG_NAME).zip  
PKG_SOURCE_URL:=http://igs.bkg.bund.de/root_ftp/NTRIP/software/  
PKG_MD5SUM:=cecff5da0173896df041bd889935fc12  
 
PKG_MAINTAINER:=Nuno Goncalves <nunojpg@gmail.com>  
 
include $(INCLUDE_DIR)/package.mk  
 
define Package/ntripserver  
SECTION:=net  
CATEGORY:=Network  
SUBMENU:=NTRIP  
TITLE:=Ntrip Version 2.0 Command Line Server  
URL:=http://igs.bkg.bund.de/ntrip/download  
endef  
 
define Package/ntripserver/description  
Ntrip Version 2.0 Command Line Server, reading from SISNeT Server, TCP/UDP IP Port, Serial port, or NtripCaster to support an Ntrip Version 1.0 or 2.0 Caster  
endef  
 
MAKE_FLAGS += \  
OPTS="$(TARGET_CFLAGS)"  
 
define Build/Prepare  
mkdir -p $(PKG_BUILD_DIR)  
unzip $(DL_DIR)/$(PKG_SOURCE) -d $(PKG_BUILD_DIR)  
endef  
 
define Package/ntripserver/install  
$(INSTALL_DIR) $(1)/usr/bin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/ntripserver $(1)/usr/bin/  
endef  
 
$(eval $(call BuildPackage,ntripserver))  
 
file:a/net/remserial/Makefile (deleted)
#  
# Copyright (C) 2014 nunojpg@gmail.com  
#  
# This is free software, licensed under the GNU General Public License v2.  
# See /LICENSE for more information.  
 
include $(TOPDIR)/rules.mk  
 
PKG_NAME:=remserial  
PKG_VERSION:=1.4  
PKG_RELEASE:=1  
 
PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz  
PKG_SOURCE_URL:=http://lpccomp.bc.ca/remserial/  
PKG_MD5SUM:=b19b57fd118329c5ea3aaf9887f946a6  
 
PKG_MAINTAINER:=Nuno Goncalves <nunojpg@gmail.com>  
 
include $(INCLUDE_DIR)/package.mk  
 
define Package/remserial  
SECTION:=net  
CATEGORY:=Network  
TITLE:=Bridge TCP/IP port with a device  
URL:=http://lpccomp.bc.ca/remserial/  
endef  
 
define Package/remserial/install  
$(INSTALL_DIR) $(1)/usr/bin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/remserial $(1)/usr/bin/  
endef  
 
$(eval $(call BuildPackage,remserial))  
 
file:a/net/sshtunnel/Makefile (deleted)
#  
# Copyright (C) 2010-2011 OpenWrt.org  
# Copyright (C) 2010 segal.di.ubi.pt  
#  
# This is free software, licensed under the GNU General Public License v2.  
# See /LICENSE for more information.  
#  
 
include $(TOPDIR)/rules.mk  
 
PKG_NAME:=sshtunnel  
PKG_VERSION:=3  
PKG_RELEASE:=3  
 
PKG_MAINTAINER:=Nuno Goncalves <nunojpg@gmail.com>  
 
include $(INCLUDE_DIR)/package.mk  
 
define Package/sshtunnel  
SECTION:=net  
CATEGORY:=Network  
SUBMENU:=SSH  
TITLE:=Manages Local and Remote openssh ssh(1) tunnels  
DEPENDS:=+openssh-client  
endef  
 
define Package/sshtunnel/description  
Creates openssh ssh(1) Local and Remote tunnels configured in UCI file. Can be used to allow remote connections, possibly over NATed connections or without public IP/DNS  
endef  
 
define Package/sshtunnel/conffiles  
/etc/config/sshtunnel  
endef  
 
define Build/Compile  
endef  
 
define Package/sshtunnel/install  
$(INSTALL_DIR) $(1)/etc/init.d  
$(INSTALL_BIN) ./files/sshtunnel.init $(1)/etc/init.d/sshtunnel  
$(INSTALL_DIR) $(1)/usr/bin  
$(INSTALL_BIN) ./files/sshtunnel.sh $(1)/usr/bin/  
$(INSTALL_DIR) $(1)/etc/config  
$(INSTALL_DATA) ./files/uci_sshtunnel $(1)/etc/config/sshtunnel  
endef  
 
$(eval $(call BuildPackage,sshtunnel))  
 
#!/bin/sh /etc/rc.common  
 
START=99  
STOP=01  
 
PIDFILE="/tmp/run/sshtunnel"  
 
 
append_params() {  
local p; local v; local args;  
for p in $*; do  
eval "v=\$$p"  
[ -n "$v" ] && args="$args -o $p=$v"  
done  
 
ARGS_options="${args# *}"  
}  
 
append_string() {  
local varname="$1"; local add="$2"; local separator="${3:- }"; local actual  
eval "actual=\$$varname"  
 
new="${actual:+$actual$separator}$add"  
eval "$varname=\$new"  
}  
 
load_tunnelR() {  
config_get section_server $1 server  
[ "$server" = "$section_server" ] || return 0 # continue to read next section if this is not for the current server  
let count++ # count nr of valid sections to make sure there are at least one  
 
config_get remoteaddress $1 remoteaddress "*"  
config_get remoteport $1 remoteport  
config_get localaddress $1 localaddress  
config_get localport $1 localport  
 
[ "$remoteport" -gt 0 ] || append_string "error" "[tunnelR: $1]remoteport must be a positive integer" "; "  
[ "$localport" -gt 0 ] || append_string "error" "[tunnelR: $1]localport must be a positive integer" "; "  
[ -n "$error" ] && return 1  
 
append_string "ARGS_tunnels" "-R $remoteaddress:$remoteport:$localaddress:$localport"  
}  
 
load_tunnelL() {  
config_get section_server $1 server  
[ "$server" = "$section_server" ] || return 0 # continue to read next section if this is not for the current server  
let count++ # count nr of valid sections to make sure there are at least one  
 
config_get localaddress $1 localaddress "*"  
config_get localport $1 localport  
config_get remoteaddress $1 remoteaddress  
config_get remoteport $1 remoteport  
 
[ "$remoteport" -gt 0 ] || append_string "error" "[tunnelL: $1]remoteport must be a positive integer" "; "  
[ "$localport" -gt 0 ] || append_string "error" "[tunnelL: $1]localport must be a positive integer" "; "  
[ -n "$error" ] && return 1  
 
append_string "ARGS_tunnels" "-L $localaddress:$localport:$remoteaddress:$remoteport"  
}  
 
load_tunnelD() {  
config_get section_server $1 server  
[ "$server" = "$section_server" ] || return 0 # continue to read next section if this is not for the current server  
let count++ # count nr of valid sections to make sure there are at least one  
 
config_get localaddress $1 localaddress "*"  
config_get localport $1 localport  
 
[ "$remoteport" -gt 0 ] || append_string "error" "[tunnelD: $1]remoteport must be a positive integer" "; "  
[ "$localport" -gt 0 ] || append_string "error" "[tunnelD: $1]localport must be a positive integer" "; "  
[ -n "$error" ] && return 1  
 
append_string "ARGS_tunnels" "-D $localaddress:$localport"  
}  
 
load_tunnelW() {  
config_get section_server $1 server  
[ "$server" = "$section_server" ] || return 0 # continue to read next section if this is not for the current server  
let count++ # count nr of valid sections to make sure there are at least one  
 
config_get localdev $1 localdev "*"  
config_get remotedev $1 remotedev "*"  
config_get vpntype $1 vpntype "*"  
 
[ "$vpntype" == "ethernet" ] || [ "$vpntype" == "point-to-point" ] || append_string "error" "[tunnelW: $1] vpntype must be \"ethernet\" (tap) or \"pointopoint\" (tun)" "; "  
[ "$localdev" == "any" ] || [ "$localdev" -ge 0 ] || append_string "error" "[tunnelW: $1] localdev must be an integer or \"any\"" "; "  
[ "$remotedev" == "any" ] || [ "$remotedev" -ge 0 ] || append_string "error" "[tunnelW: $1] remotedev must be an integer or \"any\"" "; "  
[ "$user" == "root" ] || logger -p user.warn -t "sshtunnel" "warning: root is required unless the tunnel device has been created manually"  
[ -n "$error" ] && return 1  
 
append_string "ARGS_tunnels" "-w $localdev:$remotedev -o Tunnel=$vpntype"  
}  
 
load_server() {  
server="$1"  
 
config_get user $1 user  
config_get hostname $1 hostname  
config_get port $1 port "22"  
config_get retrydelay $1 retrydelay "60"  
config_get PKCS11Provider $1 PKCS11Provider  
config_get CheckHostIP $1 CheckHostIP  
config_get Compression $1 Compression  
config_get CompressionLevel $1 CompressionLevel  
config_get IdentityFile $1 IdentityFile  
config_get LogLevel $1 LogLevel  
config_get ServerAliveCountMax $1 ServerAliveCountMax  
config_get ServerAliveInterval $1 ServerAliveInterval  
config_get StrictHostKeyChecking $1 StrictHostKeyChecking  
config_get TCPKeepAlive $1 TCPKeepAlive  
config_get VerifyHostKeyDNS $1 VerifyHostKeyDNS  
 
error=""  
[ -n "$user" ] \  
|| append_string "error" "user is not set" "; "  
[ -n "$hostname" ] \  
|| append_string "error" "hostname is not set" "; "  
[ "$retrydelay" -ge 1 ] \  
|| append_string "error" "retrydelay must be a positive integer" "; "  
[ -z "$PKCS11Provider" -o -f "$PKCS11Provider" ] \  
|| append_string "error" "PKCS11Provider must be a pkcs11 shared library accessible" "; "  
[ -z "$CheckHostIP" -o "$CheckHostIP"="yes" -o "$CheckHostIP"="no" ] \  
|| append_string "error" "CheckHostIP must be 'yes' or 'no'" "; "  
[ -z "$Compression" -o "$Compression"="yes" -o "$Compression"="no" ] \  
|| append_string "error" "Compression must be 'yes' or 'no'" "; "  
[ -z "$CompressionLevel" ] || [ "$CompressionLevel" -ge 1 -a "$CompressionLevel" -le 9 ] \  
|| append_string "error" "CompressionLevel must be between 1 and 9" "; "  
[ -z "$IdentityFile" -o -f "$IdentityFile" ] \  
|| append_string "error" "IdentityFile $IdentityFile not accessible" "; "  
[ -z "$LogLevel" -o "$LogLevel" = "QUIET" -o "$LogLevel" = "FATAL" -o "$LogLevel" = "ERROR" -o \  
"$LogLevel" = "INFO" -o "$LogLevel" = "VERBOSE" -o "$LogLevel" = "DEBUG" -o \  
"$LogLevel" = "DEBUG1" -o "$LogLevel" = "DEBUG2" -o "$LogLevel" = "DEBUG3" ] \  
|| append_string "error" "LogLevel is invalid" "; "  
[ -z "$ServerAliveCountMax" ] || [ "$ServerAliveCountMax" -ge 1 ] \  
|| append_string "error" "ServerAliveCountMax must be greater or equal than 1" "; "  
[ -z "$ServerAliveInterval" ] || [ "$ServerAliveInterval" -ge 0 ] \  
|| append_string "error" "ServerAliveInterval must be greater or equal than 0" "; "  
[ -z "$StrictHostKeyChecking" -o "$StrictHostKeyChecking" = "yes" -o "$StrictHostKeyChecking" = "ask" -o "$StrictHostKeyChecking" = "no" ] \  
|| append_string "error" "StrictHostKeyChecking must be 'yes', 'ask' or 'no'" "; "  
[ -z "$TCPKeepAlive" -o "$TCPKeepAlive" = "yes" -o "$TCPKeepAlive" = "no" ] \  
|| append_string "error" "TCPKeepAlive must be 'yes' or 'no'" "; "  
[ -z "$VerifyHostKeyDNS" -o "$VerifyHostKeyDNS" = "yes" -o "$VerifyHostKeyDNS" = "no" ] \  
|| append_string "error" "VerifyHostKeyDNS must be 'yes' or 'no'" "; "  
 
[ -n "$error" ] && { logger -p user.err -t "sshtunnel" "tunnels to $server not started - $error"; return; }  
 
 
ARGS=""  
ARGS_options=""  
ARGS_tunnels=""  
 
count=0  
config_foreach load_tunnelR tunnelR && config_foreach load_tunnelL tunnelL && config_foreach load_tunnelD tunnelD  
[ -n "$error" ] && { logger -p user.err -t "sshtunnel" "tunnels to $server not started - $error"; return; }  
[ "$count" -eq 0 ] && { logger -p user.err -t "sshtunnel" "tunnels to $server not started - no tunnels defined"; return; }  
 
append_params CheckHostIP Compression CompressionLevel IdentityFile LogLevel PKCS11Provider ServerAliveCountMax ServerAliveInterval StrictHostKeyChecking TCPKeepAlive VerifyHostKeyDNS  
ARGS="$ARGS_options -o ExitOnForwardFailure=yes -o BatchMode=yes -nN $ARGS_tunnels -p $port $user@$hostname"  
 
/usr/bin/sshtunnel.sh "$ARGS" "$retrydelay" "$server" &  
echo $! >> "${PIDFILE}.pids"  
logger -p user.info -t "sshtunnel" "started tunnels to $server (pid=$!;retrydelay=$retrydelay)"  
}  
 
stop() {  
if [ -f "$PIDFILE".pids ]  
then  
logger -p user.info -t "sshtunnel" "stopping all tunnels"  
 
while read pid  
do  
kill "$pid" # kill mother process first  
 
[ -f "${PIDFILE}_${pid}.pid" ] && { # if ssh was running, kill it also (mother process could be in retry wait)  
start-stop-daemon -K -p "${PIDFILE}_${pid}.pid"  
rm "${PIDFILE}_${pid}.pid"  
}  
 
logger -p daemon.info -t "sshtunnel[$pid]" "tunnel stopped"  
 
done < "${PIDFILE}.pids"  
 
rm "${PIDFILE}.pids"  
 
logger -p user.info -t "sshtunnel" "all tunnels stopped"  
else  
logger -p user.info -t "sshtunnel" "no tunnels running"  
fi  
}  
 
start() {  
[ -f "${PIDFILE}.pids" ] && stop  
 
config_load sshtunnel  
if [ -n "$(uci show sshtunnel.@server[0])" ] # at least one server section exists  
then  
logger -p user.info -t "sshtunnel" "starting all tunnels"  
config_foreach load_server server  
logger -p user.info -t "sshtunnel" "all tunnels started"  
else  
logger -p user.info -t "sshtunnel" "no servers defined"  
fi  
}  
 
#!/bin/sh  
 
PIDFILE="/tmp/run/sshtunnel"  
 
args="$1"  
retrydelay="$2"  
server="$3"  
 
while true  
do  
logger -p daemon.info -t "sshtunnel[$$][$server]" "connection started"  
 
start-stop-daemon -S -p "${PIDFILE}_${$}.pid" -mx ssh -- $args &>/tmp/log/sshtunnel_$$  
 
logger -p daemon.err -t "sshtunnel[$$][$server]" < /tmp/log/sshtunnel_$$  
rm /tmp/log/sshtunnel_$$  
logger -p daemon.info -t "sshtunnel[$$][$server]" "ssh exited with code $?, retrying in $retrydelay seconds"  
rm "${PIDFILE}_${$}.pid"  
 
sleep "$retrydelay" & wait  
done  
 
#  
# password authentication is not possible, public key authentication must be used.  
# set "option IdentityFile" to he file from which the identity (private key) for RSA or DSA authentication is read.  
# The default is ~/.ssh/identity for protocol version 1, and ~/.ssh/id_rsa and ~/.ssh/id_dsa for protocol version 2.  
# ssh will also try to load certificate information from the filename obtained by appending -cert.pub to identity filenames.  
#  
 
#config server disney  
# option user mourinho  
# option hostname server.disney.com  
# option port 22  
# option retrydelay 1  
# option CheckHostIP yes  
# option Compression no  
# option CompressionLevel 6  
# option IdentityFile ~/.ssh/id_rsa  
# option LogLevel INFO  
# option PKCS11Provider /lib/pteidpkcs11.so  
# option ServerAliveCountMax 3  
# option ServerAliveInterval 0  
# option StrictHostKeyChecking ask  
# option TCPKeepAlive yes  
# option VerifyHostKeyDNS yes  
 
# tunnelR(emote) - when the connection will be initiated to the R(emote) endpoint at  
# remoteaddress:remoteport and then forwarded to localaddress:localport  
#  
#config tunnelR http  
# option server disney  
# option remoteaddress *  
# option remoteport 9009  
# option localaddress 192.168.1.13  
# option localport 80  
 
# tunnelL(ocal) - when the connection will be initiated to the L(ocal) endpoint at  
# localaddress:localport and then forwarded to remoteaddress:remoteport  
#  
#config tunnelL test  
# option server disney  
# option localaddress *  
# option localport 1022  
# option remoteaddress secretserver.disney.com  
# option remoteport 22  
 
# tunnelD(ynamic) - when the connection will be initiated with the SOCKS4 or SOCKS5 protocol  
# to the local endpoint at localaddress:localport and then forwarded over the remote host  
#  
#config tunnelD proxy  
# option server disney  
# option localaddress *  
# option localport 4055  
 
# tunnelW - creates TUN/TAP devices on client and server to establish a VPN tunnel between them  
# vpntypes:  
# point-to-point = TUN  
# ethernet = TAP  
#  
#config tunnelW proxy  
# option server disney  
# option vpntype point-to-point|ethernet  
# option localdev any|0|1|2|...  
# option remotedev any|0|1|2|...  
 
 
#  
# Copyright (C) 2008 OpenWrt.org  
#  
# This is free software, licensed under the GNU General Public License v2.  
# See /LICENSE for more information.  
#  
 
 
include $(TOPDIR)/rules.mk  
include $(INCLUDE_DIR)/kernel.mk  
 
PKG_NAME:=pps-tools  
PKG_VERSION:=2.6.23  
PKG_RELEASE:=1  
 
include $(INCLUDE_DIR)/package.mk  
 
define Package/pps-tools  
SUBMENU:=Time Synchronization  
SECTION:=net  
CATEGORY:=Network  
DEPENDS:=@LINUX_2_6_23  
TITLE:=PPS (Pulse Per Second) Userland tools  
URL:=http://wiki.enneenne.com/index.php/LinuxPPS_support  
endef  
 
 
define Package/pps-tools/description  
Userland tools for GPS and DCF-77 Clock syncronization. PPS support in Kernel must be enabled.  
endef  
 
define Build/InstallDev  
$(INSTALL_DIR) $(1)/usr/include  
$(CP) $(PKG_BUILD_DIR)/timepps.h $(1)/usr/include/  
endef  
 
define Build/Compile  
$(MAKE) -C $(PKG_BUILD_DIR) \  
$(TARGET_CONFIGURE_OPTS) \  
CFLAGS="$(TARGET_CFLAGS) -DHAVE_ISC_READER=1 -I$(LINUX_DIR)/include -I ." \  
BINDIR="/usr/sbin" MANDIR="/usr/man"  
endef  
 
define Package/pps-tools/install  
$(INSTALL_DIR) $(1)/usr/sbin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/ppstest $(1)/usr/sbin/  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/ppsctl $(1)/usr/sbin/  
endef  
 
$(eval $(call BuildPackage,pps-tools))  
 
diff --git a/Makefile b/Makefile  
new file mode 100644  
index 0000000..a2660a2  
--- /dev/null  
+++ b/Makefile  
@@ -0,0 +1,27 @@  
+TARGETS = ppstest ppsctl  
+  
+CFLAGS += -Wall -O2 -D_GNU_SOURCE  
+CFLAGS += -I .  
+CFLAGS += -ggdb  
+  
+# -- Actions section ----------------------------------------------------------  
+  
+.PHONY : all depend dep  
+  
+all : .depend $(TARGETS)  
+  
+.depend depend dep :  
+ $(CC) $(CFLAGS) -M $(TARGETS:=.c) > .depend  
+  
+ifeq (.depend,$(wildcard .depend))  
+include .depend  
+endif  
+  
+  
+# -- Clean section ------------------------------------------------------------  
+  
+.PHONY : clean  
+  
+clean :  
+ rm -f *.o *~ core .depend  
+ rm -f ${TARGETS}  
diff --git a/ppsctl.c b/ppsctl.c  
new file mode 100644  
index 0000000..83fd08a  
--- /dev/null  
+++ b/ppsctl.c  
@@ -0,0 +1,62 @@  
+#include <stdio.h>  
+#include <unistd.h>  
+#include <stdlib.h>  
+#include <errno.h>  
+#include <sys/ioctl.h>  
+#include <sys/types.h>  
+#include <sys/stat.h>  
+#include <fcntl.h>  
+#include <string.h>  
+#include <linux/serial.h>  
+  
+void usage(char *name)  
+{  
+ fprintf(stderr, "usage: %s <ttyS> [enable|disable]\n", name);  
+  
+ exit(EXIT_FAILURE);  
+}  
+  
+int main(int argc, char *argv[])  
+{  
+ int fd;  
+ int ret;  
+ struct serial_struct ss;  
+  
+ if (argc < 2)  
+ usage(argv[0]);  
+  
+ fd = open(argv[1], O_RDWR);  
+ if (fd < 0) {  
+ perror("open");  
+ exit(EXIT_FAILURE);  
+ }  
+  
+ ret = ioctl(fd, TIOCGSERIAL, &ss);  
+ if (ret < 0) {  
+ perror("ioctl(TIOCGSERIAL)");  
+ exit(EXIT_FAILURE);  
+ }  
+  
+ if (argc < 3) { /* just read PPS status */  
+ printf("PPS is %sabled\n",  
+ ss.flags & ASYNC_HARDPPS_CD ? "en" : "dis");  
+ exit(EXIT_SUCCESS);  
+ }  
+  
+ if (argv[2][0] == 'e' || argv[2][0] == '1')  
+ ss.flags |= ASYNC_HARDPPS_CD;  
+ else if (argv[2][0] == 'd' || argv[2][0] == '0')  
+ ss.flags &= ~ASYNC_HARDPPS_CD;  
+ else {  
+ fprintf(stderr, "invalid state argument \"%s\"\n", argv[2]);  
+ exit(EXIT_FAILURE);  
+ }  
+  
+ ret = ioctl(fd, TIOCSSERIAL, &ss);  
+ if (ret < 0) {  
+ perror("ioctl(TIOCSSERIAL)");  
+ exit(EXIT_FAILURE);  
+ }  
+  
+ return 0;  
+}  
diff --git a/ppsfind b/ppsfind  
new file mode 100755  
index 0000000..93c0e17  
--- /dev/null  
+++ b/ppsfind  
@@ -0,0 +1,17 @@  
+#!/bin/sh  
+  
+SYS="/sys/class/pps/"  
+  
+if [ $# -lt 1 ] ; then  
+ echo "usage: ppsfind <name>" >&2  
+ exit 1  
+fi  
+  
+for d in $(ls $SYS) ; do  
+ if grep $1 $SYS/$d/name >& /dev/null || \  
+ grep $1 $SYS/$d/path >& /dev/null ; then  
+ echo "$d: name=$(cat $SYS/$d/name) path=$(cat $SYS/$d/path)"  
+ fi  
+done  
+  
+exit 0  
diff --git a/ppstest.c b/ppstest.c  
new file mode 100644  
index 0000000..d125ffa  
--- /dev/null  
+++ b/ppstest.c  
@@ -0,0 +1,151 @@  
+#include <stdio.h>  
+#include <stdlib.h>  
+#include <unistd.h>  
+#include <errno.h>  
+#include <string.h>  
+#include <sys/types.h>  
+#include <sys/stat.h>  
+#include <fcntl.h>  
+  
+#include <timepps.h>  
+  
+int find_source(char *path, pps_handle_t *handle, int *avail_mode)  
+{  
+ pps_params_t params;  
+ int ret;  
+  
+ printf("trying PPS source \"%s\"\n", path);  
+  
+ /* Try to find the source by using the supplied "path" name */  
+ ret = open(path, O_RDWR);  
+ if (ret < 0) {  
+ fprintf(stderr, "unable to open device \"%s\" (%m)\n", path);  
+ return ret;  
+ }  
+  
+ /* Open the PPS source (and check the file descriptor) */  
+ ret = time_pps_create(ret, handle);  
+ if (ret < 0) {  
+ fprintf(stderr, "cannot create a PPS source from device "  
+ "\"%s\" (%m)\n", path);  
+ return -1;  
+ }  
+ printf("found PPS source \"%s\"\n", path);  
+  
+ /* Find out what features are supported */  
+ ret = time_pps_getcap(*handle, avail_mode);  
+ if (ret < 0) {  
+ fprintf(stderr, "cannot get capabilities (%m)\n");  
+ return -1;  
+ }  
+ if ((*avail_mode & PPS_CAPTUREASSERT) == 0) {  
+ fprintf(stderr, "cannot CAPTUREASSERT\n");  
+ return -1;  
+ }  
+ if ((*avail_mode & PPS_OFFSETASSERT) == 0) {  
+ fprintf(stderr, "cannot OFFSETASSERT\n");  
+ return -1;  
+ }  
+  
+ /* Capture assert timestamps, and compensate for a 675 nsec  
+ * propagation delay */  
+ ret = time_pps_getparams(*handle, &params);  
+ if (ret < 0) {  
+ fprintf(stderr, "cannot get parameters (%m)\n");  
+ return -1;  
+ }  
+ params.assert_offset.tv_sec = 0;  
+ params.assert_offset.tv_nsec = 675;  
+ params.mode |= PPS_CAPTUREASSERT | PPS_OFFSETASSERT;  
+ ret = time_pps_setparams(*handle, &params);  
+ if (ret < 0) {  
+ fprintf(stderr, "cannot set parameters (%m)\n");  
+ return -1;  
+ }  
+  
+ return 0;  
+}  
+  
+int fetch_source(int i, pps_handle_t *handle, int *avail_mode)  
+{  
+ struct timespec timeout;  
+ pps_info_t infobuf;  
+ int ret;  
+  
+ /* create a zero-valued timeout */  
+ timeout.tv_sec = 3;  
+ timeout.tv_nsec = 0;  
+  
+retry:  
+ if (*avail_mode & PPS_CANWAIT) /* waits for the next event */  
+ ret = time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,  
+ &timeout);  
+ else {  
+ sleep(1);  
+ ret = time_pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,  
+ &timeout);  
+ }  
+ if (ret < 0) {  
+ if (ret == -EINTR) {  
+ fprintf(stderr, "time_pps_fetch() got a signal!\n");  
+ goto retry;  
+ }  
+  
+ fprintf(stderr, "time_pps_fetch() error %d (%m)\n", ret);  
+ return -1;  
+ }  
+  
+ printf("source %d - "  
+ "assert %ld.%09ld, sequence: %ld - "  
+ "clear %ld.%09ld, sequence: %ld\n",  
+ i,  
+ infobuf.assert_timestamp.tv_sec,  
+ infobuf.assert_timestamp.tv_nsec,  
+ infobuf.assert_sequence,  
+ infobuf.clear_timestamp.tv_sec,  
+ infobuf.clear_timestamp.tv_nsec, infobuf.clear_sequence);  
+  
+ return 0;  
+}  
+  
+void usage(char *name)  
+{  
+ fprintf(stderr, "usage: %s <ppsdev> [<ppsdev> ...]\n", name);  
+ exit(EXIT_FAILURE);  
+}  
+  
+int main(int argc, char *argv[])  
+{  
+ int num;  
+ pps_handle_t handle[4];  
+ int avail_mode[4];  
+ int i = 0;  
+ int ret;  
+  
+ /* Check the command line */  
+ if (argc < 2)  
+ usage(argv[0]);  
+  
+ for (i = 1; i < argc && i <= 4; i++) {  
+ ret = find_source(argv[i], &handle[i - 1], &avail_mode[i - 1]);  
+ if (ret < 0)  
+ exit(EXIT_FAILURE);  
+ }  
+  
+ num = i - 1;  
+ printf("ok, found %d source(s), now start fetching data...\n", num);  
+  
+ /* loop, printing the most recent timestamp every second or so */  
+ while (1) {  
+ for (i = 0; i < num; i++) {  
+ ret = fetch_source(i, &handle[i], &avail_mode[i]);  
+ if (ret < 0 && errno != ETIMEDOUT)  
+ exit(EXIT_FAILURE);  
+ }  
+ }  
+  
+ for (; i >= 0; i--)  
+ time_pps_destroy(handle[i]);  
+  
+ return 0;  
+}  
diff --git a/timepps.h b/timepps.h  
new file mode 100644  
index 0000000..28ebf4c  
--- /dev/null  
+++ b/timepps.h  
@@ -0,0 +1,193 @@  
+/*  
+ * timepps.h -- PPS API main header  
+ *  
+ * Copyright (C) 2005-2007 Rodolfo Giometti <giometti@linux.it>  
+ *  
+ * This program is free software; you can redistribute it and/or modify  
+ * it under the terms of the GNU General Public License as published by  
+ * the Free Software Foundation; either version 2 of the License, or  
+ * (at your option) any later version.  
+ *  
+ * This program is distributed in the hope that it will be useful,  
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of  
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  
+ * GNU General Public License for more details.  
+ *  
+ * You should have received a copy of the GNU General Public License  
+ * along with this program; if not, write to the Free Software  
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  
+ */  
+  
+#ifndef _SYS_TIMEPPS_H_  
+#define _SYS_TIMEPPS_H_  
+  
+#include <sys/syscall.h>  
+#include <unistd.h>  
+#include <errno.h>  
+#include <linux/pps.h>  
+  
+/*  
+ * New data structures  
+ */  
+  
+struct ntp_fp {  
+ unsigned int integral;  
+ unsigned int fractional;  
+};  
+  
+union pps_timeu {  
+ struct timespec tspec;  
+ struct ntp_fp ntpfp;  
+ unsigned long longpad[3];  
+};  
+  
+struct pps_info {  
+ unsigned long assert_sequence; /* seq. num. of assert event */  
+ unsigned long clear_sequence; /* seq. num. of clear event */  
+ union pps_timeu assert_tu; /* time of assert event */  
+ union pps_timeu clear_tu; /* time of clear event */  
+ int current_mode; /* current mode bits */  
+};  
+  
+struct pps_params {  
+ int api_version; /* API version # */  
+ int mode; /* mode bits */  
+ union pps_timeu assert_off_tu; /* offset compensation for assert */  
+ union pps_timeu clear_off_tu; /* offset compensation for clear */  
+};  
+  
+typedef int pps_handle_t; /* represents a PPS source */  
+typedef unsigned long pps_seq_t; /* sequence number */  
+typedef struct ntp_fp ntp_fp_t; /* NTP-compatible time stamp */  
+typedef union pps_timeu pps_timeu_t; /* generic data type for time stamps */  
+typedef struct pps_info pps_info_t;  
+typedef struct pps_params pps_params_t;  
+  
+#define assert_timestamp assert_tu.tspec  
+#define clear_timestamp clear_tu.tspec  
+  
+#define assert_timestamp_ntpfp assert_tu.ntpfp  
+#define clear_timestamp_ntpfp clear_tu.ntpfp  
+  
+#define assert_offset assert_off_tu.tspec  
+#define clear_offset clear_off_tu.tspec  
+  
+#define assert_offset_ntpfp assert_off_tu.ntpfp  
+#define clear_offset_ntpfp clear_off_tu.ntpfp  
+  
+/*  
+ * The PPS API  
+ */  
+  
+static __inline int time_pps_create(int source, pps_handle_t *handle)  
+{  
+ int ret;  
+  
+ if (!handle) {  
+ errno = EINVAL;  
+ return -1;  
+ }  
+  
+ /* First we check if current device is a PPS valid PPS one...  
+ */  
+ ret = ioctl(source, PPS_CHECK);  
+ if (ret) {  
+ errno = EOPNOTSUPP;  
+ return -1;  
+ }  
+  
+ /* ... then since in LinuxPPS there are no differences between a  
+ * "PPS source" and a "PPS handle", we simply return the same value.  
+ */  
+ *handle = source;  
+  
+ return 0;  
+}  
+  
+static __inline int time_pps_destroy(pps_handle_t handle)  
+{  
+ return close(handle);  
+}  
+  
+static __inline int time_pps_getparams(pps_handle_t handle,  
+ pps_params_t *ppsparams)  
+{  
+ int ret;  
+ struct pps_kparams __ppsparams;  
+  
+ ret = ioctl(handle, PPS_GETPARAMS, &__ppsparams);  
+  
+ ppsparams->api_version = __ppsparams.api_version;  
+ ppsparams->mode = __ppsparams.mode;  
+ ppsparams->assert_off_tu.tspec.tv_sec = __ppsparams.assert_off_tu.sec;  
+ ppsparams->assert_off_tu.tspec.tv_nsec = __ppsparams.assert_off_tu.nsec;  
+ ppsparams->clear_off_tu.tspec.tv_sec = __ppsparams.clear_off_tu.sec;  
+ ppsparams->clear_off_tu.tspec.tv_nsec = __ppsparams.clear_off_tu.nsec;  
+  
+ return ret;  
+}  
+  
+static __inline int time_pps_setparams(pps_handle_t handle,  
+ const pps_params_t *ppsparams)  
+{  
+ struct pps_kparams __ppsparams;  
+  
+ __ppsparams.api_version = ppsparams->api_version;  
+ __ppsparams.mode = ppsparams->mode;  
+ __ppsparams.assert_off_tu.sec = ppsparams->assert_off_tu.tspec.tv_sec;  
+ __ppsparams.assert_off_tu.nsec = ppsparams->assert_off_tu.tspec.tv_nsec;  
+ __ppsparams.clear_off_tu.sec = ppsparams->clear_off_tu.tspec.tv_sec;  
+ __ppsparams.clear_off_tu.nsec = ppsparams->clear_off_tu.tspec.tv_nsec;  
+  
+ return ioctl(handle, PPS_SETPARAMS, &__ppsparams);  
+}  
+  
+/* Get capabilities for handle */  
+static __inline int time_pps_getcap(pps_handle_t handle, int *mode)  
+{  
+ return ioctl(handle, PPS_GETCAP, mode);  
+}  
+  
+static __inline int time_pps_fetch(pps_handle_t handle, const int tsformat,  
+ pps_info_t *ppsinfobuf,  
+ const struct timespec *timeout)  
+{  
+ struct pps_fdata __fdata;  
+ int ret;  
+  
+ /* Sanity checks */  
+ if (tsformat != PPS_TSFMT_TSPEC) {  
+ errno = EINVAL;  
+ return -1;  
+ }  
+  
+ if (timeout) {  
+ __fdata.timeout.sec = timeout->tv_sec;  
+ __fdata.timeout.nsec = timeout->tv_nsec;  
+ __fdata.timeout.flags = ~PPS_TIME_INVALID;  
+ } else  
+ __fdata.timeout.flags = PPS_TIME_INVALID;  
+  
+ ret = ioctl(handle, PPS_FETCH, &__fdata);  
+  
+ ppsinfobuf->assert_sequence = __fdata.info.assert_sequence;  
+ ppsinfobuf->clear_sequence = __fdata.info.clear_sequence;  
+ ppsinfobuf->assert_tu.tspec.tv_sec = __fdata.info.assert_tu.sec;  
+ ppsinfobuf->assert_tu.tspec.tv_nsec = __fdata.info.assert_tu.nsec;  
+ ppsinfobuf->clear_tu.tspec.tv_sec = __fdata.info.clear_tu.sec;  
+ ppsinfobuf->clear_tu.tspec.tv_nsec = __fdata.info.clear_tu.nsec;  
+ ppsinfobuf->current_mode = __fdata.info.current_mode;  
+  
+ return ret;  
+}  
+  
+static __inline int time_pps_kcbind(pps_handle_t handle,  
+ const int kernel_consumer,  
+ const int edge, const int tsformat)  
+{  
+ /* LinuxPPS doesn't implement kernel consumer feature */  
+ errno = EOPNOTSUPP;  
+ return -1;  
+}  
+  
+#endif /* _SYS_TIMEPPS_H_ */  
 
file:a/utils/rtklib/Makefile (deleted)
#  
# Copyright (C) 2014 nunojpg@gmail.com  
#  
# This is free software, licensed under the GNU General Public License v2.  
# See /LICENSE for more information.  
 
include $(TOPDIR)/rules.mk  
 
PKG_NAME:=rtklib  
PKG_VERSION:=2.4.2_p4  
PKG_RELEASE:=$(PKG_SOURCE_VERSION)  
 
PKG_SOURCE_PROTO:=git  
PKG_SOURCE_URL:=git://github.com/tomojitakasu/RTKLIB.git  
PKG_SOURCE_VERSION:=4464e1259f34ba8a8b71f0e5f078faf62e1d9ced  
PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION)-$(PKG_SOURCE_VERSION).tar.gz  
PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION)  
 
PKG_MAINTAINER:=Nuno Goncalves <nunojpg@gmail.com>  
 
include $(INCLUDE_DIR)/package.mk  
 
define Package/rtklib/default  
SUBMENU:=RTKLIB Suite  
SECTION:=utils  
CATEGORY:=Utilities  
URL:=http://www.rtklib.com/  
DEPENDS:=+libpthread +librt  
endef  
 
define Package/convbin  
$(call Package/rtklib/default)  
TITLE:=RINEX Converter  
endef  
 
define Package/pos2kml  
$(call Package/rtklib/default)  
TITLE:=Solution to KML converter  
endef  
 
define Package/rnx2rtkp  
$(call Package/rtklib/default)  
TITLE:=Post-Processing Analysis  
endef  
 
define Package/rtkrcv  
$(call Package/rtklib/default)  
TITLE:=Real-Time Positioning  
endef  
 
define Package/str2str  
$(call Package/rtklib/default)  
TITLE:=Communication Server  
endef  
 
define Build/Compile  
rm -rf $(PKG_INSTALL_DIR)  
mkdir -p $(PKG_INSTALL_DIR)  
$(MAKE) -C $(PKG_BUILD_DIR)/app/convbin/gcc CC="$(TARGET_CC) $(TARGET_CFLAGS)"  
$(MAKE) -C $(PKG_BUILD_DIR)/app/pos2kml/gcc CC="$(TARGET_CC) $(TARGET_CFLAGS)"  
$(MAKE) -C $(PKG_BUILD_DIR)/app/rnx2rtkp/gcc CC="$(TARGET_CC) $(TARGET_CFLAGS)"  
$(MAKE) -C $(PKG_BUILD_DIR)/app/rtkrcv/gcc CC="$(TARGET_CC) $(TARGET_CFLAGS)"  
$(MAKE) -C $(PKG_BUILD_DIR)/app/str2str/gcc CC="$(TARGET_CC) $(TARGET_CFLAGS)"  
endef  
 
define Package/convbin/install  
$(INSTALL_DIR) $(1)/usr/bin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/app/convbin/gcc/convbin $(1)/usr/bin/  
endef  
 
define Package/pos2kml/install  
$(INSTALL_DIR) $(1)/usr/bin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/app/pos2kml/gcc/pos2kml $(1)/usr/bin/  
endef  
 
define Package/rnx2rtkp/install  
$(INSTALL_DIR) $(1)/usr/bin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/app/rnx2rtkp/gcc/rnx2rtkp $(1)/usr/bin/  
endef  
 
define Package/rtkrcv/install  
$(INSTALL_DIR) $(1)/usr/bin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/app/rtkrcv/gcc/rtkrcv $(1)/usr/bin/  
endef  
 
define Package/str2str/install  
$(INSTALL_DIR) $(1)/usr/bin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/app/str2str/gcc/str2str $(1)/usr/bin/  
endef  
 
$(eval $(call BuildPackage,convbin))  
$(eval $(call BuildPackage,pos2kml))  
$(eval $(call BuildPackage,rnx2rtkp))  
$(eval $(call BuildPackage,rtkrcv))  
$(eval $(call BuildPackage,str2str))  
 
file:a/utils/tcsh/Makefile (deleted)
#  
# Copyright (C) 2011 Nuno Goncalves <nunojpg@gmail.com>  
#  
# This is free software, licensed under the GNU General Public License v2.  
# See /LICENSE for more information.  
 
include $(TOPDIR)/rules.mk  
 
PKG_NAME:=tcsh  
PKG_VERSION:=6.17.00  
PKG_RELEASE:=1  
 
PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz  
PKG_SOURCE_URL:=ftp://ftp.astron.com/pub/tcsh/  
PKG_MD5SUM:=c47de903e3d52f6824c8dd0c91eeb477  
 
PKG_MAINTAINER:=Nuno Goncalves <nunojpg@gmail.com>  
 
include $(INCLUDE_DIR)/package.mk  
 
define Package/tcsh  
SECTION:=utils  
CATEGORY:=Utilities  
TITLE:=Enhanced Berkeley UNIX C shell  
DEPENDS:=+libncurses  
URL:=http://www.tcsh.org/  
endef  
 
define Package/tcsh/description  
Tcsh is an enhanced, but completely compatible  
version of the Berkeley UNIX C shell (csh). It  
is a command language interpreter usable both  
as an interactive login shell and a shell  
script command processor. It includes a  
command-line editor, programmable word  
completion, spelling correction, a history  
mechanism, job control and a C-like syntax.  
endef  
 
define Package/tcsh/postinst  
#!/bin/sh  
grep tcsh $${IPKG_INSTROOT}/etc/shells || \  
echo "/bin/tcsh" >> $${IPKG_INSTROOT}/etc/shells  
echo "/bin/csh" >> $${IPKG_INSTROOT}/etc/shells  
endef  
 
define Package/tcsh/install  
$(INSTALL_DIR) $(1)/bin  
$(INSTALL_BIN) $(PKG_BUILD_DIR)/tcsh $(1)/bin/  
ln -sf tcsh $(1)/bin/csh  
endef  
 
$(eval $(call BuildPackage,tcsh))  
 
--- a/Makefile.in  
+++ b/Makefile.in  
@@ -365,7 +365,7 @@  
 
gethost: gethost.c sh.err.h tc.const.h sh.h  
rm -f gethost  
- ${CC} -o gethost ${LDFLAGS} ${CFLAGS} ${CPPFLAGS} ${DFLAGS} $(srcdir)/gethost.c ${LIBES} ${EXTRALIBS}  
+ gcc -o gethost -g -O2 -I. -I. -D_PATH_TCSHELL='"/usr/local/bin/tcsh"' $(srcdir)/gethost.c ${LIBES} ${EXTRALIBS}  
 
tc.defs.c: gethost host.defs  
@rm -f $@.tmp  
 
--- a/config/linux  
+++ b/config/linux  
@@ -106,6 +106,4 @@  
#endif  
#define ECHO_STYLE BOTH_ECHO  
 
-#define NLS_CATALOGS  
-  
#endif /* _h_config */  
 
comments