int main(int argc, char *argv[])
{
memcached_st *memc;
memcached_return_t rc;
memcached_server_st *servers;
memcached_dump_fn callbacks[1];
callbacks[0]= &key_printer;
options_parse(argc, argv);
memc= memcached_create(NULL);
process_hash_option(memc, opt_hash);
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
if (opt_servers)
servers= memcached_servers_parse(opt_servers);
else
servers= memcached_servers_parse(argv[--argc]);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
(uint64_t)opt_binary);
if (!initialize_sasl(memc, opt_username, opt_passwd))
{
memcached_free(memc);
return EXIT_FAILURE;
}
rc= memcached_dump(memc, callbacks, NULL, 1);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memdump: memcache error %s", memcached_strerror(memc, rc));
if (memcached_last_error_errno(memc))
fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc)));
fprintf(stderr, "\n");
}
memcached_free(memc);
if (opt_servers)
free(opt_servers);
if (opt_hash)
free(opt_hash);
shutdown_sasl();
return EXIT_SUCCESS;
}
int
crl_main(int argc, char **argv)
{
unsigned long nmflag = 0;
X509_CRL *x = NULL;
int ret = 1, i;
BIO *out = NULL;
X509_STORE *store = NULL;
X509_STORE_CTX ctx;
X509_LOOKUP *lookup = NULL;
X509_OBJECT xobj;
EVP_PKEY *pkey;
const EVP_MD *digest;
char *digest_name = NULL;
if (bio_out == NULL) {
if ((bio_out = BIO_new(BIO_s_file())) != NULL) {
BIO_set_fp(bio_out, stdout, BIO_NOCLOSE);
}
}
digest = EVP_sha1();
memset(&crl_config, 0, sizeof(crl_config));
crl_config.informat = FORMAT_PEM;
crl_config.outformat = FORMAT_PEM;
if (options_parse(argc, argv, crl_options, &digest_name, NULL) != 0) {
crl_usage();
goto end;
}
if (crl_config.cafile != NULL || crl_config.capath != NULL)
crl_config.verify = 1;
if (crl_config.nameopt != NULL) {
if (set_name_ex(&nmflag, crl_config.nameopt) != 1) {
fprintf(stderr,
"Invalid -nameopt argument '%s'\n",
crl_config.nameopt);
goto end;
}
}
if (digest_name != NULL) {
if ((digest = EVP_get_digestbyname(digest_name)) == NULL) {
fprintf(stderr,
"Unknown message digest algorithm '%s'\n",
digest_name);
goto end;
}
}
x = load_crl(crl_config.infile, crl_config.informat);
if (x == NULL)
goto end;
if (crl_config.verify) {
store = X509_STORE_new();
lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file());
if (lookup == NULL)
goto end;
if (!X509_LOOKUP_load_file(lookup, crl_config.cafile,
X509_FILETYPE_PEM))
X509_LOOKUP_load_file(lookup, NULL,
X509_FILETYPE_DEFAULT);
lookup = X509_STORE_add_lookup(store, X509_LOOKUP_hash_dir());
if (lookup == NULL)
goto end;
if (!X509_LOOKUP_add_dir(lookup, crl_config.capath,
X509_FILETYPE_PEM))
X509_LOOKUP_add_dir(lookup, NULL,
X509_FILETYPE_DEFAULT);
ERR_clear_error();
if (!X509_STORE_CTX_init(&ctx, store, NULL, NULL)) {
BIO_printf(bio_err,
"Error initialising X509 store\n");
goto end;
}
i = X509_STORE_get_by_subject(&ctx, X509_LU_X509,
X509_CRL_get_issuer(x), &xobj);
if (i <= 0) {
BIO_printf(bio_err,
"Error getting CRL issuer certificate\n");
goto end;
}
pkey = X509_get_pubkey(xobj.data.x509);
X509_OBJECT_free_contents(&xobj);
if (!pkey) {
BIO_printf(bio_err,
"Error getting CRL issuer public key\n");
goto end;
}
i = X509_CRL_verify(x, pkey);
EVP_PKEY_free(pkey);
if (i < 0)
goto end;
if (i == 0)
BIO_printf(bio_err, "verify failure\n");
else
BIO_printf(bio_err, "verify OK\n");
}
/* Print requested information the order that the flags were given. */
for (i = 1; i <= argc; i++) {
if (crl_config.issuer == i) {
print_name(bio_out, "issuer=",
X509_CRL_get_issuer(x), nmflag);
}
if (crl_config.crlnumber == i) {
ASN1_INTEGER *crlnum;
crlnum = X509_CRL_get_ext_d2i(x,
NID_crl_number, NULL, NULL);
BIO_printf(bio_out, "crlNumber=");
if (crlnum) {
i2a_ASN1_INTEGER(bio_out, crlnum);
ASN1_INTEGER_free(crlnum);
} else
BIO_puts(bio_out, "<NONE>");
BIO_printf(bio_out, "\n");
}
if (crl_config.hash == i) {
BIO_printf(bio_out, "%08lx\n",
X509_NAME_hash(X509_CRL_get_issuer(x)));
}
#ifndef OPENSSL_NO_MD5
if (crl_config.hash_old == i) {
BIO_printf(bio_out, "%08lx\n",
X509_NAME_hash_old(X509_CRL_get_issuer(x)));
}
#endif
if (crl_config.lastupdate == i) {
BIO_printf(bio_out, "lastUpdate=");
ASN1_TIME_print(bio_out,
X509_CRL_get_lastUpdate(x));
BIO_printf(bio_out, "\n");
}
if (crl_config.nextupdate == i) {
BIO_printf(bio_out, "nextUpdate=");
if (X509_CRL_get_nextUpdate(x))
ASN1_TIME_print(bio_out,
X509_CRL_get_nextUpdate(x));
else
BIO_printf(bio_out, "NONE");
BIO_printf(bio_out, "\n");
}
if (crl_config.fingerprint == i) {
int j;
unsigned int n;
unsigned char md[EVP_MAX_MD_SIZE];
if (!X509_CRL_digest(x, digest, md, &n)) {
BIO_printf(bio_err, "out of memory\n");
goto end;
}
BIO_printf(bio_out, "%s Fingerprint=",
OBJ_nid2sn(EVP_MD_type(digest)));
for (j = 0; j < (int) n; j++) {
BIO_printf(bio_out, "%02X%c", md[j],
(j + 1 == (int)n) ? '\n' : ':');
}
}
}
out = BIO_new(BIO_s_file());
if (out == NULL) {
ERR_print_errors(bio_err);
goto end;
}
if (crl_config.outfile == NULL) {
BIO_set_fp(out, stdout, BIO_NOCLOSE);
} else {
if (BIO_write_filename(out, crl_config.outfile) <= 0) {
perror(crl_config.outfile);
goto end;
}
}
if (crl_config.text)
X509_CRL_print(out, x);
if (crl_config.noout) {
ret = 0;
goto end;
}
if (crl_config.outformat == FORMAT_ASN1)
i = (int) i2d_X509_CRL_bio(out, x);
else if (crl_config.outformat == FORMAT_PEM)
i = PEM_write_bio_X509_CRL(out, x);
else {
BIO_printf(bio_err,
"bad output format specified for outfile\n");
goto end;
}
if (!i) {
BIO_printf(bio_err, "unable to write CRL\n");
goto end;
}
ret = 0;
end:
BIO_free_all(out);
BIO_free_all(bio_out);
bio_out = NULL;
X509_CRL_free(x);
if (store) {
X509_STORE_CTX_cleanup(&ctx);
X509_STORE_free(store);
}
return (ret);
}
int
pkeyparam_main(int argc, char **argv)
{
BIO *in = NULL, *out = NULL;
EVP_PKEY *pkey = NULL;
int ret = 1;
if (single_execution) {
if (pledge("stdio cpath wpath rpath", NULL) == -1) {
perror("pledge");
exit(1);
}
}
memset(&pkeyparam_config, 0, sizeof(pkeyparam_config));
if (options_parse(argc, argv, pkeyparam_options, NULL, NULL) != 0) {
pkeyparam_usage();
return (1);
}
if (pkeyparam_config.infile) {
if (!(in = BIO_new_file(pkeyparam_config.infile, "r"))) {
BIO_printf(bio_err, "Can't open input file %s\n",
pkeyparam_config.infile);
goto end;
}
} else
in = BIO_new_fp(stdin, BIO_NOCLOSE);
if (pkeyparam_config.outfile) {
if (!(out = BIO_new_file(pkeyparam_config.outfile, "w"))) {
BIO_printf(bio_err, "Can't open output file %s\n",
pkeyparam_config.outfile);
goto end;
}
} else {
out = BIO_new_fp(stdout, BIO_NOCLOSE);
}
pkey = PEM_read_bio_Parameters(in, NULL);
if (!pkey) {
BIO_printf(bio_err, "Error reading parameters\n");
ERR_print_errors(bio_err);
goto end;
}
if (!pkeyparam_config.noout)
PEM_write_bio_Parameters(out, pkey);
if (pkeyparam_config.text)
EVP_PKEY_print_params(out, pkey, 0, NULL);
ret = 0;
end:
EVP_PKEY_free(pkey);
BIO_free_all(out);
BIO_free(in);
return ret;
}
NOEXPORT int signal_pipe_dispatch(void) {
static int sig;
static size_t ptr=0;
ssize_t num;
char *sig_name;
s_log(LOG_DEBUG, "Dispatching signals from the signal pipe");
for(;;) {
num=readsocket(signal_pipe[0], (char *)&sig+ptr, sizeof sig-ptr);
if(num==-1 && get_last_socket_error()==S_EWOULDBLOCK) {
s_log(LOG_DEBUG, "Signal pipe is empty");
return 0;
}
if(num==-1 || num==0) {
if(num)
sockerror("signal pipe read");
else
s_log(LOG_ERR, "Signal pipe closed");
s_poll_remove(fds, signal_pipe[0]);
closesocket(signal_pipe[0]);
closesocket(signal_pipe[1]);
if(signal_pipe_init()) {
s_log(LOG_ERR,
"Signal pipe reinitialization failed; terminating");
return 1;
}
s_poll_add(fds, signal_pipe[0], 1, 0);
s_log(LOG_ERR, "Signal pipe reinitialized");
return 0;
}
ptr+=(size_t)num;
if(ptr<sizeof sig) {
s_log(LOG_DEBUG, "Incomplete signal pipe read (ptr=%ld)",
(long)ptr);
return 0;
}
ptr=0;
switch(sig) {
#ifndef USE_WIN32
case SIGCHLD:
s_log(LOG_DEBUG, "Processing SIGCHLD");
#ifdef USE_FORK
client_status(); /* report status of client process */
#else /* USE_UCONTEXT || USE_PTHREAD */
child_status(); /* report status of libwrap or 'exec' process */
#endif /* defined USE_FORK */
break;
#endif /* !defind USE_WIN32 */
case SIGNAL_RELOAD_CONFIG:
s_log(LOG_DEBUG, "Processing SIGNAL_RELOAD_CONFIG");
if(options_parse(CONF_RELOAD)) {
s_log(LOG_ERR, "Failed to reload the configuration file");
} else {
unbind_ports();
log_close();
options_apply();
log_open();
ui_config_reloaded();
if(bind_ports()) {
/* FIXME: handle the error */
}
}
break;
case SIGNAL_REOPEN_LOG:
s_log(LOG_DEBUG, "Processing SIGNAL_REOPEN_LOG");
log_close();
log_open();
s_log(LOG_NOTICE, "Log file reopened");
break;
case SIGNAL_TERMINATE:
s_log(LOG_DEBUG, "Processing SIGNAL_TERMINATE");
s_log(LOG_NOTICE, "Terminated");
return 1;
default:
sig_name=signal_name(sig);
s_log(LOG_ERR, "Received %s; terminating", sig_name);
str_free(sig_name);
return 1;
}
}
}
int main(int argc, char **argv) {
log_file_disable();
log_shell_enable();
log_level_set(LOG_NOTICE);
progname = malloc(13);
strcpy(progname, "pilight-send");
struct options_t *options = NULL;
int sockfd = 0;
char *recvBuff = NULL;
char *message;
char *args = NULL;
steps_t steps = WELCOME;
/* Hold the name of the protocol */
char protobuffer[25] = "\0";
/* Does this protocol exists */
int match = 0;
/* Do we need to print the help */
int help = 0;
/* Do we need to print the version */
int version = 0;
/* Do we need to print the protocol help */
int protohelp = 0;
char *server = malloc(17);
strcpy(server, "127.0.0.1");
unsigned short port = PORT;
/* Hold the final protocol struct */
protocol_t *protocol = NULL;
JsonNode *json = json_mkobject();
JsonNode *code = json_mkobject();
/* Define all CLI arguments of this program */
options_add(&options, 'H', "help", no_value, 0, NULL);
options_add(&options, 'V', "version", no_value, 0, NULL);
options_add(&options, 'p', "protocol", has_value, 0, NULL);
options_add(&options, 'S', "server", has_value, 0, "^(([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", has_value, 0, "[0-9]{1,4}");
/* Initialize peripheral modules */
hw_init();
/* Get the protocol to be used */
while (1) {
int c;
c = options_parse(&options, argc, argv, 0, &args);
if (c == -1)
break;
switch(c) {
case 'p':
if(strlen(args) == 0) {
logprintf(LOG_ERR, "options '-p' and '--protocol' require an argument");
exit(EXIT_FAILURE);
} else {
strcpy(protobuffer, args);
}
break;
case 'V':
version = 1;
break;
case 'H':
help = 1;
break;
case 'S':
server = realloc(server, strlen(args)+1);
strcpy(server, args);
break;
case 'P':
port = (unsigned short)atoi(args);
break;
default:;
}
}
/* Check if a protocol was given */
if(strlen(protobuffer) > 0 && strcmp(protobuffer,"-V") != 0) {
if(strlen(protobuffer) > 0 && version) {
printf("-p and -V cannot be combined\n");
} else {
struct protocols_t *pnode = protocols;
/* Retrieve the used protocol */
while(pnode) {
/* Check if the protocol exists */
protocol = pnode->listener;
if(protocol_has_device(protocol, protobuffer) == 0 && match == 0 && protocol->createCode != NULL) {
match=1;
/* Check if the protocol requires specific CLI arguments
and merge them with the main CLI arguments */
if(protocol->options && help == 0) {
options_merge(&options, &protocol->options);
} else if(help == 1) {
protohelp=1;
}
break;
}
pnode = pnode->next;
}
/* If no protocols matches the requested protocol */
if(!match) {
logprintf(LOG_ERR, "this protocol is not supported");
}
}
}
/* Display help or version information */
if(version == 1) {
printf("%s %s\n", progname, "1.0");
goto close;
} else if(help == 1 || protohelp == 1 || match == 0) {
if(protohelp == 1 && match == 1 && protocol->printHelp)
printf("Usage: %s -p %s [options]\n", progname, protobuffer);
else
printf("Usage: %s -p protocol [options]\n", progname);
if(help == 1) {
printf("\t -H --help\t\t\tdisplay this message\n");
printf("\t -V --version\t\t\tdisplay version\n");
printf("\t -S --server=%s\t\tconnect to server address\n", server);
printf("\t -P --port=%d\t\t\tconnect to server port\n", port);
printf("\t -p --protocol=protocol\t\tthe protocol that you want to control\n");
}
if(protohelp == 1 && match == 1 && protocol->printHelp) {
printf("\n\t[%s]\n", protobuffer);
protocol->printHelp();
} else {
printf("\nThe supported protocols are:\n");
struct protocols_t *pnode = protocols;
/* Retrieve the used protocol */
while(pnode) {
protocol = pnode->listener;
if(protocol->createCode) {
while(protocol->devices) {
printf("\t %s\t\t",protocol->devices->id);
if(strlen(protocol->devices->id)<7)
printf("\t");
if(strlen(protocol->devices->id)<14)
printf("\t");
printf("%s\n", protocol->devices->desc);
protocol->devices = protocol->devices->next;
}
}
pnode = pnode->next;
}
}
goto close;
}
/* 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;
}
int itmp;
/* Check if we got sufficient arguments from this protocol */
struct options_t *tmp = options;
while(tmp) {
if(strlen(tmp->name) > 0) {
/* Only send the CLI arguments that belong to this protocol, the protocol name
and those that are called by the user */
if((options_get_id(&protocol->options, tmp->name, &itmp) == 0 || strcmp(tmp->name, "protocol") == 0)
&& strlen(tmp->value) > 0) {
json_append_member(code, tmp->name, json_mkstring(tmp->value));
}
}
tmp = tmp->next;
}
if(protocol->createCode(code) == 0) {
if(protocol->message) {
json_delete(protocol->message);
}
if((sockfd = socket_connect(server, port)) == -1) {
logprintf(LOG_ERR, "could not connect to pilight-daemon");
goto close;
}
while(1) {
if(steps > WELCOME) {
/* Clear the receive buffer again and read the welcome message */
if((recvBuff = socket_read(sockfd))) {
json = json_decode(recvBuff);
json_find_string(json, "message", &message);
} else {
goto close;
}
usleep(100);
}
switch(steps) {
case WELCOME:
socket_write(sockfd, "{\"message\":\"client sender\"}");
steps=IDENTIFY;
case IDENTIFY:
if(strcmp(message, "accept client") == 0) {
steps=SEND;
}
if(strcmp(message, "reject client") == 0) {
steps=REJECT;
}
case SEND:
json_delete(json);
json = json_mkobject();
json_append_member(json, "message", json_mkstring("send"));
json_append_member(json, "code", code);
char *output = json_stringify(json, NULL);
socket_write(sockfd, output);
free(output);
goto close;
break;
case REJECT:
default:
goto close;
break;
}
}
}
close:
if(json) {
json_delete(json);
}
if(sockfd) {
socket_close(sockfd);
}
log_shell_disable();
free(server);
protocol_gc();
options_delete(options);
options_gc();
free(progname);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
memcached_st *memc;
char *string;
size_t string_length;
uint32_t flags;
memcached_return_t rc;
memcached_server_st *servers;
int return_code= 0;
options_parse(argc, argv);
initialize_sockets();
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
memc= memcached_create(NULL);
process_hash_option(memc, opt_hash);
servers= memcached_servers_parse(opt_servers);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
(uint64_t)opt_binary);
if (!initialize_sasl(memc, opt_username, opt_passwd))
{
memcached_free(memc);
return EXIT_FAILURE;
}
while (optind < argc)
{
string= memcached_get(memc, argv[optind], strlen(argv[optind]),
&string_length, &flags, &rc);
if (rc == MEMCACHED_SUCCESS)
{
if (opt_displayflag)
{
if (opt_verbose)
printf("key: %s\nflags: ", argv[optind]);
printf("%x\n", flags);
}
else
{
if (opt_verbose)
{
printf("key: %s\nflags: %x\nlength: %zu\nvalue: ",
argv[optind], flags, string_length);
}
if (opt_file)
{
FILE *fp;
size_t written;
fp= fopen(opt_file, "w");
if (!fp)
{
perror("fopen");
return_code= -1;
break;
}
written= fwrite(string, 1, string_length, fp);
if (written != string_length)
{
fprintf(stderr, "error writing file (written %zu, should be %zu)\n", written, string_length);
return_code= -1;
break;
}
if (fclose(fp))
{
fprintf(stderr, "error closing file\n");
return_code= -1;
break;
}
}
else
{
printf("%.*s\n", (int)string_length, string);
}
free(string);
}
}
else if (rc != MEMCACHED_NOTFOUND)
{
fprintf(stderr, "memcat: %s: memcache error %s",
argv[optind], memcached_strerror(memc, rc));
if (memcached_last_error_errno(memc))
{
fprintf(stderr, " system error %s", strerror(memcached_last_error_errno(memc)));
}
fprintf(stderr, "\n");
return_code= -1;
break;
}
else // Unknown Issue
{
fprintf(stderr, "memcat: %s not found\n", argv[optind]);
return_code= -1;
}
optind++;
}
memcached_free(memc);
if (opt_servers)
free(opt_servers);
if (opt_hash)
free(opt_hash);
shutdown_sasl();
return return_code;
}
int
dsa_main(int argc, char **argv)
{
int ret = 1;
DSA *dsa = NULL;
int i;
BIO *in = NULL, *out = NULL;
char *passin = NULL, *passout = NULL;
if (single_execution) {
if (pledge("stdio cpath wpath rpath tty", NULL) == -1) {
perror("pledge");
exit(1);
}
}
memset(&dsa_config, 0, sizeof(dsa_config));
dsa_config.pvk_encr = 2;
dsa_config.informat = FORMAT_PEM;
dsa_config.outformat = FORMAT_PEM;
if (options_parse(argc, argv, dsa_options, NULL, NULL) != 0) {
dsa_usage();
goto end;
}
if (!app_passwd(bio_err, dsa_config.passargin, dsa_config.passargout,
&passin, &passout)) {
BIO_printf(bio_err, "Error getting passwords\n");
goto end;
}
in = BIO_new(BIO_s_file());
out = BIO_new(BIO_s_file());
if (in == NULL || out == NULL) {
ERR_print_errors(bio_err);
goto end;
}
if (dsa_config.infile == NULL)
BIO_set_fp(in, stdin, BIO_NOCLOSE);
else {
if (BIO_read_filename(in, dsa_config.infile) <= 0) {
perror(dsa_config.infile);
goto end;
}
}
BIO_printf(bio_err, "read DSA key\n");
{
EVP_PKEY *pkey;
if (dsa_config.pubin)
pkey = load_pubkey(bio_err, dsa_config.infile,
dsa_config.informat, 1, passin, "Public Key");
else
pkey = load_key(bio_err, dsa_config.infile,
dsa_config.informat, 1, passin, "Private Key");
if (pkey) {
dsa = EVP_PKEY_get1_DSA(pkey);
EVP_PKEY_free(pkey);
}
}
if (dsa == NULL) {
BIO_printf(bio_err, "unable to load Key\n");
ERR_print_errors(bio_err);
goto end;
}
if (dsa_config.outfile == NULL) {
BIO_set_fp(out, stdout, BIO_NOCLOSE);
} else {
if (BIO_write_filename(out, dsa_config.outfile) <= 0) {
perror(dsa_config.outfile);
goto end;
}
}
if (dsa_config.text) {
if (!DSA_print(out, dsa, 0)) {
perror(dsa_config.outfile);
ERR_print_errors(bio_err);
goto end;
}
}
if (dsa_config.modulus) {
fprintf(stdout, "Public Key=");
BN_print(out, dsa->pub_key);
fprintf(stdout, "\n");
}
if (dsa_config.noout)
goto end;
BIO_printf(bio_err, "writing DSA key\n");
if (dsa_config.outformat == FORMAT_ASN1) {
if (dsa_config.pubin || dsa_config.pubout)
i = i2d_DSA_PUBKEY_bio(out, dsa);
else
i = i2d_DSAPrivateKey_bio(out, dsa);
} else if (dsa_config.outformat == FORMAT_PEM) {
if (dsa_config.pubin || dsa_config.pubout)
i = PEM_write_bio_DSA_PUBKEY(out, dsa);
else
i = PEM_write_bio_DSAPrivateKey(out, dsa, dsa_config.enc,
NULL, 0, NULL, passout);
#if !defined(OPENSSL_NO_RSA) && !defined(OPENSSL_NO_RC4)
} else if (dsa_config.outformat == FORMAT_MSBLOB ||
dsa_config.outformat == FORMAT_PVK) {
EVP_PKEY *pk;
pk = EVP_PKEY_new();
EVP_PKEY_set1_DSA(pk, dsa);
if (dsa_config.outformat == FORMAT_PVK)
i = i2b_PVK_bio(out, pk, dsa_config.pvk_encr, 0,
passout);
else if (dsa_config.pubin || dsa_config.pubout)
i = i2b_PublicKey_bio(out, pk);
else
i = i2b_PrivateKey_bio(out, pk);
EVP_PKEY_free(pk);
#endif
} else {
BIO_printf(bio_err, "bad output format specified for outfile\n");
goto end;
}
if (i <= 0) {
BIO_printf(bio_err, "unable to write private key\n");
ERR_print_errors(bio_err);
} else
ret = 0;
end:
BIO_free(in);
BIO_free_all(out);
DSA_free(dsa);
free(passin);
free(passout);
return (ret);
}
int main (int argc, char *argv[])
{
struct parameters params;
lists_t_strs *deferred_overrides;
lists_t_strs *args;
#ifdef HAVE_UNAME_SYSCALL
int rc;
struct utsname uts;
#endif
#ifdef PACKAGE_REVISION
logit ("This is Music On Console (revision %s)", PACKAGE_REVISION);
#else
logit ("This is Music On Console (version %s)", PACKAGE_VERSION);
#endif
#ifdef CONFIGURATION
logit ("Configured:%s", CONFIGURATION);
#endif
#ifdef HAVE_UNAME_SYSCALL
rc = uname (&uts);
if (rc == 0)
logit ("Running on: %s %s %s", uts.sysname, uts.release, uts.machine);
#endif
log_command_line (argc, argv);
files_init ();
if (get_home () == NULL)
fatal ("Could not determine user's home directory!");
memset (¶ms, 0, sizeof(params));
options_init ();
deferred_overrides = lists_strs_new (4);
/* set locale according to the environment variables */
if (!setlocale(LC_ALL, ""))
logit ("Could not set locale!");
args = process_command_line (argc, argv, ¶ms, deferred_overrides);
if (params.dont_run_iface && params.only_server)
fatal ("-c, -a and -p options can't be used with --server!");
if (!params.config_file)
params.config_file = xstrdup (create_file_name ("config"));
options_parse (params.config_file);
if (params.config_file)
free (params.config_file);
params.config_file = NULL;
process_deferred_overrides (deferred_overrides);
lists_strs_free (deferred_overrides);
deferred_overrides = NULL;
check_moc_dir ();
io_init ();
rcc_init ();
decoder_init (params.debug);
srand (time(NULL));
if (!params.only_server && params.dont_run_iface)
server_command (¶ms, args);
else
start_moc (¶ms, args);
lists_strs_free (args);
options_free ();
decoder_cleanup ();
io_cleanup ();
rcc_cleanup ();
files_cleanup ();
compat_cleanup ();
exit (EXIT_SUCCESS);
}
int main(int argc, char **argv) {
// memtrack();
wiringXLog = _lognone;
log_file_disable();
log_shell_enable();
log_level_set(LOG_NOTICE);
if(!(progname = MALLOC(13))) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(progname, "pilight-send");
struct options_t *options = NULL;
struct ssdp_list_t *ssdp_list = NULL;
int sockfd = 0;
char *args = NULL, *recvBuff = NULL;
/* Hold the name of the protocol */
char *protobuffer = NULL;
/* Does this protocol exists */
int match = 0;
/* Do we need to print the help */
int help = 0;
/* Do we need to print the version */
int version = 0;
/* Do we need to print the protocol help */
int protohelp = 0;
char *uuid = NULL;
char *server = NULL;
unsigned short port = 0;
/* Hold the final protocol struct */
protocol_t *protocol = NULL;
JsonNode *code = NULL;
/* Define all CLI arguments of this program */
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, 'p', "protocol", OPTION_HAS_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, 'U', "uuid", OPTION_HAS_VALUE, 0, JSON_NULL, NULL, "[a-zA-Z0-9]{4}-[a-zA-Z0-9]{2}-[a-zA-Z0-9]{2}-[a-zA-Z0-9]{2}-[a-zA-Z0-9]{6}");
/* Get the protocol to be used */
while(1) {
int c;
c = options_parse(&options, argc, argv, 0, &args);
if(c == -1)
break;
if(c == -2)
c = 'H';
switch(c) {
case 'p':
if(strlen(args) == 0) {
logprintf(LOG_ERR, "options '-p' and '--protocol' require an argument");
exit(EXIT_FAILURE);
} else {
if(!(protobuffer = REALLOC(protobuffer, strlen(args)+1))) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(protobuffer, args);
}
break;
case 'V':
version = 1;
break;
case 'H':
help = 1;
break;
case 'S':
if(!(server = REALLOC(server, strlen(args)+1))) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(server, args);
break;
case 'P':
port = (unsigned short)atoi(args);
break;
case 'U':
if(!(uuid = REALLOC(uuid, strlen(args)+1))) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(uuid, args);
break;
default:;
}
}
/* Initialize protocols */
protocol_init();
/* Check if a protocol was given */
if(protobuffer && strlen(protobuffer) > 0 && strcmp(protobuffer, "-V") != 0) {
if(strlen(protobuffer) > 0 && version) {
printf("-p and -V cannot be combined\n");
} else {
struct protocols_t *pnode = protocols;
/* Retrieve the used protocol */
while(pnode) {
/* Check if the protocol exists */
protocol = pnode->listener;
if(protocol_device_exists(protocol, protobuffer) == 0 && match == 0 && protocol->createCode != NULL) {
match=1;
/* Check if the protocol requires specific CLI arguments
and merge them with the main CLI arguments */
if(protocol->options && help == 0) {
options_merge(&options, &protocol->options);
} else if(help == 1) {
protohelp=1;
}
break;
}
pnode = pnode->next;
}
/* If no protocols matches the requested protocol */
if(!match) {
logprintf(LOG_ERR, "this protocol is not supported or doesn't support sending");
}
}
}
/* 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, 2, &args);
if(c == -1)
break;
if(c == -2) {
if(match == 1) {
protohelp = 1;
} else {
help = 1;
}
break;
}
}
/* Display help or version information */
if(version == 1) {
printf("%s %s\n", progname, PILIGHT_VERSION);
goto close;
} else if(help == 1 || protohelp == 1 || match == 0) {
if(protohelp == 1 && match == 1 && protocol->printHelp)
printf("Usage: %s -p %s [options]\n", progname, protobuffer);
else
printf("Usage: %s -p protocol [options]\n", progname);
if(help == 1) {
printf("\t -H --help\t\t\tdisplay this message\n");
printf("\t -V --version\t\t\tdisplay version\n");
printf("\t -p --protocol=protocol\t\tthe protocol that you want to control\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 -C --config\t\t\tconfig file\n");
printf("\t -U --uuid=xxx-xx-xx-xx-xxxxxx\tUUID\n");
}
if(protohelp == 1 && match == 1 && protocol->printHelp) {
printf("\n\t[%s]\n", protobuffer);
protocol->printHelp();
} else {
printf("\nThe supported protocols are:\n");
struct protocols_t *pnode = protocols;
/* Retrieve the used protocol */
while(pnode) {
protocol = pnode->listener;
if(protocol->createCode) {
struct protocol_devices_t *tmpdev = protocol->devices;
while(tmpdev) {
struct pname_t *node = MALLOC(sizeof(struct pname_t));
if(!node) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
if(!(node->name = MALLOC(strlen(tmpdev->id)+1))) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(node->name, tmpdev->id);
if(!(node->desc = MALLOC(strlen(tmpdev->desc)+1))) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(node->desc, tmpdev->desc);
node->next = pname;
pname = node;
tmpdev = tmpdev->next;
}
}
pnode = pnode->next;
}
sort_list();
struct pname_t *ptmp = NULL;
while(pname) {
ptmp = pname;
printf("\t %s\t\t",ptmp->name);
if(strlen(ptmp->name) < 7)
printf("\t");
if(strlen(ptmp->name) < 15)
printf("\t");
printf("%s\n", ptmp->desc);
FREE(ptmp->name);
FREE(ptmp->desc);
pname = pname->next;
FREE(ptmp);
}
FREE(pname);
}
goto close;
}
code = json_mkobject();
int itmp = 0;
/* Check if we got sufficient arguments from this protocol */
struct options_t *tmp = options;
while(tmp) {
if(strlen(tmp->name) > 0) {
/* Only send the CLI arguments that belong to this protocol, the protocol name
and those that are called by the user */
if((options_get_id(&protocol->options, tmp->name, &itmp) == 0)
&& tmp->vartype == JSON_STRING && tmp->string_ != NULL
&& (strlen(tmp->string_) > 0)) {
if(isNumeric(tmp->string_) == 0) {
char *ptr = strstr(tmp->string_, ".");
int decimals = 0;
if(ptr != NULL) {
decimals = (int)(strlen(tmp->string_)-((size_t)(ptr-tmp->string_)+1));
}
json_append_member(code, tmp->name, json_mknumber(atof(tmp->string_), decimals));
} else {
json_append_member(code, tmp->name, json_mkstring(tmp->string_));
}
}
if(strcmp(tmp->name, "protocol") == 0 && strlen(tmp->string_) > 0) {
JsonNode *jprotocol = json_mkarray();
json_append_element(jprotocol, json_mkstring(tmp->string_));
json_append_member(code, "protocol", jprotocol);
}
}
tmp = tmp->next;
}
if(protocol->createCode(code) == 0) {
if(protocol->message) {
json_delete(protocol->message);
}
if(server && port > 0) {
if((sockfd = socket_connect(server, port)) == -1) {
logprintf(LOG_ERR, "could not connect to pilight-daemon");
goto close;
}
} else if(ssdp_seek(&ssdp_list) == -1) {
logprintf(LOG_ERR, "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) {
ssdp_free(ssdp_list);
}
socket_write(sockfd, "{\"action\":\"identify\"}");
if(socket_read(sockfd, &recvBuff, 0) != 0
|| strcmp(recvBuff, "{\"status\":\"success\"}") != 0) {
goto close;
}
JsonNode *json = json_mkobject();
json_append_member(json, "action", json_mkstring("send"));
if(uuid != NULL) {
json_append_member(code, "uuid", json_mkstring(uuid));
}
json_append_member(json, "code", code);
char *output = json_stringify(json, NULL);
socket_write(sockfd, output);
json_free(output);
json_delete(json);
if(socket_read(sockfd, &recvBuff, 0) != 0
|| strcmp(recvBuff, "{\"status\":\"success\"}") != 0) {
logprintf(LOG_ERR, "failed to send codes");
goto close;
}
}
close:
if(sockfd > 0) {
socket_close(sockfd);
}
if(recvBuff != NULL) {
FREE(recvBuff);
}
if(server != NULL) {
FREE(server);
}
if(protobuffer != NULL) {
FREE(protobuffer);
}
if(uuid != NULL) {
FREE(uuid);
}
log_shell_disable();
protocol_gc();
options_delete(options);
options_gc();
config_gc();
threads_gc();
dso_gc();
log_gc();
FREE(progname);
xfree();
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
log_file_disable();
log_shell_enable();
log_level_set(LOG_NOTICE);
progname = malloc(16);
strcpy(progname, "pilight-control");
struct options_t *options = NULL;
struct ssdp_list_t *ssdp_list = NULL;
int sockfd = 0;
char *recvBuff = NULL;
char *message = NULL;
char *pch = NULL;
steps_t steps = WELCOME;
char device[50];
char location[50];
char state[10] = {'\0'};
char values[255] = {'\0'};
struct conf_locations_t *slocation = NULL;
struct conf_devices_t *sdevice = NULL;
int has_values = 0;
char *server = NULL;
unsigned short port = 0;
JsonNode *json = NULL;
JsonNode *jconfig = NULL;
JsonNode *jcode = NULL;
JsonNode *jvalues = NULL;
/* Define all CLI arguments of this program */
options_add(&options, 'H', "help", no_value, 0, NULL);
options_add(&options, 'V', "version", no_value, 0, NULL);
options_add(&options, 'l', "location", has_value, 0, NULL);
options_add(&options, 'd', "device", has_value, 0, NULL);
options_add(&options, 's', "state", has_value, 0, NULL);
options_add(&options, 'v', "values", has_value, 0, NULL);
options_add(&options, 'S', "server", has_value, 0, "^(([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", has_value, 0, "[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, &optarg);
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 -l --location=location\t\tthe location in which the device resides\n");
printf("\t -d --device=device\t\tthe device that you want to control\n");
printf("\t -s --state=state\t\tthe new state of the device\n");
printf("\t -v --values=values\t\tspecific comma separated values, e.g.:\n");
printf("\t\t\t\t\t-v dimlevel=10\n");
exit(EXIT_SUCCESS);
break;
case 'V':
printf("%s %s\n", progname, VERSION);
exit(EXIT_SUCCESS);
break;
case 'l':
strcpy(location, optarg);
break;
case 'd':
strcpy(device, optarg);
break;
case 's':
strcpy(state, optarg);
break;
case 'v':
strcpy(values, optarg);
break;
case 'S':
server = realloc(server, strlen(optarg)+1);
strcpy(server, optarg);
break;
case 'P':
port = (unsigned short)atoi(optarg);
break;
default:
printf("Usage: %s -l location -d device -s state\n", progname);
exit(EXIT_SUCCESS);
break;
}
}
options_delete(options);
if(strlen(location) == 0 || strlen(device) == 0 || strlen(state) == 0) {
printf("Usage: %s -l location -d device -s state\n", progname);
exit(EXIT_SUCCESS);
}
if(server && port > 0) {
if((sockfd = socket_connect(server, port)) == -1) {
logprintf(LOG_ERR, "could not connect to pilight-daemon");
exit(EXIT_FAILURE);
}
} else if(ssdp_seek(&ssdp_list) == -1) {
logprintf(LOG_ERR, "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;
}
sfree((void *)&ssdp_list);
}
protocol_init();
while(1) {
if(steps > WELCOME) {
/* Clear the receive buffer again and read the welcome message */
if(steps == CONFIG) {
if((recvBuff = socket_read_big(sockfd)) != NULL) {
json = json_decode(recvBuff);
json_find_string(json, "message", &message);
} else {
goto close;
}
} else {
if((recvBuff = socket_read(sockfd)) != NULL) {
json = json_decode(recvBuff);
json_find_string(json, "message", &message);
} else {
goto close;
}
}
usleep(100);
}
switch(steps) {
case WELCOME:
socket_write(sockfd, "{\"message\":\"client controller\"}");
steps=IDENTIFY;
break;
case IDENTIFY:
if(strcmp(message, "accept client") == 0) {
steps=REQUEST;
}
if(strcmp(message, "reject client") == 0) {
steps=REJECT;
}
case REQUEST:
socket_write(sockfd, "{\"message\":\"request config\"}");
steps=CONFIG;
json_delete(json);
break;
case CONFIG:
if((jconfig = json_find_member(json, "config")) != NULL) {
config_parse(jconfig);
if(config_get_location(location, &slocation) == 0) {
if(config_get_device(location, device, &sdevice) == 0) {
JsonNode *joutput = json_mkobject();
jcode = json_mkobject();
jvalues = json_mkobject();
json_append_member(jcode, "location", json_mkstring(location));
json_append_member(jcode, "device", json_mkstring(device));
pch = strtok(values, ",=");
while(pch != NULL) {
char *name = strdup(pch);
pch = strtok(NULL, ",=");
if(pch == NULL) {
break;
} else {
char *val = strdup(pch);
if(pch != NULL) {
if(config_valid_value(location, device, name, val) == 0) {
if(isNumeric(val) == EXIT_SUCCESS) {
json_append_member(jvalues, name, json_mknumber(atoi(val)));
} else {
json_append_member(jvalues, name, json_mkstring(val));
}
has_values = 1;
} else {
logprintf(LOG_ERR, "\"%s\" is an invalid value for device \"%s\"", name, device);
goto close;
}
} else {
logprintf(LOG_ERR, "\"%s\" is an invalid value for device \"%s\"", name, device);
goto close;
}
pch = strtok(NULL, ",=");
if(pch == NULL) {
break;
}
}
}
if(config_valid_state(location, device, state) == 0) {
json_append_member(jcode, "state", json_mkstring(state));
} else {
logprintf(LOG_ERR, "\"%s\" is an invalid state for device \"%s\"", state, device);
goto close;
}
if(has_values == 1) {
json_append_member(jcode, "values", jvalues);
} else {
json_delete(jvalues);
}
json_append_member(joutput, "message", json_mkstring("send"));
json_append_member(joutput, "code", jcode);
char *output = json_stringify(joutput, NULL);
socket_write(sockfd, output);
sfree((void *)&output);
json_delete(joutput);
} else {
logprintf(LOG_ERR, "the device \"%s\" does not exist", device);
goto close;
}
} else {
logprintf(LOG_ERR, "the location \"%s\" does not exist", location);
goto close;
}
}
json_delete(json);
goto close;
break;
case REJECT:
default:
json_delete(json);
goto close;
break;
}
}
close:
if(sockfd > 0) {
socket_close(sockfd);
}
if(server) {
sfree((void *)&server);
}
log_shell_disable();
config_gc();
protocol_gc();
socket_gc();
options_gc();
log_gc();
sfree((void *)&progname);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
memcached_st *memc;
memcached_return rc;
memcached_server_st *servers;
options_parse(argc, argv);
memc= memcached_create(NULL);
process_hash_option(memc, opt_hash);
if (!opt_servers)
{
char *temp;
if ((temp= getenv("MEMCACHED_SERVERS")))
opt_servers= strdup(temp);
else
{
fprintf(stderr, "No Servers provided\n");
exit(1);
}
}
if (opt_servers)
servers= memcached_servers_parse(opt_servers);
else
servers= memcached_servers_parse(argv[--argc]);
memcached_server_push(memc, servers);
memcached_server_list_free(servers);
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL,
(uint64_t)opt_binary);
if (!initialize_sasl(memc, opt_username, opt_passwd))
{
memcached_free(memc);
return 1;
}
while (optind < argc)
{
struct stat sbuf;
int fd;
char *ptr;
ssize_t read_length;
char *file_buffer_ptr;
fd= open(argv[optind], O_RDONLY);
if (fd < 0)
{
fprintf(stderr, "memcp: %s: %s\n", argv[optind], strerror(errno));
optind++;
continue;
}
(void)fstat(fd, &sbuf);
ptr= rindex(argv[optind], '/');
if (ptr)
ptr++;
else
ptr= argv[optind];
if (opt_verbose)
{
static const char *opstr[] = { "set", "add", "replace" };
printf("op: %s\nsource file: %s\nlength: %zu\n"
"key: %s\nflags: %x\nexpires: %llu\n",
opstr[opt_method - OPT_SET], argv[optind], (size_t)sbuf.st_size,
ptr, opt_flags, (unsigned long long)opt_expires);
}
if ((file_buffer_ptr= (char *)malloc(sizeof(char) * (size_t)sbuf.st_size)) == NULL)
{
fprintf(stderr, "malloc: %s\n", strerror(errno));
exit(1);
}
if ((read_length= read(fd, file_buffer_ptr, (size_t)sbuf.st_size)) == -1)
{
fprintf(stderr, "read: %s\n", strerror(errno));
exit(1);
}
if (read_length != sbuf.st_size)
{
fprintf(stderr, "Failure reading from file\n");
exit(1);
}
if (opt_method == OPT_ADD)
rc= memcached_add(memc, ptr, strlen(ptr),
file_buffer_ptr, (size_t)sbuf.st_size,
opt_expires, opt_flags);
else if (opt_method == OPT_REPLACE)
rc= memcached_replace(memc, ptr, strlen(ptr),
file_buffer_ptr, (size_t)sbuf.st_size,
opt_expires, opt_flags);
else
rc= memcached_set(memc, ptr, strlen(ptr),
file_buffer_ptr, (size_t)sbuf.st_size,
opt_expires, opt_flags);
if (rc != MEMCACHED_SUCCESS)
{
fprintf(stderr, "memcp: %s: memcache error %s",
ptr, memcached_strerror(memc, rc));
if (memc->cached_errno)
fprintf(stderr, " system error %s", strerror(memc->cached_errno));
fprintf(stderr, "\n");
}
free(file_buffer_ptr);
close(fd);
optind++;
}
memcached_free(memc);
if (opt_servers)
free(opt_servers);
if (opt_hash)
free(opt_hash);
shutdown_sasl();
return 0;
}
int
rsa_main(int argc, char **argv)
{
int ret = 1;
RSA *rsa = NULL;
int i;
BIO *out = NULL;
char *passin = NULL, *passout = NULL;
if (single_execution) {
if (pledge("stdio rpath wpath cpath tty", NULL) == -1) {
perror("pledge");
exit(1);
}
}
memset(&rsa_config, 0, sizeof(rsa_config));
rsa_config.pvk_encr = 2;
rsa_config.informat = FORMAT_PEM;
rsa_config.outformat = FORMAT_PEM;
if (options_parse(argc, argv, rsa_options, NULL, NULL) != 0) {
rsa_usage();
goto end;
}
if (!app_passwd(bio_err, rsa_config.passargin, rsa_config.passargout,
&passin, &passout)) {
BIO_printf(bio_err, "Error getting passwords\n");
goto end;
}
if (rsa_config.check && rsa_config.pubin) {
BIO_printf(bio_err, "Only private keys can be checked\n");
goto end;
}
out = BIO_new(BIO_s_file());
{
EVP_PKEY *pkey;
if (rsa_config.pubin) {
int tmpformat = -1;
if (rsa_config.pubin == 2) {
if (rsa_config.informat == FORMAT_PEM)
tmpformat = FORMAT_PEMRSA;
else if (rsa_config.informat == FORMAT_ASN1)
tmpformat = FORMAT_ASN1RSA;
} else if (rsa_config.informat == FORMAT_NETSCAPE &&
rsa_config.sgckey)
tmpformat = FORMAT_IISSGC;
else
tmpformat = rsa_config.informat;
pkey = load_pubkey(bio_err, rsa_config.infile,
tmpformat, 1, passin, "Public Key");
} else
pkey = load_key(bio_err, rsa_config.infile,
(rsa_config.informat == FORMAT_NETSCAPE &&
rsa_config.sgckey ? FORMAT_IISSGC :
rsa_config.informat), 1, passin, "Private Key");
if (pkey != NULL)
rsa = EVP_PKEY_get1_RSA(pkey);
EVP_PKEY_free(pkey);
}
if (rsa == NULL) {
ERR_print_errors(bio_err);
goto end;
}
if (rsa_config.outfile == NULL) {
BIO_set_fp(out, stdout, BIO_NOCLOSE);
} else {
if (BIO_write_filename(out, rsa_config.outfile) <= 0) {
perror(rsa_config.outfile);
goto end;
}
}
if (rsa_config.text)
if (!RSA_print(out, rsa, 0)) {
perror(rsa_config.outfile);
ERR_print_errors(bio_err);
goto end;
}
if (rsa_config.modulus) {
BIO_printf(out, "Modulus=");
BN_print(out, rsa->n);
BIO_printf(out, "\n");
}
if (rsa_config.check) {
int r = RSA_check_key(rsa);
if (r == 1)
BIO_printf(out, "RSA key ok\n");
else if (r == 0) {
unsigned long err;
while ((err = ERR_peek_error()) != 0 &&
ERR_GET_LIB(err) == ERR_LIB_RSA &&
ERR_GET_FUNC(err) == RSA_F_RSA_CHECK_KEY &&
ERR_GET_REASON(err) != ERR_R_MALLOC_FAILURE) {
BIO_printf(out, "RSA key error: %s\n",
ERR_reason_error_string(err));
ERR_get_error(); /* remove e from error
* stack */
}
}
if (r == -1 || ERR_peek_error() != 0) { /* should happen only if
* r == -1 */
ERR_print_errors(bio_err);
goto end;
}
}
if (rsa_config.noout) {
ret = 0;
goto end;
}
BIO_printf(bio_err, "writing RSA key\n");
if (rsa_config.outformat == FORMAT_ASN1) {
if (rsa_config.pubout || rsa_config.pubin) {
if (rsa_config.pubout == 2)
i = i2d_RSAPublicKey_bio(out, rsa);
else
i = i2d_RSA_PUBKEY_bio(out, rsa);
} else
i = i2d_RSAPrivateKey_bio(out, rsa);
}
#ifndef OPENSSL_NO_RC4
else if (rsa_config.outformat == FORMAT_NETSCAPE) {
unsigned char *p, *pp;
int size;
i = 1;
size = i2d_RSA_NET(rsa, NULL, NULL, rsa_config.sgckey);
if ((p = malloc(size)) == NULL) {
BIO_printf(bio_err, "Memory allocation failure\n");
goto end;
}
pp = p;
i2d_RSA_NET(rsa, &p, NULL, rsa_config.sgckey);
BIO_write(out, (char *) pp, size);
free(pp);
}
#endif
else if (rsa_config.outformat == FORMAT_PEM) {
if (rsa_config.pubout || rsa_config.pubin) {
if (rsa_config.pubout == 2)
i = PEM_write_bio_RSAPublicKey(out, rsa);
else
i = PEM_write_bio_RSA_PUBKEY(out, rsa);
} else
i = PEM_write_bio_RSAPrivateKey(out, rsa,
rsa_config.enc, NULL, 0, NULL, passout);
#if !defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_RC4)
} else if (rsa_config.outformat == FORMAT_MSBLOB ||
rsa_config.outformat == FORMAT_PVK) {
EVP_PKEY *pk;
pk = EVP_PKEY_new();
EVP_PKEY_set1_RSA(pk, rsa);
if (rsa_config.outformat == FORMAT_PVK)
i = i2b_PVK_bio(out, pk, rsa_config.pvk_encr, 0,
passout);
else if (rsa_config.pubin || rsa_config.pubout)
i = i2b_PublicKey_bio(out, pk);
else
i = i2b_PrivateKey_bio(out, pk);
EVP_PKEY_free(pk);
#endif
} else {
BIO_printf(bio_err,
"bad output format specified for outfile\n");
goto end;
}
if (i <= 0) {
BIO_printf(bio_err, "unable to write key\n");
ERR_print_errors(bio_err);
} else
ret = 0;
end:
BIO_free_all(out);
RSA_free(rsa);
free(passin);
free(passout);
return (ret);
}
int
gendh_main(int argc, char **argv)
{
BN_GENCB cb;
DH *dh = NULL;
int ret = 1, numbits = DEFBITS;
BIO *out = NULL;
char *strbits = NULL;
if (single_execution) {
if (pledge("stdio cpath wpath rpath", NULL) == -1) {
perror("pledge");
exit(1);
}
}
BN_GENCB_set(&cb, dh_cb, bio_err);
memset(&gendh_config, 0, sizeof(gendh_config));
gendh_config.g = 2;
if (options_parse(argc, argv, gendh_options, &strbits, NULL) != 0) {
gendh_usage();
goto end;
}
if (strbits != NULL) {
const char *errstr;
numbits = strtonum(strbits, 0, INT_MAX, &errstr);
if (errstr) {
fprintf(stderr, "Invalid number of bits: %s\n", errstr);
goto end;
}
}
out = BIO_new(BIO_s_file());
if (out == NULL) {
ERR_print_errors(bio_err);
goto end;
}
if (gendh_config.outfile == NULL) {
BIO_set_fp(out, stdout, BIO_NOCLOSE);
} else {
if (BIO_write_filename(out, gendh_config.outfile) <= 0) {
perror(gendh_config.outfile);
goto end;
}
}
BIO_printf(bio_err, "Generating DH parameters, %d bit long safe prime,"
" generator %d\n", numbits, gendh_config.g);
BIO_printf(bio_err, "This is going to take a long time\n");
if (((dh = DH_new()) == NULL) ||
!DH_generate_parameters_ex(dh, numbits, gendh_config.g, &cb))
goto end;
if (!PEM_write_bio_DHparams(out, dh))
goto end;
ret = 0;
end:
if (ret != 0)
ERR_print_errors(bio_err);
if (out != NULL)
BIO_free_all(out);
if (dh != NULL)
DH_free(dh);
return (ret);
}
int main(int argc, char **argv) {
// memtrack();
atomicinit();
struct options_t *options = NULL;
struct ssdp_list_t *ssdp_list = NULL;
struct devices_t *dev = NULL;
struct JsonNode *json = NULL;
struct JsonNode *tmp = NULL;
char *recvBuff = NULL, *message = NULL, *output = NULL;
char *device = NULL, *state = NULL, *values = NULL;
char *server = NULL;
int has_values = 0, sockfd = 0, hasconfarg = 0;
unsigned short port = 0, showhelp = 0, showversion = 0;
log_file_disable();
log_shell_enable();
log_level_set(LOG_NOTICE);
#ifndef _WIN32
wiringXLog = logprintf;
#endif
if((progname = MALLOC(16)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(progname, "pilight-control");
/* Define all CLI arguments of this program */
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, 'd', "device", OPTION_HAS_VALUE, 0, JSON_NULL, NULL, NULL);
options_add(&options, 's', "state", OPTION_HAS_VALUE, 0, JSON_NULL, NULL, NULL);
options_add(&options, 'v', "values", OPTION_HAS_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, 'C', "config", OPTION_HAS_VALUE, 0, JSON_NULL, NULL, NULL);
/* 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, &optarg);
if(c == -1)
break;
if(c == -2) {
showhelp = 1;
break;
}
switch(c) {
case 'H':
showhelp = 1;
break;
case 'V':
showversion = 1;
break;
case 'd':
if((device = REALLOC(device, strlen(optarg)+1)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(device, optarg);
break;
case 's':
if((state = REALLOC(state, strlen(optarg)+1)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(state, optarg);
break;
case 'v':
if((values = REALLOC(values, strlen(optarg)+1)) == NULL) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(values, optarg);
break;
case 'C':
if(config_set_file(optarg) == EXIT_FAILURE) {
return EXIT_FAILURE;
}
hasconfarg = 1;
break;
case 'S':
if(!(server = REALLOC(server, strlen(optarg)+1))) {
fprintf(stderr, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(server, optarg);
break;
case 'P':
port = (unsigned short)atoi(optarg);
break;
default:
printf("Usage: %s -l location -d device -s state\n", progname);
goto close;
break;
}
}
options_delete(options);
if(showversion == 1) {
printf("%s v%s\n", progname, PILIGHT_VERSION);
goto close;
}
if(showhelp == 1) {
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 -C --config\t\t\tconfig file\n");
printf("\t -P --port=xxxx\t\t\tconnect to server port\n");
printf("\t -d --device=device\t\tthe device that you want to control\n");
printf("\t -s --state=state\t\tthe new state of the device\n");
printf("\t -v --values=values\t\tspecific comma separated values, e.g.:\n");
printf("\t\t\t\t\t-v dimlevel=10\n");
goto close;
}
if(device == NULL || state == NULL ||
strlen(device) == 0 || strlen(state) == 0) {
printf("Usage: %s -d device -s state\n", progname);
goto close;
}
if(server && port > 0) {
if((sockfd = socket_connect(server, port)) == -1) {
logprintf(LOG_ERR, "could not connect to pilight-daemon");
goto close;
}
} 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) {
ssdp_free(ssdp_list);
}
protocol_init();
config_init();
if(hasconfarg == 1) {
if(config_read() != EXIT_SUCCESS) {
goto close;
}
}
socket_write(sockfd, "{\"action\":\"identify\"}");
if(socket_read(sockfd, &recvBuff, 0) != 0
|| strcmp(recvBuff, "{\"status\":\"success\"}") != 0) {
goto close;
}
json = json_mkobject();
json_append_member(json, "action", json_mkstring("request config"));
output = json_stringify(json, NULL);
socket_write(sockfd, output);
json_free(output);
json_delete(json);
if(socket_read(sockfd, &recvBuff, 0) == 0) {
if(json_validate(recvBuff) == true) {
json = json_decode(recvBuff);
if(json_find_string(json, "message", &message) == 0) {
if(strcmp(message, "config") == 0) {
struct JsonNode *jconfig = NULL;
if((jconfig = json_find_member(json, "config")) != NULL) {
int match = 1;
while(match) {
struct JsonNode *jchilds = json_first_child(jconfig);
match = 0;
while(jchilds) {
if(strcmp(jchilds->key, "devices") != 0) {
json_remove_from_parent(jchilds);
tmp = jchilds;
match = 1;
}
jchilds = jchilds->next;
if(tmp != NULL) {
json_delete(tmp);
}
tmp = NULL;
}
}
config_parse(jconfig);
if(devices_get(device, &dev) == 0) {
JsonNode *joutput = json_mkobject();
JsonNode *jcode = json_mkobject();
JsonNode *jvalues = json_mkobject();
json_append_member(jcode, "device", json_mkstring(device));
if(values != NULL) {
char **array = NULL;
unsigned int n = explode(values, ",=", &array), q = 0;
for(q=0;q<n;q+=2) {
char *name = MALLOC(strlen(array[q])+1);
if(name == NULL) {
logprintf(LOG_ERR, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(name, array[q]);
if(q+1 == n) {
array_free(&array, n);
logprintf(LOG_ERR, "\"%s\" is missing a value for device \"%s\"", name, device);
FREE(name);
break;
} else {
char *val = MALLOC(strlen(array[q+1])+1);
if(val == NULL) {
logprintf(LOG_ERR, "out of memory\n");
exit(EXIT_FAILURE);
}
strcpy(val, array[q+1]);
if(devices_valid_value(device, name, val) == 0) {
if(isNumeric(val) == EXIT_SUCCESS) {
json_append_member(jvalues, name, json_mknumber(atof(val), nrDecimals(val)));
} else {
json_append_member(jvalues, name, json_mkstring(val));
}
has_values = 1;
} else {
logprintf(LOG_ERR, "\"%s\" is an invalid value for device \"%s\"", name, device);
array_free(&array, n);
FREE(name);
json_delete(json);
goto close;
}
}
FREE(name);
}
array_free(&array, n);
}
if(devices_valid_state(device, state) == 0) {
json_append_member(jcode, "state", json_mkstring(state));
} else {
logprintf(LOG_ERR, "\"%s\" is an invalid state for device \"%s\"", state, device);
json_delete(json);
goto close;
}
if(has_values == 1) {
json_append_member(jcode, "values", jvalues);
} else {
json_delete(jvalues);
}
json_append_member(joutput, "action", json_mkstring("control"));
json_append_member(joutput, "code", jcode);
output = json_stringify(joutput, NULL);
socket_write(sockfd, output);
json_free(output);
json_delete(joutput);
if(socket_read(sockfd, &recvBuff, 0) != 0
|| strcmp(recvBuff, "{\"status\":\"success\"}") != 0) {
logprintf(LOG_ERR, "failed to control %s", device);
}
} else {
logprintf(LOG_ERR, "the device \"%s\" does not exist", device);
json_delete(json);
goto close;
}
}
}
}
json_delete(json);
}
}
close:
if(recvBuff) {
FREE(recvBuff);
}
if(sockfd > 0) {
socket_close(sockfd);
}
if(server != NULL) {
FREE(server);
}
if(device != NULL) {
FREE(device);
}
if(state != NULL) {
FREE(state);
}
if(values != NULL) {
FREE(values);
}
log_shell_disable();
socket_gc();
config_gc();
protocol_gc();
options_gc();
#ifdef EVENTS
events_gc();
#endif
dso_gc();
log_gc();
threads_gc();
gc_clear();
FREE(progname);
xfree();
#ifdef _WIN32
WSACleanup();
#endif
return EXIT_SUCCESS;
}
int
prime_main(int argc, char **argv)
{
BIGNUM *bn = NULL;
char *prime = NULL;
BIO *bio_out;
char *s;
int ret = 1;
if (single_execution) {
if (pledge("stdio rpath", NULL) == -1) {
perror("pledge");
exit(1);
}
}
memset(&prime_config, 0, sizeof(prime_config));
/* Default iterations for Miller-Rabin probabilistic primality test. */
prime_config.checks = 20;
if (options_parse(argc, argv, prime_options, &prime, NULL) != 0) {
prime_usage();
return (1);
}
if (prime == NULL && prime_config.generate == 0) {
BIO_printf(bio_err, "No prime specified.\n");
prime_usage();
return (1);
}
if ((bio_out = BIO_new(BIO_s_file())) == NULL) {
ERR_print_errors(bio_err);
return (1);
}
BIO_set_fp(bio_out, stdout, BIO_NOCLOSE);
if (prime_config.generate != 0) {
if (prime_config.bits == 0) {
BIO_printf(bio_err, "Specify the number of bits.\n");
goto end;
}
bn = BN_new();
if (!bn) {
BIO_printf(bio_err, "Out of memory.\n");
goto end;
}
if (!BN_generate_prime_ex(bn, prime_config.bits,
prime_config.safe, NULL, NULL, NULL)) {
BIO_printf(bio_err, "Prime generation error.\n");
goto end;
}
s = prime_config.hex ? BN_bn2hex(bn) : BN_bn2dec(bn);
if (s == NULL) {
BIO_printf(bio_err, "Out of memory.\n");
goto end;
}
BIO_printf(bio_out, "%s\n", s);
free(s);
} else {
if (prime_config.hex) {
if (!BN_hex2bn(&bn, prime)) {
BIO_printf(bio_err, "%s is an invalid hex "
"value.\n", prime);
goto end;
}
} else {
if (!BN_dec2bn(&bn, prime)) {
BIO_printf(bio_err, "%s is an invalid decimal "
"value.\n", prime);
goto end;
}
}
BIO_printf(bio_out, "%s is %sprime\n", prime,
BN_is_prime_ex(bn, prime_config.checks,
NULL, NULL) ? "" : "not ");
}
ret = 0;
end:
BN_free(bn);
BIO_free_all(bio_out);
return (ret);
}
