status_t CommandSection::Execute(ReportRequestSet* requests) const {
FdBuffer buffer;
Fpipe cmdPipe;
Fpipe ihPipe;
if (!cmdPipe.init() || !ihPipe.init()) {
ALOGW("CommandSection '%s' failed to setup pipes", this->name.string());
return -errno;
}
pid_t cmdPid = fork_execute_cmd((char* const*)mCommand, NULL, &cmdPipe);
if (cmdPid == -1) {
ALOGW("CommandSection '%s' failed to fork", this->name.string());
return -errno;
}
pid_t ihPid = fork_execute_incident_helper(this->id, &cmdPipe, &ihPipe);
if (ihPid == -1) {
ALOGW("CommandSection '%s' failed to fork", this->name.string());
return -errno;
}
cmdPipe.writeFd().reset();
status_t readStatus = buffer.read(ihPipe.readFd().get(), this->timeoutMs);
write_section_stats(requests->sectionStats(this->id), buffer);
if (readStatus != NO_ERROR || buffer.timedOut()) {
ALOGW("CommandSection '%s' failed to read data from incident helper: %s, timedout: %s",
this->name.string(), strerror(-readStatus), buffer.timedOut() ? "true" : "false");
kill_child(cmdPid);
kill_child(ihPid);
return readStatus;
}
// Waiting for command here has one trade-off: the failed status of command won't be detected
// until buffer timeout, but it has advatage on starting the data stream earlier.
status_t cmdStatus = wait_child(cmdPid);
status_t ihStatus = wait_child(ihPid);
if (cmdStatus != NO_ERROR || ihStatus != NO_ERROR) {
ALOGW("CommandSection '%s' abnormal child processes, return status: command: %s, incident "
"helper: %s",
this->name.string(), strerror(-cmdStatus), strerror(-ihStatus));
return cmdStatus != NO_ERROR ? cmdStatus : ihStatus;
}
VLOG("CommandSection '%s' wrote %zd bytes in %d ms", this->name.string(), buffer.size(),
(int)buffer.durationMs());
status_t err = write_report_requests(this->id, buffer, requests);
if (err != NO_ERROR) {
ALOGW("CommandSection '%s' failed writing: %s", this->name.string(), strerror(-err));
return err;
}
return NO_ERROR;
}
void parent_process(pid_t pid)
{
FILE *fp;
int interval = FAIL_CHECK_INTERNAL;
print_log("main process: pid=%d", getpid());
if (signal(SIGTERM, sig_term) == SIG_ERR)
print_log("can't register SIGTERM");
while (1) {
sleep(interval);
int res = check_status();
if (res != 0) {
fp = fopen(tmp_file, "r");
if (fp != NULL) {
kill_child(fp);
fclose(fp);
interval = FAIL_CHECK_INTERNAL;
break;
}
print_log("error open %s", tmp_file);
interval = FAIL_CHECK_INTERNAL;
break;
}
interval = CHECK_INTERNAL;
}
remove(tmp_file);
}
status_t FileSection::Execute(ReportRequestSet* requests) const {
// read from mFilename first, make sure the file is available
// add O_CLOEXEC to make sure it is closed when exec incident helper
unique_fd fd(open(mFilename, O_RDONLY | O_CLOEXEC));
if (fd.get() == -1) {
ALOGW("FileSection '%s' failed to open file", this->name.string());
return this->deviceSpecific ? NO_ERROR : -errno;
}
FdBuffer buffer;
Fpipe p2cPipe;
Fpipe c2pPipe;
// initiate pipes to pass data to/from incident_helper
if (!p2cPipe.init() || !c2pPipe.init()) {
ALOGW("FileSection '%s' failed to setup pipes", this->name.string());
return -errno;
}
pid_t pid = fork_execute_incident_helper(this->id, &p2cPipe, &c2pPipe);
if (pid == -1) {
ALOGW("FileSection '%s' failed to fork", this->name.string());
return -errno;
}
// parent process
status_t readStatus = buffer.readProcessedDataInStream(fd.get(), std::move(p2cPipe.writeFd()),
std::move(c2pPipe.readFd()),
this->timeoutMs, mIsSysfs);
write_section_stats(requests->sectionStats(this->id), buffer);
if (readStatus != NO_ERROR || buffer.timedOut()) {
ALOGW("FileSection '%s' failed to read data from incident helper: %s, timedout: %s",
this->name.string(), strerror(-readStatus), buffer.timedOut() ? "true" : "false");
kill_child(pid);
return readStatus;
}
status_t ihStatus = wait_child(pid);
if (ihStatus != NO_ERROR) {
ALOGW("FileSection '%s' abnormal child process: %s", this->name.string(),
strerror(-ihStatus));
return ihStatus;
}
VLOG("FileSection '%s' wrote %zd bytes in %d ms", this->name.string(), buffer.size(),
(int)buffer.durationMs());
status_t err = write_report_requests(this->id, buffer, requests);
if (err != NO_ERROR) {
ALOGW("FileSection '%s' failed writing: %s", this->name.string(), strerror(-err));
return err;
}
return NO_ERROR;
}
status_t wait_child(pid_t pid) {
int status;
bool died = false;
// wait for child to report status up to 1 seconds
for (int loop = 0; !died && loop < WAIT_MAX; loop++) {
if (waitpid(pid, &status, WNOHANG) == pid) died = true;
// sleep for 0.2 second
nanosleep(&WAIT_INTERVAL_NS, NULL);
}
if (!died) return kill_child(pid);
return statusCode(status);
}
/* if the times don't match mac has been rebooted */
void server_child_kill_one_by_id(server_child_t *children, pid_t pid,
uid_t uid, uint32_t idlen, char *id, uint32_t boottime)
{
afp_child_t *child, *tmp;
int i;
pthread_mutex_lock(&children->servch_lock);
for (i = 0; i < CHILD_HASHSIZE; i++) {
child = children->servch_table[i];
while (child) {
tmp = child->afpch_next;
if (child->afpch_pid != pid) {
if (child->afpch_idlen == idlen && memcmp(child->afpch_clientid, id, idlen) == 0) {
if ( child->afpch_boottime != boottime ) {
/* Client rebooted */
if (uid == child->afpch_uid) {
kill_child(child);
LOG(log_warning, logtype_default,
"Terminated disconnected child[%u], client rebooted.",
child->afpch_pid);
} else {
LOG(log_warning, logtype_default,
"Session with different pid[%u]", child->afpch_pid);
}
} else {
/* One client with multiple sessions */
LOG(log_debug, logtype_default,
"Found another session[%u] for client[%u]", child->afpch_pid, pid);
}
}
} else {
/* update childs own slot */
child->afpch_boottime = boottime;
if (child->afpch_clientid)
free(child->afpch_clientid);
LOG(log_debug, logtype_default, "Setting client ID for %u", child->afpch_pid);
child->afpch_uid = uid;
child->afpch_valid = 1;
child->afpch_idlen = idlen;
child->afpch_clientid = id;
}
child = tmp;
}
}
pthread_mutex_unlock(&children->servch_lock);
}
/* if the times don't match mac has been rebooted */
void server_child_kill_one_by_id(server_child *children, int forkid, pid_t pid,
uid_t uid, uint32_t idlen, char *id, uint32_t boottime)
{
server_child_fork *fork;
struct server_child_data *child, *tmp;
int i;
fork = (server_child_fork *)children->fork + forkid;
for (i = 0; i < CHILD_HASHSIZE; i++) {
child = fork->table[i];
while (child) {
tmp = child->next;
if ( child->pid != pid) {
if (child->idlen == idlen && memcmp(child->clientid, id, idlen) == 0) {
if ( child->time != boottime ) {
/* Client rebooted */
if (uid == child->uid) {
kill_child(child);
LOG(log_warning, logtype_default,
"Terminated disconnected child[%u], client rebooted.",
child->pid);
} else {
LOG(log_warning, logtype_default,
"Session with different pid[%u]", child->pid);
}
} else {
/* One client with multiple sessions */
LOG(log_debug, logtype_default,
"Found another session[%u] for client[%u]", child->pid, pid);
}
}
} else {
/* update childs own slot */
child->time = boottime;
if (child->clientid)
free(child->clientid);
LOG(log_debug, logtype_default, "Setting client ID for %u", child->pid);
child->uid = uid;
child->valid = 1;
child->idlen = idlen;
child->clientid = id;
}
child = tmp;
}
}
}
int
main(int argc, char **argv)
{
struct stat sb;
int ret;
int fd;
char buf[1];
int status;
emkdir("one", 0777);
emkdir("two", 0777);
emkdir("one/a", 0777);
fd = child_chdir("one/a");
atexit(kill_child);
ret = read(fd, buf, 1);
if (ret < 0)
err(1, "read");
if (ret == 0)
errx(1, "EOF on read");
ret = rename("one/a", "two/a");
if (ret < 0)
err(1, "rename one/a two");
ret = lstat("two/a", &sb);
if (ret < 0)
err(1, "lstat two/a");
ret = lstat("one/a", &sb);
if (ret != -1 || errno != ENOENT)
errx(1, "one/a still exists");
kill_child();
waitpid(child_pid, &status, 0);
ret = lstat("one/a", &sb);
if (ret != -1 || errno != ENOENT)
errx(1, "one/a still exists after child");
if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
rmdir("one/a");
rmdir("two/a");
rmdir("one");
rmdir("two");
return 0;
} else
return 1;
}
void broadcast(struct message *m, fd_set *writefds) {
struct handler *h = handlers;
while(h) {
if(h->h_type == PERSISTENT) {
char *buff;
switch(h->i_type) {
case JSON:
buff = message_to_json(m);
if(! (ensure_write(h->fdout, buff, strlen(buff))
&& ensure_write(h->fdout, "\n", 1))) {
fprintf(stderr, "Failed to write to handler %s\n", h->command);
}
break;
case RAW:
buff = message_to_IRC(m);
break;
}
}
else if(h->h_type == TRANSIENT) {
kill_child(h);
launch_child(h);
char *buff;
switch(h->i_type) {
case JSON:
buff = message_to_json(m);
if(! (ensure_write(h->fdout, buff, strlen(buff))
&& ensure_write(h->fdout, "\n", 1))) {
fprintf(stderr, "Failed to write to handler %s\n", h->command);
}
close(h->fdout);
break;
case RAW:
buff = message_to_IRC(m);
if( ! ensure_write(h->fdout, buff, strlen(buff))) {
fprintf(stderr, "Failed to write to handler %s\n", h->command);
}
close(h->fdout);
break;
}
}
h = h->next;
}
}
int
main (int argc, char *argv[])
{
int i;
int time;
char *args[ARG_MAX+1];
if (argc != 4) {
usage();
if (argc == 2 && strcmp(argv[1], "-h") == 0) {
exit(0);
} else {
exit(1);
}
}
time = convert_to_seconds(argv[1], argv[2]);
convert_to_argument_list(args, argv[3]);
cpid = fork();
if (cpid == 0) {
execvp(args[0], args);
// if execvp() returns, then something failed:
fprintf(stderr, "error: unable to exec the command\n");
exit(1);
} else if (cpid > 0) {
signal(SIGINT, sighandler);
signal(SIGTERM, sighandler);
sleep(time);
kill_child();
} else {
fprintf(stderr, "error: unable to fork\n");
exit(1);
}
return 0;
}
int main(int argc, char **argv) {
int opt;
int option_index = 0;
char *socket_path = getenv("I3SOCK");
char *command = NULL;
char *fontname = NULL;
char *i3_default_sock_path = "/tmp/i3-ipc.sock";
struct xcb_color_strings_t colors = { NULL, };
/* Definition of the standard-config */
config.hide_on_modifier = 0;
config.dockpos = DOCKPOS_NONE;
config.disable_ws = 0;
static struct option long_opt[] = {
{ "socket", required_argument, 0, 's' },
{ "command", required_argument, 0, 'c' },
{ "hide", no_argument, 0, 'm' },
{ "dock", optional_argument, 0, 'd' },
{ "font", required_argument, 0, 'f' },
{ "nows", no_argument, 0, 'w' },
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'v' },
{ "verbose", no_argument, 0, 'V' },
{ "color-bar-fg", required_argument, 0, 'A' },
{ "color-bar-bg", required_argument, 0, 'B' },
{ "color-active-ws-fg", required_argument, 0, 'C' },
{ "color-active-ws-bg", required_argument, 0, 'D' },
{ "color-inactive-ws-fg", required_argument, 0, 'E' },
{ "color-inactive-ws-bg", required_argument, 0, 'F' },
{ "color-urgent-ws-bg", required_argument, 0, 'G' },
{ "color-urgent-ws-fg", required_argument, 0, 'H' },
{ "color-focus-ws-bg", required_argument, 0, 'I' },
{ "color-focus-ws-fg", required_argument, 0, 'J' },
{ NULL, 0, 0, 0}
};
while ((opt = getopt_long(argc, argv, "s:c:d::mf:whvVA:B:C:D:E:F:G:H:I:J:", long_opt, &option_index)) != -1) {
switch (opt) {
case 's':
socket_path = expand_path(optarg);
break;
case 'c':
command = strdup(optarg);
break;
case 'm':
config.hide_on_modifier = 1;
break;
case 'd':
config.hide_on_modifier = 0;
if (optarg == NULL) {
config.dockpos = DOCKPOS_BOT;
break;
}
if (!strcmp(optarg, "top")) {
config.dockpos = DOCKPOS_TOP;
} else if (!strcmp(optarg, "bottom")) {
config.dockpos = DOCKPOS_BOT;
} else {
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
break;
case 'f':
fontname = strdup(optarg);
break;
case 'w':
config.disable_ws = 1;
break;
case 'v':
printf("i3bar version " I3_VERSION " © 2010-2011 Axel Wagner and contributors\n");
exit(EXIT_SUCCESS);
break;
case 'V':
config.verbose = 1;
break;
case 'A':
read_color(&colors.bar_fg);
break;
case 'B':
read_color(&colors.bar_bg);
break;
case 'C':
read_color(&colors.active_ws_fg);
break;
case 'D':
read_color(&colors.active_ws_bg);
break;
case 'E':
read_color(&colors.inactive_ws_fg);
break;
case 'F':
read_color(&colors.inactive_ws_bg);
break;
case 'G':
read_color(&colors.urgent_ws_bg);
break;
case 'H':
read_color(&colors.urgent_ws_fg);
break;
case 'I':
read_color(&colors.focus_ws_bg);
break;
case 'J':
read_color(&colors.focus_ws_fg);
break;
default:
print_usage(argv[0]);
exit(EXIT_SUCCESS);
break;
}
}
if (fontname == NULL) {
/* This is a very restrictive default. More sensefull would be something like
* "-misc-*-*-*-*--*-*-*-*-*-*-*-*". But since that produces very ugly results
* on my machine, let's stick with this until we have a configfile */
fontname = "-misc-fixed-medium-r-semicondensed--12-110-75-75-c-60-iso10646-1";
}
if (config.dockpos != DOCKPOS_NONE) {
if (config.hide_on_modifier) {
ELOG("--dock and --hide are mutually exclusive!\n");
exit(EXIT_FAILURE);
}
} else {
config.hide_on_modifier = 1;
}
main_loop = ev_default_loop(0);
init_colors(&colors);
char *atom_sock_path = init_xcb(fontname);
if (socket_path == NULL) {
socket_path = atom_sock_path;
}
if (socket_path == NULL) {
ELOG("No Socket Path Specified, default to %s\n", i3_default_sock_path);
socket_path = expand_path(i3_default_sock_path);
}
free_colors(&colors);
init_outputs();
if (init_connection(socket_path)) {
/* We subscribe to the i3-events we need */
subscribe_events();
/* We initiate the main-function by requesting infos about the outputs and
* workspaces. Everything else (creating the bars, showing the right workspace-
* buttons and more) is taken care of by the event-driveniness of the code */
i3_send_msg(I3_IPC_MESSAGE_TYPE_GET_OUTPUTS, NULL);
if (!config.disable_ws) {
i3_send_msg(I3_IPC_MESSAGE_TYPE_GET_WORKSPACES, NULL);
}
}
/* The name of this function is actually misleading. Even if no -c is specified,
* this function initiates the watchers to listen on stdin and react accordingly */
start_child(command);
FREE(command);
/* We listen to SIGTERM/QUIT/INT and try to exit cleanly, by stopping the main-loop.
* We only need those watchers on the stack, so putting them on the stack saves us
* some calls to free() */
ev_signal *sig_term = malloc(sizeof(ev_signal));
ev_signal *sig_int = malloc(sizeof(ev_signal));
ev_signal *sig_hup = malloc(sizeof(ev_signal));
if (sig_term == NULL || sig_int == NULL || sig_hup == NULL) {
ELOG("malloc() failed: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
ev_signal_init(sig_term, &sig_cb, SIGTERM);
ev_signal_init(sig_int, &sig_cb, SIGINT);
ev_signal_init(sig_hup, &sig_cb, SIGHUP);
ev_signal_start(main_loop, sig_term);
ev_signal_start(main_loop, sig_int);
ev_signal_start(main_loop, sig_hup);
/* From here on everything should run smooth for itself, just start listening for
* events. We stop simply stop the event-loop, when we are finished */
ev_loop(main_loop, 0);
kill_child();
FREE(statusline_buffer);
clean_xcb();
ev_default_destroy();
free_workspaces();
return 0;
}
status_t GZipSection::Execute(ReportRequestSet* requests) const {
// Reads the files in order, use the first available one.
int index = 0;
unique_fd fd;
while (mFilenames[index] != NULL) {
fd.reset(open(mFilenames[index], O_RDONLY | O_CLOEXEC));
if (fd.get() != -1) {
break;
}
ALOGW("GZipSection failed to open file %s", mFilenames[index]);
index++; // look at the next file.
}
VLOG("GZipSection is using file %s, fd=%d", mFilenames[index], fd.get());
if (fd.get() == -1) {
ALOGW("GZipSection %s can't open all the files", this->name.string());
return NO_ERROR; // e.g. LAST_KMSG will reach here in user build.
}
FdBuffer buffer;
Fpipe p2cPipe;
Fpipe c2pPipe;
// initiate pipes to pass data to/from gzip
if (!p2cPipe.init() || !c2pPipe.init()) {
ALOGW("GZipSection '%s' failed to setup pipes", this->name.string());
return -errno;
}
pid_t pid = fork_execute_cmd((char* const*)GZIP, &p2cPipe, &c2pPipe);
if (pid == -1) {
ALOGW("GZipSection '%s' failed to fork", this->name.string());
return -errno;
}
// parent process
// construct Fdbuffer to output GZippedfileProto, the reason to do this instead of using
// ProtoOutputStream is to avoid allocation of another buffer inside ProtoOutputStream.
EncodedBuffer* internalBuffer = buffer.getInternalBuffer();
internalBuffer->writeHeader((uint32_t)GZippedFileProto::FILENAME, WIRE_TYPE_LENGTH_DELIMITED);
size_t fileLen = strlen(mFilenames[index]);
internalBuffer->writeRawVarint32(fileLen);
for (size_t i = 0; i < fileLen; i++) {
internalBuffer->writeRawByte(mFilenames[index][i]);
}
internalBuffer->writeHeader((uint32_t)GZippedFileProto::GZIPPED_DATA,
WIRE_TYPE_LENGTH_DELIMITED);
size_t editPos = internalBuffer->wp()->pos();
internalBuffer->wp()->move(8); // reserve 8 bytes for the varint of the data size.
size_t dataBeginAt = internalBuffer->wp()->pos();
VLOG("GZipSection '%s' editPos=%zd, dataBeginAt=%zd", this->name.string(), editPos,
dataBeginAt);
status_t readStatus = buffer.readProcessedDataInStream(
fd.get(), std::move(p2cPipe.writeFd()), std::move(c2pPipe.readFd()), this->timeoutMs,
isSysfs(mFilenames[index]));
write_section_stats(requests->sectionStats(this->id), buffer);
if (readStatus != NO_ERROR || buffer.timedOut()) {
ALOGW("GZipSection '%s' failed to read data from gzip: %s, timedout: %s",
this->name.string(), strerror(-readStatus), buffer.timedOut() ? "true" : "false");
kill_child(pid);
return readStatus;
}
status_t gzipStatus = wait_child(pid);
if (gzipStatus != NO_ERROR) {
ALOGW("GZipSection '%s' abnormal child process: %s", this->name.string(),
strerror(-gzipStatus));
return gzipStatus;
}
// Revisit the actual size from gzip result and edit the internal buffer accordingly.
size_t dataSize = buffer.size() - dataBeginAt;
internalBuffer->wp()->rewind()->move(editPos);
internalBuffer->writeRawVarint32(dataSize);
internalBuffer->copy(dataBeginAt, dataSize);
VLOG("GZipSection '%s' wrote %zd bytes in %d ms, dataSize=%zd", this->name.string(),
buffer.size(), (int)buffer.durationMs(), dataSize);
status_t err = write_report_requests(this->id, buffer, requests);
if (err != NO_ERROR) {
ALOGW("GZipSection '%s' failed writing: %s", this->name.string(), strerror(-err));
return err;
}
return NO_ERROR;
}
int main(int argc, char *argv[]) {
int opt;
struct sockaddr_can addr;
struct canfd_frame frame;
int running = 1;
int enable_canfd = 1;
int play_traffic = 1;
struct stat st;
SDL_Event event;
while ((opt = getopt(argc, argv, "Xdl:s:t:h?")) != -1) {
switch(opt) {
case 'l':
difficulty = atoi(optarg);
break;
case 's':
seed = atoi(optarg);
break;
case 't':
traffic_log = optarg;
break;
case 'd':
debug = 1;
break;
case 'X':
play_traffic = 0;
break;
case 'h':
case '?':
default:
usage(NULL);
break;
}
}
if (optind >= argc) usage("You must specify at least one can device");
if(stat(traffic_log, &st) == -1) {
char msg[256];
snprintf(msg, 255, "CAN Traffic file not found: %s\n", traffic_log);
usage(msg);
}
/* open socket */
if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
perror("socket");
return 1;
}
addr.can_family = AF_CAN;
strcpy(ifr.ifr_name, argv[optind]);
if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
perror("SIOCGIFINDEX");
return 1;
}
addr.can_ifindex = ifr.ifr_ifindex;
if (setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES,
&enable_canfd, sizeof(enable_canfd))){
printf("error when enabling CAN FD support\n");
return 1;
}
if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
perror("bind");
return 1;
}
door_id = DEFAULT_DOOR_ID;
signal_id = DEFAULT_SIGNAL_ID;
speed_id = DEFAULT_SPEED_ID;
if (seed) {
srand(seed);
door_id = (rand() % 2046) + 1;
signal_id = (rand() % 2046) + 1;
speed_id = (rand() % 2046) + 1;
door_pos = rand() % 9;
signal_pos = rand() % 9;
speed_pos = rand() % 8;
printf("Seed: %d\n", seed);
door_len = door_pos + 1;
signal_len = signal_pos + 1;
speed_len = speed_len + 2;
}
if(difficulty > 0) {
if (door_len < 8) {
door_len += rand() % (8 - door_len);
} else {
door_len = 0;
}
if (signal_len < 8) {
signal_len += rand() % (8 - signal_len);
} else {
signal_len = 0;
}
if (speed_len < 8) {
speed_len += rand() % (8 - speed_len);
} else {
speed_len = 0;
}
}
if(play_traffic) {
signal(SIGALRM,(void (*)(int))kill_child);
play_id = fork();
if((int)play_id == -1) {
printf("Error: Couldn't fork bg player\n");
exit(-1);
} else if (play_id != 0) {
play_can_traffic();
}
}
// GUI Setup
SDL_Window *window = NULL;
SDL_Surface *screenSurface = NULL;
if(SDL_Init ( SDL_INIT_VIDEO | SDL_INIT_JOYSTICK ) < 0 ) {
printf("SDL Could not initializes\n");
exit(40);
}
if( SDL_NumJoysticks() < 1) {
printf(" Warning: No joysticks connected\n");
} else {
if(SDL_IsGameController(0)) {
gGameController = SDL_GameControllerOpen(0);
if(gGameController == NULL) {
printf(" Warning: Unable to open game controller. %s\n", SDL_GetError() );
} else {
gJoystick = SDL_GameControllerGetJoystick(gGameController);
gHaptic = SDL_HapticOpenFromJoystick(gJoystick);
print_joy_info();
}
} else {
gJoystick = SDL_JoystickOpen(0);
if(gJoystick == NULL) {
printf(" Warning: Could not open joystick\n");
} else {
gHaptic = SDL_HapticOpenFromJoystick(gJoystick);
if (gHaptic == NULL) printf("No Haptic support\n");
print_joy_info();
}
}
}
window = SDL_CreateWindow("CANBus Control Panel", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
if(window == NULL) {
printf("Window could not be shown\n");
}
renderer = SDL_CreateRenderer(window, -1, 0);
SDL_Surface *image = IMG_Load(get_data("joypad.png"));
base_texture = SDL_CreateTextureFromSurface(renderer, image);
SDL_RenderCopy(renderer, base_texture, NULL, NULL);
SDL_RenderPresent(renderer);
int button, axis; // Used for checking dynamic joystick mappings
while(running) {
while( SDL_PollEvent(&event) != 0 ) {
switch(event.type) {
case SDL_QUIT:
running = 0;
break;
case SDL_WINDOWEVENT:
switch(event.window.event) {
case SDL_WINDOWEVENT_ENTER:
case SDL_WINDOWEVENT_RESIZED:
redraw_screen();
break;
}
case SDL_KEYDOWN:
switch(event.key.keysym.sym) {
case SDLK_UP:
throttle = 1;
break;
case SDLK_LEFT:
turning = -1;
break;
case SDLK_RIGHT:
turning = 1;
break;
case SDLK_LSHIFT:
lock_enabled = 1;
if(unlock_enabled) send_lock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
break;
case SDLK_RSHIFT:
unlock_enabled = 1;
if(lock_enabled) send_unlock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
break;
case SDLK_a:
if(lock_enabled) {
send_lock(CAN_DOOR1_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR1_LOCK);
}
break;
case SDLK_b:
if(lock_enabled) {
send_lock(CAN_DOOR2_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR2_LOCK);
}
break;
case SDLK_x:
if(lock_enabled) {
send_lock(CAN_DOOR3_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR3_LOCK);
}
break;
case SDLK_y:
if(lock_enabled) {
send_lock(CAN_DOOR4_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR4_LOCK);
}
break;
}
kk_check(event.key.keysym.sym);
break;
case SDL_KEYUP:
switch(event.key.keysym.sym) {
case SDLK_UP:
throttle = -1;
break;
case SDLK_LEFT:
case SDLK_RIGHT:
turning = 0;
break;
case SDLK_LSHIFT:
lock_enabled = 0;
break;
case SDLK_RSHIFT:
unlock_enabled = 0;
break;
}
break;
case SDL_JOYAXISMOTION:
axis = event.jaxis.axis;
if(axis == gAxisLeftH) {
ud(event.jaxis.value);
} else if(axis == gAxisLeftV) {
turn(event.jaxis.value);
} else if(axis == gAxisR2) {
accelerate(event.jaxis.value);
} else if(axis == gAxisRightH ||
axis == gAxisRightV ||
axis == gAxisL2 ||
axis == gJoyX ||
axis == gJoyY ||
axis == gJoyZ) {
// Do nothing, the axis is known just not connected
} else {
if (debug) printf("Unkown axis: %d\n", event.jaxis.axis);
}
break;
case SDL_JOYBUTTONDOWN:
button = event.jbutton.button;
if(button == gButtonLock) {
lock_enabled = 1;
if(unlock_enabled) send_lock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
} else if(button == gButtonUnlock) {
unlock_enabled = 1;
if(lock_enabled) send_unlock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
} else if(button == gButtonA) {
if(lock_enabled) {
send_lock(CAN_DOOR1_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR1_LOCK);
}
kk_check(SDLK_a);
} else if (button == gButtonB) {
if(lock_enabled) {
send_lock(CAN_DOOR2_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR2_LOCK);
}
kk_check(SDLK_b);
} else if (button == gButtonX) {
if(lock_enabled) {
send_lock(CAN_DOOR3_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR3_LOCK);
}
kk_check(SDLK_x);
} else if (button == gButtonY) {
if(lock_enabled) {
send_lock(CAN_DOOR4_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR4_LOCK);
}
kk_check(SDLK_y);
} else if (button == gButtonStart) {
kk_check(SDLK_RETURN);
} else {
if(debug) printf("Unassigned button: %d\n", event.jbutton.button);
}
break;
case SDL_JOYBUTTONUP:
button = event.jbutton.button;
if(button == gButtonLock) {
lock_enabled = 0;
} else if(button == gButtonUnlock) {
unlock_enabled = 0;
} else {
//if(debug) printf("Unassigned button: %d\n", event.jbutton.button);
}
break;
case SDL_JOYDEVICEADDED:
// Only use the first controller
if(event.cdevice.which == 0) {
gJoystick = SDL_JoystickOpen(0);
if(gJoystick) {
gHaptic = SDL_HapticOpenFromJoystick(gJoystick);
print_joy_info();
}
}
break;
case SDL_JOYDEVICEREMOVED:
if(event.cdevice.which == 0) {
SDL_JoystickClose(gJoystick);
gJoystick = NULL;
}
break;
case SDL_CONTROLLERDEVICEADDED:
// Only use the first controller
if(gGameController == NULL) {
gGameController = SDL_GameControllerOpen(0);
gJoystick = SDL_GameControllerGetJoystick(gGameController);
gHaptic = SDL_HapticOpenFromJoystick(gJoystick);
print_joy_info();
}
break;
case SDL_CONTROLLERDEVICEREMOVED:
if(event.cdevice.which == 0) {
SDL_GameControllerClose(gGameController);
gGameController = NULL;
}
break;
}
}
currentTime = SDL_GetTicks();
checkAccel();
checkTurn();
SDL_Delay(5);
}
kill_child(SIGKILL);
close(s);
SDL_DestroyTexture(base_texture);
SDL_FreeSurface(image);
SDL_GameControllerClose(gGameController);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
}
int main(int argc, char **argv) {
int opt;
int option_index = 0;
char *socket_path = getenv("I3SOCK");
char *i3_default_sock_path = "/tmp/i3-ipc.sock";
/* Initialize the standard config to use 0 as default */
memset(&config, '\0', sizeof(config_t));
static struct option long_opt[] = {
{ "socket", required_argument, 0, 's' },
{ "bar_id", required_argument, 0, 'b' },
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'v' },
{ NULL, 0, 0, 0}
};
while ((opt = getopt_long(argc, argv, "b:s:hv", long_opt, &option_index)) != -1) {
switch (opt) {
case 's':
socket_path = expand_path(optarg);
break;
case 'v':
printf("i3bar version " I3_VERSION " © 2010-2014 Axel Wagner and contributors\n");
exit(EXIT_SUCCESS);
break;
case 'b':
config.bar_id = sstrdup(optarg);
break;
default:
print_usage(argv[0]);
exit(EXIT_SUCCESS);
break;
}
}
if (!config.bar_id) {
/* TODO: maybe we want -f which will automatically ask i3 for the first
* configured bar (and error out if there are too many)? */
ELOG("No bar_id passed. Please let i3 start i3bar or specify --bar_id\n");
exit(EXIT_FAILURE);
}
main_loop = ev_default_loop(0);
char *atom_sock_path = init_xcb_early();
if (socket_path == NULL) {
socket_path = atom_sock_path;
}
if (socket_path == NULL) {
ELOG("No Socket Path Specified, default to %s\n", i3_default_sock_path);
socket_path = expand_path(i3_default_sock_path);
}
init_outputs();
if (init_connection(socket_path)) {
/* Request the bar configuration. When it arrives, we fill the config array. */
i3_send_msg(I3_IPC_MESSAGE_TYPE_GET_BAR_CONFIG, config.bar_id);
}
/* We listen to SIGTERM/QUIT/INT and try to exit cleanly, by stopping the main-loop.
* We only need those watchers on the stack, so putting them on the stack saves us
* some calls to free() */
ev_signal *sig_term = smalloc(sizeof(ev_signal));
ev_signal *sig_int = smalloc(sizeof(ev_signal));
ev_signal *sig_hup = smalloc(sizeof(ev_signal));
ev_signal_init(sig_term, &sig_cb, SIGTERM);
ev_signal_init(sig_int, &sig_cb, SIGINT);
ev_signal_init(sig_hup, &sig_cb, SIGHUP);
ev_signal_start(main_loop, sig_term);
ev_signal_start(main_loop, sig_int);
ev_signal_start(main_loop, sig_hup);
/* From here on everything should run smooth for itself, just start listening for
* events. We stop simply stop the event-loop, when we are finished */
ev_loop(main_loop, 0);
kill_child();
FREE(l_statusline_buffer);
FREE(r_statusline_buffer);
clean_xcb();
ev_default_destroy();
free_workspaces();
return 0;
}
int main(int argc, char *argv[])
{
int c, status;
char *src;
buf_s *in;
struct sigaction sa;
sym_record_s *rec, *recb;
pthread_t req_thread;
sigset_t mask;
if(argc > 1) {
src = readfile(argv[1]);
parse(src);
closefile();
}
else {
src = readfile("test");
parse(src);
closefile();
}
name = "ap";
name_stripped = "ap";
name_len = sizeof("ap")-1;
if(access("out/", F_OK)) {
if(errno == ENOENT)
mkdir("out", S_IRWXU);
else {
perror("Directory Access");
exit(EXIT_FAILURE);
}
}
logfile = fopen("out/ap", "w");
if(!logfile) {
perror("Error Creating file for redirection");
exit(EXIT_FAILURE);
}
sa.sa_handler = sigUSR1;
sa.sa_flags = SA_RESTART;
sigemptyset(&sa.sa_mask);
status = sigaction(SIGUSR1, &sa, NULL);
if(status < 0) {
perror("Error installing handler for SIGUSR1");
exit(EXIT_FAILURE);
}
sa.sa_handler = sigALARM;
sa.sa_flags = 0;
sigemptyset(&sa.sa_mask);
status = sigaction(SIGALRM, &sa, NULL);
if(status < 0) {
perror("Error installing handler for SIGTERM");
exit(EXIT_FAILURE);
}
shm_mediums = shmget(SHM_KEY_S, sizeof(*mediums), IPC_CREAT|SHM_R|SHM_W);
if(shm_mediums < 0) {
perror("Failed to set up shared memory segment");
exit(EXIT_FAILURE);
}
mediums = shmat(shm_mediums, NULL, 0);
if(mediums == (medium_s *)-1) {
perror("Failed to attached shared memory segment.");
exit(EXIT_FAILURE);
}
mediums->isbusy = false;
shm_mediumc = shmget(SHM_KEY_C, sizeof(*mediumc), IPC_CREAT|SHM_R|SHM_W);
if(shm_mediumc < 0) {
perror("Failed to set up shared memory segment");
exit(EXIT_FAILURE);
}
mediumc = shmat(shm_mediumc, NULL, 0);
if(mediumc == (medium_s *)-1) {
perror("Failed to attached shared memory segment.");
exit(EXIT_FAILURE);
}
mediumc->isbusy = false;
status = pthread_create(&req_thread, NULL, process_request, NULL);
if(status) {
perror("Failure to set up thread");
exit(EXIT_FAILURE);
}
sigemptyset(&mask);
sigaddset(&mask, SIGUSR2);
status = pthread_sigmask(SIG_BLOCK, &mask, NULL);
if(status) {
perror("Failure to mask SIGUSR2 in parent thread.");
exit(EXIT_FAILURE);
}
process_tasks();
in = buf_init();
/* Get command line input */
printf("> ");
while((c = getchar()) != EOF) {
buf_addc(&in, c);
if(c == '\n') {
buf_addc(&in, '\0');
parse(in->buf);
process_tasks();
buf_reset(&in);
printf("> ");
}
}
buf_free(in);
pthread_mutex_lock(&station_table_lock);
/* kill all children */
for(c = 0; c < SYM_TABLE_SIZE; c++) {
rec = station_table.table[c];
while(rec) {
kill_child(rec->data.ptr);
recb = rec->next;
free(rec);
rec = recb;
}
}
pthread_mutex_unlock(&station_table_lock);
pthread_mutex_destroy(&station_table_lock);
fclose(logfile);
exit(EXIT_SUCCESS);
}
int
main(int argc, char** argv)
{
#if HAVE_DECL_PTRACE_SETOPTIONS && HAVE_DECL_PTRACE_O_TRACEVFORKDONE
int exit_status;
_parse_opts(argc, argv);
if (fp == NULL) {
fp = stderr;
}
if (socketpair(AF_UNIX, SOCK_STREAM, 0, psync) == -1) {
tst_resm(TBROK | TERRNO, "socketpair() failed");
} else {
child = fork();
if (child == -1) {
tst_resm(TBROK | TERRNO, "fork() failed");
} else if (child == 0) {
int rc = EXIT_FAILURE;
tst_sig(FORK, DEF_HANDLER, child_cleanup);
if (close(psync[1])) {
tst_resm(TBROK, "close(psync[1]) failed)");
} else {
/* sleep until the parent wakes us up */
await_mutex(psync[0]);
rc = do_vfork(num_vforks);
}
_exit(rc);
} else {
tst_sig(FORK, kill_child, parent_cleanup);
close(psync[0]);
/* Set up ptrace */
if (ptrace(PTRACE_ATTACH, child, NULL, NULL) == -1) {
tst_resm(TBROK | TERRNO,
"ptrace(ATTACH) failed");
tst_exit();
}
if (waitpid(child, NULL, 0) != child) {
tst_resm(TBROK | TERRNO, "waitpid(%d) failed",
child);
kill_child();
} else {
if (ptrace(PTRACE_SETOPTIONS, child, NULL,
PTRACE_O_TRACEVFORK) == -1) {
tst_resm(TINFO | TERRNO,
"ptrace(PTRACE_SETOPTIONS) "
"failed.");
}
if (ptrace(PTRACE_CONT, child, NULL, NULL) == -1) {
tst_resm(TINFO | TERRNO,
"ptrace(PTRACE_CONT) failed.");
}
send_mutex(psync[1]);
close(psync[1]);
tst_resm(TINFO, "Child spawn's pid=%d", child);
fprintf(fp, "%d\n", child);
fflush(fp);
exit_status = do_trace(child, ++num_vforks);
tst_resm(exit_status == 0 ? TPASS : TFAIL,
"do_trace %s",
(exit_status == 0 ? "succeeded" : "failed"));
parent_cleanup();
}
}
}
#else
tst_resm(TCONF, "System doesn't support have required ptrace "
"capabilities.");
#endif
tst_resm(TINFO, "Exiting...");
tst_exit();
}
void
sighandler (int sig)
{
kill_child();
exit(0);
}
int main(){
main_pid = getpid();
char line[BUF][BUF];
FILE *rlist = NULL;
int igt = 0;
int total = 0;
rlist = fopen("STATIONS.txt", "r");
while( fgets ( line[igt], BUF, rlist )) {
/* get rid of ending \n from fgets */
line[igt][strlen(line[igt]) - 1] = '\0';
char *line_f = line[igt];
uris[igt] = strtok(line_f, "@");
choices[igt] = strtok(NULL, "@");
descriptions[igt] = strtok(NULL, "@");
igt++;
}
/* Initialize curses */
ITEM **my_items;
int c;
MENU *my_menu;
int n_choices, i;
ITEM *cur_item;
initscr();
/*We dont really need colors for now...*/
/*start_color();*/
cbreak();
noecho();
keypad(stdscr, TRUE);
/*wborder(0 , 0,0,0,0,0,0,0,0,);*/
/*init_pair(1, COLOR_RED,COLOR_WHITE);*/
/*init_pair(2, COLOR_GREEN,COLOR_WHITE);*/
/*init_pair(3, COLOR_MAGENTA,COLOR_WHITE);*/
/* Initialize items */
n_choices = ARRAY_SIZE(choices);
my_items = (ITEM **)calloc(n_choices + 1, sizeof(ITEM *));
for(i = 0; i < n_choices; ++i) {
my_items[i] = new_item(choices[i],descriptions[i]);
/* The F*cking user pointer */
set_item_userptr(my_items[i], func);
}
my_items[n_choices] = (ITEM *)NULL;
/* Create menu */
my_menu = new_menu((ITEM **)my_items);
set_menu_opts(my_menu,O_SHOWDESC);
int y_lines_menu = LINES - y_lines_reserved;
set_menu_format(my_menu,y_lines_menu,1);
/* Post the menu */
/*Help thingy*/
hacete_una_linea_putin(5);
mvprintw(LINES - 4, 0, " Press <ENTER> to play the station,");
mvprintw(LINES - 3, 0, " any <arrow> to move the menu buffer, <Q> to Quit or");
mvprintw(LINES - 2, 0, " <K> to Kill child mplayer process.");
hacete_una_linea_putin(1);
post_menu(my_menu);
refresh();
/*big loop thingy*/
while((c = getch()) != 113){
switch(c){
case KEY_DOWN:
menu_driver(my_menu, REQ_DOWN_ITEM);
break;
case KEY_UP:
menu_driver(my_menu, REQ_UP_ITEM);
break;
case KEY_LEFT:
menu_driver(my_menu, REQ_SCR_UPAGE);
break;
case KEY_RIGHT:
menu_driver(my_menu, REQ_SCR_DPAGE);
break;
case 107: // k
kill_child();
break;
case 10: { /* Enter == Play some radio! */
ITEM *cur;
void (*p)(char *);
if (*contador >= 1){
kill_child();
}
cur = current_item(my_menu);
description_fn = (char *)item_description(cur);
p = item_userptr(cur);
p((char *)item_name(cur));
pos_menu_cursor(my_menu);
play_radio();
cuenta = cuenta + 1;
break;
}
break;
}
}
/*That's all, free memory, kill any pid and exit.*/
unpost_menu(my_menu);
for(i = 0; i < n_choices; ++i){
free_item(my_items[i]);
}
free_menu(my_menu);
endwin();
kill_child();
exit(0);
}
