int main(int argc, char **argv) {
gc_attach(main_gc);
/* Catch all exit signals for gc */
gc_catch();
log_shell_enable();
log_file_disable();
log_level_set(LOG_NOTICE);
struct options_t *options = NULL;
char *args = NULL;
progname = malloc(13);
strcpy(progname, "pilight-uuid");
options_add(&options, 'H', "help", no_value, 0, NULL);
options_add(&options, 'V', "version", no_value, 0, NULL);
while (1) {
int c;
c = options_parse(&options, argc, argv, 1, &args);
if(c == -1)
break;
if(c == -2)
c = 'H';
switch (c) {
case 'H':
printf("Usage: %s [options]\n", progname);
printf("\t -H --help\t\tdisplay usage summary\n");
printf("\t -V --version\t\tdisplay version\n");
return (EXIT_SUCCESS);
break;
case 'V':
printf("%s %s\n", progname, VERSION);
return (EXIT_SUCCESS);
break;
default:
printf("Usage: %s [options]\n", progname);
return (EXIT_FAILURE);
break;
}
}
options_delete(options);
printf("%s\n", ssdp_genuuid());
main_gc();
return (EXIT_FAILURE);
}
/* Attaches an interrupt handler to a specific GPIO pin
Whenever an rising, falling or changing interrupt occurs
the function given as the last argument will be called */
int irq_attach(int gpio_pin, int mode) {
gc_attach(irq_free);
char command[50], folder[32];
int err;
struct stat s;
sprintf(folder, "/sys/class/gpio/gpio%d", gpio_wiringPi2BCM(gpio_pin));
if((err = stat(folder, &s)) != -1 && S_ISDIR(s.st_mode)) {
if(mode == CHANGE)
sprintf(command, "echo falling > /sys/class/gpio/gpio%d/edge", gpio_wiringPi2BCM(gpio_pin));
else if(mode == RISING)
sprintf(command, "echo rising > /sys/class/gpio/gpio%d/edge", gpio_wiringPi2BCM(gpio_pin));
else if(mode == FALLING)
sprintf(command, "echo both > /sys/class/gpio/gpio%d/edge", gpio_wiringPi2BCM(gpio_pin));
} else {
logprintf(LOG_ERR, "can't claim gpio pin %d", gpio_pin);
return EXIT_FAILURE;
}
system(command);
irq_reset(&fd, rdbuf);
memset(fn, 0x00, GPIO_FN_MAXLEN);
snprintf(fn, GPIO_FN_MAXLEN-1, "/sys/class/gpio/gpio%d/value", gpio_wiringPi2BCM(gpio_pin));
fd=open(fn, O_RDONLY);
if(fd < 0) {
return EXIT_FAILURE;
}
pfd.fd=fd;
pfd.events=POLLPRI;
if(read(fd, rdbuf, RDBUF_LEN-1)<0) {
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
// memtrack();
gc_attach(main_gc);
/* Catch all exit signals for gc */
gc_catch();
log_shell_enable();
log_file_disable();
log_level_set(LOG_NOTICE);
struct options_t *options = NULL;
struct ifaddrs *ifaddr, *ifa;
int family = 0;
char *p = NULL;
char *args = NULL;
progname = MALLOC(13);
if(!progname) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(progname, "pilight-uuid");
options_add(&options, 'H', "help", OPTION_NO_VALUE, 0, JSON_NULL, NULL, NULL);
options_add(&options, 'V', "version", OPTION_NO_VALUE, 0, JSON_NULL, NULL, NULL);
while (1) {
int c;
c = options_parse(&options, argc, argv, 1, &args);
if(c == -1)
break;
if(c == -2)
c = 'H';
switch (c) {
case 'H':
printf("Usage: %s [options]\n", progname);
printf("\t -H --help\t\tdisplay usage summary\n");
printf("\t -V --version\t\tdisplay version\n");
return (EXIT_SUCCESS);
break;
case 'V':
printf("%s %s\n", progname, PILIGHT_VERSION);
return (EXIT_SUCCESS);
break;
default:
printf("Usage: %s [options]\n", progname);
return (EXIT_FAILURE);
break;
}
}
options_delete(options);
#ifdef __FreeBSD__
if(rep_getifaddrs(&ifaddr) == -1) {
logprintf(LOG_ERR, "could not get network adapter information");
goto clear;
}
#else
if(getifaddrs(&ifaddr) == -1) {
perror("getifaddrs");
goto clear;
}
#endif
for(ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
if(ifa->ifa_addr == NULL) {
continue;
}
family = ifa->ifa_addr->sa_family;
if((strstr(ifa->ifa_name, "lo") == NULL && strstr(ifa->ifa_name, "vbox") == NULL
&& strstr(ifa->ifa_name, "dummy") == NULL) && (family == AF_INET || family == AF_INET6)) {
if((p = genuuid(ifa->ifa_name)) == NULL) {
logprintf(LOG_ERR, "could not generate the device uuid");
freeifaddrs(ifaddr);
goto clear;
} else {
printf("%s\n", p);
FREE(p);
break;
}
}
}
freeifaddrs(ifaddr);
clear:
main_gc();
return (EXIT_FAILURE);
}
int main(int argc, char **argv) {
// memtrack();
atomicinit();
gc_attach(main_gc);
/* Catch all exit signals for gc */
gc_catch();
log_shell_enable();
log_file_disable();
log_level_set(LOG_NOTICE);
if((progname = MALLOC(16)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(progname, "pilight-receive");
struct options_t *options = NULL;
struct ssdp_list_t *ssdp_list = NULL;
char *server = NULL;
unsigned short port = 0;
unsigned short stats = 0;
char *args = NULL;
options_add(&options, 'H', "help", OPTION_NO_VALUE, 0, JSON_NULL, NULL, NULL);
options_add(&options, 'V', "version", OPTION_NO_VALUE, 0, JSON_NULL, NULL, NULL);
options_add(&options, 'S', "server", OPTION_HAS_VALUE, 0, JSON_NULL, NULL, "^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]).){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$");
options_add(&options, 'P', "port", OPTION_HAS_VALUE, 0, JSON_NULL, NULL, "[0-9]{1,4}");
options_add(&options, 's', "stats", OPTION_NO_VALUE, 0, JSON_NULL, NULL, "[0-9]{1,4}");
/* Store all CLI arguments for later usage
and also check if the CLI arguments where
used correctly by the user. This will also
fill all necessary values in the options struct */
while(1) {
int c;
c = options_parse(&options, argc, argv, 1, &args);
if(c == -1)
break;
if(c == -2)
c = 'H';
switch(c) {
case 'H':
printf("\t -H --help\t\t\tdisplay this message\n");
printf("\t -V --version\t\t\tdisplay version\n");
printf("\t -S --server=x.x.x.x\t\tconnect to server address\n");
printf("\t -P --port=xxxx\t\t\tconnect to server port\n");
printf("\t -s --stats\t\t\tshow CPU and RAM statistics\n");
exit(EXIT_SUCCESS);
break;
case 'V':
printf("%s v%s\n", progname, PILIGHT_VERSION);
exit(EXIT_SUCCESS);
break;
case 'S':
if((server = MALLOC(strlen(args)+1)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(server, args);
break;
case 'P':
port = (unsigned short)atoi(args);
break;
case 's':
stats = 1;
break;
default:
printf("Usage: %s -l location -d device\n", progname);
exit(EXIT_SUCCESS);
break;
}
}
options_delete(options);
if(server != NULL && port > 0) {
if((sockfd = socket_connect(server, port)) == -1) {
logprintf(LOG_ERR, "could not connect to pilight-daemon");
return EXIT_FAILURE;
}
} else if(ssdp_seek(&ssdp_list) == -1) {
logprintf(LOG_NOTICE, "no pilight ssdp connections found");
goto close;
} else {
if((sockfd = socket_connect(ssdp_list->ip, ssdp_list->port)) == -1) {
logprintf(LOG_ERR, "could not connect to pilight-daemon");
goto close;
}
}
if(ssdp_list != NULL) {
ssdp_free(ssdp_list);
}
if(server != NULL) {
FREE(server);
}
struct JsonNode *jclient = json_mkobject();
struct JsonNode *joptions = json_mkobject();
json_append_member(jclient, "action", json_mkstring("identify"));
json_append_member(joptions, "receiver", json_mknumber(1, 0));
json_append_member(joptions, "stats", json_mknumber(stats, 0));
json_append_member(jclient, "options", joptions);
char *out = json_stringify(jclient, NULL);
socket_write(sockfd, out);
json_free(out);
json_delete(jclient);
if(socket_read(sockfd, &recvBuff, 0) != 0 ||
strcmp(recvBuff, "{\"status\":\"success\"}") != 0) {
goto close;
}
while(main_loop) {
if(socket_read(sockfd, &recvBuff, 0) != 0) {
goto close;
}
char **array = NULL;
unsigned int n = explode(recvBuff, "\n", &array), i = 0;
for(i=0;i<n;i++) {
struct JsonNode *jcontent = json_decode(array[i]);
struct JsonNode *jtype = json_find_member(jcontent, "type");
if(jtype != NULL) {
json_remove_from_parent(jtype);
json_delete(jtype);
}
char *content = json_stringify(jcontent, "\t");
printf("%s\n", content);
json_delete(jcontent);
json_free(content);
}
array_free(&array, n);
}
close:
if(sockfd > 0) {
socket_close(sockfd);
}
if(recvBuff != NULL) {
FREE(recvBuff);
recvBuff = NULL;
}
options_gc();
log_shell_disable();
log_gc();
FREE(progname);
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
gc_attach(main_gc);
/* Catch all exit signals for gc */
gc_catch();
log_shell_enable();
log_level_set(LOG_NOTICE);
struct options_t *options = NULL;
struct hardware_t *hardware = NULL;
char *args = NULL;
char *stmp = NULL;
int duration = 0;
int i = 0;
int y = 0;
int z = 0;
steps_t state = CAPTURE;
steps_t pState = WAIT;
int recording = 1;
int bit = 0;
int raw[255] = {0};
int pRaw[255] = {0};
int code[255] = {0};
int onCode[255] = {0};
int offCode[255] = {0};
int allCode[255] = {0};
int unit1Code[255] = {0};
int unit2Code[255] = {0};
int unit3Code[255] = {0};
int binary[255] = {0};
int pBinary[255] = {0};
int onBinary[255] = {0};
int offBinary[255] = {0};
int allBinary[255] = {0};
int unit1Binary[255] = {0};
int unit2Binary[255] = {0};
int unit3Binary[255] = {0};
int loop = 1;
unsigned short match = 0;
int temp[75] = {-1};
int footer = 0;
int pulse = 0;
int onoff[75] = {-1};
int all[75] = {-1};
int unit[75] = {-1};
int rawLength = 0;
int binaryLength = 0;
memset(onoff, -1, 75);
memset(unit, -1, 75);
memset(all, -1, 75);
memset(temp, -1, 75);
settingsfile = malloc(strlen(SETTINGS_FILE)+1);
strcpy(settingsfile, SETTINGS_FILE);
progname = malloc(16);
strcpy(progname, "pilight-learn");
options_add(&options, 'H', "help", no_value, 0, NULL);
options_add(&options, 'V', "version", no_value, 0, NULL);
options_add(&options, 'S', "settings", has_value, 0, NULL);
while (1) {
int c;
c = options_parse(&options, argc, argv, 1, &args);
if(c == -1 || c == -2)
break;
switch (c) {
case 'H':
printf("Usage: %s [options]\n", progname);
printf("\t -H --help\t\tdisplay usage summary\n");
printf("\t -V --version\t\tdisplay version\n");
printf("\t -S --settings\t\tsettings file\n");
return (EXIT_SUCCESS);
break;
case 'V':
printf("%s %s\n", progname, VERSION);
return (EXIT_SUCCESS);
break;
case 'S':
if(access(args, F_OK) != -1) {
settingsfile = realloc(settingsfile, strlen(args)+1);
strcpy(settingsfile, args);
settings_set_file(args);
} else {
fprintf(stderr, "%s: the settings file %s does not exists\n", progname, args);
return EXIT_FAILURE;
}
break;
default:
printf("Usage: %s [options]\n", progname);
return (EXIT_FAILURE);
break;
}
}
options_delete(options);
if(access(settingsfile, F_OK) != -1) {
if(settings_read() != 0) {
return EXIT_FAILURE;
}
}
if(settings_find_string("hw-mode", &stmp) == 0) {
hw_mode = stmp;
}
hardware_init();
struct hardwares_t *htmp = hardwares;
match = 0;
while(htmp) {
if(strcmp(htmp->listener->id, hw_mode) == 0) {
hardware = htmp->listener;
match = 1;
break;
}
htmp = htmp->next;
}
if(match == 1 && hardware->init) {
hardware->init();
printf("Please make sure the daemon is not running when using this debugger.\n\n");
}
if(match == 0 || !hardware->receive || strcmp(hw_mode, "none") == 0) {
printf("The hw-mode \"%s\" isn't compatible with %s\n", hw_mode, progname);
main_gc();
return EXIT_SUCCESS;
}
while(loop && match == 1 && hardware->receive) {
switch(state) {
case CAPTURE:
printf("1. Please send and hold one of the OFF buttons.");
break;
case ON:
/* Store the previous OFF button code */
for(i=0;i<binaryLength;i++) {
offBinary[i] = binary[i];
}
printf("2. Please send and hold the ON button for the same device\n");
printf(" as for which you send the previous OFF button.");
break;
case OFF:
/* Store the previous ON button code */
for(i=0;i<binaryLength;i++) {
onBinary[i] = binary[i];
}
for(i=0;i<rawLength;i++) {
onCode[i] = code[i];
}
z=0;
/* Compare the ON and OFF codes and save bit that are different */
for(i=0;i<binaryLength;i++) {
if(offBinary[i] != onBinary[i]) {
onoff[z++]=i;
}
}
for(i=0;i<rawLength;i++) {
offCode[i] = code[i];
}
printf("3. Please send and hold (one of the) ALL buttons.\n");
printf(" If you're remote doesn't support turning ON or OFF\n");
printf(" all devices at once, press the same OFF button as in\n");
printf(" the beginning.");
break;
case ALL:
z=0;
memset(temp,-1,75);
/* Store the ALL code */
for(i=0;i<binaryLength;i++) {
allBinary[i] = binary[i];
if(allBinary[i] != onBinary[i]) {
temp[z++] = i;
}
}
for(i=0;i<rawLength;i++) {
allCode[i] = code[i];
}
/* Compare the ALL code to the ON and OFF code and store the differences */
y=0;
for(i=0;i<binaryLength;i++) {
if(allBinary[i] != offBinary[i]) {
all[y++] = i;
}
}
if((unsigned int)z < y) {
for(i=0;i<z;i++) {
all[z]=temp[z];
}
}
printf("4. Please send and hold the ON button with the lowest ID.");
break;
case UNIT1:
/* Store the lowest unit code */
for(i=0;i<binaryLength;i++) {
unit1Binary[i] = binary[i];
}
for(i=0;i<rawLength;i++) {
unit1Code[i] = code[i];
}
printf("5. Please send and hold the ON button with the second to lowest ID.");
break;
case UNIT2:
/* Store the second to lowest unit code */
for(i=0;i<binaryLength;i++) {
unit2Binary[i] = binary[i];
}
for(i=0;i<rawLength;i++) {
unit2Code[i] = code[i];
}
printf("6. Please send and hold the ON button with the highest ID.");
break;
case PROCESSUNIT:
z=0;
/* Store the highest unit code and compare the three codes. Store all
bit that are different */
for(i=0;i<binaryLength;i++) {
unit3Binary[i] = binary[i];
if((unit2Binary[i] != unit1Binary[i]) || (unit1Binary[i] != unit3Binary[i]) || (unit2Binary[i] != unit3Binary[i])) {
unit[z++]=i;
}
}
for(i=0;i<rawLength;i++) {
unit3Code[i] = code[i];
}
state=STOP;
break;
case WAIT:
case STOP:
default:;
}
fflush(stdout);
if(state!=WAIT)
pState=state;
if(state==STOP)
loop = 0;
else
state=WAIT;
duration = hardware->receive();
/* If we are recording, keep recording until the next footer has been matched */
if(recording == 1) {
if(bit < 255) {
raw[bit++] = duration;
} else {
bit = 0;
recording = 0;
}
}
/* First try to catch code that seems to be a footer.
If a real footer has been recognized, start using that as the new footer */
if((duration > 4440 && footer == 0) || ((footer-(footer*0.1)<duration) && (footer+(footer*0.1)>duration))) {
recording = 1;
pulse_length = duration/PULSE_DIV;
/* Check if we are recording similar codes */
for(i=0;i<(bit-1);i++) {
if(!(((pRaw[i]-(pRaw[i]*0.3)) < raw[i]) && ((pRaw[i]+(pRaw[i]*0.3)) > raw[i]))) {
y=0;
z=0;
recording=0;
}
pRaw[i]=raw[i];
}
y++;
/* Continue if we have 2 matches */
if(y>2) {
/* If we are certain we are recording similar codes.
Save the raw code length */
if(footer>0) {
if(rawLength == 0)
rawLength=bit;
}
if(rawLength == 0 || rawLength == bit) {
/* Try to catch the footer, and the low and high values */
for(i=0;i<bit;i++) {
if((i+1)<bit && i > 2 && footer > 0) {
if((raw[i]/pulse_length) >= 2) {
pulse=raw[i];
}
}
if(duration > 5000 && duration < 100000)
footer=raw[i];
}
/* If we have gathered all data, stop with the loop */
if(footer > 0 && pulse > 0 && rawLength > 0) {
/* Convert the raw code into binary code */
for(i=0;i<rawLength;i++) {
if((unsigned int)raw[i] > (pulse-pulse_length)) {
code[i]=1;
} else {
code[i]=0;
}
}
for(i=2;i<rawLength; i+=4) {
if(code[i+1] == 1) {
binary[i/4]=1;
} else {
binary[i/4]=0;
}
}
if(binaryLength == 0)
binaryLength = (int)((float)i/4);
/* Check if the subsequent binary code matches
to check if the same button was still held */
if(binaryLength == (i/4)) {
for(i=0;i<binaryLength;i++) {
if(pBinary[i] != binary[i]) {
z=1;
}
}
/* If we are capturing a different button
continue to the next step */
if(z==1 || state == CAPTURE) {
switch(pState) {
case CAPTURE:
state=ON;
break;
case ON:
state=OFF;
break;
case OFF:
state=ALL;
break;
case ALL:
state=UNIT1;
break;
case UNIT1:
state=UNIT2;
break;
case UNIT2:
state=PROCESSUNIT;
break;
case PROCESSUNIT:
state=STOP;
break;
case WAIT:
case STOP:
default:;
}
printf(" Done.\n\n");
pState=WAIT;
}
}
}
}
}
bit=0;
}
/* Reset the button repeat counter */
if(z==1) {
z=0;
for(i=0;i<binaryLength;i++) {
pBinary[i]=binary[i];
}
}
}
rmDup(all, onoff);
rmDup(unit, onoff);
rmDup(all, unit);
/* Print everything */
printf("--[RESULTS]--\n");
printf("\n");
printf("pulse:\t\t%d\n",normalize(pulse));
printf("rawlen:\t\t%d\n",rawLength);
printf("binlen:\t\t%d\n",binaryLength);
printf("plslen:\t\t%d\n",pulse_length);
printf("\n");
printf("on-off bit(s):\t");
z=0;
while(onoff[z] > -1) {
printf("%d ",onoff[z++]);
}
printf("\n");
printf("all bit(s):\t");
z=0;
while(all[z] > -1) {
printf("%d ",all[z++]);
}
printf("\n");
printf("unit bit(s):\t");
z=0;
while(unit[z] > -1) {
printf("%d ",unit[z++]);
}
printf("\n\n");
printf("Raw code:\n");
for(i=0;i<rawLength;i++) {
printf("%d ",normalize(raw[i])*pulse_length);
}
printf("\n");
printf("Raw simplified:\n");
printf("On:\t");
for(i=0;i<rawLength;i++) {
printf("%d",onCode[i]);
}
printf("\n");
printf("Off:\t");
for(i=0;i<rawLength;i++) {
printf("%d",offCode[i]);
}
printf("\n");
printf("All:\t");
for(i=0;i<rawLength;i++) {
printf("%d",allCode[i]);
}
printf("\n");
printf("Unit 1:\t");
for(i=0;i<rawLength;i++) {
printf("%d",unit1Code[i]);
}
printf("\n");
printf("Unit 2:\t");
for(i=0;i<rawLength;i++) {
printf("%d",unit2Code[i]);
}
printf("\n");
printf("Unit 3:\t");
for(i=0;i<rawLength;i++) {
printf("%d",unit3Code[i]);
}
printf("\n");
printf("Binary code:\n");
printf("On:\t");
for(i=0;i<binaryLength;i++) {
printf("%d",onBinary[i]);
}
printf("\n");
printf("Off:\t");
for(i=0;i<binaryLength;i++) {
printf("%d",offBinary[i]);
}
printf("\n");
printf("All:\t");
for(i=0;i<binaryLength;i++) {
printf("%d",allBinary[i]);
}
printf("\n");
printf("Unit 1:\t");
for(i=0;i<binaryLength;i++) {
printf("%d",unit1Binary[i]);
}
printf("\n");
printf("Unit 2:\t");
for(i=0;i<binaryLength;i++) {
printf("%d",unit2Binary[i]);
}
printf("\n");
printf("Unit 3:\t");
for(i=0;i<binaryLength;i++) {
printf("%d",unit3Binary[i]);
}
printf("\n");
return (EXIT_SUCCESS);
}
int main(int argc, char **argv) {
gc_attach(main_gc);
/* Catch all exit signals for gc */
gc_catch();
log_shell_enable();
log_file_disable();
log_level_set(LOG_NOTICE);
struct options_t *options = NULL;
char *args = NULL;
char *hwfile = NULL;
pid_t pid = 0;
if(!(settingsfile = malloc(strlen(SETTINGS_FILE)+1))) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(settingsfile, SETTINGS_FILE);
if(!(progname = malloc(12))) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(progname, "pilight-raw");
options_add(&options, 'H', "help", OPTION_NO_VALUE, 0, JSON_NULL, NULL, NULL);
options_add(&options, 'V', "version", OPTION_NO_VALUE, 0, JSON_NULL, NULL, NULL);
options_add(&options, 'S', "settings", OPTION_HAS_VALUE, 0, JSON_NULL, NULL, NULL);
while (1) {
int c;
c = options_parse(&options, argc, argv, 1, &args);
if(c == -1)
break;
if(c == -2)
c = 'H';
switch (c) {
case 'H':
printf("Usage: %s [options]\n", progname);
printf("\t -H --help\t\tdisplay usage summary\n");
printf("\t -V --version\t\tdisplay version\n");
printf("\t -S --settings\t\tsettings file\n");
return (EXIT_SUCCESS);
break;
case 'V':
printf("%s %s\n", progname, VERSION);
return (EXIT_SUCCESS);
break;
case 'S':
if(access(args, F_OK) != -1) {
settingsfile = realloc(settingsfile, strlen(args)+1);
if(!settingsfile) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(settingsfile, args);
settings_set_file(args);
} else {
fprintf(stderr, "%s: the settings file %s does not exists\n", progname, args);
return EXIT_FAILURE;
}
break;
default:
printf("Usage: %s [options]\n", progname);
return (EXIT_FAILURE);
break;
}
}
options_delete(options);
char pilight_daemon[] = "pilight-daemon";
char pilight_learn[] = "pilight-learn";
char pilight_debug[] = "pilight-debug";
if((pid = findproc(pilight_daemon, NULL)) > 0) {
logprintf(LOG_ERR, "pilight-daemon instance found (%d)", (int)pid);
return (EXIT_FAILURE);
}
if((pid = findproc(pilight_learn, NULL)) > 0) {
logprintf(LOG_ERR, "pilight-learn instance found (%d)", (int)pid);
return (EXIT_FAILURE);
}
if((pid = findproc(pilight_debug, NULL)) > 0) {
logprintf(LOG_ERR, "pilight-debug instance found (%d)", (int)pid);
return (EXIT_FAILURE);
}
if(access(settingsfile, F_OK) != -1) {
if(settings_read() != 0) {
return EXIT_FAILURE;
}
}
hardware_init();
if(settings_find_string("hardware-file", &hwfile) == 0) {
hardware_set_file(hwfile);
if(hardware_read() == EXIT_FAILURE) {
goto clear;
}
}
/* Start threads library that keeps track of all threads used */
threads_create(&pth, NULL, &threads_start, (void *)NULL);
struct conf_hardware_t *tmp_confhw = conf_hardware;
while(tmp_confhw) {
if(tmp_confhw->hardware->init() == EXIT_FAILURE) {
logprintf(LOG_ERR, "could not initialize %s hardware mode", tmp_confhw->hardware->id);
goto clear;
}
threads_register(tmp_confhw->hardware->id, &receive_code, (void *)tmp_confhw->hardware, 0);
tmp_confhw = tmp_confhw->next;
}
while(main_loop) {
sleep(1);
}
clear:
main_gc();
return (EXIT_FAILURE);
}
void logprintf(int prio, const char *format_str, ...) {
int save_errno = errno;
va_list ap;
if(logfile == NULL) {
logfile = realloc(logfile, strlen(LOG_FILE)+1);
strcpy(logfile, LOG_FILE);
}
if(filelog == 0 && shelllog == 0)
return;
if(loglevel >= prio) {
if(lf == NULL && filelog == 1) {
if((lf = fopen(logfile, "a+")) == NULL) {
logprintf(LOG_WARNING, "could not open logfile %s", logfile);
} else {
gc_attach(log_gc);
}
}
if(filelog == 1 && lf != NULL && loglevel < LOG_DEBUG) {
logmarkup();
fputs(debug_log, lf);
va_start(ap, format_str);
if(prio==LOG_WARNING)
fprintf(lf,"WARNING: ");
if(prio==LOG_ERR)
fprintf(lf,"ERROR: ");
if(prio==LOG_INFO)
fprintf(lf, "INFO: ");
if(prio==LOG_NOTICE)
fprintf(lf, "NOTICE: ");
vfprintf(lf, format_str, ap);
fputc('\n',lf);
fflush(lf);
va_end(ap);
}
if(shelllog == 1 || prio == LOG_ERR) {
logmarkup();
fputc('\n', stderr);
fputs(debug_log, stderr);
va_start(ap, format_str);
if(prio==LOG_WARNING)
fprintf(stderr, "WARNING: ");
if(prio==LOG_ERR)
fprintf(stderr, "ERROR: ");
if(prio==LOG_INFO)
fprintf(stderr, "INFO: ");
if(prio==LOG_NOTICE)
fprintf(stderr, "NOTICE: ");
if(prio==LOG_DEBUG)
fprintf(stderr, "DEBUG: ");
vfprintf(stderr, format_str, ap);
fputc('\n', stderr);
fflush(stderr);
va_end(ap);
}
}
sfree((void *)&logfile);
errno = save_errno;
}
int main(int argc, char **argv)
{
unsigned short port = 0;
char* server = NULL;
unsigned short stats = 0;
struct ssdp_list_t *ssdp_list = NULL;
atomicinit();
gc_attach(main_gc);
gc_catch();
if(server != NULL && port > 0) {
if((sockfd = socket_connect(server, port)) == -1){
printf("error: could not connect to pilight-daemon\n");
return EXIT_FAILURE;
}
}
else if(ssdp_seek(&ssdp_list) == -1){
printf("error: no pilight ssdp connections found\n");
goto close;
}
else{
if((sockfd = socket_connect(ssdp_list->ip, ssdp_list->port)) == -1){
printf("error: could not connect to pilight-daemon\n");
goto close;
}
}
if(ssdp_list != NULL)
ssdp_free(ssdp_list);
if(server != NULL)
FREE(server);
struct JsonNode *jclient = json_mkobject();
struct JsonNode *joptions = json_mkobject();
json_append_member(jclient, "action", json_mkstring("identify"));
json_append_member(joptions, "receiver", json_mknumber(1, 0));
json_append_member(joptions, "stats", json_mknumber(stats, 0));
json_append_member(jclient, "options", joptions);
char *out = json_stringify(jclient, NULL);
socket_write(sockfd, out);
json_free(out);
json_delete(jclient);
if(socket_read(sockfd, &recvBuff, 0)!=0 || strcmp(recvBuff, "{\"status\":\"success\"}")!=0)
goto close;
if(iniInit("config.ini")) // get values from config.ini
goto close;
display(0, 0, 0); // init display
unsigned short filteropt = 1;
int lastmin = -1, firstrx = 0;
while(main_loop){
if(socket_read(sockfd, &recvBuff, 0) != 0)
goto close;
char **array = NULL;
unsigned int n = explode(recvBuff, "\n", &array), i = 0;
for(i=0; i<n; i++){
struct JsonNode *jcontent = json_decode(array[i]);
struct JsonNode *jtype = json_find_member(jcontent, "type");
if(jtype != NULL){
json_remove_from_parent(jtype);
json_delete(jtype);
}
if(filteropt == 1){
char *pr = NULL;
double id = 0.0;
double ch = 0.0;
struct JsonNode *jmessage = json_find_member(jcontent, "message");
json_find_string(jcontent, "protocol", &pr);
json_find_number(jmessage, "id", &id);
json_find_number(jmessage, "channel", &ch);
int j = 0;
for(j=0; j<stations; j++){ // step through protocol filters
if(strcmp(station[j].pr, "-")==0 || strcmp(station[j].pr, pr)==0){ // protocol not specified or found
if(j == 0){ // datetime protocol is the first
if(firstrx){
double min = 0.0;
json_find_number(jmessage, "minute", &min);
if((int)min != lastmin){
display(-1, 0.0, 0.0);
lastmin = (int)min;
}
}
}
else if(strcmp(station[j].id, "-")==0 || (int)id==atoi(station[j].id)){ // id not specified or found
if(strcmp(station[j].ch, "-")==0 || (int)ch==atoi(station[j].ch)){ // channel not specified or found
double temp = 0.0, humi = 0.0;
json_find_number(jmessage, "temperature", &temp);
json_find_number(jmessage, "humidity", &humi);
display(j-1, temp, humi);
firstrx = 1;
break;
}
}
}
}
}
else{
char *content = json_stringify(jcontent, "\t");
printf("%s\n", content);
json_free(content);
}
json_delete(jcontent);
}
array_free(&array, n);
}
close:
if(sockfd > 0)
socket_close(sockfd);
if(recvBuff != NULL){
FREE(recvBuff);
recvBuff = NULL;
}
iniClean();
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
// memtrack();
atomicinit();
gc_attach(main_gc);
/* Catch all exit signals for gc */
gc_catch();
log_shell_enable();
log_file_disable();
log_level_set(LOG_NOTICE);
struct options_t *options = NULL;
char *p = NULL;
char *args = NULL;
if((progname = MALLOC(13)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(progname, "pilight-uuid");
options_add(&options, 'H', "help", OPTION_NO_VALUE, 0, JSON_NULL, NULL, NULL);
options_add(&options, 'V', "version", OPTION_NO_VALUE, 0, JSON_NULL, NULL, NULL);
while (1) {
int c;
c = options_parse(&options, argc, argv, 1, &args);
if(c == -1)
break;
if(c == -2)
c = 'H';
switch (c) {
case 'H':
printf("Usage: %s [options]\n", progname);
printf("\t -H --help\t\tdisplay usage summary\n");
printf("\t -V --version\t\tdisplay version\n");
return (EXIT_SUCCESS);
break;
case 'V':
printf("%s v%s\n", progname, PILIGHT_VERSION);
return (EXIT_SUCCESS);
break;
default:
printf("Usage: %s [options]\n", progname);
return (EXIT_FAILURE);
break;
}
}
options_delete(options);
int nrdevs = 0, x = 0;
char **devs = NULL;
if((nrdevs = inetdevs(&devs)) > 0) {
for(x=0;x<nrdevs;x++) {
if((p = genuuid(devs[x])) == NULL) {
logprintf(LOG_ERR, "could not generate the device uuid");
} else {
strcpy(pilight_uuid, p);
FREE(p);
break;
}
}
}
array_free(&devs, nrdevs);
printf("%s\n", pilight_uuid);
main_gc();
return (EXIT_FAILURE);
}
int main(int argc, char **argv) {
/* Run main garbage collector when quiting the daemon */
gc_attach(main_gc);
/* Catch all exit signals for gc */
gc_catch();
loglevel = LOG_INFO;
log_file_disable();
log_shell_enable();
char *logfile = malloc(strlen(LOG_FILE)+1);
strcpy(logfile, LOG_FILE);
log_file_set(logfile);
sfree((void *)&logfile);
prevMessage = malloc(4);
memset(prevMessage, '\0', 4);
progname = malloc(14);
strcpy(progname, "splash-daemon");
struct socket_callback_t socket_callback;
struct options_t *options = NULL;
char *args = NULL;
char buffer[BUFFER_SIZE];
int f;
options_add(&options, 'H', "help", no_value, 0, NULL);
options_add(&options, 'V', "version", no_value, 0, NULL);
options_add(&options, 'D', "nodaemon", no_value, 0, NULL);
while (1) {
int c;
c = options_parse(&options, argc, argv, 1, &args);
if (c == -1)
break;
switch(c) {
case 'H':
printf("Usage: %s [options]\n", progname);
printf("\t -H --help\t\tdisplay usage summary\n");
printf("\t -V --version\t\tdisplay version\n");
printf("\t -S --settings\t\tsettings file\n");
printf("\t -D --nodaemon\t\tdo not daemonize and\n");
printf("\t\t\t\tshow debug information\n");
return (EXIT_SUCCESS);
break;
case 'V':
printf("%s %s\n", progname, "1.0");
return (EXIT_SUCCESS);
break;
case 'D':
nodaemon=1;
break;
default:
printf("Usage: %s [options]\n", progname);
return (EXIT_FAILURE);
break;
}
}
options_delete(options);
pid_file = malloc(sizeof(PID_FILE)+1);
strcpy(pid_file, PID_FILE);
template_file = malloc(14);
strcpy(template_file, "template.json");
if((f = open(pid_file, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)) != -1) {
if(read(f, buffer, BUFFER_SIZE) != -1) {
//If the file is empty, create a new process
if(!atoi(buffer)) {
running = 0;
} else {
//Check if the process is running
kill(atoi(buffer), 0);
//If not, create a new process
if(errno == ESRCH) {
running = 0;
}
}
}
} else {
logprintf(LOG_ERR, "could not open / create pid_file %s", pid_file);
return EXIT_FAILURE;
}
close(f);
if(nodaemon == 1 || running == 1) {
log_level_set(LOG_DEBUG);
}
if(running == 1) {
nodaemon=1;
logprintf(LOG_NOTICE, "already active (pid %d)", atoi(buffer));
return EXIT_FAILURE;
}
if(nodaemon == 0) {
deamonize();
socket_start(PORT);
fb_init();
} else {
socket_start(PORT);
}
if(template_read(template_file) == EXIT_FAILURE) {
logprintf(LOG_NOTICE, "failed to read template file %s", template_file);
main_gc();
return EXIT_FAILURE;
}
if(nodaemon == 1) {
//template_print();
}
//initialise all socket_clients and handshakes to 0 so not checked
memset(socket_clients, 0, sizeof(socket_clients));
socket_callback.client_disconnected_callback = NULL;
socket_callback.client_connected_callback = NULL;
socket_callback.client_data_callback = &socket_parse_data;
main_draw();
/* Make sure the server part is non-blocking by creating a new thread */
pthread_create(&pth, NULL, &update_progress, (void *)NULL);
socket_wait((void *)&socket_callback);
while(main_loop) {
sleep(1);
}
return EXIT_FAILURE;
}
void logprintf(int prio, const char *format_str, ...) {
int save_errno = errno;
va_list ap;
if(filelog == 0 && shelllog == 0)
return;
if(loglevel >= prio) {
if(lf == NULL && filelog == 1) {
if((lf = fopen(logfile, "a+")) == NULL) {
logprintf(LOG_WARNING, "could not open logfile %s", logfile);
} else {
gc_attach(log_gc);
}
}
time_t current;
char *currents;
current=time(¤t);
currents=ctime(¤t);
if(filelog == 1 && lf != NULL && loglevel < LOG_DEBUG) {
fprintf(lf,"[%15.15s] %s: ",currents+4, progname);
va_start(ap, format_str);
if(prio==LOG_WARNING)
fprintf(lf,"WARNING: ");
if(prio==LOG_ERR)
fprintf(lf,"ERROR: ");
if(prio==LOG_INFO)
fprintf(lf, "INFO: ");
if(prio==LOG_NOTICE)
fprintf(lf, "NOTICE: ");
vfprintf(lf, format_str, ap);
fputc('\n',lf);
fflush(lf);
va_end(ap);
}
if(shelllog == 1) {
fprintf(stderr, "[%15.15s] %s: ",currents+4, progname);
va_start(ap, format_str);
if(prio==LOG_WARNING)
fprintf(stderr, "WARNING: ");
if(prio==LOG_ERR)
fprintf(stderr, "ERROR: ");
if(prio==LOG_INFO)
fprintf(stderr, "INFO: ");
if(prio==LOG_NOTICE)
fprintf(stderr, "NOTICE: ");
if(prio==LOG_DEBUG)
fprintf(stderr, "DEBUG: ");
vfprintf(stderr, format_str, ap);
fputc('\n',stderr);
fflush(stderr);
va_end(ap);
}
}
errno = save_errno;
}
