int main(int argc, char *argv[]){
char bf_ip[SIZE] = "", bf_rfcomm[SIZE] = "", bf_seial[SIZE] = "";
char buffer[20] = "";
int port_no = atoi(argv[1]);
uint32_t svc_uuid_int[] = {0x1101, 0x1000, 0x80000080 ,0x5f9b34fb};
FD_ZERO(&readfds);
printf("Program start up!\n");
// setup_serial(BAUD, DEVICE_ARDUINO);
// setup_rfcomm(svc_uuid_int);
setup_ip(port_no);
fflush(stdin);
FD_SET(STDIN, &readfds);
fd_set readfds_temp;
while(1){
readfds_temp = readfds;
select(FD_SETSIZE, &readfds_temp, NULL, NULL, NULL);
// just for jumping out of loop through command
if (FD_ISSET(STDIN, &readfds_temp)){
scanf("%s", buffer);
if(strcmp(buffer, "end")==0){
break;
}
}
// if (FD_ISSET(fd_rfcomm_server, &readfds_temp)){
// accept_rfcomm();
// }
if (FD_ISSET(fd_ip_server, &readfds_temp)){
accept_ip();
}
//if all three connections are established, start reading
//ip or rfcomm writing should be before serial.
// if(fd_rfcomm > 0 && fd_serial > 0 && fd_ip > 0){
// if (FD_ISSET(fd_rfcomm, &readfds_temp)){
// read_rfcomm(bf_rfcomm);
// if(strcmp(bf_rfcomm, EXPLORE)==0)
// write_serial(bf_rfcomm);
// else if(strcmp(bf_rfcomm, RUN)==0)
// write_ip(bf_rfcomm);
// bzero(bf_rfcomm,sizeof(bf_rfcomm));
// }
// if (FD_ISSET(fd_serial, &readfds_temp)){
// read_serial(bf_seial);
// write_ip(bf_seial);
// bzero(bf_seial,sizeof(bf_seial));
// }
if (FD_ISSET(fd_ip, &readfds_temp)){
read_ip(bf_ip);
write_ip(bf_ip);
// write_serial(bf_ip);
bzero(bf_ip,sizeof(bf_ip));
}
}
// }
close_ip();
// close_rfcomm();
// close_serial();
printf("Programm terminating...\n");
}
/* read a dhcp option and add it to opt_list */
static int read_opt(char *line, void *arg)
{
struct option_set **opt_list = arg;
char *opt, *val, *endptr;
struct dhcp_option *option = NULL;
int retval = 0, length = 0;
char buffer[255];
u_int16_t result_u16;
u_int32_t result_u32;
int i;
if (!(opt = strtok(line, " \t="))) return 0;
for (i = 0; options[i].code; i++)
if (!strcmp(options[i].name, opt))
option = &(options[i]);
if (!option) return 0;
do {
val = strtok(NULL, ", \t");
if (val) {
length = option_lengths[option->flags & TYPE_MASK];
retval = 0;
switch (option->flags & TYPE_MASK) {
case OPTION_IP:
retval = read_ip(val, buffer);
break;
case OPTION_IP_PAIR:
retval = read_ip(val, buffer);
if (!(val = strtok(NULL, ", \t/-"))) retval = 0;
if (retval) retval = read_ip(val, buffer + 4);
break;
case OPTION_STRING:
length = strlen(val);
if (length > 0) {
if (length > 254) length = 254;
memcpy(buffer, val, length);
retval = 1;
}
break;
case OPTION_BOOLEAN:
retval = read_yn(val, buffer);
break;
case OPTION_U8:
buffer[0] = strtoul(val, &endptr, 0);
retval = (endptr[0] == '\0');
break;
case OPTION_U16:
result_u16 = htons(strtoul(val, &endptr, 0));
memcpy(buffer, &result_u16, 2);
retval = (endptr[0] == '\0');
break;
case OPTION_S16:
result_u16 = htons(strtol(val, &endptr, 0));
memcpy(buffer, &result_u16, 2);
retval = (endptr[0] == '\0');
break;
case OPTION_U32:
result_u32 = htonl(strtoul(val, &endptr, 0));
memcpy(buffer, &result_u32, 4);
retval = (endptr[0] == '\0');
break;
case OPTION_S32:
result_u32 = htonl(strtol(val, &endptr, 0));
memcpy(buffer, &result_u32, 4);
retval = (endptr[0] == '\0');
break;
default:
break;
}
if (retval)
attach_option(opt_list, option, buffer, length);
};
} while (val && retval && option->flags & OPTION_LIST);
return retval;
}
int args_read(int argc, char *argv[], s_gimx_params* params)
{
int ret = 0;
int c;
unsigned char controller = 0;
unsigned char input = 0;
struct option long_options[] =
{
/* These options set a flag. */
{"nograb", no_argument, ¶ms->grab, 0},
{"status", no_argument, ¶ms->status, 1},
{"subpos", no_argument, ¶ms->subpositions, 1},
{"force-updates", no_argument, ¶ms->force_updates, 1},
{"curses", no_argument, ¶ms->curses, 1},
{"window-events", no_argument, ¶ms->window_events, 1},
{"btstack", no_argument, ¶ms->btstack, 1},
/* These options don't set a flag. We distinguish them by their indices. */
{"bdaddr", required_argument, 0, 'b'},
{"config", required_argument, 0, 'c'},
{"dst", required_argument, 0, 'd'},
{"event", required_argument, 0, 'e'},
{"hci", required_argument, 0, 'h'},
{"help", no_argument, 0, 'm'},
{"keygen", required_argument, 0, 'k'},
{"log", required_argument, 0, 'l'},
{"port", required_argument, 0, 'p'},
{"refresh", required_argument, 0, 'r'},
{"src", required_argument, 0, 's'},
{"type", required_argument, 0, 't'},
{"version", no_argument, 0, 'v'},
{0, 0, 0, 0}
};
while (1)
{
/* getopt_long stores the option index here. */
int option_index = 0;
c = getopt_long (argc, argv, "b:c:d:e:h:k:l:p:r:s:t:vm", long_options, &option_index);
/* Detect the end of the options. */
if (c == -1)
break;
if(controller == MAX_CONTROLLERS)
{
printf(_("ignoring: -%c %s (max controllers reached)\n"), c, optarg);
continue;
}
switch (c)
{
case 0:
/* If this option set a flag, do nothing else now. */
if (long_options[option_index].flag != 0)
break;
printf(_("option %s"), long_options[option_index].name);
if (optarg)
printf(_(" with arg %s"), optarg);
printf("\n");
break;
case 'b':
adapter_get(controller)->atype = E_ADAPTER_TYPE_BLUETOOTH;
adapter_get(controller)->bdaddr_dst = optarg;
if(adapter_get(controller)->ctype == C_TYPE_NONE)
{
adapter_get(controller)->ctype = C_TYPE_SIXAXIS;
}
printf(_("controller #%d: option -b with value `%s'\n"), controller + 1, optarg);
++controller;
printf(_("now reading arguments for controller #%d\n"), controller + 1);
break;
case 'c':
params->config_file = optarg;
printf(_("global option -c with value `%s'\n"), optarg);
input = 1;
break;
case 'e':
{
char label[AXIS_NAME_MAX_SIZE];
int axis;
int value;
if(sscanf(optarg, "%"STR(AXIS_NAME_MAX_SIZE)"[^(](%d)", label, &value) != 2)
{
fprintf(stderr, _("Bad event format: %s\n"), optarg);
ret = -1;
}
else
{
// strip trailing spaces
char * end;
for (end = label + strlen(label) - 1; end > label && *end == ' '; --end) {}
*(end + 1) = '\0';
if((axis = controller_get_axis_index(label)) != -1)
{
printf(_("controller #%d: option -e with value `%s(%d)'\n"), controller + 1, label, value);
adapter_set_axis(controller, axis, value);
adapter_get(controller)->event = 1;
input = 1;
}
else
{
fprintf(stderr, _("Bad axis name for event: %s\n"), optarg);
ret = -1;
}
}
}
break;
case 'h':
adapter_get(controller)->dongle_index = atoi(optarg);
printf(_("controller #%d: option -h with value `%d'\n"), controller + 1, adapter_get(controller)->dongle_index);
break;
case 'd':
if(read_ip(optarg, &adapter_get(controller)->dst_ip,
&adapter_get(controller)->dst_port) < 0)
{
printf(_("Bad format for argument -d: '%s'\n"), optarg);
ret = -1;
}
else
{
adapter_get(controller)->atype = E_ADAPTER_TYPE_REMOTE_GIMX;
printf(_("controller #%d: option -d with value `%s'\n"), controller + 1, optarg);
++controller;
printf(_("now reading arguments for controller #%d\n"), controller + 1);
}
break;
case 'm':
usage();
exit(0);
break;
case 's':
if(read_ip(optarg, &adapter_get(controller)->src_ip,
&adapter_get(controller)->src_port) < 0)
{
printf(_("Bad format for argument -s: '%s'\n"), optarg);
ret = -1;
}
else
{
printf(_("controller #%d: option -s with value `%s'\n"), controller + 1, optarg);
input = 1;
params->network_input = 1;
}
break;
case 'k':
params->keygen = optarg;
printf(_("controller #%d: option -k with value `%s'\n"), controller + 1, optarg);
break;
case 'l':
if(params->logfilename == NULL)
{
if(!params->curses)
{
params->logfilename = optarg;
if(params->logfilename && strlen(params->logfilename))
{
char file_path[PATH_MAX];
snprintf(file_path, sizeof(file_path), "%s%s%s%s", params->homedir, GIMX_DIR, LOG_DIR, params->logfilename);
params->logfile = fopen(file_path, "w");
if(params->logfile != NULL)
{
dup2(fileno(params->logfile), fileno(stdout));
dup2(fileno(params->logfile), fileno(stderr));
}
else
{
printf(_("can't open log file (%s)\n"), file_path);
ret = -1;
}
}
printf(_("global option -l with value `%s'\n"), optarg);
}
else
{
printf(_("log file can't be used with curses\n"));
ret = -1;
}
}
else
{
printf(_("only one log file can be specified\n"));
ret = -1;
}
break;
case 'p':
if(adapter_get(controller)->atype == E_ADAPTER_TYPE_NONE)
{
// no adapter type specified => try to guess it from the port
if(strstr(optarg, DEV_HIDRAW) || !strstr(optarg, DEV_SERIAL))
{
adapter_get(controller)->atype = E_ADAPTER_TYPE_GPP;
}
else
{
adapter_get(controller)->atype = E_ADAPTER_TYPE_DIY_USB;
}
}
if(adapter_set_port(controller, optarg) < 0)
{
printf(_("port already used: `%s'\n"), optarg);
ret = -1;
}
else
{
printf(_("controller #%d: option -p with value `%s'\n"), controller + 1, optarg);
++controller;
printf(_("now reading arguments for controller #%d\n"), controller + 1);
}
break;
case 'r':
params->refresh_period = atof(optarg) * 1000;
if(params->refresh_period)
{
params->postpone_count = 3 * DEFAULT_REFRESH_PERIOD / params->refresh_period;
printf(_("global option -r with value `%s'\n"), optarg);
}
else
{
fprintf(stderr, "Bad refresh period: %s\n", optarg);
ret = -1;
}
break;
case 't':
printf(_("controller #%d: option -t with value `%s'\n"), controller + 1, optarg);
if (!strcmp(optarg, "GPP"))
{
adapter_get(controller)->atype = E_ADAPTER_TYPE_GPP;
}
else
{
adapter_get(controller)->ctype = controller_get_type(optarg);
if (adapter_get(controller)->ctype == C_TYPE_NONE)
{
fprintf(stderr, "Bad controller type: %s\n", optarg);
ret = -1;
}
}
break;
case 'v':
printf("GIMX %s %s\n", INFO_VERSION, INFO_ARCH);
exit(0);
break;
case '?':
usage();
exit(-1);
break;
default:
printf(_("unrecognized option: %c\n"), c);
ret = -1;
break;
}
}
if(params->status || params->logfilename)
params->curses = 0;
if(!params->grab)
printf(_("grab flag is unset\n"));
if(params->status)
printf(_("status flag is set\n"));
if(params->subpositions)
printf(_("subpos flag is set\n"));
if(params->force_updates)
printf(_("force_updates flag is set\n"));
if(params->curses)
printf(_("curses flag is set\n"));
if(params->window_events)
printf(_("window_events flag is set\n"));
if(params->btstack)
printf(_("btstack flag is set\n"));
if(!input)
{
fprintf(stderr, "At least a config file, an event, or a source IP:port should be specified as argument.\n");
ret = -1;
}
if(params->logfile)
{
log_info();
}
return ret;
}
