int main(int argc, char **argv)
{
if(argc < 2) {
fprintf(stderr, "usage: %s 'script.k'\n", argv[0]);
return 1;
}
memcached_st *mc = memcached_create(NULL);
memcached_server_list_st servers;
memcached_return_t rc;
servers = memcached_server_list_append(NULL, "127.0.0.1", 11211, &rc);
if(rc != MEMCACHED_SUCCESS) {
fprintf(stderr, "memcached_server_list_append failed\n");
}
rc = memcached_server_Push(mc, servers);
memcached_server_list_Free(servers);
logpool_t *logpool = logpool_open_client(NULL, "0.0.0.0", 14801);
size_t script_len;
char *script = loadFile(argv[1], &script_len);
memcached_set(mc, "dump_Init", strlen("dump_Init"), script, script_len, 0, 0);
logpool_procedure(logpool, "dump", strlen("dump"));
struct Log *logbuf = alloca(sizeof(struct Log) + 256);
while(1) {
if(logpool_client_get(logpool, logbuf, 256) == NULL) {
break;
}
log_dump(stderr, "log=(", logbuf, ")\n", 1);
usleep(1);
}
logpool_close(logpool);
free(script);
return 0;
}
static void match_link_dump_item(link_item_t *link, match_link_dump_t *desc)
{
if ( ! link_txt_attached(&(link->src.txt), desc->id) )
return;
(desc->count)++;
/* Update link time stamp */
link->tstamp = desc->tstamp;
/* Send message to attached link subprocess */
if ( link->fd_out != -1 ) {
write(link->fd_out, desc->str, desc->len);
}
/* No attached link : display message directly */
else {
log_dump(log_hdr(link->tstamp, link->name), desc->str);
}
}
void fatal_error(const char* file, unsigned line, const char* fmt, ...)
{
va_list ap;
fprintf(stderr, "%s:%d: error: ", file, line);
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, "\n");
if (avail_)
{
fprintf(stderr, "context:\n");
log_dump();
}
exit(1);
}
static void server_read_callback(struct bufferevent *bev, void *ctx)
{
struct range_stream *cs = (struct range_stream *) ctx;
struct io *io = cs->io;
debug_print(0, "read_cb bev=%p", bev);
while (!range_stream_empty(cs)) {
int log_size;
struct Log *log = range_stream_get(cs, &log_size);
if (log == NULL) {
break;
}
char *data = log_get_data((struct Log *) log);
debug_print(0, "%d %d %s", log->protocol, log->logsize, data);
switch (log_data_protocol(log)) {
case LOGPOOL_EVENT_READ:
debug_print(1, "R %d %d, '%s'", log->klen, log->vlen, data);
pool_add((struct Procedure*) log, bev, io->pool);
break;
case LOGPOOL_EVENT_WRITE:
#if LOGPOOL_DEBUG >= 1
log_dump(stderr, "W ", (struct Log *) log, "\n", 0);
#endif
pool_exec((struct Log *) log, log_size, io->pool);
break;
case LOGPOOL_EVENT_QUIT:
debug_print(1, "Q %d, %d\n", log->klen, log->vlen);
pool_delete_connection(io->pool, bev);
bufferevent_free(bev);
goto L_exit;
case LOGPOOL_EVENT_NULL:
default:
/*TODO*/abort();
break;
}
}
L_exit:;
return;
}
int main(int argc, char **argv)
{
if(argc < 2) {
fprintf(stderr, "usage: %s 'compiled-llvm-bitcode'\n", argv[0]);
return 1;
}
llcache_t *llmc = llcache_new("0.0.0.0", 11211);
logpool_t *logpool = logpool_open_client(NULL, "0.0.0.0", 14801);
llcache_set(llmc, "tid_usage_init", argv[1]);
logpool_procedure(logpool, "tid_usage", strlen("tid_usage"));
struct Log *logbuf = alloca(sizeof(struct Log) + 256);
while(1) {
if(logpool_client_get(logpool, logbuf, 256) == NULL) {
break;
}
log_dump(stderr, "log=(", logbuf, ")\n", 1);
usleep(1);
}
logpool_close(logpool);
llcache_delete(llmc);
return 0;
}
int main(int argc, char **argv)
{
logpool_t *logpool;
logpool = logpool_open_client(NULL, "0.0.0.0", 14801);
if(argc < 2) {
fprintf(stderr, "usage: %s key value key value ...\n", argv[0]);
goto L_error;
}
logpool_procedure(logpool, argv[1], strlen(argv[1]));
struct Log *logbuf = alloca(sizeof(struct Log) + 256);
while(1) {
logpool_client_get(logpool, logbuf, 256);
log_dump(stdout, "log=(", logbuf, ")\n", 1);
usleep(1);
}
logpool_close(logpool);
return 0;
L_error:;
logpool_close(logpool);
return 1;
}
u08 cmd_parse(u08 len, const char *cmd)
{
u08 status;
switch(cmd[0]) {
// ----- v) version -----
case 'v':
uart_send_string("plip2slip " VERSION);
uart_send_crlf();
return SER_PARSE_CMD_OK;
// ----- x) exit -----
case 'x':
return SER_PARSE_CMD_EXIT;
// ----- s) stats -----
case 's':
if(len==1) {
// show stats
stats_dump();
return SER_PARSE_CMD_OK;
} else {
switch(cmd[1]) {
case 'r': // stats reset
stats_reset();
return SER_PARSE_CMD_OK;
default:
return SER_PARSE_CMD_UNKNOWN;
}
}
// ----- b) bench -----
case 'b':
bench_dump();
return SER_PARSE_CMD_OK;
// ----- p) param -----
case 'p':
if(len==1) {
// show params
param_dump();
return SER_PARSE_CMD_OK;
} else {
switch(cmd[1]) {
case 's': // param save
status = param_save();
return (status == PARAM_OK) ? SER_PARSE_CMD_OK : SER_PARSE_CMD_FAIL;
case 'l': // param load
status = param_load();
return (status == PARAM_OK) ? SER_PARSE_CMD_OK : SER_PARSE_CMD_FAIL;
case 'r': // param reset
param_reset();
return SER_PARSE_CMD_OK;
default:
return SER_PARSE_CMD_UNKNOWN;
}
}
return SER_PARSE_CMD_UNKNOWN;
// ----- m) mode -----
case 'm':
if(len==2) {
u08 value;
status = parse_nybble(cmd[1],&value);
if(!status || (value >= PARAM_MODE_TOTAL_NUMBER)) {
return SER_PARSE_CMD_FAIL;
}
param.mode = value;
return SER_PARSE_CMD_OK;
}
return SER_PARSE_CMD_UNKNOWN;
// ----- f) fake_tx -----
case 'f':
if(len==2) {
u08 value;
status = parse_nybble(cmd[1],&value);
if(!status) {
return SER_PARSE_CMD_FAIL;
}
param.fake_tx = value ? 1 : 0;
return SER_PARSE_CMD_OK;
}
return SER_PARSE_CMD_UNKNOWN;
// ----- l) log -----
case 'l':
if(len==1) {
// show log
log_dump();
return SER_PARSE_CMD_OK;
} else {
switch(cmd[1]) {
case 'r': // reset log
log_init();
return SER_PARSE_CMD_OK;
default:
return SER_PARSE_CMD_UNKNOWN;
}
}
return SER_PARSE_CMD_UNKNOWN;
// ----- e) error sim -----
case 'e':
if(len==2) {
u08 value;
status = parse_nybble(cmd[1],&value);
if(!status) {
return SER_PARSE_CMD_FAIL;
}
for(u08 i=0;i<value;i++) {
error_add();
}
return SER_PARSE_CMD_OK;
} else {
error_add();
}
return SER_PARSE_CMD_OK;
// unknown command
default:
return SER_PARSE_CMD_UNKNOWN;
}
}
void cmd_parser(unsigned long data)
{
char *curr_pos = &user_string[0];
int ret;
while(1) {
while(cmd_in_progress)
os_TaskDelay(10);
DBG_P(( DBG_L0 "\r\n> "));
cmd_parser_read_line();
if(strlen(user_string) == 0) {
/* Do Nothing. */
}
else if(!memcmp(user_string,"iwlist",6)){
userif_prepare_scan_cmd(0);
}
else if(!memcmp(user_string,"iwconf",6)){
curr_pos = &user_string[get_next_word(user_string)];
if(!memcmp(curr_pos,"essid",5)) {
curr_pos = &curr_pos[get_next_word(curr_pos)];
specificSSID.Len = strlen(curr_pos);
memcpy((void *)specificSSID.SsId, curr_pos, strlen(curr_pos));
if(link_present) {
if(currbss_type != BSS_INDEPENDENT)
userif_prepare_deauth_cmd();
else
userif_prepare_adhoc_stop_cmd();
} else {
userif_prepare_scan_cmd(1);
}
link_present = 0;
} else if (!memcmp(curr_pos,"mode",4)) {
curr_pos = &curr_pos[get_next_word(curr_pos)];
if(!memcmp(curr_pos,"ad-hoc",6)) {
bss_type = BSS_INDEPENDENT;
} else if(!memcmp(curr_pos,"manage",6)) {
bss_type = BSS_INFRASTRUCTURE;
} else {
bss_type = BSS_ANY;
}
} else if (!memcmp(curr_pos,"ap",2)) {
curr_pos = &curr_pos[get_next_word(curr_pos)];
get_macaddr(curr_pos,(char *)specificBSSID);
if (FindBSSIDinList()) {
userif_prepare_auth_cmd();
} else {
if(link_present) {
link_present = 0;
userif_prepare_deauth_cmd();
} else {
userif_prepare_scan_cmd(2);
}
}
}
}
else if(!memcmp(user_string,"econfi",6)){
unsigned int ip;
unsigned int nm;
unsigned int gw;
curr_pos = &user_string[get_next_word(user_string)];
get_ipaddr(curr_pos, (char *)&ip);
curr_pos = &curr_pos[get_next_word(curr_pos)];
get_ipaddr(curr_pos, (char *)&nm);
curr_pos = &curr_pos[get_next_word(curr_pos)];
get_ipaddr(curr_pos, (char *)&gw);
sys_tcpip_init(ip, nm);
}
else if(!memcmp(user_string, "printip", 7)){
DBG_P(( DBG_L0 "%d.%d.%d.%d,", ip_addr[0], ip_addr[1], ip_addr[2],
ip_addr[3] ));
DBG_P(( DBG_L0 "%d.%d.%d.%d,", net_mask[0], net_mask[1],
net_mask[2], net_mask[3] ));
DBG_P(( DBG_L0 "%d.%d.%d.%d\r\n", def_gtwy[0], def_gtwy[1],
def_gtwy[2], def_gtwy[3] ));
}
else if(!memcmp(user_string, "printmac", 8)){
char mac[6];
GetMACAddr(NULL, mac);
DBG_P(( DBG_L0 "%02x:%02x:%02x:%02x:%02x:%02x\r\n", \
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]));
}
else if(!memcmp(user_string,"ping",4)){
curr_pos = &user_string[get_next_word(user_string)];
if(!memcmp(curr_pos,"stop",4)) {
send_ping = 0;
} else {
get_ipaddr(curr_pos, ping_ipaddr);
#ifdef EMBEDDED_TCPIP
userif_prepare_open_raw_socket();
#else
userif_prepare_macaddr_get_cmd();
#endif
send_ping = 1;
}
}
/* Link-local address manager. */
else if(!memcmp(user_string, "linklocal", 9)) {
curr_pos = &user_string[get_next_word(user_string)];
if(!memcmp(curr_pos, "start", 5)) {
/* Launch the link local manager */
ret = ll_init();
if(ret)
DBG_P(( DBG_L0 "Error launching link local: %d.\r\n", ret));
} else if(!memcmp(curr_pos, "stop", 4)) {
/* Kill the link local manager. */
ret = ll_shutdown();
if(ret)
DBG_P(( DBG_L0 "Error killing link local: %d.\r\n", ret));
}
}
/* mDNS responder */
else if(!memcmp(user_string, "mdns", 4)) {
curr_pos = &user_string[get_next_word(user_string)];
if(!memcmp(curr_pos, "start", 5)) {
/* launch the mDNS responder */
ret = mdns_responder_init();
if(ret)
DBG_P(( DBG_L0 "Error launching mDNS responder: %d.\r\n",ret));
}
else if(!memcmp(curr_pos, "stop", 4)) {
/* stop the mDNS responder */
ret = mdns_responder_shutdown();
if(ret)
DBG_P(( DBG_L0 "Error stopping mDNS responder: %d.\r\n", ret));
}
}
else if(!memcmp(user_string, "mcast", 5 )){
curr_pos = &user_string[get_next_word(user_string)];
if(!memcmp(curr_pos, "get", 3 )) {
userif_prepare_mcast_cmd();
}
else if(!memcmp(curr_pos, "set", 3 )) {
userif_prepare_mcast_add_cmd();
}
}
/* httpd interface */
else if(!memcmp(user_string, "httpd", 5)) {
curr_pos = &user_string[get_next_word(user_string)];
if(!memcmp(curr_pos, "start", 5)) {
ret = httpd_init();
if(ret)
DBG_P(( DBG_L0 "Error launching httpd: %d.\r\n",ret));
}
else if(!memcmp(curr_pos, "stop", 4)) {
ret = httpd_shutdown();
if(ret)
DBG_P(( DBG_L0 "Error stopping httpd: %d.\r\n", ret));
}
else {
DBG_P(( DBG_L0 "No such httpd command: %s.\r\n", curr_pos));
}
}
/* log interface */
else if(!memcmp(user_string, "log", 3)) {
curr_pos = &user_string[get_next_word(user_string)];
if(!memcmp(curr_pos, "init", 5)) {
ret = log_init();
if(ret)
DBG_P(( DBG_L0 "Error launching logger: %d.\r\n",ret));
}
else if(!memcmp(curr_pos, "shutdown", 8)) {
ret = log_shutdown();
if(ret)
DBG_P(( DBG_L0 "Error stopping logger: %d.\r\n", ret));
}
else if(!memcmp(curr_pos, "dump", 4)) {
ret = log_dump();
if(ret)
DBG_P(( DBG_L0 "Error dumping log: %d.\r\n", ret));
}
else if(!memcmp(curr_pos, "purge", 5)) {
ret = log_purge();
if(ret)
DBG_P(( DBG_L0 "Error purging log: %d.\r\n", ret));
}
else if(!memcmp(curr_pos, "write", 5)) {
curr_pos = &curr_pos[get_next_word(curr_pos)];
ret = log(curr_pos);
if(ret)
DBG_P(( DBG_L0 "Failed to write log: %d.\r\n", ret));
}
else {
DBG_P(( DBG_L0 "No such log command: %s.\r\n", curr_pos));
}
}
else if(!memcmp(user_string, "help", 4)) {
print_usage();
}
else {
#ifdef UART_DRV
DBG_P(( DBG_L0 "Unknown command.\r\n"));
#endif
}
}
}
