wiringpi-ruby 2.0.0 → 2.1.3

data/ext/wiringpi/WiringPi/wiringPi/wpiExtensions.h

@@ -0,0 +1,26 @@
+/*
+ * extensions.h:
+ *	Part of the GPIO program to test, peek, poke and otherwise
+ *	noodle with the GPIO hardware on the Raspberry Pi.
+ *	Copyright (c) 2012-2015 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi 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 Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+
+extern int loadWPiExtension (char *progName, char *extensionData, int verbose) ;

data/ext/wiringpi/WiringPi/wiringPiD/daemonise.c

@@ -0,0 +1,82 @@
+/*
+ * daemonise.c:
+ *	Fairly generic "Turn the current process into a daemon" code.
+ *
+ *	Copyright (c) 2016-2017 Gordon Henderson.
+ *********************************************************************************
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <syslog.h>
+#include <signal.h>
+#include <sys/stat.h>
+
+#include "daemonise.h"
+
+void daemonise (const char *pidFile)
+{
+  pid_t pid ;
+  int i ;
+  FILE *fd ;
+
+  syslog (LOG_DAEMON | LOG_INFO, "Becoming daemon") ;
+
+// Fork from the parent
+
+  if ((pid = fork ()) < 0)
+  {
+    syslog (LOG_DAEMON | LOG_ALERT, "Fork no. 1 failed: %m") ;
+    exit (EXIT_FAILURE) ;
+  }
+
+  if (pid > 0)			// Parent - terminate
+    exit (EXIT_SUCCESS) ;
+
+// Now running on the child - become session leader
+
+  if (setsid() < 0)
+  {
+    syslog (LOG_DAEMON | LOG_ALERT, "setsid failed: %m") ;
+    exit (EXIT_FAILURE) ;
+  }
+
+// Ignore a few signals
+
+  signal (SIGCHLD, SIG_IGN) ;
+  signal (SIGHUP,  SIG_IGN) ;
+
+// Fork again
+
+  if ((pid = fork ()) < 0)
+  {
+    syslog (LOG_DAEMON | LOG_ALERT, "Fork no. 2 failed: %m") ;
+    exit (EXIT_FAILURE) ;
+  }
+
+  if (pid > 0)			// parent - terminate
+    exit (EXIT_SUCCESS) ;
+
+// Tidying up - reset umask, change to / and close all files
+
+  umask (0) ;
+  chdir ("/") ;
+
+  for (i = 0 ; i < sysconf (_SC_OPEN_MAX) ; ++i)
+    close (i) ;
+
+// Write PID into /var/run
+
+  if (pidFile != NULL)
+  {
+    if ((fd = fopen (pidFile, "w")) == NULL)
+    {
+      syslog (LOG_DAEMON | LOG_ALERT, "Unable to write PID file: %m") ;
+      exit (EXIT_FAILURE) ;
+    }
+
+    fprintf (fd, "%d\n", getpid ()) ;
+    fclose (fd) ;
+  }
+}

data/ext/wiringpi/WiringPi/wiringPiD/daemonise.h

@@ -0,0 +1,9 @@
+/*
+ * daemonise.h:
+ *	Fairly generic "Turn the current process into a daemon" code.
+ *
+ *	Copyright (c) 2016-2017 Gordon Henderson.
+ *********************************************************************************
+ */
+
+extern void daemonise (const char *pidFile) ;

data/ext/wiringpi/WiringPi/wiringPiD/drcNetCmd.h

@@ -0,0 +1,43 @@
+/*
+ * drcNetCmd.c:
+ *	Copyright (c) 2012-2017 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi 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 Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#define	DEFAULT_SERVER_PORT	6124
+
+#define	DRCN_PIN_MODE		1
+#define	DRCN_PULL_UP_DN		2
+
+#define	DRCN_DIGITAL_WRITE	3
+#define	DRCN_DIGITAL_WRITE8	4
+#define	DRCN_ANALOG_WRITE	5
+#define	DRCN_PWM_WRITE		6
+
+#define	DRCN_DIGITAL_READ	7
+#define	DRCN_DIGITAL_READ8	8
+#define	DRCN_ANALOG_READ	9
+
+
+struct drcNetComStruct
+{
+  uint32_t pin ;
+  uint32_t cmd ;
+  uint32_t data ;
+};

data/ext/wiringpi/WiringPi/wiringPiD/network.c

@@ -0,0 +1,330 @@
+/*
+ * network.c:
+ *	Part of wiringPiD
+ *	Copyright (c) 2012-2017 Gordon Henderson
+ ***********************************************************************
+ * This file is part of wiringPi:
+ *	https://projects.drogon.net/raspberry-pi/wiringpi/
+ *
+ *    wiringPi is free software: you can redistribute it and/or modify
+ *    it under the terms of the GNU Lesser General Public License as published by
+ *    the Free Software Foundation, either version 3 of the License, or
+ *    (at your option) any later version.
+ *
+ *    wiringPi 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 Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public License
+ *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
+ ***********************************************************************
+ */
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdarg.h>
+#include <malloc.h>
+
+#include <fcntl.h>
+#include <crypt.h>
+
+#include "network.h"
+
+#define	TRUE	(1==1)
+#define	FALSE	(!TRUE)
+
+// Local data
+
+#define	SALT_LEN	16
+
+static char salt [SALT_LEN + 1] ;
+static char *returnedHash = NULL ;
+static int serverFd = -1 ;
+
+// Union for the server Socket Address
+
+static union
+{
+  struct sockaddr_in  sin ;
+  struct sockaddr_in6 sin6 ;
+} serverSockAddr ; 
+
+// and client address
+
+static union
+{
+  struct sockaddr_in  sin ;
+  struct sockaddr_in6 sin6 ;
+} clientSockAddr ;
+
+
+/*
+ * getClientIP:
+ *	Returns a pointer to a static string containing the clients IP address
+ *********************************************************************************
+ */
+
+char *getClientIP (void)
+{
+  char buf [INET6_ADDRSTRLEN] ;
+  static char ipAddress [1024] ;
+
+  if (clientSockAddr.sin.sin_family == AF_INET)	// IPv4
+  {
+    if (snprintf (ipAddress, 1024, "IPv4: %s", 
+	inet_ntop (clientSockAddr.sin.sin_family, (void *)&clientSockAddr.sin.sin_addr, buf, sizeof (buf))) == 1024)
+      strcpy (ipAddress, "Too long") ;
+  }
+  else						// IPv6
+  {
+    if (clientSockAddr.sin.sin_family == AF_INET6 && IN6_IS_ADDR_V4MAPPED (&clientSockAddr.sin6.sin6_addr))
+    {
+      if (snprintf (ipAddress, 1024, "IPv4in6: %s", 
+	inet_ntop (clientSockAddr.sin.sin_family, (char *)&clientSockAddr.sin6.sin6_addr, buf, sizeof(buf))) == 1024)
+      strcpy (ipAddress, "Too long") ;
+    }
+    else
+    {
+      if (snprintf (ipAddress, 1024, "IPv6: %s", 
+	inet_ntop (clientSockAddr.sin.sin_family, (char *)&clientSockAddr.sin6.sin6_addr, buf, sizeof(buf))) == 1024)
+      strcpy (ipAddress, "Too long") ;
+    }
+  }
+
+  return ipAddress ;
+}
+
+
+
+/*
+ * clientPstr: clientPrintf:
+ *	Print over a network socket
+ *********************************************************************************
+ */
+
+static int clientPstr (int fd, char *s)
+{
+  int len = strlen (s) ;
+  return (write (fd, s, len) == len) ? 0 : -1 ;
+}
+
+static int clientPrintf (const int fd, const char *message, ...)
+{
+  va_list argp ;
+  char buffer [1024] ;
+
+  va_start (argp, message) ;
+    vsnprintf (buffer, 1023, message, argp) ;
+  va_end (argp) ;
+
+  return clientPstr (fd, buffer) ;
+}
+
+
+/*
+ * sendGreeting:
+ *	Send some text to the client device
+ *********************************************************************************
+ */
+
+int sendGreeting (int clientFd)
+{
+  if (clientPrintf (clientFd, "200 Welcome to wiringPiD - http://wiringpi.com/\n") < 0)
+    return -1 ;
+
+  return clientPrintf (clientFd, "200 Connecting from: %s\n", getClientIP ()) ;
+}
+
+
+/*
+ * getSalt:
+ *	Create a random 'salt' value for the password encryption process
+ *********************************************************************************
+ */
+
+static int getSalt (char drySalt [])
+{
+  static const char *seaDog =	"abcdefghijklmnopqrstuvwxyz"
+				"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+				"0123456789/." ;
+
+  unsigned char wetSalt [SALT_LEN] ;
+  int i, fd ;
+
+  if ((fd = open ("/dev/urandom", O_RDONLY)) < 0)
+    return fd ;
+
+  if (read (fd, wetSalt, SALT_LEN) != SALT_LEN)
+    return -1 ;
+
+  close (fd) ;
+
+  for (i = 0 ; i < SALT_LEN ; ++i)
+    drySalt [i] = seaDog [wetSalt [i] & 63] ;
+    
+  drySalt [SALT_LEN] = 0 ;
+
+  return 0 ;
+}
+
+
+/*
+ * sendChallenge:
+ *	Create and send our salt (aka nonce) to the remote device
+ *********************************************************************************
+ */
+
+int sendChallenge (int clientFd)
+{
+  if (getSalt (salt) < 0)
+    return -1 ;
+
+  return clientPrintf (clientFd, "Challenge %s\n", salt) ;
+}
+
+
+/*
+ * getResponse:
+ *	Read the encrypted password from the remote device.
+ *********************************************************************************
+ */
+
+
+int getResponse (int clientFd)
+{
+  char reply [1024] ;
+  int len ;
+
+// Being sort of lazy about this. I'm expecting an SHA-512 hash back and these
+//	are exactly 86 characters long, so no reason not to, I guess...
+
+  len = 86 ;
+
+  if (setsockopt (clientFd, SOL_SOCKET, SO_RCVLOWAT, (void *)&len, sizeof (len)) < 0)
+    return -1 ;
+
+  len = recv (clientFd, reply, 86, 0) ;
+  if (len != 86)
+    return -1 ;
+
+  reply [len] = 0 ;
+
+  if ((returnedHash = malloc (len + 1)) == NULL)
+    return -1 ;
+
+  strcpy (returnedHash, reply) ;
+
+  return 0 ;
+}
+
+
+/*
+ * passwordMatch:
+ *	See if there's a match. If not, we simply dump them.
+ *********************************************************************************
+ */
+
+int passwordMatch (const char *password)
+{
+  char *encrypted ;
+  char salted [1024] ;
+
+  sprintf (salted, "$6$%s$", salt) ;
+
+  encrypted = crypt (password, salted) ;
+
+// 20: $6$ then 16 characters of salt, then $
+// 86 is the length of an SHA-512 hash
+
+  return strncmp (encrypted + 20, returnedHash, 86) == 0 ;
+}
+
+
+/* 
+ * setupServer:
+ *	Do what's needed to create a local server socket instance that can listen
+ *	on both IPv4 and IPv6 interfaces.
+ *********************************************************************************
+ */
+
+int setupServer (int serverPort)
+{
+  socklen_t clientSockAddrSize = sizeof (clientSockAddr) ;
+
+  int on = 1 ;
+  int family ;
+  socklen_t serverSockAddrSize ;
+  int clientFd ;
+
+// Try to create an IPv6 socket
+
+  serverFd = socket (PF_INET6, SOCK_STREAM, 0) ;
+
+// If it didn't work, then fall-back to IPv4.
+
+  if (serverFd < 0)
+  {
+    if ((serverFd = socket (PF_INET, SOCK_STREAM, 0)) < 0)
+      return -1 ;
+
+    family             = AF_INET ;
+    serverSockAddrSize = sizeof (struct sockaddr_in) ;
+  }
+  else		// We got an IPv6 socket
+  {
+    family             = AF_INET6 ;
+    serverSockAddrSize = sizeof (struct sockaddr_in6) ;
+  }
+
+  if (setsockopt (serverFd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) < 0)
+    return -1 ;
+
+// Setup the servers socket address - cope with IPv4 and v6.
+
+  memset (&serverSockAddr, 0, sizeof (serverSockAddr)) ;
+  switch (family)
+  {
+    case AF_INET:
+      serverSockAddr.sin.sin_family      = AF_INET ;
+      serverSockAddr.sin.sin_addr.s_addr = htonl (INADDR_ANY) ;
+      serverSockAddr.sin.sin_port        = htons (serverPort) ;
+      break;
+
+    case AF_INET6:
+      serverSockAddr.sin6.sin6_family = AF_INET6 ;
+      serverSockAddr.sin6.sin6_addr   = in6addr_any ;
+      serverSockAddr.sin6.sin6_port   = htons (serverPort) ;
+  }
+
+// Bind, listen and accept
+
+  if (bind (serverFd, (struct sockaddr *)&serverSockAddr, serverSockAddrSize) < 0)
+    return -1 ;
+
+  if (listen (serverFd, 4) < 0)	// Really only going to talk to one client at a time...
+    return -1 ;
+
+  if ((clientFd = accept (serverFd, (struct sockaddr *)&clientSockAddr, &clientSockAddrSize)) < 0)
+    return -1 ;
+
+  return clientFd ;
+}
+
+
+/*
+ * closeServer:
+ *********************************************************************************
+ */
+
+void closeServer (int clientFd)
+{
+  if (serverFd != -1) close (serverFd) ;
+  if (clientFd != -1) close (clientFd) ;
+  serverFd = clientFd = -1 ;
+}