struct s_list *f_keys_initialize(struct s_list *supplied, const char *file, char separator) { struct s_list *result = supplied; struct s_keys_entry *entry; char buffer[d_string_buffer_size], *pointer; FILE *stream; if (!result) f_list_init(&result); if ((stream = fopen(file, "r"))) { while (!feof(stream)) { memset(buffer, 0, d_string_buffer_size); if (fgets(buffer, d_string_buffer_size, stream)) if ((pointer = strchr(buffer, separator))) { *pointer = '\0'; pointer++; f_string_trim(buffer); f_string_trim(pointer); if ((f_string_strlen(buffer) > 0) && (f_string_strlen(pointer) > 0)) if ((entry = (struct s_keys_entry *) d_malloc(sizeof(struct s_keys_entry)))) { strncpy(entry->key, buffer, d_string_buffer_size); strncpy(entry->value, pointer, d_string_buffer_size); f_list_append(result, (struct s_list_node *)entry, e_list_insert_head); } } } fclose(stream); } return result; }
int main (int argc, char *argv[]) { struct s_interface *main_interface = (struct s_interface *) malloc(sizeof(struct s_interface)); char *current_pointer, *next_pointer, csv_file[d_string_buffer_size], default_calibration[d_string_buffer_size], buffer[d_string_buffer_size] = {'\0'}; int index = 0, ladder, local_selection[d_calibrations_ladders]; size_t length; f_memory_init(); if (argc >= 2) { if ((current_pointer = strstr(argv[1], d_compare_postfix))) { length = f_string_strlen(argv[1]); while ((current_pointer < (length+argv[1])) && (!isdigit(*current_pointer))) current_pointer++; while ((current_pointer < (length+argv[1])) && (isdigit(*current_pointer))) { buffer[index++] = *current_pointer; current_pointer++; } } environment.selected_trb = atoi(buffer); snprintf(default_calibration, d_string_buffer_size, "%s%02d", d_compare_default, environment.selected_trb); if (argc >= 3) strncpy(default_calibration, argv[2], d_string_buffer_size); for (ladder = 0; ladder < d_calibrations_ladders; ++ladder) local_selection[ladder] = d_false; if (f_analyze_calibration(&environment, argv[1], default_calibration)) { snprintf(csv_file, d_string_buffer_size, "%s.csv", argv[1]); f_analyze_values(&environment); f_analyze_values_write(&environment, stdout); gtk_init(&argc, &argv); if (f_compare_initialize(main_interface, "UI/UI_main.glade")) { if (argc == 4) { current_pointer = argv[3]; while ((next_pointer = strchr(current_pointer, ','))) { ladder = atoi(current_pointer); local_selection[ladder] = d_true; p_compare_loop_toggle(main_interface, ladder, d_true); current_pointer = (next_pointer+1); } if (f_string_strlen(current_pointer) > 0) { ladder = atoi(current_pointer); local_selection[ladder] = d_true; p_compare_loop_toggle(main_interface, ladder, d_true); } } else for (ladder = 0; ladder < d_calibrations_ladders; ++ladder) { local_selection[ladder] = d_true; p_compare_loop_toggle(main_interface, ladder, d_true); } f_analyze_export(&environment, csv_file, local_selection); gtk_idle_add((GSourceFunc)f_compare_loop, main_interface); gtk_main(); } } else fprintf(stderr, "one of these directories doesn't contains calibration files\n"); } else fprintf(stderr, "usage:\n%s <calibration> {reference calibration} {list of masked ladders CSV}\n", argv[0]); f_memory_destroy(); return 0; }
int main (int argc, char *argv[]) { char buffer[d_string_buffer_size] = {0}; int index; /* ./ localhost port {command} */ if (argc >= 4) { for (index = 3; index < argc; ++index) { strncat(buffer, argv[index], (d_string_buffer_size-f_string_strlen(buffer))); strncat(buffer, d_remote_separator, (d_string_buffer_size-f_string_strlen(buffer))); } strncat(buffer, d_remote_final, (d_string_buffer_size-f_string_strlen(buffer))); if (!f_remote_inject(argv[1], argv[2], buffer)) d_err(e_log_level_ever, "error, unable to communicate with %s:%s", argv[1], argv[2]); } else fprintf(stderr, "magrathea_remote usage:\n%s <IP> <port> {command ...}\n", argv[0]); return 0; }
void p_telnet_device_refresh_readout(int client, struct s_console *console) { fd_set sockets; struct timeval timeout = {0, d_telnet_device_timeout}; char character; if (v_telnet_device.clients[client].socket.initialized) { FD_ZERO(&sockets); FD_SET(v_telnet_device.clients[client].socket.socket, &sockets); if (select(v_telnet_device.clients[client].socket.socket+1, &sockets, NULL, NULL, &timeout) > 0) while (read(v_telnet_device.clients[client].socket.socket, &character, 1) > 0) { if (character == '\n') { if (f_string_strlen(v_telnet_device.clients[client].buffer) > 0) { if (f_string_strcmp(v_telnet_device.clients[client].buffer, d_magrathea_exit_command) != 0) { #ifdef d_telnet_echoing fprintf(stdout, "[<<] %s\n", v_telnet_device.clients[client].buffer); fflush(stdout); #endif p_console_execute(console, v_telnet_device.clients[client].buffer, v_telnet_device.clients[client].socket.socket); p_telnet_device_refresh_command(client); } else { p_telnet_device_destroy_client(client); break; } } memset(v_telnet_device.clients[client].buffer, 0, d_string_buffer_size); v_telnet_device.clients[client].data_pointer = 0; break; } else if (character == '\b') { if (v_telnet_device.clients[client].data_pointer > 0) v_telnet_device.clients[client].buffer[--(v_telnet_device.clients[client].data_pointer)] = '\0'; } else if ((character != '\r') && (v_telnet_device.clients[client].data_pointer < (d_string_buffer_size-1))) v_telnet_device.clients[client].buffer[v_telnet_device.clients[client].data_pointer++] = character; } } }
d_define_method(label, update_texture)(struct s_object *self, TTF_Font *font, struct s_object *environment) { d_using(label); char buffer[d_string_buffer_size]; int width, height; struct s_drawable_attributes *drawable_attributes = d_cast(self, drawable); struct s_uiable_attributes *uiable_attributes = d_cast(self, uiable); struct s_environment_attributes *environment_attributes = d_cast(environment, environment); TTF_Font *current_font; SDL_Surface *unoptimized_surface; SDL_Color white = { 255, 255, 255, 255 }; if (label_attributes->image) { SDL_DestroyTexture(label_attributes->image); label_attributes->image = NULL; } if ((current_font = font) || (current_font = label_attributes->last_font)) { label_attributes->last_font = current_font; if (f_string_strlen(label_attributes->string_content) > 0) { if ((unoptimized_surface = TTF_RenderText_Blended(current_font, label_attributes->string_content, white))) { label_attributes->image = SDL_CreateTextureFromSurface(environment_attributes->renderer, unoptimized_surface); if (SDL_QueryTexture(label_attributes->image, NULL, NULL, &width, &height) == 0) { label_attributes->string_width = width; label_attributes->string_height = height; if (label_attributes->format == e_label_background_format_adaptable) { label_attributes->last_width = width + (uiable_attributes->border_w * 2.0); label_attributes->last_height = height + (uiable_attributes->border_h * 2.0); } d_call(&(drawable_attributes->point_dimension), m_point_set_x, (double)label_attributes->last_width); d_call(&(drawable_attributes->point_dimension), m_point_set_y, (double)label_attributes->last_height); if (label_attributes->last_blend != e_drawable_blend_undefined) d_call(self, m_drawable_set_blend, label_attributes->last_blend); d_call(self, m_drawable_set_maskRGB, (unsigned int)label_attributes->last_mask_R, (unsigned int)label_attributes->last_mask_G, (unsigned int)label_attributes->last_mask_B); d_call(self, m_drawable_set_maskA, (unsigned int)label_attributes->last_mask_A); } else { snprintf(buffer, d_string_buffer_size, "unable to retrieve informations for label \"%s\" exception", label_attributes->string_content); d_throw(v_exception_texture, buffer); } SDL_FreeSurface(unoptimized_surface); } else { snprintf(buffer, d_string_buffer_size, "ungenerable texture for label \"%s\" exception", label_attributes->string_content); d_throw(v_exception_texture, buffer); } } } else { snprintf(buffer, d_string_buffer_size, "ungenerable texture for label \"%s\" with missing font exception", label_attributes->string_content); d_throw(v_exception_texture, buffer); } d_call(self, m_emitter_raise, v_uiable_signals[e_uiable_signal_content_changed]); return self; }
int f_trigger_device_trigger(unsigned char code, char **tokens, size_t elements, int output) { char buffer[d_string_buffer_size]; enum e_adlink_trigger trigger = e_adlink_trigger_50; int argument, result = d_false, speed = 0; if (f_console_parameter("-off", tokens, elements, d_true) != d_console_parameter_null) trigger = e_adlink_trigger_disabled; else if (f_console_parameter("-ext", tokens, elements, d_true) != d_console_parameter_null) trigger = e_adlink_trigger_external; else if ((argument = f_console_parameter("-s", tokens, elements, d_false)) != d_console_parameter_null) switch ((speed = atoi(tokens[argument]))) { case 20: trigger = e_adlink_trigger_20; break; case 100: trigger = e_adlink_trigger_100; break; case 200: trigger = e_adlink_trigger_200; break; case 300: trigger = e_adlink_trigger_300; break; case 50: default: trigger = e_adlink_trigger_50; } if ((result = f_adlink_trigger_setup(trigger))) v_trigger_current = trigger; if (output != d_console_descriptor_null) { if (result) { switch (trigger) { case e_adlink_trigger_disabled: strncpy(buffer, "trigger has been disabled\n", d_string_buffer_size); break; case e_adlink_trigger_external: strncpy(buffer, "running external trigger\n", d_string_buffer_size); break; case e_adlink_trigger_100: case e_adlink_trigger_200: case e_adlink_trigger_300: case e_adlink_trigger_50: case e_adlink_trigger_20: default: snprintf(buffer, d_string_buffer_size, "running trigger @ %dHz\n", trigger); } } else snprintf(buffer, d_string_buffer_size, "%sYEK!%s 404 of trigger board\n", v_console_styles[e_console_style_red], v_console_styles[e_console_style_reset]); write(output, buffer, f_string_strlen(buffer)); fsync(output); } return result; }
int f_remote_inject(const char *ip, const char *port, const char *command) { struct addrinfo hints = {AI_PASSIVE, AF_INET, SOCK_STREAM}, *response = NULL; int client_socket, result = d_false, flags; if (getaddrinfo(ip, port, &hints, &response) == 0) { if ((client_socket = socket(response->ai_family, response->ai_socktype, response->ai_protocol))) { if (connect(client_socket, response->ai_addr, response->ai_addrlen) == 0) { if ((flags = fcntl(client_socket, F_GETFL)) != -1) { fcntl(client_socket, F_SETFL, flags|O_NONBLOCK); write(client_socket, command, f_string_strlen(command)); usleep(d_remote_hard_delay); write(client_socket, d_remote_exit_command, f_string_strlen(d_remote_exit_command)); usleep(d_remote_hard_delay); result = d_true; } shutdown(client_socket, SHUT_RDWR); } close(client_socket); } freeaddrinfo(response); } return result; }
int p_analyze_directory(char *directory, struct s_analyzer_action *actions, const char *directory_ignore_list) { DIR *stream; struct dirent *descriptor; char next_directory[PATH_MAX]; int result = d_true; size_t length; if ((stream = opendir(directory))) { while ((descriptor = readdir(stream))) if ((descriptor->d_name[0] != '.') && (!(strstr(directory_ignore_list, descriptor->d_name)))) { length = f_string_strlen(directory); if (directory[length-1] == '/') directory[length-1] = '\0'; snprintf(next_directory, PATH_MAX, "%s/%s", directory, descriptor->d_name); if (!(result = p_analyze_directory(next_directory, actions, directory_ignore_list))) break; } closedir(stream); } else result = p_analyze_directory_file(directory, actions); return result; }
d_define_method(label, set_content_char)(struct s_object *self, char *string_content, TTF_Font *font, struct s_object *environment) { d_using(label); size_t string_length = f_string_strlen(string_content); if (string_length > 0) { if (label_attributes->string_content) { /* realloc only if really needed */ if (label_attributes->size < (string_length+1)) { if ((label_attributes->string_content = (char *)d_realloc(label_attributes->string_content, (string_length+1)))) label_attributes->size = (string_length+1); else d_die(d_error_malloc); } } else if ((label_attributes->string_content = (char *)d_malloc(string_length+1))) label_attributes->size = (string_length+1); else d_die(d_error_malloc); strncpy(label_attributes->string_content, string_content, string_length); label_attributes->string_content[string_length] = '\0'; } else if (label_attributes->string_content) memset(label_attributes->string_content, '\0', label_attributes->size); p_label_update_texture(self, font, environment); return self; }
void p_telnet_device_refresh_command(int client) { char buffer[d_string_buffer_size]; snprintf(buffer, d_string_buffer_size, "[magrathea %s]>", d_magrathea_version); write(v_telnet_device.clients[client].socket.socket, buffer, f_string_strlen(buffer)); fsync(v_telnet_device.clients[client].socket.socket); }