WebSVN – heizung – Diff – /trunk/heizung.c

 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdlib.h>
+#include <libgen.h>
 #include <math.h>
 #include <time.h>
 #include <signal.h>
 #include <syslog.h>
 #include <errno.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <fcntl.h>
 #include <netdb.h>
+#include <dirent.h>
 #include <netinet/in.h>
 #include <sys/param.h>
 #include <sys/ioctl.h>
 #include <pwd.h>
 #include <grp.h>
+{
       HEIZUNG *heizung;
       struct HEIZINDEX *next;
 }HEIZINDEX;
+struct SOCKETS
+{
+      int sockfd;
+      int newfd;
+};
 CONFIGURE configs;
 HEIZINDEX *HeizFirst;
 float ActTemperature;
 float ActPressure;
-static pthread_t pthr_pars, pthr_temp_pars;
+static pthread_t pthr_pars, pthr_temp_pars, pthr_process;
 // Prototypes
 void daemon_start(int ignsigcld);
 void *pthr_temperature(void *pV_data);
 void *pthr_parser(void *pV_data);
 void sig_child(void);
+void sendList(int s1);
+int listSchemas(int s1);
 int parseCommand(int s1, char *cmd);
+void *processCommands(void *pV_data);
 void changeToUser(char *, char *);
 HEIZINDEX *allocateMemory(void);
 HEIZINDEX *insertMemory(HEIZINDEX *pos);
 void freeMemory(void);
 HEIZINDEX *freeChainMember(HEIZINDEX *member);
 void freeDay(int wday);
 void insertMember(int wday, long endt, float temp);
+char *makeFileName(char *ret, char *fname, int len);
 int readHeizPlan(void);
+int readHeizPlanName(char *fname);
 int writeHeizPlan(void);
+int writeHeizPlanName(char *fname);
 void readConf(void);
 char *readLine(int fd, char *buf, int bufLen);
 char *trim(char *str);
 char *remove_string(char *str, char *search, char *ret);
 static pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_mutex_t fastmutex_ser = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t fastmutex_proc = PTHREAD_MUTEX_INITIALIZER;
 /*
  * The main program, initializing everything and start the daemon.
  */
 int main(int argc, char *argv[])
 	      sz.tm_mon = zeit->tm_mon;
 	      sz.tm_mday = zeit->tm_mday;
 	      sz.tm_year = zeit->tm_year;
 	      sz.tm_isdst = zeit->tm_isdst;
 	      tstart = mktime(&sz);
-	      loctm = t - tstart;	// Seconds since midnight
+	      loctm = (t - tstart) + 1;	// Seconds since midnight
 	      act = HeizFirst;
 	      while(act)
+	      {
 		 if (act->heizung->wday == wday && loctm >= act->heizung->start && loctm <= act->heizung->end)
+	}
 	pthread_mutex_unlock(&fastmutex_ser);
+}
+void *processCommands(void *pV_data)
+{
+char ch, buf[128];
+int i, s1, s;
+struct SOCKETS *soc;
+	soc = (struct SOCKETS *)pV_data;
+	s1 = soc->newfd;
+	s = soc->sockfd;
+	memset(&buf[0], 0, sizeof(buf));
+	i = 0;
+	while (read(s1,&ch,1) > 0)
+	{
+	   if (i < (sizeof(buf) - 1))
+	   {
+	      buf[i] = ch;
+	      if (ch == ';' || ch == 0x0d)
+	      {
+	      int pstat;
+		 pthread_mutex_lock (&fastmutex_proc);
+		 if (!strncmp(buf, "quit", 4))
+		    break;
+		 if ((pstat = parseCommand(s1,buf)) == 0)
+		 {
+		 char hv0[128];
+		    sprintf(&hv0[0],"INVALID COMMAND: %s;",buf);
+		    write(s1,hv0,strlen(hv0));
+		 }
+		 else if (pstat == 2)
+		    write(s1, "NAK;", 4);
+		 else
+		    write(s1,"OK;",3);
+		 memset(&buf[0], 0, sizeof(buf));
+		 i = 0;
+		 pthread_mutex_unlock(&fastmutex_proc);
+		 continue;
+	      }
+	   }
+	   i++;
+	}
+	close(s1);
+}
-void *pthr_parser( void *pV_data )
+void *pthr_parser(void *pV_data)
+{
-int i;
-char ch, buf[128], str[INET_ADDRSTRLEN];
+char ch, str[INET_ADDRSTRLEN];
 // socket structure
 struct sockaddr_in client1, server1;
 struct servent *serviceInfo;
-int s1,s;
+int s1, s;
 socklen_t length;
+struct SOCKETS soc;
 	// socket server
 	if (configs.port > 0)
 	   server1.sin_port = htons(configs.port);
 	else if ((serviceInfo = getservbyname ("heizung", "tcp")))
 	length = sizeof(client1);
         syslog (LOG_DEBUG, "Server ready: %d",s);
 	while (1)
+	{
+	   pthread_mutex_lock (&fastmutex);
 	   // Read time table at every loop, to be sure to have the latest
 	   // version (User may change it at every time)
 	   if (!readHeizPlan())
+	   {
 	      if (!HeizFirst)
+	      {
-	         syslog(LOG_DAEMON, "Error reading table %s with plan!", configs.HeizPath);
+		 syslog(LOG_DAEMON, "Error reading table %s with plan!", configs.HeizPath);
-	         exit(EXIT_FAILURE);
+		 exit(EXIT_FAILURE);
+	      }
 	      else
 		 syslog(LOG_DAEMON, "Error reading table with plan! Will work with old one.");
+	   }
+	   pthread_mutex_unlock(&fastmutex);
 	   if ((s1 = accept (s, (struct sockaddr *)&client1, &length)) < 0)
+	   {
 	      syslog (LOG_DAEMON, "Error in accept: %d: %s", s1, strerror(errno));
+	      continue;
+	   }
-	   pthread_mutex_lock (&fastmutex);
 	   inet_ntop(AF_INET, &(client1.sin_addr), str, INET_ADDRSTRLEN);
 	   syslog (LOG_INFO, "Connected to client %s", str);
-	   memset(&buf[0], 0, sizeof(buf));
+	   soc.sockfd = s;
-	   i = 0;
+	   soc.newfd = s1;
-	   while (read(s1,&ch,1) > 0)
+	   if (pthread_create(&pthr_process, NULL, processCommands, (void *)&soc) != 0)
+	   {
+	      syslog (LOG_DAEMON,"Create of thread \"pthr_parser\" failed!");
-	      if (i < (sizeof(buf) - 1))
+	      close(s1);
-	      {
+	   }
-		 buf[i] = ch;
+	}
-		 if (ch == ';' || ch == 0x0d)
-		 {
+	close (s);
-		    if (!strncmp(buf, "quit", 4))
+	serial_close();
-		       break;
+	return NULL;
+}
-		    if (!parseCommand(s1,buf))
+void sendList(int s1)
-		    {
+{
-		    char hv0[128];
+char hv0[256];
+int i, wday = 1;
+HEIZINDEX *act;
-		       sprintf(&hv0[0],"INVALID COMMAND: %s;",buf);
+	// We will write out the week days in the correct order.
-		       write(s1,hv0,strlen(hv0));
+	// So we need 2 loops. The first one is runnung for every week day
+	// and the 2nd one will find every entry for the actual week day.
+	while (wday <= 7)
-		    }
+	{
-		    else
+	   act = HeizFirst;
-		       write(s1,"OK;",3);
+	   i = 1;		// The line counter --> reset it to 1 for every week day
+	   while (act)
+	   {
-		    memset(&buf[0], 0, sizeof(buf));
+	      if (act->heizung->wday == wday)
-		    i = 0;
+	      {
+		 sprintf(&hv0[0], "LINE:%d:%d:%lu:%lu:%.1f;", i, act->heizung->wday,
+			act->heizung->start, act->heizung->end, act->heizung->temp);
-		    continue;
+		 write(s1, &hv0[0], strlen(hv0));
-		 }
+		 i++;
+	      }
-	      i++;
+	      act = act->next;
+	   }
-	   close (s1);
+	   wday++;
-	   pthread_mutex_unlock(&fastmutex);
+	}
+}
+int listSchemas(int s1)
+{
+char hv0[256];
+DIR *dir;
+struct dirent *de;
+char *ldup, *lp;
+	if ((ldup = strdup(configs.HeizPath)) == NULL)
+	{
+	   syslog(LOG_DAEMON, "Not enough memory for path: %s", strerror(errno));
+	   return 2;
+	}
+	lp = dirname(ldup);
+	if ((dir = opendir(lp)) == NULL)
+	{
+	   syslog(LOG_DAEMON, "Could not open directory %s: %s", lp, strerror(errno));
-	serial_close();
+	   free(ldup);
+	   return 2;
+	}
+	strcpy(&hv0[0], "SCHEMA START;");
+	write(s1, hv0, strlen(hv0));
+	while ((de = readdir(dir)) != NULL)
+	{
+	   if (de->d_type == DT_REG && strstr(de->d_name, ".heat") != NULL)
+	   {
+	   char dn[256], *p;
+	      memset(&dn[0], 0, sizeof(dn));
+	      strncpy(dn, de->d_name, sizeof(dn)-1);
+	      if ((p = strrchr(dn, '.')) != NULL)
+		 *p = 0;
+	      else
+		 continue;
+	      sprintf(&hv0[0], "SCHEMA FILE:%s;", dn);
+	      write(s1, hv0, strlen(hv0));
+	   }
+	}
+	closedir(dir);
+	free(ldup);
-	return NULL;
+	return 1;
+}
 int parseCommand(int s1, char *cmd)
+{
 char bef[32],par[1024], *p;
 	memset(par,0,sizeof(par));
 	if ((p = strchr(cmd,':')) != NULL)		// do we have a parameter?
+	{
 	   strncpy(bef,cmd,p - cmd);
-	   strncpy(par,p+1,strlen(p+1));
+	   strncpy(par,p+1,strlen(p)-2);	// Cut off the trailing semi colon
+	}
 	else
 	   strncpy(bef,cmd,strlen(cmd)-1);
 	if (!strcasecmp(bef, "LIST"))		// Write out current list
-	{
-	   int wday = 1;
-	   i = 1;	// The line counter
-	   // We will write out the week days in the correct order.
-	   // So we need 2 loops. The first one is runnung for every week day
-	   // and the 2nd one will find every entry for the actual week day.
-	   while (wday <= 7)
-	   {
-	      act = HeizFirst;
-	      while (act)
+	   sendList(s1);
-	      {
-		 if (act->heizung->wday == wday)
-		 {
-		    sprintf(&hv0[0], "LINE:%d:%d:%lu:%lu:%.1f;", i, act->heizung->wday,
-			act->heizung->start, act->heizung->end, act->heizung->temp);
-		    write(s1, &hv0[0], strlen(hv0));
-		    i++;
-		 }
-		 act = act->next;
-	      }
-	      wday++;
-	   }
-	}
 	if (!strcasecmp(bef, "GET WDAY"))		// Write out a particular week day
+	{
 	int wday = atoi(par);
 		 if ((act = allocateMemory()) == NULL)
+		 {
 		    syslog(LOG_DAEMON,"Error allocating memory for a temperature line.");
 		    sprintf(&hv0[0], "ERROR:Not enough memory!");
 		    write(s1, &hv0[0], strlen(hv0));
-		    return 0;
+		    return 2;
+		 }
 		 act->heizung->wday = wday;
 		 act->heizung->end = endt;
 		 act->heizung->temp = temp;
 	   tmp = atof(par);
 	   insertMember(wday, endt, tmp);
 	   writeHeizPlan();
+	}
+	// SAVE SCHEMA:<name>;
+	if (!strcasecmp(bef, "SAVE SCHEMA"))	// Save the current heating plan into a file
+        {
+	   sprintf(&hv0[0], "%s.heat", par);
+	   if (!writeHeizPlanName(hv0))
+	      return 2;
+	}
+	// LOAD SCHEMA:<name>;
+	if (!strcasecmp(bef, "LOAD SCHEMA"))	// Load a previous saved schema from a file
+	{
+	   sprintf(&hv0[0], "%s.heat", par);
+	   if (!readHeizPlanName(hv0))
+	      return 2;
+	   // write the new schema immediately to the default file
+	   writeHeizPlan();
+	   sendList(s1);
+	}
+	// DELETE SCHEMA:<name>;
+	if (!strcasecmp(bef, "DELETE SCHEMA"))	// Delete an existing schema
+        {
+	   makeFileName(&hv0[0], par, sizeof(hv0));
+	   if (strlen(hv0) < (sizeof(hv0) - 6))
+	      strcat(&hv0[0], ".heat");
+	   else
+	   {
+	      syslog(LOG_DAEMON, "File name too large for internal buffer");
+	      return 2;
+	   }
+	   if (access(hv0, R_OK | W_OK))
+	   {
+	      syslog(LOG_DAEMON,"No access to file %s: %s", hv0, strerror(errno));
+	      return 2;
+	   }
+	   if (unlink(hv0) == -1)
+	   {
+	      syslog(LOG_DAEMON,"Error deleting file %s: %s", hv0, strerror(errno));
+	      return 2;
+	   }
+	   return listSchemas(s1);
+	}
+	// LIST SCHEMA;
+	if (!strcasecmp(bef, "LIST SCHEMA"))	// Return a list of all available schamas
+	   return listSchemas(s1);
 	return 1;
+}
 /*
  * Remove a complete day
+	}
 	close (fd);
+}
+char *makeFileName(char *ret, char *fname, int len)
+{
+char *fdup, *pright, *cfg, *lcfg;
+	if (ret == NULL || fname == NULL || !len || !strlen(fname))
+	   return NULL;
+	if (!access(fname, R_OK | W_OK))
+	{
+	   memset(ret, 0, len);
+	   strncpy(ret, fname, len-1);
+	   return ret;
+	}
+	fdup = strdup(fname);
+	if (fdup == NULL)
+	{
+	   syslog(LOG_DAEMON, "Error allocating memory: %s", strerror(errno));
+	   return NULL;
+	}
+	cfg = strdup(configs.HeizPath);
+	if (cfg == NULL)
+	{
+	   syslog(LOG_DAEMON, "Error allocating memory: %s", strerror(errno));
+	   free(fdup);
+	   return NULL;
+	}
+	pright = basename(fdup);
+	lcfg = dirname(cfg);
+	memset(ret, 0, len);
+	strncpy(ret, lcfg, len-1);
+	if (strlen(ret) < (len - (strlen(pright) + 2)))
+	{
+	   strcat(ret, "/");
+	   strcat(ret, pright);
+	   free(fdup);
+	   free(cfg);
+	   return ret;
+	}
+	free(fdup);
+	free(cfg);
+	return NULL;
+}
 int readHeizPlan(void)
+{
+	return readHeizPlanName(configs.HeizPath);
+}
+int readHeizPlanName(char* fname)
+{
 int fd, i, wday;
 ulong tim;
 char line[512];
 char *p, *xp;
 char hv0[64], hv1[128];
+char path[512];
 float temperature;
 int counter = 0;
 HEIZINDEX *act, *prev;
 	fd = -1;
+	if (makeFileName(&path[0], fname, sizeof(path)) == NULL)
+	{
+	   syslog(LOG_DAEMON,"No or invalid path %s", fname);
+	   return 0;
+	}
-	if (access(configs.HeizPath, R_OK))
+	if (access(path, R_OK))
+	{
-	   syslog(LOG_DAEMON,"Access to file %s denied: %s", configs.HeizPath, strerror(errno));
+	   syslog(LOG_DAEMON,"Access to file %s denied: %s", path, strerror(errno));
 	   return 0;
+	}
-	if ((fd = open(configs.HeizPath, O_RDONLY)) == -1)
+	if ((fd = open(path, O_RDONLY)) == -1)
+	{
-	   syslog(LOG_DAEMON,"Error opening file %s: %s", configs.HeizPath, strerror(errno));
+	   syslog(LOG_DAEMON,"Error opening file %s: %s", path, strerror(errno));
 	   return 0;
+	}
 	act = prev = NULL;
 	freeMemory();
  * write the (may be) altered plan.
  * This function allways writes whole plan.
  */
 int writeHeizPlan()
+{
+	return writeHeizPlanName(configs.HeizPath);
+}
+int writeHeizPlanName(char *fname)
+{
 int fd;
-char hv0[512];
+char hv0[512], path[512];
 HEIZINDEX *act;
 	fd = -1;
-	if (access(configs.HeizPath, R_OK))
+	if (makeFileName(&path[0], fname, sizeof(path)) == NULL)
+	{
+	   syslog(LOG_DAEMON,"No or invalid path %s", fname);
 	   return 0;
+	}
-	if ((fd = open(configs.HeizPath, O_RDWR | O_TRUNC)) == -1)
+	if ((fd = open(path, O_RDWR | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) == -1)
+	{
+	   syslog(LOG_DAEMON, "Error opening/creating file %s: %s", path, strerror(errno));
 	   return 0;
+	}
 	act = HeizFirst;
 	while(act)
+	{

Subversion Repositories heizung

(root)/trunk/heizung.c – Rev 8 → 9