str mnstr_open_wastreamwrap(Stream *S, str *filename)
{
stream *s;
if ((s = open_wastream(*filename)) == NULL || mnstr_errnr(s)) {
int errnr = mnstr_errnr(s);
if (s)
mnstr_destroy(s);
throw(IO, "streams.open", "could not open file '%s': %s",
*filename, strerror(errnr));
} else {
*(stream**)S = s;
}
return MAL_SUCCEED;
}
char *
getConsoleInput(Client c, const char *prompt, int linemode, int exit_on_error)
{
char *line = NULL;
char *buf = NULL;
size_t length;
(void) exit_on_error;
(void) linemode;
do {
#ifdef HAVE_LIBREADLINE
if (prompt) {
if (buf)
free(buf);
buf = readline(prompt);
/* add a newline to the end since that makes
further processing easier */
if (buf) {
add_history(buf);
length = strlen(buf);
buf = realloc(buf, length + 2);
if( buf == NULL){
GDKerror("getConsoleInput: " MAL_MALLOC_FAIL);
return NULL;
}
buf[length++] = '\n';
buf[length] = 0;
}
line = buf;
} else
#endif
{
#ifndef HAVE_LIBREADLINE
if (prompt) {
fputs(prompt, stdout);
fflush(stdout);
}
#endif
if (buf == NULL) {
buf= malloc(BUFSIZ);
if( buf == NULL){
GDKerror("getConsoleInput: " MAL_MALLOC_FAIL);
return NULL;
}
}
line = fgets(buf, BUFSIZ, stdin);
}
if (line == NULL) {
/* end of file */
if (buf)
free(buf);
return NULL;
} else
length = strlen(line);
if (length > 0 ) {
/* test for special commands */
while (length > 0 &&
(*line & ~0x7F) == 0 &&
isspace((int) *line)) {
line++;
length--;
}
/* in the switch, use continue if the line was
processed, use break to send to parser */
switch (*line) {
case '\0':
/* empty line */
break;
case '\\':
switch (line[1]) {
case 'q':
free(buf);
return NULL;
default:
break;
}
line= NULL;
break;
case '<':
/* read commands from file */
if (line[length - 1] == '\n')
line[--length] = 0;
if (line[length - 1] == '\r')
line[--length] = 0;
/* doFile(mid, line + 1, 0);*/
line= NULL;
continue;
case '>':
/* redirect output to file */
line++;
length--;
if (line[length - 1] == '\n')
line[--length] = 0;
if (line[length - 1] == '\r')
line[--length] = 0;
if (c->fdout && c->fdout != GDKout && c->fdout != GDKerr){
close_stream(c->fdout);
c->fdout= 0;
}
if (length == 0 || strcmp(line, "stdout") == 0)
c->fdout = GDKout;
else if (strcmp(line, "stderr") == 0)
c->fdout = GDKerr;
else if ((c->fdout = open_wastream(line)) == NULL) {
c->fdout = GDKout;
mnstr_printf(GDKerr, "Cannot open %s\n", line);
}
line = NULL;
continue;
#ifdef HAVE_LIBREADLINE
case '!':
{ char *nl;
int i;
if(line[1]=='\n') {
for(i=0; i< history_length; i++){
nl= history_get(i)? history_get(i)->line:0;
if( nl)
mnstr_printf(c->fdout, "%d %s\n", i, nl);
}
line = NULL;
} else
if( history_expand(line,&nl) ==1 ) {
mnstr_printf(c->fdout,"#%s",nl);
line= nl;
} else line= NULL;
}
continue;
#endif
case '?':
if( line[1] && line[1]!='\n'){
showHelp( c->nspace,line+1, c->fdout);
} else
showCommands();
line= NULL;
continue;
}
/* make sure we return a pointer that can (and should) be freed by the caller */
if (line)
line = buf;
}
} while (line == NULL);
return line;
}
int main(int argc, char **argv)
{
MT_Id pid;
int i, j = 0;
char *err = NULL;
char name[MYBUFSIZ + 1];
char hostname[1024];
Sensor se = NULL;
static SOCKET sockfd;
static struct option long_options[18] = {
{ "increment", 0, 0, 'i' },
{ "batch", 1, 0, 'b' },
{ "columns", 1, 0, 'c' },
{ "client", 0, 0, 'c' },
{ "port", 1, 0, 'p' },
{ "protocol", 1, 0, 'p' },
{ "timestamp", 0, 0, 't' },
{ "time", 1, 0, 't' },
{ "events", 1, 0, 'e' },
{ "sensor", 1, 0, 's' },
{ "server", 0, 0, 's' },
{ "replay", 0, 0, 'r' },
{ "delay", 1, 0, 'd' },
{ "file", 1, 0, 'f' },
{ "host", 1, 0, 'h' },
{ "trace", 0, 0, 't' },
{ "help", 1, 0, '?' },
{ 0, 0, 0, 0 }
};
THRdata[0] = (void *) file_wastream(stdout, "stdout");
THRdata[1] = (void *) file_rastream(stdin, "stdin");
for (i = 0; i < THREADS; i++) {
GDKthreads[i].tid = i + 1;
}
for (;;) {
int option_index = 0;
int c = getopt_long(argc, argv, "i:b:c:c:p:p:t:t:e:s:s:r:d:f:h:t:?:0",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'b':
batchsize = optarg ? atol(optarg) : -1;
if (batchsize <= 0) {
mnstr_printf(SEout, "Illegal batch %d\n", batchsize);
exit(0);
}
break;
case 'c':
if (strcmp(long_options[option_index].name, "client") == 0) {
server = 0;
break;
}
columns = optarg ? atol(optarg) : -1;
if (columns <= 0) {
mnstr_printf(SEout, "Illegal columns %d\n", columns);
exit(0);
}
break;
case 'd':
delay = optarg ? atol(optarg) : -1;
if (delay < 0) {
mnstr_printf(SEout, "Illegal delay %d\n", delay);
exit(0);
}
break;
case 'i':
autoincrement = optarg ? atol(optarg) : 0;
if (autoincrement < 0) {
mnstr_printf(SEout, "Illegal increment %d\n", autoincrement);
exit(0);
}
break;
case 't':
if (strcmp(long_options[option_index].name, "timestamp") == 0) {
timestamp = 1;
break;
}
if (strcmp(long_options[option_index].name, "time") == 0) {
timecolumn = optarg ? atol(optarg) : 0;
break;
}
if (strcmp(long_options[option_index].name, "trace") == 0) {
trace = optarg ? atol(optarg) : 1;
} else {
usage();
exit(0);
}
break;
case 'f':
datafile = optarg && *optarg? optarg:0;
break;
case 'e':
if (strcmp(long_options[option_index].name, "events") == 0) {
events = optarg ? atol(optarg) : -1;
if (events < -1) {
mnstr_printf(SEout, "illegal events value, reset to -1\n");
events = -1;
} else if (events == 0) {
mnstr_printf(SEout, "Illegal events value %d\n", events);
exit(0);
}
break;
} else {
usage();
exit(0);
}
break;
case 'r':
replay= 1;
break;
case 's':
if (strcmp(long_options[option_index].name, "sensor") == 0) {
sensor = optarg;
break;
}
if (strcmp(long_options[option_index].name, "server") == 0) {
server = 1;
break;
} else {
usage();
exit(0);
}
break;
case 'p':
if (strcmp(long_options[option_index].name, "protocol") == 0) {
char *name= optarg? optarg: "xyz";
if (strcmp(name, "TCP") == 0 || strcmp(name, "tcp") == 0) {
protocol = TCP;
break;
}
if (strcmp(name, "UDP") == 0 || strcmp(name, "udp") == 0) {
protocol = UDP;
break;
}
if (strcmp(name, "CSV") == 0 || strcmp(name, "csv") == 0) {
protocol = CSV;
break;
}
if (strcmp(name, "debug") == 0) {
protocol = DEB;
break;
}
}
if (strcmp(long_options[option_index].name, "port") == 0) {
port = optarg ? atol(optarg) : -1;
#ifdef SENSOR_DEBUG
mnstr_printf(SEout, "#PORT : %d\n", port);
#endif
break;
} else {
usage();
exit(0);
}
break;
case 'h':
host = optarg;
break;
case '?':
default:
usage();
exit(0);
}
}
signal(SIGABRT, stopSend);
#ifdef SIGPIPE
signal(SIGPIPE, stopSend);
#endif
#ifdef SIGHUP
signal(SIGHUP, stopSend);
#endif
signal(SIGTERM, stopSend);
signal(SIGINT, stopSend);
/* display properties */
if (trace) {
mnstr_printf(SEout, "--host=%s\n", host);
mnstr_printf(SEout, "--port=%d\n", port);
mnstr_printf(SEout, "--sensor=%s\n", sensor);
mnstr_printf(SEout, "--columns=%d\n", columns);
mnstr_printf(SEout, "--autoincrement=%d\n", autoincrement);
mnstr_printf(SEout, "--timestamp=%d\n", timestamp);
mnstr_printf(SEout, "--time=%d\n", timecolumn);
mnstr_printf(SEout, "--events=%d\n", events);
mnstr_printf(SEout, "--batch=%d\n", batchsize);
mnstr_printf(SEout, "--replay=%d\n", replay);
mnstr_printf(SEout, "--delay=%d\n", delay);
mnstr_printf(SEout, "--protocol %s\n", protocolname[protocol]);
mnstr_printf(SEout, "--trace=%d\n", trace);
mnstr_printf(SEout, "--server=%d\n", server);
mnstr_printf(SEout, "--client=%d\n", server);
if (datafile)
mnstr_printf(SEout, "--input=%s\n", datafile);
}
estimateOverhead();
strncpy(hostname, host, 1024);
if (strcmp(host, "localhost") == 0)
gethostname(hostname, 1024);
host = hostname;
/*
* We limit the protocols for the time being to what can be
* considered a safe method.
*/
if (protocol == DEB) {
/* save event stream in a file */
Sensor se = SEnew(sensor);
if (events == -1 || batchsize != 1) {
printf("Provide an event limit using --events=<nr> and --batch=1\n");
return 0;
}
if (datafile)
se->toServer = open_wastream(datafile);
else
se->toServer = file_wastream(stdout, "stdout");
produceStream(se);
}
if (protocol == UDP) {
Sensor se = SEnew(sensor);
se->toServer = udp_wastream(host, port, sensor);
if (se->toServer == NULL) {
perror("Sensor: Could not open stream");
mnstr_printf(SEout, "#stream %s.%d.%s\n", host, port, sensor);
return 0;
}
produceStream(se);
}
if (protocol == TCP) {
if (server && (err = socket_server_connect(&sockfd, port))) {
mnstr_printf(SEout, "#SENSOR:start server:%s\n", err);
return 0;
}
do {
int createThread = 0;
snprintf(name, MYBUFSIZ - (strlen(sensor) + sizeof(j)), "%s%d", sensor, j++);
se = SEnew(name);
name[0] = 0;
err = NULL;
if (server) {
#ifdef SENSOR_DEBUG
mnstr_printf(SEout, "#listen %s as server is %d \n", se->name, server);
#endif
err = socket_server_listen(sockfd, &(se->newsockfd));
if (err) {
mnstr_printf(SEout, "#SENSOR:server listen:%s\n", err);
break;
}
} else {
#ifdef SENSOR_DEBUG
mnstr_printf(SEout, "#%s is client \n", se->name);
#endif
err = socket_client_connect(&(se->newsockfd), host, port);
if (err) {
mnstr_printf(SEout, "#SENSOR:client start:%s\n", err);
break;
}
}
se->toServer = socket_wastream(se->newsockfd, se->name);
if (se->toServer == NULL) {
perror("Sensor: Could not open stream");
mnstr_printf(SEout, "#stream %s.%d.%s\n", host, port, sensor);
socket_close(se->newsockfd);
return 0;
}
if (server) {
createThread = MT_create_thread(&pid, (void (*)(void *))produceServerStream, se, MT_THR_DETACHED);
#ifdef SENSOR_DEBUG
if (createThread)
mnstr_printf(SEout, "#Create thread is : %d \n", createThread);
#else
(void) createThread;
#endif
} else { /* client part */
produceServerStream(se);
}
} while (server);
if (server)
socket_close(sockfd);
if (se)
shutdown(se->newsockfd, SHUT_RDWR);
}
return 0;
}
