No OneTemporary
Actions

Size

40 KB

Subscribers

None

View Options

	diff --git a/dns320l-daemon.c b/dns320l-daemon.c
	--- a/dns320l-daemon.c
	+++ b/dns320l-daemon.c
	@@ -1,1075 +1,1062 @@
	/*

	Simple system daemon for D-Link DNS-320L

	(c) 2013 Andreas Boehler, andreas _AT_ aboehler.at

	This code is based on a few other people's work and in parts shamelessly copied.
	The ThermalTable was provided by Lorenzo Martignoni and the fan control
	algorithm is based on his fan-daemon.py implementation.

	The MCU protocol was reverse engineered by strace() calls to up_send_daemon and
	up_read_daemon of the original firmware.

	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 3 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, see <http://www.gnu.org/licenses/>.

	*/

	#include <errno.h>
	#include <termios.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <memory.h>
	#include <signal.h>
	#include <poll.h>
	#include <sys/socket.h>
	#include <sys/ioctl.h>
	#include <sys/types.h>
	#include <sys/time.h>
	#include <time.h>
	#include <arpa/inet.h>
	#include <netinet/in.h>
	#include <sys/uio.h>
	#include <syslog.h>
	#include <iniparser.h>

	#include "dns320l.h"
	#include "dns320l-daemon.h"

	int ls;
	int fd;

	DaemonConfig stDaemonConfig;

	/** @file dns320l-daemon.c
	@brief Implementation of a free system daemon replacement for
	the D-Link DNS-320L NAS
	@author Andreas Boehler, andreas _AT_ aboehler.at
	@version 1.0
	@date 2013/09/12
	*/

	-/** <i>Function</i> that reads a GPIO value from sysfs interface.
	- @param gpio The GPIO number to read
	- @param value Pointer where the value is to be put
	- @param gpioDir Pointer containing the sysfs path to the GPIO subdir
	- @return The GPIO's value
	- */
	+
	int gpio_get_value(unsigned int gpio, unsigned int *value)
	{
	int fd, len;
	char buf[100];
	char ch;

	len = snprintf(buf, sizeof(buf), "%s/gpio%d/value", stDaemonConfig.gpioDir, gpio);

	fd = open(buf, O_RDONLY);
	if (fd < 0) {
	syslog(LOG_ERR, "gpio/get-value");
	return fd;
	}

	read(fd, &ch, 1);

	if (ch != '0') {
	*value = 1;
	} else {
	*value = 0;
	}

	close(fd);
	return 0;
	}

	-/** <i>Function</i> that cleans up a socket after shutdown
	- @param shut If 1, the socket is shutdown first
	- @param s The socket to work on
	- @param howmany Number of sockets to close?
	-*/
	void cleanup(int shut,int s,int howmany)
	{
	int retval;

	/*
	* Shutdown and close sock1 completely.
	*/
	if (shut)
	{
	retval = shutdown(s,howmany);
	if (retval == -1)
	syslog(LOG_ERR, "shutdown");
	}
	retval = close (s);
	if (retval)
	syslog(LOG_ERR, "close");
	}

	-/** <i>Function</i> that is called by the OS upon sending a signal
	- to the application
	- @param sig The signal number received
	-*/
	static void sighandler(int sig)
	{
	syslog(LOG_DEBUG, "Signal Handler called\n");
	switch(sig)
	{
	case SIGINT:
	cleanup(0, ls, 1);
	exit(EXIT_SUCCESS);
	break;
	case SIGTERM:
	cleanup(0, ls, 1);
	if(stDaemonConfig.syncOnShutdown)
	HandleCommand("systohc", 7, NULL, 0);
	syslog(LOG_INFO, "Shutting down machine in 10s...\n");
	SendCommand(fd, DeviceShutdownCmd, 0);
	exit(EXIT_SUCCESS);
	break;
	}
	}

	-/** <i>Function</i> that sets interface attributes on a given
	- serial port.
	- @param fd The file descriptor (serial port) to work with
	- @param speed The speed the interface to configure
	- @param parity Use parity or not
	- @return 0 on success, otherwise 1
	-*/
	int set_interface_attribs (int fd, int speed, int parity)
	{
	struct termios tty;
	memset (&tty, 0, sizeof tty);
	if (tcgetattr (fd, &tty) != 0)
	{
	syslog(LOG_ERR, "error %d from tcgetattr", errno);
	return -1;
	}

	cfsetospeed (&tty, speed);
	cfsetispeed (&tty, speed);

	tty.c_cflag = (tty.c_cflag & ~CSIZE) \| CS8; // 8-bit chars
	// disable IGNBRK for mismatched speed tests; otherwise receive break
	// as \000 chars
	tty.c_iflag &= ~IGNBRK; // ignore break signal
	tty.c_lflag = 0; // no signaling chars, no echo,
	// no canonical processing
	tty.c_oflag = 0; // no remapping, no delays
	tty.c_cc[VMIN] = 0; // read doesn't block
	tty.c_cc[VTIME] = 5; // 0.5 seconds read timeout

	tty.c_iflag &= ~(IXON \| IXOFF \| IXANY); // shut off xon/xoff ctrl

	tty.c_cflag \|= (CLOCAL \| CREAD);// ignore modem controls,
	// enable reading
	tty.c_cflag &= ~(PARENB \| PARODD); // shut off parity
	tty.c_cflag \|= parity;
	tty.c_cflag &= ~CSTOPB;
	tty.c_cflag &= ~CRTSCTS;

	if (tcsetattr (fd, TCSANOW, &tty) != 0)
	{
	syslog(LOG_ERR, "error %d from tcsetattr", errno);
	return -1;
	}
	return 0;
	}

	-/** <i>Function</i> that sets an interface to either blocking
	- or non-blocking mode
	- @param fd The file descriptor to work with
	- @param should_block Flag whether it should block or not
	-*/
	void set_blocking (int fd, int should_block)
	{
	struct termios tty;
	memset (&tty, 0, sizeof tty);
	if (tcgetattr (fd, &tty) != 0)
	{
	syslog(LOG_ERR, "error %d from tggetattr", errno);
	return;
	}

	tty.c_cc[VMIN] = should_block ? 1 : 0;
	tty.c_cc[VTIME] = 5; // 0.5 seconds read timeout

	if (tcsetattr (fd, TCSANOW, &tty) != 0)
	syslog(LOG_ERR, "error %d setting term attributes", errno);
	}

	-/** <i>Function</i> that checks the first few bytes of the MCU's response
	- whether it corresponds to the sent command
	- @param buf The buffer to compare
	- @param cmd The command that was sent
	- @param len The lenght of the command
	- @return SUCCESS on success, otherwise ERR_WRONG_ANSWER
	-*/
	int CheckResponse(char buf, char cmd, int len)
	{
	int i;
	int tmp;
	int failure = 0;

	// Attention, 5 is hardcoded here and never checked!
	for(i=0;i<5;i++)
	{
	if(buf[i] != cmd[i])
	{
	syslog(LOG_ERR, "Char %i is %i but should be %i\n", i, buf[i], cmd[i]);
	failure = 1;
	break;
	}
	}
	if(failure)
	{
	for(i=0;i<len;i++)
	{
	syslog(LOG_DEBUG, "Buf/Cmd %i: %i %i\n", i, buf[i], cmd[i]);
	}
	return ERR_WRONG_ANSWER;
	}
	if(buf[len-1] != cmd[len-1])
	return ERR_WRONG_ANSWER;
	return SUCCESS;
	}

	-/** <i>Function</i> that sends a command to the MCU and waits
	- for response and/or ACK.
	- @param fd The serial port to work on
	- @param cmd The command to send
	- @param outArray An array where the response shall be put, can be NULL for no response
	- @return SUCCESS, ERR_WRONG_ANSWER or the number of bytes received
	- */
	+void ClearSerialPort(int fd)
	+{
	+ char buf[100];
	+ struct pollfd fds[1];
	+ fds[0].fd = fd;
	+ fds[0].events = POLLIN;
	+ int n = 0;
	+ int pollrc;
	+ pollrc = poll(fds, 1, 0);
	+ if(pollrc > 0)
	+ {
	+ if(fds[0].revents & POLLIN)
	+ {
	+ syslog(LOG_DEBUG, "Clearing Serial Port...\n");
	+ do
	+ {
	+ n = read(fd, buf, sizeof(buf));
	+ } while(n == sizeof(buf));
	+ }
	+ }
	+}
	+
	int SendCommand(int fd, char cmd, char outArray)
	{
	+ int nRetries = -1;
	+ int ret;
	+ do
	+ {
	+ ret = _SendCommand(fd, cmd, outArray);
	+ nRetries++;
	+ } while((ret != SUCCESS) && (nRetries < stDaemonConfig.nRetries));
	+
	+ return ret;
	+}
	+
	+int _SendCommand(int fd, char cmd, char outArray)
	+{
	int n;
	int i;
	int j;
	ssize_t count;

	char buf[15]; // We need to keep the DateAndTime values here
	// Yes, we're sending byte by byte here - b/c the lenght of
	// commands and responses can vary!

	+ ClearSerialPort(fd); // We clear the serial port in case
	+ // some old data from a previous request is still pending
	+
	i=0;
	do
	{
	count = write(fd, &cmd[i], 1);
	i++;
	- usleep(50); // The MCU seems to need some time..
	+ usleep(100); // The MCU seems to need some time..
	if(count != 1)
	{
	syslog(LOG_ERR, "Error writing byte %i: %i, count: %i\n", (i-1), cmd[i-1], count);
	+ return ERR_WRITE_ERROR;
	}
	} while(cmd[i-1] != CMD_STOP_MAGIC);

	i=0;
	do
	{
	n = read(fd, &buf[i], 1);
	i++;
	} while((n == 1) && (buf[i-1] != CMD_STOP_MAGIC));


	if(buf[i-1] != CMD_STOP_MAGIC)
	{
	syslog(LOG_ERR, "Got no stop magic!\n");
	for(j=0;j<i;j++)
	{
	syslog(LOG_DEBUG, "Buf %i: %i\n", j, buf[j]);
	}
	return ERR_WRONG_ANSWER;
	}
	else
	{
	// If outArray is not NULL, an answer was requested
	if(outArray != NULL)
	{
	- CheckResponse(buf, cmd, i);
	+ if(CheckResponse(buf, cmd, i) != SUCCESS)
	+ {
	+ return ERR_WRONG_ANSWER;
	+ }
	// Copy the answer to the outArray
	for(j=0; j<i; j++)
	{
	outArray[j] = buf[j];
	}
	usleep(20000); // Give the µC some time to answer...

	// Wait for ACK from Serial
	i=0;
	do
	{
	n = read(fd, &buf[i], 1);
	i++;
	} while((n == 1) && (buf[i-1] != CMD_STOP_MAGIC));


	if(buf[i-1] != CMD_STOP_MAGIC)
	{
	syslog(LOG_ERR, "Got no stop magic!\n");
	for(j=0;j<i;j++)
	{
	syslog(LOG_DEBUG, "Buf %i: %i\n", j, buf[j]);
	}

	return ERR_WRONG_ANSWER;
	}

	CheckResponse(buf, AckFromSerial, i);
	syslog(LOG_DEBUG, "Returning %i read bytes\n", n);
	return j;
	}
	// Only wait for ACK if no response is expected
	else
	{
	return CheckResponse(buf, AckFromSerial, i);
	}
	}
	}

	-/** <i>Function</i> that handles commands received by the socket
	- and puts the response back into the retMessage buffer
	- @param message The message that was received (the command)
	- @param messageLen The lenght of the received message
	- @param retMessage Pointer to an output array for the response message
	- @parma bufSize The size of the message buffer
	- @return 0 on success, 1 on failure, 2 for quit and 3 for daemon shutdown
	-*/
	int HandleCommand(char message, int messageLen, char retMessage, int bufSize)
	{
	int tmp;
	int len;
	int i;
	time_t rtcTime;
	time_t sysTime;
	struct timeval setTime;
	char timeStr[100];
	struct tm strTime;
	struct tm *strSetTime;
	char buf[15];
	char cmdBuf[15];

	syslog(LOG_DEBUG, "Handling Command: %s\n", message);

	// This is a very ugly list of if-else and strncmp calls...

	if(strncmp(message, "DeviceReady", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "DeviceReady\n");
	if(SendCommand(fd, DeviceReadyCmd, NULL) == SUCCESS)
	strncpy(retMessage, "OK\n", bufSize);
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "GetTemperature", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "GetTemperature\n");
	if(SendCommand(fd, ThermalStatusGetCmd, buf) > ERR_WRONG_ANSWER)
	{
	tmp = ThermalTable[(int)buf[5]];
	snprintf(retMessage, bufSize, "%d", tmp);
	len = strlen(retMessage);
	if(bufSize > 1)
	{
	retMessage[len] = '\n';
	retMessage[len+1] = '\0';
	}
	}
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	/* else if(strncmp(message, "DeviceShutdown", strlen("DeviceShutdown")) == 0)
	{
	syslog(LOG_DEBUG, "DeviceShutdown");
	if(messageLen >= (strlen("DeviceShutdown") + 2))
	{
	//tmp = atoi(&message[strlen("DeviceShutdown") + 1]); // FIXME: The parameter is never passed, we default to 10s here..
	//printf("%s\n", tmp);
	if(SendCommand(fd, DeviceShutdownCmd, NULL) == SUCCESS)
	strncpy(retMessage, "OK\n", bufSize);
	else
	strncpy(retMessage, "ERR\n", bufSize);
	}
	}*/

	else if(strncmp(message, "quit", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "Quit\n");
	strncpy(retMessage, "Bye\n", bufSize);
	return 2;
	}

	else if(strncmp(message, "EnablePowerRecovery", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "EnablePowerRecovery");
	if(SendCommand(fd, APREnableCmd, NULL) == SUCCESS)
	strncpy(retMessage, "OK\n", bufSize);
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "DisablePowerRecovery", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "DisablePowerRecovery");
	if(SendCommand(fd, APRDisableCmd, NULL) == SUCCESS)
	strncpy(retMessage, "OK\n", bufSize);
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "GetPowerRecoveryState", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "GetPowerRecoveryState");
	if(SendCommand(fd, APRStatusCmd, buf) > ERR_WRONG_ANSWER)
	{
	snprintf(retMessage, bufSize, "%d", buf[5]);
	len = strlen(retMessage);
	if(bufSize > 1)
	{
	retMessage[len] = '\n';
	retMessage[len+1] = '\0';
	}
	}
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "EnableWOL", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "EnableWOL");
	if(SendCommand(fd, WOLStatusEnableCmd, NULL) == SUCCESS)
	strncpy(retMessage, "OK\n", bufSize);
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "DisableWOL", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "DisableWOL");
	if(SendCommand(fd, WOLStatusDisableCmd, NULL) == SUCCESS)
	strncpy(retMessage, "OK\n", bufSize);
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "GetWOLState", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "GetWOLState");
	if(SendCommand(fd, WOLStatusGetCmd, buf) > ERR_WRONG_ANSWER)
	{
	snprintf(retMessage, bufSize, "%d", buf[5]);
	len = strlen(retMessage);
	if(bufSize > 1)
	{
	retMessage[len] = '\n';
	retMessage[len+1] = '\0';
	}
	}
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "PowerLedOn", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "PowerLedOn");
	if(SendCommand(fd, PwrLedOnCmd, NULL) == SUCCESS)
	strncpy(retMessage, "OK\n", bufSize);
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "PowerLedOff", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "PowerLedOff");
	if(SendCommand(fd, PwrLedOffCmd, NULL) == SUCCESS)
	strncpy(retMessage, "OK\n", bufSize);
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "PowerLedBlink", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "PowerLedBlink");
	if(SendCommand(fd, PwrLedBlinkCmd, NULL) == SUCCESS)
	strncpy(retMessage, "OK\n", bufSize);
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "systohc", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "systohc");
	// Copy the command to our buffer
	for(i=0;i<13;i++)
	{
	cmdBuf[i] = WDateAndTimeCmd[i];
	}
	sysTime = time(NULL);
	strSetTime = localtime(&sysTime);
	// Put the current local time into the command buffer
	cmdBuf[5] = (char)strSetTime->tm_sec;
	cmdBuf[6] = (char)strSetTime->tm_min;
	cmdBuf[7] = (char)strSetTime->tm_hour;
	cmdBuf[8] = (char)strSetTime->tm_wday;
	cmdBuf[9] = (char)strSetTime->tm_mday;
	cmdBuf[10] = (char)(strSetTime->tm_mon + 1);
	cmdBuf[11] = (char)(strSetTime->tm_year - 100);
	// And modify the values so that the MCU understands them...
	for(i=5;i<12;i++)
	{
	cmdBuf[i] = ((cmdBuf[i] / 10) << 4) + (cmdBuf[i] % 10);
	}
	if(SendCommand(fd, cmdBuf, NULL) == SUCCESS)
	strncpy(retMessage, "OK\n", bufSize);
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "hctosys", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "hctosys");
	// Retrieve RTC time first
	if(SendCommand(fd, RDateAndTimeCmd, buf) > ERR_WRONG_ANSWER)
	{
	for(i=5;i<12;i++)
	{
	buf[i] = (buf[i] & 0x0f) + 10 * ((buf[i] & 0xf0) >> 4); // The other end is a µC (doh!)
	}

	strTime.tm_year = (100 + (int)buf[11]);
	strTime.tm_mon = buf[10]-1;
	strTime.tm_mday = buf[9];
	strTime.tm_hour = buf[7];
	strTime.tm_min = buf[6];
	strTime.tm_sec = buf[5];
	strTime.tm_isdst = -1;
	rtcTime = mktime(&strTime);
	strcpy(timeStr, ctime(&rtcTime));
	// Retrieve system time
	sysTime = time(NULL);
	setTime.tv_sec = rtcTime;
	setTime.tv_usec = 0;
	// Set the time and print the difference on success
	if(settimeofday(&setTime, NULL) != 0)
	strncpy(retMessage, "ERR\n", bufSize);
	else
	snprintf(retMessage, bufSize, "RTC: %sSys: %sDiff: %.fs\n", timeStr, ctime(&sysTime), difftime(sysTime, rtcTime));
	}
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "ReadRtc", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "ReadRtc");
	if(SendCommand(fd, RDateAndTimeCmd, buf) > ERR_WRONG_ANSWER)
	{
	for(i=5;i<12;i++)
	{
	buf[i] = (buf[i] & 0x0f) + 10 * ((buf[i] & 0xf0) >> 4); // The other end is a µC (doh!)
	}
	strTime.tm_year = (100 + (int)buf[11]);
	strTime.tm_mon = buf[10]-1;
	strTime.tm_mday = buf[9];
	strTime.tm_hour = buf[7];
	strTime.tm_min = buf[6];
	strTime.tm_sec = buf[5];
	strTime.tm_isdst = -1;
	rtcTime = mktime(&strTime);
	strcpy(timeStr, ctime(&rtcTime));
	snprintf(retMessage, bufSize, "RTC: %s", timeStr);
	}
	else
	{
	strncpy(retMessage, "ERR\n", bufSize);
	return 1;
	}
	}

	else if(strncmp(message, "ShutdownDaemon", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "ShutdownDaemon");
	strncpy(retMessage, "OK\n", bufSize);
	return 3;
	}

	else if(strncmp(message, "help", messageLen) == 0)
	{
	syslog(LOG_DEBUG, "help");
	strncpy(retMessage, "Available Commands: DeviceReady, GetTemperature, "// DeviceShutdown, "
	"EnablePowerRecovery, DisablePowerRecovery, GetPowerRecoveryState, "
	"EnableWOL, DisableWOL, GetWOLState, PowerLedOn, "
	"PowerLedOff, PowerLedBlink, systohc, hctosys, ReadRtc, ShutdownDaemon, quit\n", bufSize);
	}
	else
	{
	strncpy(retMessage, "Command not Understood!\n", bufSize);
	}

	return 0;
	}

	-/** <i>Main Function</i>
	- @param argc The argument count
	- @param argv The argument vector
	- @return EXIT_SUCCESS on success, otherwise EXIT_ERROR
	-*/
	int main(int argc, char *argv[])
	{
	char response[500];
	int i;
	pid_t pid;
	pid_t sid;
	int powerBtn;
	int pressed;
	int opt;
	int sleepCount;
	int pollTimeMs;
	int readRtcOnStartup = 0;
	char buf[100];
	char *configPath = "/etc/dns320l-daemon.ini";
	char msgBuf[15];
	int temperature;
	int fanSpeed;
	struct sockaddr_in s_name;
	struct pollfd *fds = NULL;
	nfds_t nfds;
	int retval;
	int ret;
	int msgIdx;
	char message[500];
	dictionary *iniFile;
	socklen_t namelength;
	pressed = 0;
	nfds = 1;
	opt = 1;
	sleepCount = 0;
	pollTimeMs = 10; // Sleep 10ms for every loop
	fanSpeed = -1;

	stDaemonConfig.goDaemon = 1;
	stDaemonConfig.debug = 0;

	// Parse command line arguments
	while((i = getopt(argc, argv, "fc:d")) != -1)
	{
	switch(i)
	{
	case 'f':
	stDaemonConfig.goDaemon = 0;
	break;
	case 'd':
	stDaemonConfig.debug = 1;
	stDaemonConfig.goDaemon = 0;
	break;
	case 'c':
	configPath = optarg;
	break;
	case '?':
	if(optopt == 'c')
	fprintf(stderr, "Option -%c requires an argument.\n", optopt);
	else if (isprint (optopt))
	fprintf (stderr, "Unknown option `-%c'.\n", optopt);
	else
	fprintf (stderr,
	"Unknown option character `\\x%x'.\n",
	optopt);
	fprintf(stderr, "Usage: %s [-f] [-c configPath] [-d]\n", argv[0]);
	fprintf(stderr, " where\n");
	fprintf(stderr, " -f don't detach\n");
	fprintf(stderr, " -c configPath path to .ini\n");
	fprintf(stderr, " -d debug (implies -f)\n");
	return EXIT_FAILURE;
	}

	}

	// Register some signal handlers
	signal(SIGTERM, sighandler);
	signal(SIGINT, sighandler);

	// Load our configuration file or use default values
	// if it doesn't exist!
	iniFile = iniparser_load(configPath);
	stDaemonConfig.portName = iniparser_getstring(iniFile, "Serial:Port", "/dev/ttyS1");
	stDaemonConfig.syncOnStartup = iniparser_getint(iniFile, "Daemon:SyncTimeOnStartup", 0);
	stDaemonConfig.fanPollTime = iniparser_getint(iniFile, "Fan:PollTime", 15);
	stDaemonConfig.tempLow = iniparser_getint(iniFile, "Fan:TempLow", 45);
	stDaemonConfig.tempHigh = iniparser_getint(iniFile, "Fan:TempHigh", 50);
	stDaemonConfig.hysteresis = iniparser_getint(iniFile, "Fan:Hysteresis", 2);
	stDaemonConfig.gpioPollTime = iniparser_getint(iniFile, "GPIO:PollTime", 1);
	stDaemonConfig.gpioDir = iniparser_getstring(iniFile, "GPIO:SysfsGpioDir", "/sys/class/gpio");
	stDaemonConfig.serverPort = iniparser_getint(iniFile, "Daemon:ServerPort", 57367);
	stDaemonConfig.pollGpio = iniparser_getint(iniFile, "Daemon:PollGPIO", 1);
	stDaemonConfig.syncOnShutdown = iniparser_getint(iniFile, "Daemon:SyncTimeOnShutdown", 0);
	+ stDaemonConfig.nRetries = iniparser_getint(iniFile, "Serial:NumberOfRetries", 5);

	// Setup syslog
	if(stDaemonConfig.debug)
	setlogmask(LOG_UPTO(LOG_DEBUG));
	else
	setlogmask(LOG_UPTO(LOG_INFO));

	if(stDaemonConfig.goDaemon)
	openlog("dns320l-daemon", LOG_CONS \| LOG_PID \| LOG_NDELAY, LOG_LOCAL1);
	else
	openlog("dns320l-daemon", LOG_CONS \| LOG_PID \| LOG_NDELAY \| LOG_PERROR, LOG_LOCAL1);

	if(stDaemonConfig.goDaemon)
	{
	pid = fork();
	if(pid < 0)
	{
	syslog(LOG_ERR, "Forking failed.\n");
	return EXIT_FAILURE;
	}

	if(pid > 0)
	{
	return EXIT_SUCCESS;
	}
	// From here on we are the child process...
	umask(0);
	sid = setsid();
	if(sid < 0)
	{
	syslog(LOG_ERR, "Could not create process group\n");
	return EXIT_FAILURE;
	}

	if((chdir("/")) < 0)
	{
	syslog(LOG_ERR, "Could not chdir(\"/\")\n");
	return EXIT_FAILURE;
	}
	close(STDIN_FILENO);
	close(STDOUT_FILENO);
	close(STDERR_FILENO);

	}




	// Open our socket server
	if ((ls = socket (AF_INET, SOCK_STREAM, 0)) == -1){
	syslog(LOG_ERR, "socket");
	exit(EXIT_FAILURE);
	}

	if (setsockopt(ls,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof opt)<0){
	syslog(LOG_ERR, "setsockopt (SO_RESUSEADDR): %s\r\n",strerror(errno));
	exit(EXIT_FAILURE);
	}


	s_name.sin_family = AF_INET;
	s_name.sin_port = htons(stDaemonConfig.serverPort);
	s_name.sin_addr.s_addr = htonl(INADDR_ANY);

	syslog(LOG_DEBUG, "Bind name to ls. \n");
	retval = bind (ls,(struct sockaddr *)&s_name, sizeof s_name);
	if (retval)
	{
	syslog(LOG_ERR, "bind");
	cleanup(0, ls,1);
	exit(EXIT_FAILURE);
	}

	syslog(LOG_DEBUG, "Listen on ls for connections. \n");
	retval = listen (ls, 5);
	if (retval)
	{
	syslog(LOG_ERR, "listen");
	cleanup(0, ls,1);
	exit(EXIT_FAILURE);
	}
	syslog(LOG_INFO, "Server startup success on port %i\n", stDaemonConfig.serverPort);

	fds = (struct pollfd )calloc(1,nfdssizeof(struct pollfd));
	fds->fd = ls;
	fds->events = POLLIN \| POLLPRI;

	fd = open (stDaemonConfig.portName, O_RDWR \| O_NOCTTY \| O_SYNC);
	if (fd < 0)
	{
	syslog(LOG_ERR, "error %d opening %s: %s", errno, stDaemonConfig.portName, strerror (errno));
	return;
	}

	set_interface_attribs (fd, B115200, 0); // set speed to 115,200 bps, 8n1 (no parity)
	set_blocking (fd, 0); // set no blocking

	- // Flush the serial port first...
	-
	- read(fd, buf, 100);

	// Send the DeviceReady command to the MCU
	if(SendCommand(fd, DeviceReadyCmd, NULL) == SUCCESS)
	syslog(LOG_INFO, "dns320l-daemon startup complete, going to FanControl mode");
	else
	{
	syslog(LOG_ERR, "Error sending DeviceReady command, exit!\n");
	return EXIT_FAILURE;
	}

	if(stDaemonConfig.syncOnStartup)
	{
	syslog(LOG_INFO, "Setting system clock from RTC...\n");
	if(HandleCommand("hctosys", 7, NULL, 0) != 0)
	syslog(LOG_ERR, "Error setting system time from RTC!\n");
	}

	// Go to endless loop and do the following:
	// Get the thermal status
	// Check temperature and adjust fan speeds
	// Wake every 1s to poll the power button GPIO
	// Wake every few ms to poll the sockets for connections
	// Sleep

	while(1)
	{
	sleepCount = 0;
	if(SendCommand(fd, ThermalStatusGetCmd, msgBuf) > ERR_WRONG_ANSWER)
	temperature = msgBuf[5];
	else
	temperature = 0;
	if(temperature > 0)
	{
	temperature = ThermalTable[temperature];
	syslog(LOG_DEBUG, "Read Temperature: %i\n", temperature);
	if(temperature < (stDaemonConfig.tempLow - stDaemonConfig.hysteresis))
	{
	if(fanSpeed != 0)
	{
	syslog(LOG_DEBUG, "Set Fan Stop\n");
	SendCommand(fd, FanStopCmd, NULL);
	fanSpeed = 0;
	}
	}
	else if(temperature < stDaemonConfig.tempLow)
	{
	if(fanSpeed > 1)
	{
	syslog(LOG_DEBUG, "Set Fan Half\n");
	SendCommand(fd, FanHalfCmd, NULL);
	fanSpeed = 1;
	}
	}
	else if(temperature < (stDaemonConfig.tempHigh - stDaemonConfig.hysteresis))
	{
	if(fanSpeed != 1)
	{
	syslog(LOG_DEBUG, "Set Fan Half\n");
	SendCommand(fd, FanHalfCmd, NULL);
	fanSpeed = 1;
	}
	}
	else if(temperature < stDaemonConfig.tempHigh)
	{
	if(fanSpeed < 1)
	{
	syslog(LOG_DEBUG, "Set Fan Half\n");
	SendCommand(fd, FanHalfCmd, NULL);
	fanSpeed = 1;
	}
	}
	else
	{
	if(fanSpeed != 2)
	{
	syslog(LOG_DEBUG, "Set Fan Full\n");
	SendCommand(fd, FanFullCmd, NULL);
	fanSpeed = 2;
	}
	}
	}
	else
	{
	syslog(LOG_ERR, "Error reading Temperature!\n");
	}


	while((sleepCount * pollTimeMs) < (stDaemonConfig.fanPollTime * 1000))
	{
	if(stDaemonConfig.pollGpio && (((sleepCount * pollTimeMs) % (stDaemonConfig.gpioPollTime* 1000)) == 0))
	{
	if(gpio_get_value(GPIO_BUTTON_POWER, &powerBtn) == 0)
	{
	if((powerBtn == 0) && !pressed)
	{
	pressed = 1;
	syslog(LOG_INFO, "Power Button Pressed, shutting down system!\n");
	SendCommand(fd, DeviceShutdownCmd, NULL);
	execl("/sbin/shutdown", "shutdown", "-h", "now", (char *)0);
	}
	}

	}
	sleepCount++;

	ret=poll(fds,nfds,pollTimeMs); // Time out after pollTimeMs
	if (ret == -1){
	syslog(LOG_ERR, "poll");
	exit(EXIT_FAILURE);
	}
	for (i=0;(i<nfds) && (ret);i++)
	{
	if (!(fds+i)->revents)
	continue;
	ret--;
	if (((fds+i)->fd == ls) && ((fds+i)->revents & POLLIN))
	{
	/*
	* Accept connection from socket ls:
	* accepted connection will be on socket (fds+nfds)->fd.
	*/
	syslog(LOG_DEBUG, "POLLIN on ls. Accepting connection\n");
	namelength = sizeof (s_name);
	fds = (struct pollfd )realloc(fds,(nfds+1)sizeof(struct pollfd));
	(fds+nfds)->fd = accept (ls, (struct sockaddr *)&s_name, &namelength);
	if ((fds+nfds)->fd == -1)
	{
	syslog(LOG_ERR, "accept");
	cleanup(0, (fds+nfds)->fd, 1);
	fds = (struct pollfd )realloc(fds,nfdssizeof(struct pollfd));
	continue;
	}
	(fds+nfds)->events = POLLIN \| POLLRDNORM;
	nfds++;
	continue;
	}
	if ((fds+i)->revents & POLLNVAL)
	{
	syslog(LOG_DEBUG, "POLLNVAL on socket. Freeing resource\n");
	nfds--;
	memcpy(fds+i,fds+i+1,nfds-i);
	fds = (struct pollfd )realloc(fds,nfdssizeof(struct pollfd));
	continue;
	}
	if ((fds+i)->revents & POLLHUP)
	{
	syslog(LOG_DEBUG, "POLLHUP => peer reset connection ...\n");
	cleanup(0,(fds+i)->fd,2);
	nfds--;
	memcpy(fds+i,fds+i+1,nfds-i);
	fds = (struct pollfd )realloc(fds,nfdssizeof(struct pollfd));
	continue;
	}
	if ((fds+i)->revents & POLLERR){
	syslog(LOG_DEBUG, "POLLERR => peer reset connection ...\n");
	cleanup(0,(fds+i)->fd,2);
	nfds--;
	memcpy(fds+i,fds+i+1,nfds-i);
	fds = (struct pollfd )realloc(fds,nfdssizeof(struct pollfd));
	continue;
	}
	if ((fds+i)->revents & POLLRDNORM)
	{
	retval = recv((fds+i)->fd, message, sizeof(message)-1, 0); // Don't forget the string terminator here!
	syslog(LOG_DEBUG, "-> (recv) retval = %d.\n",retval); /* ped */
	msgIdx = retval;
	if (retval <=0)
	{
	if (retval == 0)
	{
	syslog(LOG_DEBUG, "recv()==0 => peer disconnected...\n");
	cleanup(1,(fds+i)->fd,2);
	}
	else
	{
	syslog(LOG_ERR, "receive");
	cleanup( 0, (fds+i)->fd,1);
	}
	nfds--;
	memcpy(fds+i,fds+i+1,nfds-i);
	fds = (struct pollfd )realloc(fds,nfdssizeof(struct pollfd));
	continue;
	}
	while((retval > 0) && (message[msgIdx-2] != '\r') && ((msgIdx+1) < sizeof(message)))
	{
	retval = recv((fds+i)->fd, &message[msgIdx-2], sizeof(message) - retval - 1, 0);
	syslog(LOG_DEBUG, " \t -> (recv) retval = %d.\n", retval);
	if(retval > 0)
	msgIdx += retval - 2;
	}
	if(msgIdx > 1)
	if(message[msgIdx-1] == '\n')
	if(message[msgIdx-2] == '\r')
	message[msgIdx-2] = '\0';
	else
	message[msgIdx-1] = '\0';

	syslog(LOG_DEBUG, "Normal message : %.*s\n",retval,message);
	msgIdx = HandleCommand(message, msgIdx, response, sizeof(response));
	retval = send((fds+i)->fd, response, strlen(response), 0);
	if((retval < 0) \|\| (msgIdx > 1))
	{
	syslog(LOG_DEBUG, "send()==0 => peer disconnected...\n");
	cleanup(1,(fds+1)->fd, 2);
	}
	if(msgIdx == 3)
	{
	syslog(LOG_INFO, "Shutting down dns320l-daemon...\n");
	return EXIT_SUCCESS;
	}
	continue;
	}
	}
	}
	}
	closelog();
	iniparser_freedict(iniFile);
	return EXIT_SUCCESS;
	}
	diff --git a/dns320l-daemon.h b/dns320l-daemon.h
	--- a/dns320l-daemon.h
	+++ b/dns320l-daemon.h
	@@ -1,29 +1,112 @@
	#ifndef DNS320L_DAEMON_H
	#define DNS320L_DAEMON_H


	typedef struct
	{
	int syncOnStartup;
	int syncOnShutdown;
	int fanPollTime;
	int pollGpio;
	int gpioPollTime;
	int serverPort;
	int goDaemon;
	int debug;
	char *gpioDir;
	char *portName;
	int tempLow;
	int tempHigh;
	int hysteresis;
	+ int nRetries;

	} DaemonConfig;

	+/** <i>Function</i> that reads a GPIO value from sysfs interface.
	+ @param gpio The GPIO number to read
	+ @param value Pointer where the value is to be put
	+ @param gpioDir Pointer containing the sysfs path to the GPIO subdir
	+ @return The GPIO's value
	+ */
	+int gpio_get_value(unsigned int gpio, unsigned int *value);

	+/** <i>Function</i> that cleans up a socket after shutdown
	+ @param shut If 1, the socket is shutdown first
	+ @param s The socket to work on
	+ @param howmany Number of sockets to close?
	+*/
	+void cleanup(int shut,int s,int howmany);
	+
	+/** <i>Function</i> that is called by the OS upon sending a signal
	+ to the application
	+ @param sig The signal number received
	+*/
	+static void sighandler(int sig);
	+
	+/** <i>Function</i> that sets interface attributes on a given
	+ serial port.
	+ @param fd The file descriptor (serial port) to work with
	+ @param speed The speed the interface to configure
	+ @param parity Use parity or not
	+ @return 0 on success, otherwise 1
	+*/
	+int set_interface_attribs (int fd, int speed, int parity);
	+
	+/** <i>Function</i> that sets an interface to either blocking
	+ or non-blocking mode
	+ @param fd The file descriptor to work with
	+ @param should_block Flag whether it should block or not
	+*/
	+void set_blocking (int fd, int should_block);

	+/** <i>Function</i> that checks the first few bytes of the MCU's response
	+ whether it corresponds to the sent command
	+ @param buf The buffer to compare
	+ @param cmd The command that was sent
	+ @param len The lenght of the command
	+ @return SUCCESS on success, otherwise ERR_WRONG_ANSWER
	+*/
	+int CheckResponse(char buf, char cmd, int len);

	+/** <i>Function</i> that clears the current Serial Port buffer
	+ by reading some bytes
	+ @param fd The serial port to work on
	+ */
	+void ClearSerialPort(int fd);
	+
	+/** <i>Function</i> that wraps around the internal send command and handles retry
	+ @param fd The serial port to work on
	+ @param cmd The command to send
	+ @param outArray An array where the response shall be put, can be NULL for no response
	+ @return SUCCESS, ERR_WRONG_ANSWER or the number of bytes received
	+ */
	+int SendCommand(int fd, char cmd, char outArray);
	+
	+/** <i>Function</i> that sends a command to the MCU and waits
	+ for response and/or ACK.
	+ @param fd The serial port to work on
	+ @param cmd The command to send
	+ @param outArray An array where the response shall be put, can be NULL for no response
	+ @return SUCCESS, ERR_WRONG_ANSWER or the number of bytes received
	+ */
	+int _SendCommand(int fd, char cmd, char outArray);
	+
	+/** <i>Function</i> that handles commands received by the socket
	+ and puts the response back into the retMessage buffer
	+ @param message The message that was received (the command)
	+ @param messageLen The lenght of the received message
	+ @param retMessage Pointer to an output array for the response message
	+ @parma bufSize The size of the message buffer
	+ @return 0 on success, 1 on failure, 2 for quit and 3 for daemon shutdown
	+*/
	+int HandleCommand(char message, int messageLen, char retMessage, int bufSize);
	+
	+/** <i>Main Function</i>
	+ @param argc The argument count
	+ @param argv The argument vector
	+ @return EXIT_SUCCESS on success, otherwise EXIT_ERROR
	+*/
	+int main(int argc, char *argv[]);



	#endif //DNS320L_DAEMON_H
	diff --git a/dns320l-daemon.ini b/dns320l-daemon.ini
	--- a/dns320l-daemon.ini
	+++ b/dns320l-daemon.ini
	@@ -1,17 +1,18 @@
	[Serial]
	Port = /dev/ttyS1
	+NumberOfRetries = 3

	[Daemon]
	ServerPort = 57367
	SyncTimeOnStartup = 0
	SyncTimeOnShutdown = 0

	[GPIO]
	SysfsGpioDir = /sys/class/gpio
	PollTime = 1

	[Fan]
	PollTime = 15
	TempLow = 45
	TempHigh = 50
	Hysteresis = 2
	diff --git a/dns320l.h b/dns320l.h
	--- a/dns320l.h
	+++ b/dns320l.h
	@@ -1,84 +1,85 @@
	#ifndef DNS320L_H
	#define DNS320L_H
	/*

	Simple system daemon for D-Link DNS-320L

	(c) 2013 Andreas Boehler, andreas _AT_ aboehler.at

	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 3 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, see <http://www.gnu.org/licenses/>.

	*/

	#define ERR_WRONG_ANSWER -1
	+#define ERR_WRITE_ERROR -2
	#define SUCCESS 1

	#define CMD_START_MAGIC 0xfa
	#define CMD_STOP_MAGIC 0xfb
	#define GPIO_BUTTON_POWER 29

	char DeviceReadyCmd[] = {0xfa, 0x03, 0x01, 0x00, 0x00, 0x00, 0xfb};
	char AckFromSerial[] = {0xfa, 0x30, 0x00, 0x00, 0x00, 0x00, 0xfb};
	char ThermalStatusGetCmd[] = {0xfa, 0x03, 0x08, 0x00, 0x00, 0x00, 0xfb};
	char FanStopCmd[] = {0xfa, 0x02, 0x00, 0x00, 0x00, 0x00, 0xfb};
	char FanHalfCmd[] = {0xfa, 0x02, 0x00, 0x01, 0x00, 0x00, 0xfb};
	char FanFullCmd[] = {0xfa, 0x02, 0x00, 0x02, 0x00, 0x00, 0xfb};
	char DeviceShutdownCmd[] = {0xfa, 0x03, 0x03, 0x01, 0x01, 0x0a, 0xfb};
	char APREnableCmd[] = {0xfa, 0x03, 0x02, 0x01, 0x00, 0x00, 0xfb};
	char APRDisableCmd[] = {0xfa, 0x03, 0x02, 0x00, 0x00, 0x00, 0xfb};
	char APRStatusCmd[] = {0xfa, 0x03, 0x02, 0x02, 0x00, 0x00, 0xfb};
	char PwrLedOnCmd[] = {0xfa, 0x03, 0x06, 0x01, 0x00, 0x01, 0xfb};
	char PwrLedOffCmd[] = {0xfa, 0x03, 0x06, 0x00, 0x00, 0x01, 0xfb};
	char PwrLedBlinkCmd[] = {0xfa, 0x03, 0x06, 0x02, 0x00, 0x01, 0xfb};
	char WOLStatusEnableCmd[] = {0xfa, 0x03, 0x0a, 0x01, 0x00, 0x00, 0xfb};
	char WOLStatusDisableCmd[] = {0xfa, 0x03, 0x0a, 0x00, 0x00, 0x00, 0xfb};
	char WOLStatusGetCmd[] = {0xfa, 0x03, 0x0a, 0x02, 0x00, 0x00, 0xfb};
	char RDateAndTimeCmd[] = {0xfa, 0x01, 0x08, 0x01, 0x01, 0x00, 0xfb};
	char WAlarmEnableCmd[] = {0xfa, 0x01, 0x10, 0x02, 0x01, 0x01, 0xfb};
	char WAlarmDisableCmd[] = {0xfa, 0x01, 0x10, 0x02, 0x01, 0x00, 0xfb};
	char RAlarmMonthCmd[] = {0xfa, 0x01, 0x0a, 0x01, 0x01, 0x00, 0xfb};
	char RAlarmDateCmd[] = {0xfa, 0x01, 0x0b, 0x01, 0x01, 0x00, 0xfb};
	char RAlarmHourCmd[] = {0xfa, 0x01, 0x0c, 0x01, 0x01, 0x00, 0xfb};
	char RAlarmSecondCmd[] = {0xfa, 0x01, 0x0e, 0x01, 0x01, 0x00, 0xfb};
	char RAlarmMinuteCmd[] = {0xfa, 0x01, 0x0d, 0x01, 0x01, 0x00, 0xfb};
	char RAlarmFlagCmd[] = {0xfa, 0x01, 0x0f, 0x01, 0x01, 0x00, 0xfb};
	char WAlarmMonthCmd[] = {0xfa, 0x01, 0x0a, 0x02, 0x01, 0x00, 0xfb};
	char WAlarmDateCmd[] = {0xfa, 0x01, 0x0b, 0x02, 0x01, 0x00, 0xfb};
	char WAlarmHourCmd[] = {0xfa, 0x01, 0x0c, 0x02, 0x01, 0x00, 0xfb};
	char WAlarmMinuteCmd[] = {0xfa, 0x01, 0x0d, 0x02, 0x01, 0x00, 0xfb};
	char WAlarmSecondCmd[] = {0xfa, 0x01, 0x0e, 0x02, 0x01, 0x00, 0xfb};
	char WDateAndTimeCmd[] = {0xfa, 0x01, 0x08, 0x02, 0x07, 0x17, 0x06, 0x21, 0x02, 0x10, 0x09, 0x13, 0xfb};

	const char ThermalTable[] = {0x74, 0x73, 0x72, 0x71, 0x70, 0x6F, 0x6E, 0x6D, 0x6C, 0x6B,
	0x6A, 0x69, 0x68, 0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61,
	0x60, 0x5F, 0x5E, 0x5D, 0x5C, 0x5B, 0x5A, 0x59, 0x58, 0x57,
	0x56, 0x55, 0x54, 0x53, 0x52, 0x51, 0x50, 0x4F, 0x4E, 0x4D,
	0x4C, 0x4B, 0x4A, 0x49, 0x48, 0x47, 0x46, 0x45, 0x44, 0x43,
	0x42, 0x41, 0x41, 0x40, 0x3F, 0x3E, 0x3E, 0x3D, 0x3D, 0x3C,
	0x3B, 0x3A, 0x3A, 0x39, 0x38, 0x38, 0x37, 0x36, 0x36, 0x35,
	0x34, 0x34, 0x33, 0x33, 0x32, 0x31, 0x31, 0x30, 0x30, 0x2F,
	0x2F, 0x2E, 0x2E, 0x2D, 0x2C, 0x2C, 0x2B, 0x2B, 0x2A, 0x2A,
	0x29, 0x29, 0x28, 0x28, 0x27, 0x27, 0x27, 0x26, 0x26, 0x25,
	0x25, 0x24, 0x24, 0x23, 0x23, 0x22, 0x22, 0x21, 0x21, 0x21,
	0x20, 0x20, 0x1F, 0x1F, 0x1E, 0x1E, 0x1E, 0x1D, 0x1D, 0x1C,
	0x1C, 0x1B, 0x1B, 0x1B, 0x1B, 0x1A, 0x19, 0x19, 0x19, 0x18,
	0x18, 0x17, 0x17, 0x25, 0x1B, 0x1B, 0x19, 0x19, 0x19, 0x18,
	0x18, 0x17, 0x17, 0x16, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14,
	0x14, 0x13, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x10, 0x10,
	0x10, 0xF, 0xF, 0xE, 0xE, 0xE, 0xD, 0xD, 0xC, 0xC, 0xC, 0xB,
	0xB, 0xA, 0xA, 9, 9, 9, 8, 8, 7, 7, 7, 6, 6, 5, 5, 4, 4, 4, 3,
	3, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0};


	#endif //DNS320L_H

File Metadata

Mime Type: text/x-diff
Expires: Fri, Jan 24, 3:09 AM (1 d, 13 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 532416
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions