root/branches/renetcolSMP/src/renetcolSender.c @ 166

Revision 165, 17.8 KB (checked in by andreu, 10 years ago)

filters readed by all renetcolSMP process

  • Property svn:eol-style set to native
Line 
1/*
2 * File: renetcolSender.c
3 *
4 * Authors: ANDREU Francois-Xavier
5 *
6 * Copyright (C) 2005-2011 GIP RENATER
7 */
8
9/*  This file is part of renetcol.
10 *
11 *  renetcol is free software; you can redistribute it and/or modify
12 *  it under the terms of the GNU General Public License as published by
13 *  the Free Software Foundation; either version 2 of the License, or
14 *  (at your option) any later version.
15 *
16 *  renetcol is distributed in the hope that it will be useful,
17 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 *  GNU General Public License for more details.
20 *
21 *  You should have received a copy of the GNU General Public License
22 *  along with renetcol; if not, write to the Free Software
23 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
24 */
25
26#include "renetcolSender.h"
27
28key_t myKeySMP1 = 0;
29int myQueueSMP1 = 0;
30key_t myKeySMP2 = 0;
31int myQueueSMP2 = 0;
32key_t myKeySMP3 = 0;
33int myQueueSMP3 = 0;
34key_t myKeySMP4 = 0;
35int myQueueSMP4 = 0;
36
37msgType myMsgSMP1;
38msgType myMsgSMP2;
39msgType myMsgSMP3;
40msgType myMsgSMP4;
41long type;
42RulesPtr rulesListPtr;
43char *keyIdSMP1;
44char *keyIdSMP2;
45char *keyIdSMP3;
46char *keyIdSMP4;
47char *remoteHost;
48int i=0;
49int j=0;
50unsigned char *myTextSMP1;
51unsigned char *myTextSMP2;
52unsigned char *myTextSMP3;
53unsigned char *myTextSMP4;
54unsigned char buffer2[2];
55unsigned char buffer4[4];
56unsigned short nb=0;
57unsigned short typeMsg = 0;
58RulesPtr tmp = NULL;
59
60/*
61 *   subsstr
62 *
63 *   substitute '_' char in a string with ' '
64 */
65char *subsstr(char *chin)
66{
67    int i;
68    for (i = 0; i < strlen(chin); i++) {
69        if (chin[i] == '_') {
70            chin[i] = ' ';
71        }
72    }
73    return chin;
74}
75
76/*
77 * todo
78 */
79int
80todo(int sock, char *host)
81{
82  char buffer[256];
83  int length;
84  FILE *ruleFile;
85  FILE *tmpFile;
86  char port[6];
87/*  char value[44]; */
88  char filters[249];
89/*  char operator[2]; */
90  char lines[1024][256]; /* FIXME : here perhaps use a constante like MAX_FILTERS *3 */
91  char line[256];
92  char lineCopy[256];
93  char strTok[1];
94  char strName[100];
95  int cpt = 0;
96  int i = 0;
97  int ruleToDelete = 0;
98  static char * fields;
99
100  while (1){
101    length = read(sock, buffer, 256);
102    if (length < 0){
103      syslog(LOG_ERR, " read : %s", strerror(errno));
104      close(sock);
105      return 1;
106    }
107    if (length == 0)
108      break;
109    buffer[length] = '\0';
110    if (strncmp("DELETE", buffer, 6)==0){
111      /* DELETE ALL RULES FROM A REMOTE CLIENT */
112      if (!(ruleFile = fopen(RULES_FILE, "r"))) {
113        syslog (LOG_ERR, "error during %s opening\n", RULES_FILE);
114        close(sock);
115        exit(1);
116      } else {
117        while ( fgets(line, 256, ruleFile) != 0) {
118          strncpy(lineCopy, line, 256);
119          if (strncmp("N", lineCopy, 1) == 0){
120            ruleToDelete = 0;
121            if (sscanf(lineCopy, "%1s %s\n",
122                       strTok,
123                       strName) != 0) {
124              if (strncmp(strName, host, strlen(host)) == 0){
125                ruleToDelete = 1;
126              } else {
127                strncpy(lines[cpt], line, strlen(line));
128              }
129            } else {
130              close(sock);
131              return 1;
132            }
133          } else {
134            if (ruleToDelete==0) {
135              strncpy(lines[cpt], lineCopy, strlen(lineCopy));
136            }
137          }
138          cpt++;
139        } /* while end */
140        fclose(ruleFile);
141        if (!(tmpFile = fopen(FILE_TEMPO, "w"))) {
142          syslog (LOG_ERR, "error during %s opening", FILE_TEMPO);
143          close(sock);
144          return 1;
145        } else {
146          for (i=0; i<cpt; i++){
147            fprintf(tmpFile, "%s", lines[i]);
148          }
149          fclose(tmpFile);
150          if (remove(RULES_FILE)!=0){
151            syslog(LOG_ERR, "rules.txt remove pb: %s", strerror(errno));
152            close(sock);
153            return 1;
154          }
155          if (rename(FILE_TEMPO, RULES_FILE)!=0){
156            syslog(LOG_ERR, "rename file pb: %s", strerror(errno));
157            close(sock);
158            return 1;
159          }
160        }
161      }
162    } else {
163      /* NEW RULE */
164      if (sscanf(buffer, "%s %s\n",
165                port,
166                filters) == 0) {
167syslog (LOG_ERR, "reception de : %s, %s et %s", buffer, port, filters);
168        syslog (LOG_ERR, "error in rule syntax: %s", filters);
169        close(sock);
170        return 1;
171      }
172syslog (LOG_ERR, "filters : %s", filters);
173      subsstr(filters);
174syslog (LOG_ERR, "filters modifies : %s", filters);
175      if (!(ruleFile = fopen(RULES_FILE, "a"))) {
176        syslog (LOG_ERR, "error during %s opening", RULES_FILE);
177        close(sock);
178        return 1;
179      } else {
180        fprintf(ruleFile, "N %s\n", host);
181        fprintf(ruleFile, "O socket %s %s\n", host, port);
182        fprintf(ruleFile, "%s\n", filters);
183        fclose(ruleFile);
184      }
185    }
186  }
187  close(sock);
188  return 0;
189}
190
191/*
192 * tcpServer
193 */
194int
195tcpServer ()
196{
197  struct addrinfo index, *result;
198  struct sockaddr_storage listenAddress;
199  socklen_t listenAddressLen;
200  int listenSock;
201  int returnCode;
202  pid_t renetcolSMP1PID = 0;
203  pid_t renetcolSMP2PID = 0;
204  pid_t renetcolSMP3PID = 0;
205  pid_t renetcolSMP4PID = 0;
206  FILE *pidFile;
207  unsigned pid;
208  char line[256];
209  int status;
210
211  memset(&index, 0, sizeof index);
212  index.ai_flags = AI_PASSIVE;
213  index.ai_family = AF_UNSPEC;
214  index.ai_socktype = SOCK_STREAM;
215  index.ai_protocol = IPPROTO_TCP;
216  returnCode = getaddrinfo(NULL, RECEPT_PORT, &index, &result);
217  if (returnCode != 0) {
218    syslog(LOG_ERR, "getaddrinfo : %s", strerror(errno));
219    return -1;
220  }
221  listenAddressLen = result->ai_addrlen;
222  memcpy(&listenAddress, result->ai_addr, (size_t) listenAddressLen);
223  listenSock = socket(result->ai_family, result->ai_socktype,
224                      result->ai_protocol);
225  if ( listenSock < 0) {
226    syslog(LOG_ERR, "socket : %s", strerror(errno));
227    freeaddrinfo(result);
228    return -1;
229  }
230  freeaddrinfo(result);
231
232  {
233    int on = 1;
234    setsockopt(listenSock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on);
235  }
236  if (bind(listenSock, (struct sockaddr *) &listenAddress,
237           listenAddressLen) < 0 ||
238      listen(listenSock, 8) < 0) {
239    syslog(LOG_ERR, "bind or listen : %s", strerror(errno));
240    return -1;
241  }
242  for (;;) {
243    int clientSock;
244    struct sockaddr_storage clientAddress;
245    socklen_t clientAddressLen;
246    char host[NI_MAXHOST];
247
248    memset(&clientAddress, 0, sizeof clientAddress);
249    clientAddressLen = (socklen_t) sizeof clientAddress;
250
251    if ((clientSock =
252         accept(listenSock, (struct sockaddr *)
253                &clientAddress,
254                &clientAddressLen)) < 0) {
255      continue;
256    }
257    if (clientAddress.ss_family != AF_INET &&
258        clientAddress.ss_family != AF_INET6) {
259      close(clientSock);
260      continue;
261    }
262    if (getnameinfo((struct sockaddr *) &clientAddress,
263                    clientAddressLen, host, sizeof host,
264                    NULL, (size_t) 0, NI_NUMERICHOST) == 0) {
265      syslog(LOG_INFO,
266             "New connection from %s", host);
267    }
268    remoteHost = host;
269    switch (fork ()) {
270    case 0 :
271      close (listenSock);
272      todo(clientSock, remoteHost);
273      /* get PID SMP1 */
274      if (!(pidFile = fopen("/var/run/renetcolSMP1.pid", "r"))) {
275              syslog (LOG_ERR, "error during /var/run/renetcolSMP1.pid opening : %s\n",
276                    strerror(errno));
277              exit(1);
278      } else {
279              fgets(line, 256, pidFile);
280              if (sscanf(line, "%u", &pid)==0)
281                syslog(LOG_ERR,"sscanf : %s", strerror(errno));
282        renetcolSMP1PID = pid;
283      }
284      fclose(pidFile);
285      if (renetcolSMP1PID==0){
286              syslog(LOG_INFO, "PID SMP1 null");
287      }else{
288              if (kill(renetcolSMP1PID, SIGUSR1)<0)
289                syslog(LOG_ERR, "I can't send SIGUSR1 to renetcolSMP1 process : %s", strerror(errno));
290      }
291      /* get PID SMP2 */
292      if (!(pidFile = fopen("/var/run/renetcolSMP2.pid", "r"))) {
293              syslog (LOG_ERR, "error during /var/run/renetcolSMP2.pid opening : %s\n",
294                    strerror(errno));
295              exit(1);
296      } else {
297              fgets(line, 256, pidFile);
298              if (sscanf(line, "%u", &pid)==0)
299                syslog(LOG_ERR,"sscanf : %s", strerror(errno));
300        renetcolSMP2PID = pid;
301      }
302      fclose(pidFile);
303      if (renetcolSMP2PID==0){
304              syslog(LOG_INFO, "PID SMP2 null");
305      }else{
306              if (kill(renetcolSMP2PID, SIGUSR1)<0)
307                syslog(LOG_ERR, "I can't send SIGUSR1 to renetcolSMP2 process : %s", strerror(errno));
308      }
309      /* get PID SMP3 */
310      if (!(pidFile = fopen("/var/run/renetcolSMP3.pid", "r"))) {
311              syslog (LOG_ERR, "error during /var/run/renetcolSMP3.pid opening : %s\n",
312                    strerror(errno));
313              exit(1);
314      } else {
315              fgets(line, 256, pidFile);
316              if (sscanf(line, "%u", &pid)==0)
317                syslog(LOG_ERR,"sscanf : %s", strerror(errno));
318        renetcolSMP3PID = pid;
319      }
320      fclose(pidFile);
321      if (renetcolSMP3PID==0){
322              syslog(LOG_INFO, "PID SMP3 null");
323      }else{
324              if (kill(renetcolSMP3PID, SIGUSR1)<0)
325                syslog(LOG_ERR, "I can't send SIGUSR1 to renetcolSMP3 process : %s", strerror(errno));
326      }
327      /* get PID SMP4 */
328      if (!(pidFile = fopen("/var/run/renetcolSMP4.pid", "r"))) {
329              syslog (LOG_ERR, "error during /var/run/renetcolSMP4.pid opening : %s\n",
330                    strerror(errno));
331              exit(1);
332      } else {
333              fgets(line, 256, pidFile);
334              if (sscanf(line, "%u", &pid)==0)
335                syslog(LOG_ERR,"sscanf : %s", strerror(errno));
336        renetcolSMP4PID = pid;
337      }
338      fclose(pidFile);
339      if (renetcolSMP4PID==0){
340              syslog(LOG_INFO, "PID SMP4 null");
341      }else{
342              if (kill(renetcolSMP4PID, SIGUSR1)<0)
343                syslog(LOG_ERR, "I can't send SIGUSR1 to renetcolSMP4 process : %s", strerror(errno));
344      }
345      exit (0);
346    case -1 :
347      syslog (LOG_ERR, "fork : %s", strerror(errno));
348      return (-1);
349    default :
350      close (clientSock);
351      if (waitpid( -1, &status, WNOHANG)==-1){
352              syslog(LOG_ERR, "waitpid : %s", strerror(errno));
353        exit(1);
354      }
355    }
356  }
357  return (0);
358}
359
360/*
361 *
362 */
363void initConfSender(){
364  RulesPtr tmp = NULL;
365
366  tmp = rulesListPtr;
367  for ( ; tmp; tmp=tmp->next) {
368    rulesListPtr = delRule(tmp, rulesListPtr);
369  }
370  rulesListPtr = NULL;
371  rulesListPtr = getRules(rulesListPtr, RULES_FILE);
372  tmp = rulesListPtr;
373  for ( ; tmp; tmp=tmp->next) {
374    if (tmp->type != 2) {
375      rulesListPtr = delRule(tmp, rulesListPtr);
376    }
377  }
378  tmp = NULL;
379}
380
381/*
382 * Main
383 * ----
384 */
385int
386main (int argc, char *argv[])
387{
388  int s=0;
389  unsigned short rulesID = 0;
390  FILE *pidFile;
391  pid_t renetcolSMP1PID = 0;
392  pid_t renetcolSMP2PID = 0;
393  pid_t renetcolSMP3PID = 0;
394  pid_t renetcolSMP4PID = 0;
395  if ( argc != 6) {
396    fprintf (stderr,
397             "%s: Usage: %s <key> <msg type>\n exp: %s renetcol 1 \n or %s renetcolSMP1 renetcolSMP2 renetcolSMP3 renetcolSMP4 1\n",
398             argv[0], argv[0], argv[0]);
399    exit(1);
400  }
401  if (sscanf (argv[5], "%ld", &type) != 1){
402    fprintf(stderr, "renetcolSender: Error, Invalid message type in command\n");
403    exit(1);
404  }
405
406  openlog(argv[0], LOG_PID, LOG_USER);
407
408  keyIdSMP1 = (char *) malloc((strlen(argv[1])+1) * sizeof(char));
409  strcpy (keyIdSMP1, argv[1]);
410  keyIdSMP2 = (char *) malloc((strlen(argv[2])+1) * sizeof(char));
411  strcpy (keyIdSMP2, argv[2]);
412  keyIdSMP3 = (char *) malloc((strlen(argv[3])+1) * sizeof(char));
413  strcpy (keyIdSMP3, argv[3]);
414  keyIdSMP4 = (char *) malloc((strlen(argv[4])+1) * sizeof(char));
415  strcpy (keyIdSMP4, argv[4]);
416
417  rulesListPtr = NULL;
418  rulesListPtr = getRules(rulesListPtr, RULES_FILE);
419  /* we delete rules which are not type socket */
420  tmp = rulesListPtr;
421  for ( ; tmp; tmp=tmp->next) {
422    if (tmp->type != 2) {
423      rulesListPtr = delRule(tmp, rulesListPtr);
424    }
425  }
426  tmp = NULL;
427  /* get IPC messages queue */
428  if ((myKeySMP1 = ftok(keyIdSMP1, 0))== -1){
429    syslog(LOG_ERR, "ftok : %s", strerror(errno));
430    exit(1);
431  }
432  if ((myQueueSMP1 = msgget(myKeySMP1, 0)) == -1){
433    syslog(LOG_ERR, "msgget : %s", strerror(errno));
434    exit(1);
435  }
436  if ((myKeySMP2 = ftok(keyIdSMP2, 0))== -1){
437    syslog(LOG_ERR, "ftok : %s", strerror(errno));
438    exit(1);
439  }
440  if ((myQueueSMP2 = msgget(myKeySMP2, 0)) == -1){
441    syslog(LOG_ERR, "msgget : %s", strerror(errno));
442    exit(1);
443  }
444  if ((myKeySMP3 = ftok(keyIdSMP3, 0))== -1){
445    syslog(LOG_ERR, "ftok : %s", strerror(errno));
446    exit(1);
447  }
448  if ((myQueueSMP3 = msgget(myKeySMP3, 0)) == -1){
449    syslog(LOG_ERR, "msgget : %s", strerror(errno));
450    exit(1);
451  }
452  if ((myKeySMP4 = ftok(keyIdSMP4, 0))== -1){
453    syslog(LOG_ERR, "ftok : %s", strerror(errno));
454    exit(1);
455  }
456  if ((myQueueSMP4 = msgget(myKeySMP4, 0)) == -1){
457    syslog(LOG_ERR, "msgget : %s", strerror(errno));
458    exit(1);
459  }
460
461/*   chdir ("/"); */
462  fprintf(stderr, "renetcolSender: I become a deamon, next messages via syslogd. Bye.\n");
463  if (fork () != 0)
464    exit (0);
465  if (setsid() == -1){
466    exit(4);
467  }
468/*   for (i = 0; i < FOPEN_MAX; i ++) */
469/*     close (i); */
470
471  /* launch a TCP server to listen remote clients */
472  switch (fork ()) {
473  case 0 : /* son */
474    tcpServer();
475  case -1 :
476    syslog (LOG_ERR, "fork : %s", strerror(errno));
477    return (-1);
478  default : /* father */
479    break;
480  }
481  /* loop on the message queue */
482  while (1) {
483    i=0;
484    myTextSMP1 = msgRcv(myQueueSMP1, &myMsgSMP1, type);
485    buffer2[0]= *(myTextSMP1+i); i++;
486    buffer2[1]= *(myTextSMP1+i); i++;
487    typeMsg = *((unsigned short *)&buffer2);
488    if (1==typeMsg){
489      /* we send the template definition to all the known destination */
490      tmp = rulesListPtr;
491      for ( ; tmp; tmp=tmp->next) {
492        s = sendMessage(tmp->host->sockId, myTextSMP1, sizeof(myMsgSMP1.text),
493                          tmp->host->hostAddressPtr);
494      }
495    } else if (11==*((unsigned short*)&buffer2)){
496      buffer2[0]= *(myTextSMP1+i); i++;
497      buffer2[1]= *(myTextSMP1+i); i++;
498      rulesID = *((unsigned short *)&buffer2);
499      /* here we send the flow to the correct remote client */
500      tmp = rulesListPtr;
501      for ( ; tmp; tmp=tmp->next) { /* FIXME while */
502              if (tmp->id == rulesID){
503                s = sendMessage(tmp->host->sockId, myTextSMP1, sizeof(myMsgSMP1.text),
504                            tmp->host->hostAddressPtr);
505              }
506      }
507    } else if (12==*((unsigned short*)&buffer2)){
508      buffer4[0]= *(myTextSMP1+i); i++;
509      buffer4[1]= *(myTextSMP1+i); i++;
510      buffer4[2]= *(myTextSMP1+i); i++;
511      buffer4[3]= *(myTextSMP1+i); i++;
512      renetcolSMP1PID = *((pid_t *)&buffer4);
513      if (!(pidFile = fopen("/var/run/renetcolSMP1.pid", "w"))) {
514        syslog (LOG_ERR, "error during /var/run/renetcolSMP1.pid opening : %s\n",
515                    strerror(errno));
516              exit(1);
517      } else {
518              if (fprintf(pidFile, "%u", renetcolSMP1PID)==0)
519              syslog(LOG_ERR,"fprintf : %s", strerror(errno));
520      }
521      fclose(pidFile);
522    } else if (13==*((unsigned short*)&buffer2)){
523      initConfSender();
524    } else {
525      syslog(LOG_INFO, "Msg type undefined ??");
526    }
527    i=0;
528
529    myTextSMP2 = msgRcv(myQueueSMP2, &myMsgSMP2, type);
530    buffer2[0]= *(myTextSMP2+i); i++;
531    buffer2[1]= *(myTextSMP2+i); i++;
532    typeMsg = *((unsigned short *)&buffer2);
533    if (1==typeMsg){
534      /* we send the template definition to all the known destination */
535      tmp = rulesListPtr;
536      for ( ; tmp; tmp=tmp->next) {
537        s = sendMessage(tmp->host->sockId, myTextSMP2, sizeof(myMsgSMP2.text),
538                          tmp->host->hostAddressPtr);
539      }
540    } else if (14==*((unsigned short*)&buffer2)){
541      buffer4[0]= *(myTextSMP2+i); i++;
542      buffer4[1]= *(myTextSMP2+i); i++;
543      buffer4[2]= *(myTextSMP2+i); i++;
544      buffer4[3]= *(myTextSMP2+i); i++;
545      renetcolSMP2PID = *((pid_t *)&buffer4);
546      if (!(pidFile = fopen("/var/run/renetcolSMP2.pid", "w"))) {
547        syslog (LOG_ERR, "error during /var/run/renetcolSMP2.pid opening : %s\n",
548                            strerror(errno));
549              exit(1);
550      } else {
551              if (fprintf(pidFile, "%u", renetcolSMP2PID)==0)
552              syslog(LOG_ERR,"fprintf : %s", strerror(errno));
553      }
554      fclose(pidFile);
555    } else if (13==*((unsigned short*)&buffer2)){
556      initConfSender();
557    } else {
558      syslog(LOG_ERR,"message type undefined for this queue SMP2");
559    }
560    i=0;
561
562    myTextSMP3 = msgRcv(myQueueSMP3, &myMsgSMP3, type);
563    buffer2[0]= *(myTextSMP3+i); i++;
564    buffer2[1]= *(myTextSMP3+i); i++;
565    typeMsg = *((unsigned short *)&buffer2);
566    if (1==typeMsg){
567      /* we send the template definition to all the known destination */
568      tmp = rulesListPtr;
569      for ( ; tmp; tmp=tmp->next) {
570        s = sendMessage(tmp->host->sockId, myTextSMP3, sizeof(myMsgSMP3.text),
571                          tmp->host->hostAddressPtr);
572      }
573    } else if (15==*((unsigned short*)&buffer2)){
574      buffer4[0]= *(myTextSMP3+i); i++;
575      buffer4[1]= *(myTextSMP3+i); i++;
576      buffer4[2]= *(myTextSMP3+i); i++;
577      buffer4[3]= *(myTextSMP3+i); i++;
578      renetcolSMP3PID = *((pid_t *)&buffer4);
579      if (!(pidFile = fopen("/var/run/renetcolSMP3.pid", "w"))) {
580        syslog (LOG_ERR, "error during /var/run/renetcolSMP3.pid opening : %s\n",
581                            strerror(errno));
582              exit(1);
583      } else {
584              if (fprintf(pidFile, "%u", renetcolSMP3PID)==0)
585              syslog(LOG_ERR,"fprintf : %s", strerror(errno));
586      }
587      fclose(pidFile);
588    } else if (13==*((unsigned short*)&buffer2)){
589      initConfSender();
590    } else {
591      syslog(LOG_ERR,"message type undefined for this queue SMP3");
592    }
593    i=0;
594
595    myTextSMP4 = msgRcv(myQueueSMP4, &myMsgSMP4, type);
596    buffer2[0]= *(myTextSMP4+i); i++;
597    buffer2[1]= *(myTextSMP4+i); i++;
598    typeMsg = *((unsigned short *)&buffer2);
599    if (1==typeMsg){
600      /* we send the template definition to all the known destination */
601      tmp = rulesListPtr;
602      for ( ; tmp; tmp=tmp->next) {
603        s = sendMessage(tmp->host->sockId, myTextSMP4, sizeof(myMsgSMP4.text),
604                          tmp->host->hostAddressPtr);
605      }
606    } else if (16==*((unsigned short*)&buffer2)){
607      buffer4[0]= *(myTextSMP4+i); i++;
608      buffer4[1]= *(myTextSMP4+i); i++;
609      buffer4[2]= *(myTextSMP4+i); i++;
610      buffer4[3]= *(myTextSMP4+i); i++;
611      renetcolSMP4PID = *((pid_t *)&buffer4);
612      if (!(pidFile = fopen("/var/run/renetcolSMP4.pid", "w"))) {
613        syslog (LOG_ERR, "error during /var/run/renetcolSMP4.pid opening : %s\n",
614                            strerror(errno));
615              exit(1);
616      } else {
617              if (fprintf(pidFile, "%u", renetcolSMP4PID)==0)
618              syslog(LOG_ERR,"fprintf : %s", strerror(errno));
619      }
620      fclose(pidFile);
621    } else if (13==*((unsigned short*)&buffer2)){
622      initConfSender();
623    } else {
624      syslog(LOG_ERR,"message type undefined for this queue SMP4");
625    }
626    i=0;
627  }
628  return(0);
629}
Note: See TracBrowser for help on using the browser.