static void fill_data (gint n_columns) { GtkTreeIter iter; GtkListStore *model = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (list_view))); GIOChannel *channel; if (options.extra_data && *options.extra_data) { gchar **args = options.extra_data; gint i = 0; gtk_widget_freeze_child_notify (list_view); while (args[i] != NULL) { gint j; gtk_list_store_append (model, &iter); for (j = 0; j < n_columns; j++, i++) { YadColumn *col = (YadColumn *) g_slist_nth_data (options.list_data.columns, j); GdkPixbuf *pb; if (args[i] == NULL) break; switch (col->type) { case YAD_COLUMN_CHECK: case YAD_COLUMN_RADIO: if (strcasecmp ((gchar *) args[i], "true") == 0) gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, TRUE, -1); else gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, FALSE, -1); break; case YAD_COLUMN_NUM: gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, g_ascii_strtoll (args[i], NULL, 10), -1); break; case YAD_COLUMN_FLOAT: gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, g_ascii_strtod (args[i], NULL), -1); break; case YAD_COLUMN_IMAGE: pb = get_pixbuf (args[i], YAD_SMALL_ICON); if (pb) { gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, pb, -1); g_object_unref (pb); } break; default: gtk_list_store_set (GTK_LIST_STORE (model), &iter, j, args[i], -1); break; } } } gtk_widget_thaw_child_notify (list_view); if (settings.always_selected) { GtkTreeIter it; GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (list_view)); GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (list_view)); gtk_tree_model_get_iter_first (model, &it); gtk_tree_selection_select_iter (sel, &it); } } if (options.common_data.listen || !(options.extra_data && *options.extra_data)) { channel = g_io_channel_unix_new (0); g_io_channel_set_encoding (channel, NULL, NULL); g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL); g_io_add_watch (channel, G_IO_IN | G_IO_HUP, handle_stdin, GINT_TO_POINTER (n_columns)); } }
GHashTable * SlashProcNet_GetSnmp(void) { GHashTable *myHashTable = NULL; GIOChannel *myChannel = NULL; GIOStatus keyIoStatus; GIOStatus valIoStatus; gchar *myKeyLine = NULL; gchar *myValLine = NULL; Bool parseError = FALSE; int fd = -1; static GRegex *myKeyRegex = NULL; static GRegex *myValRegex = NULL; if (myKeyRegex == NULL) { myKeyRegex = g_regex_new("^(\\w+): (\\w+ )*(\\w+)$", G_REGEX_OPTIMIZE, 0, NULL); myValRegex = g_regex_new("^(\\w+): (-?\\d+ )*(-?\\d+)$", G_REGEX_OPTIMIZE, 0, NULL); ASSERT(myKeyRegex); ASSERT(myValRegex); } if ((fd = g_open(pathToNetSnmp, O_RDONLY)) == -1) { return NULL; } myChannel = g_io_channel_unix_new(fd); myHashTable = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); /* * Expected format: * * pfx0: key0 key1 key2 ... keyN * pfx0: val0 val1 val2 ... valN * ... * pfxN: ... */ while ((keyIoStatus = g_io_channel_read_line(myChannel, &myKeyLine, NULL, NULL, NULL)) == G_IO_STATUS_NORMAL && (valIoStatus = g_io_channel_read_line(myChannel, &myValLine, NULL, NULL, NULL)) == G_IO_STATUS_NORMAL) { GMatchInfo *keyMatchInfo = NULL; GMatchInfo *valMatchInfo = NULL; gchar **myKeys = NULL; gchar **myVals = NULL; gchar **myKey = NULL; gchar **myVal = NULL; gchar *keyPrefix = NULL; gchar *valPrefix = NULL; /* * Per format above, we expect a pair of lines with a matching prefix. */ { if (!g_regex_match(myKeyRegex, myKeyLine, 0, &keyMatchInfo) || !g_regex_match(myValRegex, myValLine, 0, &valMatchInfo)) { parseError = TRUE; goto badIteration; } keyPrefix = g_match_info_fetch(keyMatchInfo, 1); valPrefix = g_match_info_fetch(valMatchInfo, 1); ASSERT(keyPrefix); ASSERT(valPrefix); if (strcmp(keyPrefix, valPrefix)) { parseError = TRUE; goto badIteration; } } myKeys = g_strsplit(myKeyLine, " ", 0); myVals = g_strsplit(myValLine, " ", 0); /* * Iterate over the columns, combining the column keys with the prefix * to form the new key name. (I.e., "Ip: InDiscards" => "IpInDiscards".) */ for (myKey = &myKeys[1], myVal = &myVals[1]; *myKey && *myVal; myKey++, myVal++) { gchar *hashKey; guint64 *myIntVal = NULL; hashKey = g_strjoin(NULL, keyPrefix, *myKey, NULL); g_strstrip(hashKey); /* * By virtue of having matched the above regex, this conversion * must hold. */ myIntVal = g_new(guint64, 1); *myIntVal = g_ascii_strtoull(*myVal, NULL, 10); /* * If our input contains duplicate keys, which I really don't see * happening, the latter value overrides the former. * * NB: myHashTable claims ownership of hashKey. */ g_hash_table_insert(myHashTable, hashKey, myIntVal); } /* * Make sure the column counts matched. If we succeeded, both pointers * should now be NULL. */ if (*myKey || *myVal) { parseError = TRUE; } badIteration: g_match_info_free(keyMatchInfo); g_match_info_free(valMatchInfo); g_free(keyPrefix); g_free(valPrefix); g_strfreev(myKeys); g_strfreev(myVals); g_free(myKeyLine); g_free(myValLine); myKeyLine = NULL; myValLine = NULL; if (parseError) { break; } } /* * Error conditions: * Hash table empty: Unable to parse any input. * myKeyLine != NULL: Failed to read "key" and "value" lines during * same loop iteration. * parseError == TRUE: See loop body above. */ if (keyIoStatus == G_IO_STATUS_ERROR || valIoStatus == G_IO_STATUS_ERROR || g_hash_table_size(myHashTable) == 0 || parseError) { g_hash_table_destroy(myHashTable); myHashTable = NULL; } g_free(myKeyLine); g_free(myValLine); myKeyLine = NULL; myValLine = NULL; close(fd); g_io_channel_unref(myChannel); return myHashTable; }
GPtrArray * SlashProcNet_GetRoute(void) { GIOChannel *myChannel = NULL; GIOStatus myIoStatus; GPtrArray *myArray = NULL; gchar *myLine = NULL; int fd = -1; static GRegex *myFieldsRE = NULL; static GRegex *myValuesRE = NULL; if (myFieldsRE == NULL) { myFieldsRE = g_regex_new("^Iface\\s+Destination\\s+Gateway\\s+Flags\\s+" "RefCnt\\s+Use\\s+Metric\\s+Mask\\s+MTU\\s+" "Window\\s+IRTT\\s*$", 0, 0, NULL); myValuesRE = g_regex_new("^(\\w+)\\s+([[:xdigit:]]{8})\\s+" "([[:xdigit:]]{8})\\s+([[:xdigit:]]{4})\\s+" "\\d+\\s+\\d+\\s+(\\d+)\\s+" "([[:xdigit:]]{8})\\s+(\\d+)\\s+\\d+\\s+(\\d+)\\s*$", 0, 0, NULL); ASSERT(myFieldsRE); ASSERT(myValuesRE); } /* * 1. Open pathToNetRoute, associate it with a GIOChannel. */ if ((fd = g_open(pathToNetRoute, O_RDONLY)) == -1) { Warning("%s: open(%s): %s\n", __func__, pathToNetRoute, g_strerror(errno)); return NULL; } myChannel = g_io_channel_unix_new(fd); /* * 2. Sanity check the header, making sure it matches what we expect. * (It's -extremely- unlikely this will change, but we should check * anyway.) */ myIoStatus = g_io_channel_read_line(myChannel, &myLine, NULL, NULL, NULL); if (myIoStatus != G_IO_STATUS_NORMAL || g_regex_match(myFieldsRE, myLine, 0, NULL) == FALSE) { goto out; } g_free(myLine); myLine = NULL; myArray = g_ptr_array_new(); /* * 3. For each line... */ while ((myIoStatus = g_io_channel_read_line(myChannel, &myLine, NULL, NULL, NULL)) == G_IO_STATUS_NORMAL) { GMatchInfo *myMatchInfo = NULL; struct rtentry *myEntry = NULL; struct sockaddr_in *sin = NULL; Bool parseError = FALSE; /* * 3a. Validate with regex. */ if (!g_regex_match(myValuesRE, myLine, 0, &myMatchInfo)) { parseError = TRUE; goto badIteration; } /* * 3b. Allocate new rtentry, add to array. This simplifies the cleanup * code path. */ myEntry = g_new0(struct rtentry, 1); g_ptr_array_add(myArray, myEntry); /* * 3c. Copy contents to new struct rtentry. */ myEntry->rt_dev = g_match_info_fetch(myMatchInfo, 1); sin = (struct sockaddr_in *)&myEntry->rt_dst; sin->sin_family = AF_INET; sin->sin_addr.s_addr = MatchToGuint64(myMatchInfo, 2, 16); sin = (struct sockaddr_in *)&myEntry->rt_gateway; sin->sin_family = AF_INET; sin->sin_addr.s_addr = MatchToGuint64(myMatchInfo, 3, 16); sin = (struct sockaddr_in *)&myEntry->rt_genmask; sin->sin_family = AF_INET; sin->sin_addr.s_addr = MatchToGuint64(myMatchInfo, 6, 16); myEntry->rt_flags = MatchToGuint64(myMatchInfo, 4, 16); myEntry->rt_metric = MatchToGuint64(myMatchInfo, 5, 10); myEntry->rt_mtu = MatchToGuint64(myMatchInfo, 7, 10); myEntry->rt_irtt = MatchToGuint64(myMatchInfo, 8, 10); badIteration: g_free(myLine); myLine = NULL; g_match_info_free(myMatchInfo); myMatchInfo = NULL; if (parseError) { break; } } if (myArray && myIoStatus != G_IO_STATUS_EOF) { SlashProcNet_FreeRoute(myArray); myArray = NULL; } out: g_free(myLine); close(fd); g_io_channel_unref(myChannel); return myArray; }
int main(int argc, char *argv[]) { GHashTable *fbs; GIOChannel *channel; GIOStatus status; GError *error = NULL; gchar *buf; gsize size; if ( filter_agent_init(argc, argv) ) { fprintf(stderr, "TestFarm Virtual User Filter Agent\n"); fprintf(stderr, "%s\n", filter_agent_desc); return 1; } setbuf(stdout, NULL); fbs = g_hash_table_new(NULL, NULL); channel = g_io_channel_unix_new(fileno(stdin)); while ( (status = g_io_channel_read_line(channel, &buf, &size, NULL, &error)) == G_IO_STATUS_NORMAL ) { if ( buf != NULL ) { char op = buf[0]; char *s_num = buf + 1; char *str = strchr(s_num, ' '); unsigned long num; if ( str != NULL ) { *(str++) = '\0'; g_strstrip(str); } num = strtoul(s_num, NULL, 0); switch ( op ) { case '!': if ( str != NULL ) { int shmid = atoi(str); frame_buf_t *fb = g_hash_table_lookup(fbs, GINT_TO_POINTER(shmid)); if ( fb == NULL ) { fb = frame_buf_map(shmid, 0); if ( fb != NULL ) { g_hash_table_insert(fbs, GINT_TO_POINTER(shmid), fb); fprintf(stderr, "[INFO ] APPLY %lu: new shmid=%d %ux%u\n", num, shmid, fb->rgb.width, fb->rgb.height); } else { fprintf(stderr, "[ERROR] APPLY %lu: cannot map shmid=%d\n", num, shmid); } } if ( fb != NULL ) { filter_agent_apply(num, fb); } else { filter_agent_applied(num); } } else { fprintf(stderr, "[ERROR] APPLY %lu: missing parameter <shmid>\n", num); filter_agent_applied(num); } break; case '?': filter_agent_show(num); break; case '+': { char *class_id = NULL; GList *options = NULL; while ( str != NULL ) { char *str2 = strchr(str, ' '); if ( str2 != NULL ) { *(str2++) = '\0'; while ( (*str2 != '\0') && (*str2 < ' ') ) str2++; } if ( *str != '\0' ) { if ( class_id == NULL ) class_id = str; else options = g_list_append(options, str); } str = str2; } fprintf(stderr, "[INFO ] ADD %lu: class='%s'\n", num, class_id); filter_agent_add(num, class_id, options); g_list_free(options); } break; case '-': filter_agent_remove(num); break; } g_free(buf); } } if ( status == G_IO_STATUS_ERROR ) { fprintf(stderr, "[ERROR] read error: %s\n", error->message); } g_hash_table_destroy(fbs); g_io_channel_unref(channel); return 0; }
void GwSpawn::run() { describe(); // Working directory. const gchar *workingdirectory = NULL; if (!myworkingdirectory.empty()) workingdirectory = myworkingdirectory.c_str(); // Store arguments in argv. char *argv[myarguments.size() + 2]; // I know these casts are ugly. To do: figure out a better way. argv[0] = (char *)myprogram.c_str(); for (unsigned int i = 0; i < myarguments.size(); i++) { argv[i + 1] = (char *)myarguments[i].c_str(); } // Terminate argv. argv[myarguments.size() + 1] = NULL; // Spawn flags. int flags = G_SPAWN_SEARCH_PATH; if (mydevnull) { flags |= (G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL); } // Possible pipes. gint standard_input_filedescriptor = 0; gint standard_output_filedescriptor; gint standard_error_filedescriptor; gint *standard_input_filedescriptor_pointer = NULL; gint *standard_output_filedescriptor_pointer = NULL; gint *standard_error_filedescriptor_pointer = NULL; gchar *standard_output = NULL; gchar *standard_error = NULL; gchar **standard_output_pointer = NULL; gchar **standard_error_pointer = NULL; if (myread) { standard_output_filedescriptor_pointer = &standard_output_filedescriptor; standard_error_filedescriptor_pointer = &standard_error_filedescriptor; standard_output_pointer = &standard_output; standard_error_pointer = &standard_error; } if (!mywrite.empty()) { standard_input_filedescriptor_pointer = &standard_input_filedescriptor; } // Spawn process. if (myasync) { result = g_spawn_async_with_pipes(workingdirectory, argv, NULL, (GSpawnFlags) flags, NULL, NULL, &pid, standard_input_filedescriptor_pointer, standard_output_filedescriptor_pointer, standard_error_filedescriptor_pointer, NULL); // Handle writing to stdin. if (standard_input_filedescriptor) { tiny_spawn_write(standard_input_filedescriptor, mywrite); close(standard_input_filedescriptor); } } else { result = g_spawn_sync(workingdirectory, argv, NULL, (GSpawnFlags) flags, NULL, NULL, standard_output_pointer, standard_error_pointer, &exitstatus, NULL); } // Handle case we didn't spawn the process. if (!result) { exitstatus = -1; ustring message = myprogram; message.append(_(" didn't spawn")); gw_critical(message); return; } // Handle progress function. if (myprogress || standard_input_filedescriptor) { ProgressWindow *progresswindow = NULL; if (myprogress) progresswindow = new ProgressWindow(mytext, myallowcancel); ustring filename = gw_build_filename("/proc", convert_to_string(pid)); while (g_file_test(filename.c_str(), G_FILE_TEST_EXISTS)) { if (progresswindow) { progresswindow->pulse(); if (progresswindow->cancel) { unix_kill(pid); cancelled = true; } } g_usleep(500000); } // Close pid. g_spawn_close_pid(pid); if (progresswindow) { delete progresswindow; } } // Handle reading the output. if (myread) { // In async mode we've got file descriptors, and in sync mode we have // gchar * output. // If async mode, read the output and close the descriptors. if (myasync) { GIOChannel *channel_out = g_io_channel_unix_new(standard_output_filedescriptor); g_io_channel_read_to_end(channel_out, &standard_output, NULL, NULL); g_io_channel_shutdown(channel_out, false, NULL); GIOChannel *channel_err = g_io_channel_unix_new(standard_error_filedescriptor); g_io_channel_read_to_end(channel_err, &standard_error, NULL, NULL); g_io_channel_shutdown(channel_err, false, NULL); } ParseLine parse_out(standard_output); standardout = parse_out.lines; ParseLine parse_err(standard_error); standarderr = parse_err.lines; // Free data. if (standard_output) g_free(standard_output); if (standard_error) g_free(standard_error); } }
int main (int argc, char **argv) { GstBus *bus; GOptionContext *ctx; GIOChannel *io_stdin; GError *err = NULL; gboolean res; GOptionEntry options[] = { {NULL} }; GThread *rthread; /* Clear application state */ memset (state, 0, sizeof (*state)); state->animate = TRUE; state->current_buffer = NULL; state->caps = NULL; #if !GLIB_CHECK_VERSION (2, 31, 0) /* must initialise the threading system before using any other GLib funtion */ if (!g_thread_supported ()) g_thread_init (NULL); #endif ctx = g_option_context_new ("[ADDITIONAL ARGUMENTS]"); g_option_context_add_main_entries (ctx, options, NULL); g_option_context_add_group (ctx, gst_init_get_option_group ()); if (!g_option_context_parse (ctx, &argc, &argv, &err)) { g_print ("Error initializing: %s\n", GST_STR_NULL (err->message)); g_option_context_free (ctx); g_clear_error (&err); exit (1); } g_option_context_free (ctx); if (argc != 2) { g_print ("Usage: %s <URI> or <PIPELINE-DESCRIPTION>\n", argv[0]); exit (1); } /* Initialize GStreamer */ gst_init (&argc, &argv); /* initialize inter thread comunnication */ init_intercom (state); TRACE_VC_MEMORY ("state 0"); if (!(rthread = g_thread_new ("render", (GThreadFunc) render_func, NULL))) { g_print ("Render thread create failed\n"); exit (1); } /* Initialize player */ if (gst_uri_is_valid (argv[1])) { res = init_playbin_player (state, argv[1]); } else { res = init_parse_launch_player (state, argv[1]); } if (!res) goto done; /* Create a GLib Main Loop and set it to run */ state->main_loop = g_main_loop_new (NULL, FALSE); /* Add a keyboard watch so we get notified of keystrokes */ io_stdin = g_io_channel_unix_new (fileno (stdin)); g_io_add_watch (io_stdin, G_IO_IN, (GIOFunc) handle_keyboard, state); g_io_channel_unref (io_stdin); /* *INDENT-OFF* */ g_print ("Available commands: \n" " a - Toggle animation \n" " p - Pause playback \n" " r - Resume playback \n" " l - Query position/duration\n" " f - Seek 30 seconds forward \n" " b - Seek 30 seconds backward \n" " q - Quit \n"); /* *INDENT-ON* */ /* Connect the bus handlers */ bus = gst_element_get_bus (state->pipeline); gst_bus_set_sync_handler (bus, (GstBusSyncHandler) bus_sync_handler, state, NULL); gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH); gst_bus_enable_sync_message_emission (bus); g_signal_connect (G_OBJECT (bus), "message::error", (GCallback) error_cb, state); g_signal_connect (G_OBJECT (bus), "message::buffering", (GCallback) buffering_cb, state); g_signal_connect (G_OBJECT (bus), "message::eos", (GCallback) eos_cb, state); g_signal_connect (G_OBJECT (bus), "message::qos", (GCallback) qos_cb, state); g_signal_connect (G_OBJECT (bus), "message::state-changed", (GCallback) state_changed_cb, state); gst_object_unref (bus); /* Make player start playing */ gst_element_set_state (state->pipeline, GST_STATE_PLAYING); /* Start the mainloop */ state->main_loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (state->main_loop); done: /* Release pipeline */ if (state->pipeline) { gst_element_set_state (state->pipeline, GST_STATE_NULL); if (state->vsink) { gst_object_unref (state->vsink); state->vsink = NULL; } gst_object_unref (state->pipeline); } /* Unref the mainloop */ if (state->main_loop) { g_main_loop_unref (state->main_loop); } /* Stop rendering thread */ state->running = FALSE; g_thread_join (rthread); if (state->caps) { gst_caps_unref (state->caps); state->caps = NULL; } terminate_intercom (state); TRACE_VC_MEMORY ("at exit"); return 0; }
// it will return TRUE if scucceed gboolean send_socket( int argc, char *argv[], gboolean wait) { #ifdef DETAIL g_debug("! Launch send_socket() to send data to the exiting LilyTerm !"); g_debug("! send_socket() argc = %d, wait = %d", argc, wait); print_array("! send_socket() argv", argv); #endif GError *error = NULL; gsize len; extern gchar **environ; gchar *locale_list = get_locale_list(); const gchar *VTE_CJK_WIDTH_STR = g_getenv("VTE_CJK_WIDTH"); // VTE_CJK_WIDTH can't = NULL if (VTE_CJK_WIDTH_STR == NULL) VTE_CJK_WIDTH_STR = ""; // g_debug("Got LOCALE = %s in send_socket...", get_encoding_from_locale(NULL)); gchar *encoding = get_encoding_from_locale(NULL); if (! compare_strings(encoding, "ANSI_X3.4-1968", TRUE)) { g_free(encoding); encoding = g_strdup("UTF-8"); } // g_debug("Got encoding = %s in send_socket...", encoding); gchar *lc_messages = g_strdup(get_default_lc_data(LC_MESSAGES)); gchar *environ_str = convert_array_to_string(environ, '\t'); // print_array("! send_socket() environ", environ); // g_debug("environ_str = %s", environ_str); gchar *argv_str = convert_array_to_string(argv, '\x10'); #ifdef SAFEMODE gboolean need_free_argv_str = TRUE; if (argv_str==NULL) argv_str=g_strdup(""); if (argv_str==NULL) { need_free_argv_str = FALSE; argv_str = ""; } #endif // g_debug("argv_str = %s", argv_str); // g_debug("SEND DATA: SOCKET_DATA_VERSION = %s", SOCKET_DATA_VERSION); // g_debug("SEND DATA: locale_list = %s", locale_list); // g_debug("SEND DATA: encoding = %s", encoding); // g_debug("SEND DATA: PWD = %s", PWD); // g_debug("SEND DATA: VTE_CJK_WIDTH_STR = %s", VTE_CJK_WIDTH_STR); // g_debug("SEND DATA: wmclass_name = %s", wmclass_name); // g_debug("SEND DATA: wmclass_class = %s", wmclass_class); // g_debug("SEND DATA: environ_str = %s", environ_str); // g_debug("SEND DATA: argv_str = %s", argv_str); // 0 1 2 3 4 5 6 7 8 9 10 11 // send data: SOCKET_DATA_VERSION SHELL LOCALE_LIST ENCODING LC_MESSAGES PWD HOME VTE_CJK_WIDTH_STR wmclass_name wmclass_class ENVIRON ARGV // 0 1 2 3 4 5 6 7 8 9 10 11 gchar *arg_str = g_strdup_printf("%s\x10%s\x10%s\x10%s\x10%s\x10%s\x10%s\x10%s\x10%s\x10%s\x10%s\x10%s\x10", SOCKET_DATA_VERSION, shell, locale_list, encoding, lc_messages, pwd, home, VTE_CJK_WIDTH_STR, wmclass_name, wmclass_class, environ_str, argv_str); // g_debug("arg_str = %s", arg_str); g_free(locale_list); g_free(encoding); g_free(lc_messages); g_free(environ_str); #ifdef SAFEMODE if (need_free_argv_str) #endif g_free(argv_str); // write data! #ifdef SAFEMODE if (fcntl(socket_fd, F_GETFL) < 0) return FALSE; #endif GIOChannel *channel = g_io_channel_unix_new(socket_fd); // main_channel is NULL, so that we don't need to launch clear_channel() if (!channel) return socket_fault(12, NULL, NULL, FALSE); // set the channel to read binary file if (g_io_channel_set_encoding(channel, NULL, &error) == G_IO_STATUS_ERROR) return socket_fault(9, error, channel, TRUE); g_io_channel_set_buffered (channel, FALSE); #ifdef SAFEMODE if ((arg_str == NULL) || (g_io_channel_write_chars(channel, arg_str, -1, &len, &error)==G_IO_STATUS_ERROR)) #else if (g_io_channel_write_chars(channel, arg_str, -1, &len, &error)==G_IO_STATUS_ERROR) #endif // main_channel is NULL, so that we don't need to launch clear_channel() return socket_fault(11, error, channel, TRUE); // flush writing datas if (g_io_channel_flush(channel, &error) == G_IO_STATUS_ERROR) // main_channel is NULL, so that we don't need to launch clear_channel() return socket_fault(13, error, channel, TRUE); g_free(arg_str); // So far so good. shutdown and clear channel! clear_channel(channel, TRUE); // FIXME: sleep for 1 sec to wait the socket server. any better idea? if (wait) sleep(1); return TRUE; }
GIOChannel* i_io_channel_unix_new_listen (gchar const* address, guint port, gboolean nonblocking) { GIOChannel* channel; gint fd = -1; gchar* port_str; struct addrinfo* ai; struct addrinfo* p; struct addrinfo hints; g_return_val_if_fail(port != 0, NULL); memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = 0; hints.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG | AI_PASSIVE; port_str = g_strdup_printf("%u", port); if (getaddrinfo(address, port_str, &hints, &ai) != 0) { g_free(port_str); return NULL; } g_free(port_str); for (p = ai; p != NULL; p = p->ai_next) { if ((fd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) { continue; } if (nonblocking) { fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK); } if (bind(fd, p->ai_addr, p->ai_addrlen) < 0) { close(fd); fd = -1; continue; } break; } freeaddrinfo(ai); if (fd < 0) { return NULL; } if (listen(fd, 128) < 0) { close(fd); return NULL; } channel = g_io_channel_unix_new(fd); if (nonblocking) { g_io_channel_set_flags(channel, g_io_channel_get_flags(channel) | G_IO_FLAG_NONBLOCK, NULL); } return channel; }
int main (int argc, char *argv[]) { GOptionContext *opt_context; GError *error; GDBusConnectionFlags connection_flags; GIOChannel *io_channel; GDBusProxyFlags proxy_flags; GDBusMessage *message; GVariant *value; gchar *client_ident; gchar *input; gchar *response; gsize *len; gint ret,ret_loc; ret = 1; g_type_init (); error = NULL; object_path = NULL; opt_context = g_option_context_new ("ksr-chat-client() usage:"); g_option_context_set_summary (opt_context, "To connect to server under tcp:host=0.0.0.0 as \"maryl\" and start chatting, use:\n" " \"ksr-chat-client -n maryl -a tcp:host=0.0.0.0"); g_option_context_add_main_entries (opt_context, opt_entries, NULL); if (!g_option_context_parse (opt_context, &argc, &argv, &error)) { g_printerr ("Error parsing options: %s\n", error->message); g_error_free (error); goto out; } if (!input_is_valid()) goto out; connection_flags = G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT; connection = g_dbus_connection_new_for_address_sync (opt_address, connection_flags, NULL, /* GDBusAuthObserver */ NULL, /* GCancellable */ &error); if (connection == NULL) { g_printerr ("Error connecting to the DBus : %s\n", error->message); g_error_free(error); goto out; } g_print ("Connected to server!\n"); disallowed_chars = g_regex_new("\n", 0, 0, NULL); object_path = g_strdup_printf ("%s/%s", OBJECT_PATH,opt_name); // Now register the nickname error = NULL; value = g_dbus_connection_call_sync (connection, NULL, TMP_OBJECT_PATH, INTERFACE_PATH, "RegisterMe", g_variant_new ("(s)", opt_name), NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (value == NULL) { g_printerr ("Could not register!\n"); goto out; } else { g_variant_get (value, "(&s)", &response); if (g_strcmp0(response,REGISTRATION_RESPONSE_OK) == 0) g_print ("Registered a nickname %s , the chat is ready!\n",opt_name); else if (g_strcmp0(response,REGISTRATION_RESPONSE_NOT_OK) == 0) { g_print ("Could not register your nickname %s, please change it!\n",opt_name); goto out; } } g_dbus_connection_signal_subscribe(connection, NULL, INTERFACE_PATH, NULL, NULL, NULL, G_DBUS_SIGNAL_FLAGS_NONE, handle_signals, NULL, NULL); loop = g_main_loop_new (NULL, FALSE); // FD = 0 = stdin io_channel = g_io_channel_unix_new(0); if (!g_io_add_watch_full (io_channel, G_PRIORITY_HIGH, G_IO_IN, handle_input, NULL, NULL)) g_error ("Cannot add watch on GIOChannel!\n"); g_main_loop_run (loop); ret = 0; out: g_option_context_free (opt_context); return ret; }
/** * gst_rtsp_server_get_io_channel: * @server: a #GstRTSPServer * * Create a #GIOChannel for @server. The io channel will listen on the * configured service. * * Returns: the GIOChannel for @server or NULL when an error occured. */ GIOChannel * gst_rtsp_server_get_io_channel (GstRTSPServer * server) { GIOChannel *channel; int ret, sockfd = -1; struct addrinfo hints; struct addrinfo *result, *rp; #ifdef USE_SOLINGER struct linger linger; #endif g_return_val_if_fail (GST_IS_RTSP_SERVER (server), NULL); memset (&hints, 0, sizeof (struct addrinfo)); hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */ hints.ai_socktype = SOCK_STREAM; /* stream socket */ hints.ai_flags = AI_PASSIVE | AI_CANONNAME; /* For wildcard IP address */ hints.ai_protocol = 0; /* Any protocol */ hints.ai_canonname = NULL; hints.ai_addr = NULL; hints.ai_next = NULL; GST_DEBUG_OBJECT (server, "getting address info of %s/%s", server->address, server->service); GST_RTSP_SERVER_LOCK (server); /* resolve the server IP address */ if ((ret = getaddrinfo (server->address, server->service, &hints, &result)) != 0) goto no_address; /* create server socket, we loop through all the addresses until we manage to * create a socket and bind. */ for (rp = result; rp; rp = rp->ai_next) { sockfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol); if (sockfd == -1) { GST_DEBUG_OBJECT (server, "failed to make socket (%s), try next", g_strerror (errno)); continue; } /* make address reusable */ ret = 1; if (setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, (void *) &ret, sizeof (ret)) < 0) { /* warn but try to bind anyway */ GST_WARNING_OBJECT (server, "failed to reuse socker (%s)", g_strerror (errno)); } if (bind (sockfd, rp->ai_addr, rp->ai_addrlen) == 0) { GST_DEBUG_OBJECT (server, "bind on %s", rp->ai_canonname); break; } GST_DEBUG_OBJECT (server, "failed to bind socket (%s), try next", g_strerror (errno)); close (sockfd); sockfd = -1; } freeaddrinfo (result); if (sockfd == -1) goto no_socket; GST_DEBUG_OBJECT (server, "opened sending server socket with fd %d", sockfd); /* keep connection alive; avoids SIGPIPE during write */ ret = 1; if (setsockopt (sockfd, SOL_SOCKET, SO_KEEPALIVE, (void *) &ret, sizeof (ret)) < 0) goto keepalive_failed; #ifdef USE_SOLINGER /* make sure socket is reset 5 seconds after close. This ensure that we can * reuse the socket quickly while still having a chance to send data to the * client. */ linger.l_onoff = 1; linger.l_linger = 5; if (setsockopt (sockfd, SOL_SOCKET, SO_LINGER, (void *) &linger, sizeof (linger)) < 0) goto linger_failed; #endif /* set the server socket to nonblocking */ fcntl (sockfd, F_SETFL, O_NONBLOCK); GST_DEBUG_OBJECT (server, "listening on server socket %d with queue of %d", sockfd, server->backlog); if (listen (sockfd, server->backlog) == -1) goto listen_failed; GST_DEBUG_OBJECT (server, "listened on server socket %d, returning from connection setup", sockfd); /* create IO channel for the socket */ channel = g_io_channel_unix_new (sockfd); g_io_channel_set_close_on_unref (channel, TRUE); GST_INFO_OBJECT (server, "listening on service %s", server->service); GST_RTSP_SERVER_UNLOCK (server); return channel; /* ERRORS */ no_address: { GST_ERROR_OBJECT (server, "failed to resolve address: %s", gai_strerror (ret)); goto close_error; } no_socket: { GST_ERROR_OBJECT (server, "failed to create socket: %s", g_strerror (errno)); goto close_error; } keepalive_failed: { GST_ERROR_OBJECT (server, "failed to configure keepalive socket: %s", g_strerror (errno)); goto close_error; } #ifdef USE_SOLINGER linger_failed: { GST_ERROR_OBJECT (server, "failed to no linger socket: %s", g_strerror (errno)); goto close_error; } #endif listen_failed: { GST_ERROR_OBJECT (server, "failed to listen on socket: %s", g_strerror (errno)); goto close_error; } close_error: { if (sockfd >= 0) { close (sockfd); } GST_RTSP_SERVER_UNLOCK (server); return NULL; } }
static void start_ntp(char *server) { GIOChannel *channel; struct sockaddr_in addr; int tos = IPTOS_LOWDELAY, timestamp = 1; if (server == NULL) return; DBG("server %s", server); if (channel_watch > 0) goto send; transmit_fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0); if (transmit_fd < 0) { connman_error("Failed to open time server socket"); return; } memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; if (bind(transmit_fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) { connman_error("Failed to bind time server socket"); close(transmit_fd); return; } if (setsockopt(transmit_fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) { connman_error("Failed to set type of service option"); close(transmit_fd); return; } if (setsockopt(transmit_fd, SOL_SOCKET, SO_TIMESTAMP, ×tamp, sizeof(timestamp)) < 0) { connman_error("Failed to enable timestamp support"); close(transmit_fd); return; } channel = g_io_channel_unix_new(transmit_fd); if (channel == NULL) { close(transmit_fd); return; } g_io_channel_set_encoding(channel, NULL, NULL); g_io_channel_set_buffered(channel, FALSE); g_io_channel_set_close_on_unref(channel, TRUE); channel_watch = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, received_data, NULL, NULL); g_io_channel_unref(channel); send: send_packet(transmit_fd, server); }
int sniffer_init(void) { struct sockaddr_nfc_llcp sockaddr; int sock = 0; int err; int one = 1; buffer = g_malloc(BUFFER_LEN); sock = socket(AF_NFC, SOCK_RAW, NFC_SOCKPROTO_LLCP); if (sock < 0) { print_error("socket: %s", strerror(errno)); return -1; } err = setsockopt(sock, SOL_SOCKET, SO_TIMESTAMP, &one, sizeof(one)); if (err < 0) print_error("setsockopt: %s", strerror(errno)); memset(&sockaddr, 0, sizeof(struct sockaddr_nfc_llcp)); sockaddr.sa_family = AF_NFC; sockaddr.dev_idx = opts.adapter_idx; sockaddr.nfc_protocol = NFC_PROTO_NFC_DEP; err = bind(sock, (struct sockaddr *)&sockaddr, sizeof(struct sockaddr_nfc_llcp)); if (err < 0) { print_error("bind: %s", strerror(errno)); goto exit; } gio_channel = g_io_channel_unix_new(sock); g_io_channel_set_close_on_unref(gio_channel, TRUE); g_io_channel_set_encoding(gio_channel, NULL, NULL); g_io_channel_set_buffered(gio_channel, FALSE); watch = g_io_add_watch(gio_channel, G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR, gio_handler, NULL); g_io_channel_unref(gio_channel); if (opts.pcap_filename) { err = pcap_file_init(opts.pcap_filename); if (err) goto exit; } err = llcp_decode_init(); if (err) goto exit; printf("Start sniffer on nfc%d\n\n", opts.adapter_idx); exit: if (err) sniffer_cleanup(); return err; }
static void* plain_sockets_thread_func (void *data) { GMainContext *context; ClientData cd; int fd; struct sockaddr_un addr; GIOChannel *channel; GSource *gsource; g_printerr ("Starting client thread %p\n", g_thread_self()); fd = socket (PF_UNIX, SOCK_STREAM, 0); if (fd < 0) { g_printerr ("Failed to create socket: %s", strerror (errno)); exit (1); } _DBUS_ZERO (addr); addr.sun_family = AF_UNIX; #ifdef HAVE_ABSTRACT_SOCKETS /* remember that abstract names aren't nul-terminated so we rely * on sun_path being filled in with zeroes above. */ addr.sun_path[0] = '\0'; /* this is what says "use abstract" */ strncpy (&addr.sun_path[1], plain_sockets_address, _DBUS_MAX_SUN_PATH_LENGTH - 2); /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */ #else /* HAVE_ABSTRACT_SOCKETS */ strncpy (addr.sun_path, plain_sockets_address, _DBUS_MAX_SUN_PATH_LENGTH - 1); #endif /* ! HAVE_ABSTRACT_SOCKETS */ if (connect (fd, (struct sockaddr*) &addr, sizeof (addr)) < 0) { g_printerr ("Failed to connect to socket %s: %s", plain_sockets_address, strerror (errno)); exit (1); } context = g_main_context_new (); cd.iterations = 1; cd.loop = g_main_loop_new (context, FALSE); cd.vtable = data; channel = g_io_channel_unix_new (fd); gsource = g_io_create_watch (channel, G_IO_IN | G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL | G_IO_PRI); g_source_set_callback (gsource, (GSourceFunc)plain_sockets_client_side_watch, &cd, NULL); g_source_attach (gsource, context); g_io_channel_unref (channel); g_printerr ("Client thread writing to prime pingpong\n"); write_junk (fd, echo_call_size, cd.vtable->fake_malloc_overhead); g_printerr ("Client thread done writing primer\n"); g_printerr ("Client thread entering main loop\n"); g_main_loop_run (cd.loop); g_printerr ("Client thread %p exiting main loop\n", g_thread_self()); g_source_destroy (gsource); close (fd); g_main_loop_unref (cd.loop); g_main_context_unref (context); return NULL; }
static void* plain_sockets_init_server (ServerData *sd) { PlainSocketServer *server; struct sockaddr_un addr; static char path[] = "/tmp/dbus-test-profile-XXXXXX"; char *p; GIOChannel *channel; server = g_new0 (PlainSocketServer, 1); server->sd = sd; server->vtable = sd->vtable; /* for convenience */ p = path; while (*p) { if (*p == 'X') *p = 'a' + (int) (26.0*rand()/(RAND_MAX+1.0)); ++p; } g_printerr ("Socket is %s\n", path); server->listen_fd = socket (PF_UNIX, SOCK_STREAM, 0); if (server->listen_fd < 0) { g_printerr ("Failed to create socket: %s", strerror (errno)); exit (1); } _DBUS_ZERO (addr); addr.sun_family = AF_UNIX; #ifdef HAVE_ABSTRACT_SOCKETS /* remember that abstract names aren't nul-terminated so we rely * on sun_path being filled in with zeroes above. */ addr.sun_path[0] = '\0'; /* this is what says "use abstract" */ strncpy (&addr.sun_path[1], path, _DBUS_MAX_SUN_PATH_LENGTH - 2); /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */ #else /* HAVE_ABSTRACT_SOCKETS */ { struct stat sb; if (stat (path, &sb) == 0 && S_ISSOCK (sb.st_mode)) unlink (path); } strncpy (addr.sun_path, path, _DBUS_MAX_SUN_PATH_LENGTH - 1); #endif /* ! HAVE_ABSTRACT_SOCKETS */ if (bind (server->listen_fd, (struct sockaddr*) &addr, sizeof (addr)) < 0) { g_printerr ("Failed to bind socket \"%s\": %s", path, strerror (errno)); exit (1); } if (listen (server->listen_fd, 30 /* backlog */) < 0) { g_printerr ("Failed to listen on socket \"%s\": %s", path, strerror (errno)); exit (1); } plain_sockets_address = path; channel = g_io_channel_unix_new (server->listen_fd); server->source_id = g_io_add_watch (channel, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL | G_IO_PRI, plain_sockets_new_client_watch, server); g_io_channel_unref (channel); return server; }
int main(int argc, char **argv){ GtkBuilder *builder = NULL; GError *error = NULL; GtkWidget *main_window = NULL; GtkWidget *main_screen = NULL; GtkWidget *button_list[MAX_BUTTON]; GtkWidget *led_list[MAX_LEDS]; #ifndef TRUE_COLOR guint32 virtual_color[256]; #endif // init_sighandler(); //init gtk context gtk_init(&argc, &argv); gdk_rgb_init(); //init color palette #ifndef TRUE_COLOR virtual_palette_set((unsigned int *)virtual_color); V_CPU.cmap = gdk_rgb_cmap_new(virtual_color, 256); #endif builder = gtk_builder_new(); //load UI from file. If error occurs, report it and quit application. if(!gtk_builder_add_from_file(builder, UI_FILE, &error)) { g_warning("%s", error->message); g_free(error); return -1; } // gtk_builder_connect_signals(builder,NULL); //create main_window and configure it main_screen an buttonq main_window = GTK_WIDGET(gtk_builder_get_object(builder,"main_window")); gtk_signal_connect(GTK_OBJECT (main_window), "delete_event", GTK_SIGNAL_FUNC(destroy),NULL); //create main screen and configure it main_screen = GTK_WIDGET(gtk_builder_get_object(builder,"main_screen")); //gtk_drawing_area_size(GTK_DRAWING_AREA(main_screen), SCREEN_XRES, SCREEN_YRES); gtk_signal_connect(GTK_OBJECT (main_screen), "expose_event", GTK_SIGNAL_FUNC(on_darea_expose),NULL); //refresh screen rate 75 ms gtk_timeout_add(75, Repaint,(gpointer)main_screen); //read kb layout provide by user interface virtual_kb_create_button(builder,button_list,MAX_BUTTON,kb_layout,read_kb); //create radio button provide by user interface virtual_leds_create_radio_button(builder,led_list,MAX_LEDS); //add stdin in watch descriptor V_CPU.gui_event = gio_watch; V_CPU.gui_event[0].watch = (void*)g_io_channel_unix_new(0); g_io_add_watch((GIOChannel *)V_CPU.gui_event[0].watch,G_IO_IN, (GIOFunc)gio_watch[0].func,0); gtk_widget_add_events(main_screen, GDK_POINTER_MOTION_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK); gtk_widget_show(main_window); //destroy builder, since we don't need it anymore g_object_unref(G_OBJECT(builder)); //init hardware init_hardware((void *)&V_CPU); //wait for pipe ready if(load_pipe()<0) { return -1; } //main gtk loop gtk_main(); return 0; }
int main (int argc, char *argv []) { /*Running Shell*/ GError *error = NULL; python_shell_data = g_try_malloc (sizeof (ChildProcessData)); python_shell_data->argv = NULL; python_shell_data->slave_termios = g_try_malloc (sizeof (struct termios)); python_shell_data->current_dir = NULL; bash_loaded = ptyFork (python_shell_data, &error); gtk_init (&argc, &argv); python_shell_data->channel = g_io_channel_unix_new (python_shell_data->master_fd); g_io_add_watch (python_shell_data->channel, G_IO_IN, (GIOFunc)read_masterFd, &(python_shell_data->master_fd)); /**********/ /*Loading Options*/ if (g_file_test ("./options.inf", G_FILE_TEST_EXISTS)) load_options_from_file ("./options.inf"); else { options.indent_width = 4; options.tab_width = 4; options.is_code_completion = TRUE; options.is_code_folding = TRUE; options.show_line_numbers = TRUE; options.font_name = "Liberation Mono"; } /*************/ options.python_shell_path = "/usr/bin/python"; options.comment_out_str = "##"; options.indent_width_str = " "; options.tab_width_str = " "; env_python_path = ""; gchar **p = options.env_vars; if (p) { while (*p) { gchar *s = g_strstr_len (*p, -1, "PYTHONPATH="); if (s) { env_python_path = s + strlen ("PYTHONPATH="); break; } p++; } } /*Get sys.path*/ char *sys_path_argv[] = {"python", "./scripts/path.py", NULL}; g_spawn_sync (NULL, sys_path_argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, &sys_path_string, NULL, NULL, NULL); /***********/ char *_str = g_strconcat (sys_path_string, "\n", env_python_path, NULL); g_free (sys_path_string); sys_path_string = _str; file_monitor = file_monitor_new (file_monitor_changed); /*Setting Main Window*/ GtkWidget *navigate_bookmarks; builder = gtk_builder_new (); gtk_builder_add_from_file (builder, "./ui/main.ui", NULL); content_box = GTK_WIDGET (gtk_builder_get_object (builder, "content_box")); window = gtk_builder_get_object (builder, "main_window"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); path_browser = path_browser_new (); g_object_ref (path_browser); proj_notebook = project_notebook_new (); /**Setting proj_syms_tree_view**/ symbols_view = symbols_view_new (); g_object_ref (symbols_view); /*************************/ content_paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); g_object_ref (content_paned); status_bar = gtk_statusbar_new (); g_object_ref (status_bar); gtk_notebook_append_page (GTK_NOTEBOOK (proj_notebook), symbols_view, gtk_label_new ("Symbols")); gtk_notebook_append_page (GTK_NOTEBOOK (proj_notebook), path_browser, gtk_label_new ("Paths")); navigate_bookmarks = GTK_WIDGET (gtk_builder_get_object (builder, "navigate_bookmarks")); bookmarks_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (navigate_bookmarks), bookmarks_menu); GtkAccelGroup *accelgroup = GTK_ACCEL_GROUP (gtk_builder_get_object (builder, "accelgroup")); /*Connecting menu item's signals*/ //For File Menu g_signal_connect (gtk_builder_get_object (builder, "file_new"), "activate", G_CALLBACK (file_new_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_new_tab"), "activate", G_CALLBACK (file_new_tab_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_open"), "activate", G_CALLBACK (file_open_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "recentchoosermenu"), "selection-done", G_CALLBACK (file_recent_menu_selection_done), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_save"), "activate", G_CALLBACK (file_save_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_save_as"), "activate", G_CALLBACK (file_save_as_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_save_copy_as"), "activate", G_CALLBACK (file_save_copy_as_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_save_all"), "activate", G_CALLBACK (file_save_all_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_close_tab"), "activate", G_CALLBACK (file_close_tab_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_close_all_tabs"), "activate", G_CALLBACK (file_close_all_tabs_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "file_quit"), "activate", G_CALLBACK (file_quit_activate), NULL); //For Edit Menu g_signal_connect (gtk_builder_get_object (builder, "edit_undo"), "activate", G_CALLBACK (edit_undo_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_redo"), "activate", G_CALLBACK (edit_redo_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_cut"), "activate", G_CALLBACK (edit_cut_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_copy"), "activate", G_CALLBACK (edit_copy_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_paste"), "activate", G_CALLBACK (edit_paste_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_delete"), "activate", G_CALLBACK (edit_delete_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_select_all"), "activate", G_CALLBACK (edit_select_all_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_select_function"), "activate", G_CALLBACK (edit_select_function_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_select_block"), "activate", G_CALLBACK (edit_select_block_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_fold_all_func"), "activate", G_CALLBACK (edit_fold_all_func_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_unfold_all_func"), "activate", G_CALLBACK (edit_unfold_all_func_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_fold_current_func"), "activate", G_CALLBACK (edit_fold_current_func_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_autocomplete"), "activate", G_CALLBACK (edit_autocomplete_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "edit_matching_paranthesis"), "activate", G_CALLBACK (edit_matching_paranthesis_activate), NULL); //For Format Menu g_signal_connect (gtk_builder_get_object (builder, "format_inc_indent"), "activate", G_CALLBACK (format_inc_indent_activate), NULL); gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_inc_indent")), "activate", accelgroup, GDK_KEY_bracketright, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); g_signal_connect (gtk_builder_get_object (builder, "format_dec_indent"), "activate", G_CALLBACK (format_dec_indent_activate), NULL); gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_dec_indent")), "activate", accelgroup, GDK_KEY_bracketleft, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); g_signal_connect (gtk_builder_get_object (builder, "format_comment_out"), "activate", G_CALLBACK (format_comment_out_activate), NULL); gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_comment_out")), "activate", accelgroup, GDK_KEY_3, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); g_signal_connect (gtk_builder_get_object (builder, "format_uncomment_out"), "activate", G_CALLBACK (format_uncomment_out_activate), NULL); gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_uncomment_out")), "activate", accelgroup, GDK_KEY_4, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); g_signal_connect (gtk_builder_get_object (builder, "format_tabify_region"), "activate", G_CALLBACK (format_tabify_region_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "format_untabify_region"), "activate", G_CALLBACK (format_untabify_region_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "format_uppercase"), "activate", G_CALLBACK (format_uppercase_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "format_lowercase"), "activate", G_CALLBACK (format_lowercase_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "format_strip_spaces"), "activate", G_CALLBACK (format_strip_spaces_activate), NULL); //For Search Menu g_signal_connect (gtk_builder_get_object (builder, "search_find"), "activate", G_CALLBACK (search_find_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_next"), "activate", G_CALLBACK (search_find_next_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_prev"), "activate", G_CALLBACK (search_find_prev_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_replace"), "activate", G_CALLBACK (search_find_replace_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_selected"), "activate", G_CALLBACK (search_find_selected_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_in_text"), "activate", G_CALLBACK (search_find_in_text_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_find_file"), "activate", G_CALLBACK (search_find_file_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_replace_file"), "activate", G_CALLBACK (search_replace_file_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "search_reg_exp"), "activate", G_CALLBACK (search_reg_exp_activate), NULL); //For Navigation Menu g_signal_connect (gtk_builder_get_object (builder, "navigate_back"), "activate", G_CALLBACK (navigate_back_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_forward"), "activate", G_CALLBACK (navigate_forward_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_first_line"), "activate", G_CALLBACK (navigate_first_line_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_last_line"), "activate", G_CALLBACK (navigate_last_line_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_line_history"), "select", G_CALLBACK (navigate_line_history_select), NULL); g_signal_connect (gtk_builder_get_object (builder, "naviagate_add_bookmark"), "activate", G_CALLBACK (naviagate_add_bookmark_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "naviagate_clear_bookmarks"), "activate", G_CALLBACK (naviagate_clear_bookmarks_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_prev_bookmarks"), "activate", G_CALLBACK (navigate_prev_bookmarks_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_next_bookmark"), "activate", G_CALLBACK (navigate_next_bookmark_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_bookmarks"), "activate", G_CALLBACK (navigate_bookmarks_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_line"), "activate", G_CALLBACK (navigate_go_to_line_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_block_start"), "activate", G_CALLBACK (navigate_go_to_block_start_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_func_def"), "activate", G_CALLBACK (navigate_go_to_func_def_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_next_func"), "activate", G_CALLBACK (navigate_go_to_next_func_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_prev_func"), "activate", G_CALLBACK (navigate_go_to_prev_func_activate), NULL); //For Project Menu g_signal_connect (gtk_builder_get_object (builder, "project_new"), "activate", G_CALLBACK (project_new_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_open"), "activate", G_CALLBACK (project_open_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_save"), "activate", G_CALLBACK (project_save_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_save_as"), "activate", G_CALLBACK (project_save_as_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_save_copy_as"), "activate", G_CALLBACK (project_save_copy_as_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_empty"), "activate", G_CALLBACK (project_empty_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_close"), "activate", G_CALLBACK (project_close_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_preferences"), "activate", G_CALLBACK (project_preferences_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "project_recent"), "activate", G_CALLBACK (project_recent_activate), NULL); //For Python Shell Menu g_signal_connect (gtk_builder_get_object (builder, "python_shell_open"), "activate", G_CALLBACK (python_shell_open_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "python_shell_restart"), "activate", G_CALLBACK (python_shell_restart_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "python_shell_close"), "activate", G_CALLBACK (python_shell_close_activate), NULL); //For Run Menu g_signal_connect (gtk_builder_get_object (builder, "run_run_script"), "activate", G_CALLBACK (run_run_script_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "run_debug_script"), "activate", G_CALLBACK (run_debug_script_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "run_run_project"), "activate", G_CALLBACK (run_run_project_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "run_debug_project"), "activate", G_CALLBACK (run_debug_project_activate), NULL); //For Debug Menu g_signal_connect (gtk_builder_get_object (builder, "debug_open_pdb_shell"), "activate", G_CALLBACK (debug_open_pdb_shell_activate), NULL); //For Tools Menu g_signal_connect (gtk_builder_get_object (builder, "tools_options"), "activate", G_CALLBACK (tools_options_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "tools_auto_indent"), "activate", G_CALLBACK (tools_auto_indent_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "tools_class_browser"), "activate", G_CALLBACK (tools_class_browser_activate), NULL); /*************************/ /**Connecting Toolbar's signals**/ g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_menu"), "clicked", G_CALLBACK (toolbar_new_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_file"), "activate", G_CALLBACK (toolbar_new_file_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_project"), "activate", G_CALLBACK (toolbar_new_proj_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_menu"), "clicked", G_CALLBACK (toolbar_open_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_file"), "activate", G_CALLBACK (toolbar_open_file_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_project"), "activate", G_CALLBACK (toolbar_open_proj_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_menu"), "clicked", G_CALLBACK (toolbar_save_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_file"), "activate", G_CALLBACK (toolbar_save_file_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_project"), "activate", G_CALLBACK (toolbar_save_project_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as"), "clicked", G_CALLBACK (toolbar_save_as_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as_file"), "activate", G_CALLBACK (toolbar_save_as_file_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as_project"), "activate", G_CALLBACK (toolbar_save_as_project_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_undo"), "clicked", G_CALLBACK (toolbar_undo_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_redo"), "clicked", G_CALLBACK (toolbar_redo_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_cut"), "clicked", G_CALLBACK (toolbar_cut_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_copy"), "clicked", G_CALLBACK (toolbar_copy_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_paste"), "clicked", G_CALLBACK (toolbar_cut_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_delete"), "clicked", G_CALLBACK (toolbar_delete_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_select_all"), "clicked", G_CALLBACK (toolbar_select_all_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_find"), "clicked", G_CALLBACK (toolbar_find_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_find_replace"), "clicked", G_CALLBACK (toolbar_find_replace_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_inc_indent"), "clicked", G_CALLBACK (toolbar_inc_indent_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_dec_indent"), "clicked", G_CALLBACK (toolbar_dec_indent_clicked), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_next_line"), "clicked", G_CALLBACK (navigate_forward_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_prev_line"), "clicked", G_CALLBACK (navigate_back_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_add_bookmark"), "clicked", G_CALLBACK (naviagate_add_bookmark_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_next_bookmark"), "clicked", G_CALLBACK (navigate_next_bookmark_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_prev_bookmark"), "clicked", G_CALLBACK (navigate_prev_bookmarks_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_clear_bookmark"), "clicked", G_CALLBACK (naviagate_clear_bookmarks_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_run"), "clicked", G_CALLBACK (toolbar_run), NULL); /*g_signal_connect (gtk_builder_get_object (builder, "toolbar_debug"), "clicked", G_CALLBACK (toolbar_dec_indent_clicked), NULL); */ g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_shell"), "clicked", G_CALLBACK (python_shell_open_activate), NULL); g_signal_connect (gtk_builder_get_object (builder, "toolbar_options"), "clicked", G_CALLBACK (tools_options_activate), NULL); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_add_bookmark")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksadd.png",NULL))); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_next_bookmark")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksnext.png",NULL))); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_prev_bookmark")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksprev.png",NULL))); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_clear_bookmark")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksclear.png",NULL))); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_debug")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/debug.png",NULL))); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_open_shell")), gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/python_shell.png",NULL))); /*************************/ line_history_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_builder_get_object (builder, "navigate_line_history")), line_history_menu); GtkRecentFilter *py_recent_filter = gtk_recent_filter_new (); gtk_recent_filter_set_name (py_recent_filter, "Python Files"); gtk_recent_filter_add_pattern (py_recent_filter, "*.py"); gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (gtk_builder_get_object (builder, "recentchoosermenu")), py_recent_filter); /* Connecting window's signals and events */ g_signal_connect (window, "delete-event", G_CALLBACK (delete_event), NULL); g_signal_connect (window, "destroy", G_CALLBACK (main_window_destroy), NULL); /********************************/ /*Other global variables*/ search_text = NULL; bookmark_array= NULL; bookmark_array_size = 0; current_bookmark_index = -1; /******************/ /*Initialize Regular Expressions*/ regex_class = g_regex_new ("[ \\ \\t]*\\bclass\\b\\s*\\w+\\s*\\(*.*\\)*:", 0, 0, NULL); regex_func = g_regex_new ("[ \\ \\t]*def\\s+[\\w\\d_]+\\s*\\(.+\\)\\:", 0, 0, NULL); /*Regex if you don't want to search imports with in indentation*/ /*regex_import = g_regex_new ("^import\\s+[\\w\\d_\\.]+", 0, 0, NULL); regex_import_as = g_regex_new ("^import\\s+[\\w\\d_\\.]+\\s+as\\s+[\\w\\d_]+", 0, 0, NULL);*/ regex_from_import = g_regex_new ("^from\\s+[\\w\\d_\\.]+\\s+import\\s+[\\w\\d_]+", 0, 0, NULL); regex_from_import_as = g_regex_new ("^from\\s+[\\w\\d_\\.]+\\s+import\\s+[\\w\\d_]+as\\s+[\\w\\d_]", 0, 0, NULL); regex_global_var = g_regex_new ("^[\\w\\d_]+\\s*=\\s*[\\w\\d_]+\\s*\\(.+\\)", 0, 0, NULL); regex_static_var = g_regex_new ("^\\s*[\\w\\d_]+\\s*=.+", 0, 0, NULL); regex_word = g_regex_new ("[self]*[\\w\\d_\\.]+$", 0, 0, NULL); regex_local_var = g_regex_new ("^\\s*[\\w\\d_\\.]+\\s*=.+", 0, 0, NULL); regex_self_var = g_regex_new ("^\\s+self\\.[\\w\\d_]+\\s*=.+", 0, 0, NULL); /*Regex if you want to search imports with in indentation*/ regex_import = g_regex_new ("^\\s*import\\s+[\\w\\d_\\.]+", 0, 0, NULL); regex_import_as = g_regex_new ("^\\s*import\\s+[\\w\\d_]+\\s+as\\s+[\\w\\d_]+", 0, 0, NULL); /***********************/ async_queue = g_async_queue_new (); //Creating code_widget_array //code_widget_array = g_malloc0 (1*sizeof (CodeWidget *)); //code_widget_array [0] = codewidget_new (); code_widget_array_size = 0; notebook = gtk_notebook_new (); g_object_ref (notebook); //gtk_notebook_append_page (GTK_NOTEBOOK (notebook), code_widget_array [0]->vbox, // gtk_label_new ("New File")); /*If bash is not loaded*/ if (!bash_loaded) { gchar *msg = g_strdup_printf ("Cannot run Python Shell (%s)", error->message); gtk_statusbar_push (GTK_STATUSBAR (status_bar), 0, msg); g_free (msg); g_error_free (error); } /****************/ GtkSettings *settings = gtk_settings_get_default (); g_object_set (settings, "gtk-application-prefer-dark-theme", TRUE, NULL); gtk_window_maximize (GTK_WINDOW (window)); gtk_widget_show_all (GTK_WIDGET (window)); gtk_main (); return 0; }
char * netstatus_sysdeps_read_iface_statistics (const char *iface, gulong *in_packets, gulong *out_packets, gulong *in_bytes, gulong *out_bytes) { GError *error; char *command_line; char **argv; char *error_message = NULL; int pipe_out; g_return_val_if_fail (iface != NULL, NULL); g_return_val_if_fail (in_packets != NULL, NULL); g_return_val_if_fail (out_packets != NULL, NULL); g_return_val_if_fail (in_bytes != NULL, NULL); g_return_val_if_fail (out_bytes != NULL, NULL); *in_packets = -1; *out_packets = -1; *in_bytes = -1; *out_bytes = -1; error = NULL; command_line = g_strdup_printf ("/usr/bin/netstat -n -I %s -b -f inet", iface); if (!g_shell_parse_argv (command_line, NULL, &argv, &error)) { error_message = g_strdup_printf (_("Could not parse command line '%s': %s"), command_line, error->message); g_error_free (error); g_free (command_line); return error_message; } g_free (command_line); error = NULL; if (g_spawn_async_with_pipes (NULL, argv, NULL, 0, NULL, NULL, NULL, NULL, &pipe_out, NULL, &error)) { GIOChannel *channel; char *buf; int prx_idx, ptx_idx; int brx_idx, btx_idx; channel = g_io_channel_unix_new (pipe_out); g_io_channel_read_line (channel, &buf, NULL, NULL, NULL); parse_header (buf, &prx_idx, &ptx_idx, &brx_idx, &btx_idx); g_free (buf); if (prx_idx == -1 || ptx_idx == -1 || brx_idx == -1 || btx_idx == -1) { error_message = g_strdup (_("Could not parse 'netstat' output. Unknown format")); goto error_shutdown; } g_io_channel_read_line (channel, &buf, NULL, NULL, NULL); if (!parse_stats (buf, prx_idx, ptx_idx, in_packets, out_packets, brx_idx, btx_idx, in_bytes, out_bytes)) { error_message = g_strdup_printf (_("Could not parse interface statistics from '%s'. " "prx_idx = %d; ptx_idx = %d; brx_idx = %d; btx_idx = %d;"), buf, prx_idx, ptx_idx, brx_idx, btx_idx); } else if (*in_packets == -1 || *out_packets == -1 || *in_bytes == -1 || *out_bytes == -1) { error_message = g_strdup_printf ("Could not obtain information on interface '%s' from netstat", iface); } g_free (buf); error_shutdown: g_io_channel_unref (channel); close (pipe_out); } else { error_message = g_strdup_printf ("Error running /usr/bin/netstat for '%s': %s", iface, error->message); g_error_free (error); } g_strfreev (argv); return error_message; }
static void process_exec(PROCESS_REC *rec, const char *cmd) { const char *shell_args[4] = { "/bin/sh", "-c", NULL, NULL }; char **args; int in[2], out[2]; int n; if (pipe(in) == -1) return; if (pipe(out) == -1) return; shell_args[2] = cmd; rec->pid = fork(); if (rec->pid == -1) { /* error */ close(in[0]); close(in[1]); close(out[0]); close(out[1]); return; } if (rec->pid != 0) { /* parent process */ GIOChannel *outio = g_io_channel_unix_new(in[1]); rec->in = g_io_channel_unix_new(out[0]); rec->out = net_sendbuffer_create(outio, 0); close(out[1]); close(in[0]); pidwait_add(rec->pid); return; } /* child process, try to clean up everything */ setsid(); setuid(getuid()); setgid(getgid()); signal(SIGINT, SIG_IGN); signal(SIGQUIT, SIG_DFL); putenv("TERM=tty"); /* set stdin, stdout and stderr */ dup2(in[0], STDIN_FILENO); dup2(out[1], STDOUT_FILENO); dup2(out[1], STDERR_FILENO); /* don't let child see our files */ for (n = 3; n < 256; n++) close(n); if (rec->shell) { execvp(shell_args[0], (char **) shell_args); fprintf(stderr, "Exec: /bin/sh: %s\n", g_strerror(errno)); } else { args = g_strsplit(cmd, " ", -1); execvp(args[0], args); fprintf(stderr, "Exec: %s: %s\n", args[0], g_strerror(errno)); } _exit(-1); }
void screenshot_save_start (GdkPixbuf *pixbuf, SaveFunction callback, gpointer user_data) { GPid pid; gboolean ret; int parent_exit_notification[2]; int pipe_from_child[2]; pipe (parent_exit_notification); pipe (pipe_from_child); parent_dir = make_temp_directory (); if (parent_dir == NULL) return; tmp_filename = g_build_filename (parent_dir, _("Screenshot.png"), NULL); save_callback = callback; save_user_data = user_data; pid = fork (); if (pid == 0) { GError *error = NULL; char c; signal (SIGINT, signal_handler); signal (SIGTERM, signal_handler); close (parent_exit_notification [1]); close (pipe_from_child [0]); if (icc_profile_base64 != NULL) { ret = gdk_pixbuf_save (pixbuf, tmp_filename, "png", &error, "icc-profile", icc_profile_base64, "tEXt::Software", "gnome-screenshot", NULL); } else { ret = gdk_pixbuf_save (pixbuf, tmp_filename, "png", &error, "tEXt::Software", "gnome-screenshot", NULL); } if (!ret) { if (error && error->message) write (pipe_from_child[1], error->message, strlen (error->message)); else #define ERROR_MESSAGE _("Unknown error saving screenshot to disk") write (pipe_from_child[1], ERROR_MESSAGE, strlen (ERROR_MESSAGE)); } /* By closing the pipe, we let the main process know that we're * done saving it. */ close (pipe_from_child[1]); read (parent_exit_notification[0], &c, 1); clean_up_temporary_dir (FALSE); _exit (0); } else if (pid > 0) { GIOChannel *channel; close (parent_exit_notification[0]); close (pipe_from_child[1]); channel = g_io_channel_unix_new (pipe_from_child[0]); g_io_add_watch (channel, G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL, read_pipe_from_child, NULL); g_io_channel_unref (channel); g_child_watch_add (pid, child_done_notification, NULL); } else /* George awesomely wrote code originally to handle the * could-not-fork case synchronously. I'm not copying it, as I'm * guessing that the system is pretty hosed if that's the case. * However, he gets major kudos for trying. (-: */ g_assert_not_reached (); }
/* * starts gdb, collects commands and start the first one */ static gboolean run(const gchar* file, const gchar* commandline, GList* env, GList *witer, GList *biter, const gchar* terminal_device, dbg_callbacks* callbacks) { GError *err = NULL; const gchar *exclude[] = { "LANG", NULL }; gchar **gdb_env = utils_copy_environment(exclude, "LANG", "C", NULL); gchar *working_directory = g_path_get_dirname(file); GList *lines, *iter; GList *commands = NULL; GString *command; int bp_index; queue_item *item; dbg_cbs = callbacks; /* spawn GDB */ if (!g_spawn_async_with_pipes(working_directory, (gchar**)gdb_args, gdb_env, GDB_SPAWN_FLAGS, NULL, NULL, &gdb_pid, &gdb_in, &gdb_out, NULL, &err)) { dbg_cbs->report_error(_("Failed to spawn gdb process")); g_free(working_directory); g_strfreev(gdb_env); return FALSE; } g_free(working_directory); g_strfreev(gdb_env); /* move gdb to it's own process group */ setpgid(gdb_pid, 0); /* set handler for gdb process exit event */ gdb_src_id = g_child_watch_add(gdb_pid, on_gdb_exit, NULL); /* create GDB GIO chanels */ gdb_ch_in = g_io_channel_unix_new(gdb_in); gdb_ch_out = g_io_channel_unix_new(gdb_out); /* reading starting gdb messages */ lines = read_until_prompt(); for (iter = lines; iter; iter = iter->next) { gchar *unescaped = g_strcompress((gchar*)iter->data); if (strlen(unescaped)) { colorize_message((gchar*)iter->data); } } g_list_foreach(lines, (GFunc)g_free, NULL); g_list_free(lines); /* add initial watches to the list */ while (witer) { gchar *name = (gchar*)witer->data; variable *var = variable_new(name, VT_WATCH); watches = g_list_append(watches, var); witer = witer->next; } /* collect commands */ /* loading file */ command = g_string_new(""); g_string_printf(command, "-file-exec-and-symbols \"%s\"", file); commands = add_to_queue(commands, _("~\"Loading target file.\\n\""), command->str, _("Error loading file"), FALSE); g_string_free(command, TRUE); /* setting asyncronous mode */ commands = add_to_queue(commands, NULL, "-gdb-set target-async 1", _("Error configuring GDB"), FALSE); /* setting null-stop array printing */ commands = add_to_queue(commands, NULL, "-interpreter-exec console \"set print null-stop\"", _("Error configuring GDB"), FALSE); /* enable pretty printing */ commands = add_to_queue(commands, NULL, "-enable-pretty-printing", _("Error configuring GDB"), FALSE); /* set locale */ command = g_string_new(""); g_string_printf(command, "-gdb-set environment LANG=%s", g_getenv("LANG")); commands = add_to_queue(commands, NULL, command->str, NULL, FALSE); g_string_free(command, TRUE); /* set arguments */ command = g_string_new(""); g_string_printf(command, "-exec-arguments %s", commandline); commands = add_to_queue(commands, NULL, command->str, NULL, FALSE); g_string_free(command, TRUE); /* set passed evironment */ iter = env; while (iter) { gchar *name, *value; name = (gchar*)iter->data; iter = iter->next; value = (gchar*)iter->data; command = g_string_new(""); g_string_printf(command, "-gdb-set environment %s=%s", name, value); commands = add_to_queue(commands, NULL, command->str, NULL, FALSE); g_string_free(command, TRUE); iter = iter->next; } /* set breaks */ bp_index = 1; while (biter) { breakpoint *bp = (breakpoint*)biter->data; GString *error_message = g_string_new(""); command = g_string_new(""); g_string_printf(command, "-break-insert -f \"\\\"%s\\\":%i\"", bp->file, bp->line); g_string_printf(error_message, _("Breakpoint at %s:%i cannot be set\nDebugger message: %s"), bp->file, bp->line, "%s"); commands = add_to_queue(commands, NULL, command->str, error_message->str, TRUE); g_string_free(command, TRUE); if (bp->hitscount) { command = g_string_new(""); g_string_printf(command, "-break-after %i %i", bp_index, bp->hitscount); commands = add_to_queue(commands, NULL, command->str, error_message->str, TRUE); g_string_free(command, TRUE); } if (strlen(bp->condition)) { command = g_string_new(""); g_string_printf (command, "-break-condition %i %s", bp_index, bp->condition); commands = add_to_queue(commands, NULL, command->str, error_message->str, TRUE); g_string_free(command, TRUE); } if (!bp->enabled) { command = g_string_new(""); g_string_printf (command, "-break-disable %i", bp_index); commands = add_to_queue(commands, NULL, command->str, error_message->str, TRUE); g_string_free(command, TRUE); } g_string_free(error_message, TRUE); bp_index++; biter = biter->next; } /* set debugging terminal */ command = g_string_new("-inferior-tty-set "); g_string_append(command, terminal_device); commands = add_to_queue(commands, NULL, command->str, NULL, FALSE); g_string_free(command, TRUE); /* connect read callback to the output chanel */ gdb_id_out = g_io_add_watch(gdb_ch_out, G_IO_IN, on_read_async_output, commands); item = (queue_item*)commands->data; /* send message to debugger messages window */ if (item->message) { dbg_cbs->send_message(item->message->str, "grey"); } /* send first command */ gdb_input_write_line(item->command->str); return TRUE; }
GtkWidget * progress_create_widget (GtkWidget * dlg) { GtkWidget *w; GIOChannel *channel; // fix it when vertical specified #if GTK_CHECK_VERSION(3,0,0) w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); #else w = gtk_vbox_new (FALSE, 0); #endif progress_bar = gtk_progress_bar_new (); gtk_widget_set_name (progress_bar, "yad-progress-widget"); if (options.progress_data.log_on_top) gtk_box_pack_end (GTK_BOX (w), progress_bar, FALSE, FALSE, 0); else gtk_box_pack_start (GTK_BOX (w), progress_bar, FALSE, FALSE, 0); if (options.progress_data.percentage > 100) options.progress_data.percentage = 100; gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress_bar), options.progress_data.percentage / 100.0); if (options.progress_data.progress_text) gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress_bar), options.progress_data.progress_text); #if GTK_CHECK_VERSION(3,0,0) gtk_progress_bar_set_inverted (GTK_PROGRESS_BAR (progress_bar), options.progress_data.rtl); #else if (options.progress_data.rtl) gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (progress_bar), GTK_PROGRESS_RIGHT_TO_LEFT); #endif if (options.progress_data.log) { GtkWidget *ex, *sw; ex = gtk_expander_new (options.progress_data.log); gtk_expander_set_spacing (GTK_EXPANDER (ex), 2); gtk_expander_set_expanded (GTK_EXPANDER (ex), options.progress_data.log_expanded); gtk_box_pack_start (GTK_BOX (w), ex, TRUE, TRUE, 2); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), options.hscroll_policy, options.vscroll_policy); gtk_container_add (GTK_CONTAINER (ex), sw); progress_log = gtk_text_view_new (); gtk_widget_set_name (progress_log, "yad-text-widget"); gtk_widget_set_size_request (progress_log, -1, options.progress_data.log_height); gtk_container_add (GTK_CONTAINER (sw), progress_log); log_buffer = gtk_text_buffer_new (NULL); gtk_text_view_set_buffer (GTK_TEXT_VIEW (progress_log), log_buffer); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (progress_log), 5); gtk_text_view_set_right_margin (GTK_TEXT_VIEW (progress_log), 5); gtk_text_view_set_editable (GTK_TEXT_VIEW (progress_log), FALSE); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (progress_log), FALSE); } #if GTK_CHECK_VERSION(3,0,0) else gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (progress_bar), TRUE); #endif channel = g_io_channel_unix_new (0); g_io_channel_set_encoding (channel, NULL, NULL); g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, NULL); g_io_add_watch (channel, G_IO_IN | G_IO_HUP, handle_stdin, dlg); return w; }
gboolean ice_setup_listeners (int num_listeners, IceListenObj *listen_objs, XfsmManager *manager) { GIOChannel *channel; char *auth_setup_file; gchar *command; FILE *cleanup_fp; FILE *setup_fp; int fd; int n; IceSetIOErrorHandler (ice_error_handler); IceAddConnectionWatch (ice_connection_watch, manager); cleanup_fp = ice_tmpfile(&auth_cleanup_file); if (cleanup_fp == NULL) return FALSE; setup_fp = ice_tmpfile(&auth_setup_file); if (setup_fp == NULL) { fclose (cleanup_fp); unlink (auth_cleanup_file); g_free (auth_cleanup_file); return FALSE; } for (n = 0; n < num_listeners; n++) { fd = IceGetListenConnectionNumber (listen_objs[n]); /* Make sure we don't pass on these file descriptors to an * exec'd child process. */ fcntl (fd, F_SETFD, fcntl (fd, F_GETFD, 0) | FD_CLOEXEC); channel = g_io_channel_unix_new (fd); g_io_add_watch (channel, G_IO_ERR | G_IO_HUP | G_IO_IN, ice_connection_accept, listen_objs[n]); g_io_channel_unref (channel); /* setup auth for this listener */ ice_auth_add (setup_fp, cleanup_fp, "ICE", listen_objs[n]); ice_auth_add (setup_fp, cleanup_fp, "XSMP", listen_objs[n]); IceSetHostBasedAuthProc (listen_objs[n], ice_auth_proc); } fclose (setup_fp); fclose (cleanup_fp); /* setup ICE authority and remove setup file */ command = g_strdup_printf ("%s source %s", ICEAUTH_CMD, auth_setup_file); if (system (command) != 0) { g_warning ("Failed to setup the ICE authentication data, session " "management might not work properly."); } g_free (command); unlink (auth_setup_file); g_free (auth_setup_file); return TRUE; }
static void * example_thread(void *data) { NiceAgent *agent; NiceCandidate *local, *remote; GIOChannel* io_stdin; guint stream_id; gchar *line = NULL; int rval; io_stdin = g_io_channel_unix_new(fileno(stdin)); g_io_channel_set_flags (io_stdin, G_IO_FLAG_NONBLOCK, NULL); // Create the nice agent agent = nice_agent_new(g_main_loop_get_context (gloop), NICE_COMPATIBILITY_RFC5245); if (agent == NULL) g_error("Failed to create agent"); // Set the STUN settings and controlling mode if (stun_addr) { g_object_set(G_OBJECT(agent), "stun-server", stun_addr, NULL); g_object_set(G_OBJECT(agent), "stun-server-port", stun_port, NULL); } g_object_set(G_OBJECT(agent), "controlling-mode", controlling, NULL); // Connect to the signals g_signal_connect(G_OBJECT(agent), "candidate-gathering-done", G_CALLBACK(cb_candidate_gathering_done), NULL); g_signal_connect(G_OBJECT(agent), "new-selected-pair", G_CALLBACK(cb_new_selected_pair), NULL); g_signal_connect(G_OBJECT(agent), "component-state-changed", G_CALLBACK(cb_component_state_changed), NULL); // Create a new stream with one component stream_id = nice_agent_add_stream(agent, 1); if (stream_id == 0) g_error("Failed to add stream"); // Attach to the component to receive the data // Without this call, candidates cannot be gathered nice_agent_attach_recv(agent, stream_id, 1, g_main_loop_get_context (gloop), cb_nice_recv, NULL); // Start gathering local candidates if (!nice_agent_gather_candidates(agent, stream_id)) g_error("Failed to start candidate gathering"); g_debug("waiting for candidate-gathering-done signal..."); g_mutex_lock(&gather_mutex); while (!exit_thread && !candidate_gathering_done) g_cond_wait(&gather_cond, &gather_mutex); g_mutex_unlock(&gather_mutex); if (exit_thread) goto end; // Candidate gathering is done. Send our local candidates on stdout printf("Copy this line to remote client:\n"); printf("\n "); print_local_data(agent, stream_id, 1); printf("\n"); // Listen on stdin for the remote candidate list printf("Enter remote data (single line, no wrapping):\n"); printf("> "); fflush (stdout); while (!exit_thread) { GIOStatus s = g_io_channel_read_line (io_stdin, &line, NULL, NULL, NULL); if (s == G_IO_STATUS_NORMAL) { // Parse remote candidate list and set it on the agent rval = parse_remote_data(agent, stream_id, 1, line); if (rval == EXIT_SUCCESS) { g_free (line); break; } else { fprintf(stderr, "ERROR: failed to parse remote data\n"); printf("Enter remote data (single line, no wrapping):\n"); printf("> "); fflush (stdout); } g_free (line); } else if (s == G_IO_STATUS_AGAIN) { usleep (100000); } } g_debug("waiting for state READY or FAILED signal..."); g_mutex_lock(&negotiate_mutex); while (!exit_thread && !negotiation_done) g_cond_wait(&negotiate_cond, &negotiate_mutex); g_mutex_unlock(&negotiate_mutex); if (exit_thread) goto end; // Get current selected candidate pair and print IP address used if (nice_agent_get_selected_pair (agent, stream_id, 1, &local, &remote)) { gchar ipaddr[INET6_ADDRSTRLEN]; nice_address_to_string(&local->addr, ipaddr); printf("\nNegotiation complete: ([%s]:%d,", ipaddr, nice_address_get_port(&local->addr)); nice_address_to_string(&remote->addr, ipaddr); printf(" [%s]:%d)\n", ipaddr, nice_address_get_port(&remote->addr)); } // Listen to stdin and send data written to it printf("\nSend lines to remote (Ctrl-D to quit):\n"); printf("> "); fflush (stdout); while (!exit_thread) { GIOStatus s = g_io_channel_read_line (io_stdin, &line, NULL, NULL, NULL); if (s == G_IO_STATUS_NORMAL) { nice_agent_send(agent, stream_id, 1, strlen(line), line); g_free (line); printf("> "); fflush (stdout); } else if (s == G_IO_STATUS_AGAIN) { usleep (100000); } else { // Ctrl-D was pressed. nice_agent_send(agent, stream_id, 1, 1, "\0"); break; } } end: g_io_channel_unref (io_stdin); g_object_unref(agent); g_main_loop_quit (gloop); return NULL; }
/* Spawn passwd backend * Returns: TRUE on success, FALSE otherwise and sets error appropriately */ static gboolean spawn_passwd (PasswordDialog *pdialog, GError **error) { gchar *argv[2]; gchar *envp[1]; gint my_stdin, my_stdout, my_stderr; argv[0] = "/usr/bin/passwd"; /* Is it safe to rely on a hard-coded path? */ argv[1] = NULL; envp[0] = NULL; /* If we pass an empty array as the environment, * will the childs environment be empty, and the * locales set to the C default? From the manual: * "If envp is NULL, the child inherits its * parent'senvironment." * If I'm wrong here, we somehow have to set * the locales here. */ if (!g_spawn_async_with_pipes (NULL, /* Working directory */ argv, /* Argument vector */ envp, /* Environment */ G_SPAWN_DO_NOT_REAP_CHILD, /* Flags */ NULL, /* Child setup */ NULL, /* Data to child setup */ &pdialog->backend_pid, /* PID */ &my_stdin, /* Stdin */ &my_stdout, /* Stdout */ &my_stderr, /* Stderr */ error)) { /* GError */ /* An error occurred */ free_passwd_resources (pdialog); return FALSE; } /* 2>&1 */ if (dup2 (my_stderr, my_stdout) == -1) { /* Failed! */ g_set_error (error, PASSDLG_ERROR, PASSDLG_ERROR_BACKEND, "%s", strerror (errno)); /* Clean up */ stop_passwd (pdialog); return FALSE; } /* Open IO Channels */ pdialog->backend_stdin = g_io_channel_unix_new (my_stdin); pdialog->backend_stdout = g_io_channel_unix_new (my_stdout); /* Set raw encoding */ /* Set nonblocking mode */ if (g_io_channel_set_encoding (pdialog->backend_stdin, NULL, error) != G_IO_STATUS_NORMAL || g_io_channel_set_encoding (pdialog->backend_stdout, NULL, error) != G_IO_STATUS_NORMAL || g_io_channel_set_flags (pdialog->backend_stdin, G_IO_FLAG_NONBLOCK, error) != G_IO_STATUS_NORMAL || g_io_channel_set_flags (pdialog->backend_stdout, G_IO_FLAG_NONBLOCK, error) != G_IO_STATUS_NORMAL ) { /* Clean up */ stop_passwd (pdialog); return FALSE; } /* Turn off buffering */ g_io_channel_set_buffered (pdialog->backend_stdin, FALSE); g_io_channel_set_buffered (pdialog->backend_stdout, FALSE); /* Add IO Channel watcher */ pdialog->backend_stdout_watch_id = g_io_add_watch (pdialog->backend_stdout, G_IO_IN | G_IO_PRI, (GIOFunc) io_watch_stdout, pdialog); /* Add child watcher */ pdialog->backend_child_watch_id = g_child_watch_add (pdialog->backend_pid, (GChildWatchFunc) child_watch_cb, pdialog); /* Success! */ return TRUE; }
GPid storage_daemon_spawn_for_variant (StorageDaemon *daemon, const gchar **argv, const GVariantType *type, void (*callback) (GPid, GVariant *, GError *, gpointer), gpointer user_data) { GError *error = NULL; struct VariantReaderData *data; gchar *prog = NULL; GPid pid; gint output_fd; gchar *cmd; /* * This is so we can override the location of storaged-lvm-helper * during testing. */ if (!strchr (argv[0], '/')) { prog = storage_daemon_get_resource_path (daemon, TRUE, argv[0]); argv[0] = prog; } cmd = g_strjoinv (" ", (gchar **)argv); g_debug ("spawning for variant: %s", cmd); g_free (cmd); if (!g_spawn_async_with_pipes (NULL, (gchar **)argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL, &pid, NULL, &output_fd, NULL, &error)) { callback (0, NULL, error, user_data); g_error_free (error); return 0; } data = g_new0 (struct VariantReaderData, 1); data->type = type; data->callback = callback; data->user_data = user_data; data->pid = pid; data->output = g_byte_array_new (); data->output_channel = g_io_channel_unix_new (output_fd); g_io_channel_set_encoding (data->output_channel, NULL, NULL); g_io_channel_set_flags (data->output_channel, G_IO_FLAG_NONBLOCK, NULL); data->output_watch = g_io_add_watch (data->output_channel, G_IO_IN, variant_reader_child_output, data); g_child_watch_add_full (G_PRIORITY_DEFAULT_IDLE, pid, variant_reader_watch_child, data, variant_reader_destroy); g_free (prog); return pid; }
int main(int argc, char *argv[]) { GstElement *pipeline, *bin, *effect_element, *convert, *sink; GstPad *pad, *ghost_pad; char *pipeline_str; GIOChannel *io_stdin = g_io_channel_unix_new(fileno(stdin)); CustomData data; GstStateChangeReturn ret; gboolean list_effects = FALSE; gchar *effect_name = NULL; GError *error = NULL; GstPlugin *gaudiplugin; gchar *props_str = NULL; GOptionContext *context; GOptionEntry options[] = { { "list-effects", 'l', 0, G_OPTION_ARG_NONE, &list_effects, "list available effects and exits", NULL }, { "effect", 'e', 0, G_OPTION_ARG_STRING, &effect_name, "set the desired effect", NULL }, { "props", 'p', 0, G_OPTION_ARG_STRING, &props_str, "for property setting (-p \"silent,bool,true;adjustement,uint,150\")", NULL }, { NULL } }; setlocale(LC_ALL, "fr_FR.utf8"); gst_init(&argc, &argv); gaudiplugin = gst_registry_find_plugin(GET_PLUGIN_REGISTRY, "gaudieffects"); if (gaudiplugin == NULL) { g_print("Pas de plugin “gaudieffects” trouvé !! :(\n"); return -1; } context = g_option_context_new(""); g_option_context_add_main_entries(context, options, ""); if (!g_option_context_parse(context, &argc, &argv, &error)) { g_print("option parsing failed: %s\n", error->message); return -1; } g_option_context_free(context); if (list_effects == TRUE) return list_gaudieffects_features(); if (argc > 1) { if (g_str_has_prefix(argv[1], "http://") || g_str_has_prefix(argv[1], "ftp://")) pipeline_str = g_strdup_printf("%s uri=\"%s\"", PLAYBIN, argv[1]); else if (argv[1][0] == '~') pipeline_str = g_strdup_printf("%s uri=\"file://%s%s\"", PLAYBIN, g_get_home_dir(), argv[1]+1); else if (g_file_test(argv[1], G_FILE_TEST_IS_REGULAR)) pipeline_str = g_strdup_printf("playbin uri=\"file://%s\"", argv[1]); else pipeline_str = g_strdup_printf("%s uri=%s", PLAYBIN, DEFAULT_URI); } else pipeline_str = g_strdup_printf("%s uri=%s", PLAYBIN, DEFAULT_URI); g_io_add_watch(io_stdin, G_IO_IN, (GIOFunc)handle_keyboard, &data); pipeline = gst_parse_launch(pipeline_str, NULL); if (gst_plugin_is_loaded(gaudiplugin) == FALSE) gst_plugin_load(gaudiplugin); if (effect_name == NULL) effect_name = "solarize"; effect_element = gst_element_factory_make(effect_name, effect_name); convert = gst_element_factory_make("videoconvert", "convert"); sink = gst_element_factory_make("autovideosink", "video_sink"); if (!effect_element || !convert || !sink) { g_printerr("Not all elements could be created.\n"); return -1; } bin = gst_bin_new("video_sink_bin"); gst_bin_add_many(GST_BIN(bin), effect_element, convert, sink, NULL); gst_element_link_many(effect_element, convert, sink, NULL); pad = gst_element_get_static_pad(effect_element, "sink"); ghost_pad = gst_ghost_pad_new("sink", pad); gst_pad_set_active(ghost_pad, TRUE); gst_element_add_pad(bin, ghost_pad); gst_object_unref(pad); g_object_set(GST_OBJECT(pipeline), "video-sink", bin, NULL); if (props_str != NULL) set_props(effect_element, props_str); ret = gst_element_set_state(pipeline, GST_STATE_PLAYING); if (ret == GST_STATE_CHANGE_FAILURE) { g_printerr("Unable to set the pipeline to the playing state.\n"); gst_object_unref(pipeline); return -1; } data.loop = g_main_loop_new(NULL, FALSE); g_main_loop_run(data.loop); g_io_channel_unref(io_stdin); gst_element_set_state(pipeline, GST_STATE_NULL); gst_object_unref(pipeline); return 0; }
GHashTable * SlashProcNet_GetSnmp6(void) { GHashTable *myHashTable = NULL; GIOChannel *myChannel = NULL; GIOStatus ioStatus; gchar *myInputLine = NULL; Bool parseError = FALSE; int fd = -1; static GRegex *myRegex = NULL; if (myRegex == NULL) { myRegex = g_regex_new("^(\\w+)\\s+(-?\\d+)\\s*$", G_REGEX_OPTIMIZE, 0, NULL); ASSERT(myRegex); } if ((fd = g_open(pathToNetSnmp6, O_RDONLY)) == -1) { return NULL; } myChannel = g_io_channel_unix_new(fd); myHashTable = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); /* * Expected format: * * key1 value1 * key2 value2 * ... * keyN valueN */ while ((ioStatus = g_io_channel_read_line(myChannel, &myInputLine, NULL, NULL, NULL)) == G_IO_STATUS_NORMAL) { GMatchInfo *matchInfo = NULL; if (g_regex_match(myRegex, myInputLine, 0, &matchInfo)) { gchar *myKey = NULL; gchar *myVal = NULL; guint64 *myIntVal = NULL; myKey = g_match_info_fetch(matchInfo, 1); myVal = g_match_info_fetch(matchInfo, 2); /* * By virtue of having matched the above regex, this conversion * must hold. */ myIntVal = g_new(guint64, 1); *myIntVal = g_ascii_strtoull(myVal, NULL, 10); /* * The hash table will take ownership of myKey and myIntVal. We're * still responsible for myVal. */ g_hash_table_insert(myHashTable, myKey, myIntVal); g_free(myVal); } else { parseError = TRUE; } g_match_info_free(matchInfo); g_free(myInputLine); myInputLine = NULL; if (parseError) { break; } } if (ioStatus == G_IO_STATUS_ERROR || g_hash_table_size(myHashTable) == 0 || parseError) { g_hash_table_destroy(myHashTable); myHashTable = NULL; } close(fd); g_io_channel_unref(myChannel); return myHashTable; }
static gint initRTP(AirplayRenderer *self, gint *controlPort, gint *timingPort) { AirplayRendererPrivate *priv = AIRPLAY_RENDERER_GET_PRIVATE(self); if(priv->dataSocket) { g_object_unref(priv->dataSocket); priv->dataSocket = NULL; } if(priv->controlSocket) { g_object_unref(priv->controlSocket); priv->controlSocket = NULL; } if(priv->timingSocket) { g_object_unref(priv->timingSocket); priv->timingSocket = NULL; } GError *error = NULL; struct sockaddr_in addr4; struct sockaddr_in6 addr6; gushort *sinPort = NULL; if(priv->socketFamily == G_SOCKET_FAMILY_IPV4) { memset(&addr4, 0, sizeof(addr4)); addr4.sin_family = AF_INET; addr4.sin_addr.s_addr = htonl(INADDR_ANY); sinPort = &(addr4.sin_port); } else { memset(&addr6, 0, sizeof(addr6)); addr6.sin6_family = AF_INET6; addr6.sin6_addr = in6addr_any; addr6.sin6_flowinfo = 0; sinPort = &(addr6.sin6_port); } gint port = 6000; GSocket *dataSocket = NULL; GSocket *controlSocket = NULL; GSocket *timingSocket = NULL; gint serverPort = -1; for(; TRUE; port += 3) { if(!dataSocket) { dataSocket = g_socket_new(priv->socketFamily, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, &error); if(error) { g_printerr("AirplayRenderer: data socket create failed: %s\n", error->message); return 0; } } if(!controlSocket) { controlSocket = g_socket_new(priv->socketFamily, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, &error); if(error) { g_printerr("AirplayRenderer: control socket create failed: %s\n", error->message); return 0; } } if(!timingSocket) { timingSocket = g_socket_new(priv->socketFamily, G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, &error); if(error) { g_printerr("AirplayRenderer: timing socket create failed: %s\n", error->message); return 0; } } *sinPort = htons(port); GSocketAddress *addr = NULL; if(priv->socketFamily == G_SOCKET_FAMILY_IPV4) { addr = g_socket_address_new_from_native(&addr4, sizeof(addr4)); } else { addr = g_socket_address_new_from_native(&addr6, sizeof(addr6)); } if(!g_socket_bind(dataSocket, addr, TRUE, &error)) { g_socket_close(dataSocket, &error); continue; } else { serverPort = port; } g_object_unref(addr); *sinPort = htons(port + 1); if(priv->socketFamily == G_SOCKET_FAMILY_IPV4) { addr = g_socket_address_new_from_native(&addr4, sizeof(addr4)); } else { addr = g_socket_address_new_from_native(&addr6, sizeof(addr6)); } if(!g_socket_bind(controlSocket, addr, TRUE, &error)) { g_socket_close(controlSocket, &error); continue; } else { *controlPort = port + 1; } g_object_unref(addr); *sinPort = htons(port + 2); if(priv->socketFamily == G_SOCKET_FAMILY_IPV4) { addr = g_socket_address_new_from_native(&addr4, sizeof(addr4)); } else { addr = g_socket_address_new_from_native(&addr6, sizeof(addr6)); } if(!g_socket_bind(timingSocket, addr, TRUE, &error)) { g_socket_close(timingSocket, &error); continue; } else { *timingPort = port + 2; } g_object_unref(addr); break; } priv->dataSocket = dataSocket; priv->controlSocket = controlSocket; priv->timingSocket = timingSocket; gint fd = g_socket_get_fd(dataSocket); gint nRcvbuf = 81920 * 4; setsockopt(fd, SOL_SOCKET,SO_RCVBUF, (char *)&nRcvbuf, sizeof(gint)); // gint nNetTimeout = 5000; // setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&nNetTimeout, sizeof(gint)); priv->dataChannel = g_io_channel_unix_new(fd); priv->dataWatchID = g_io_add_watch(priv->dataChannel, G_IO_IN, (GIOFunc)dataRead, self); fd = g_socket_get_fd(controlSocket); priv->controlChannel = g_io_channel_unix_new(fd); priv->controlWatchID = g_io_add_watch(priv->controlChannel, G_IO_IN, (GIOFunc)controlRead, self); fd = g_socket_get_fd(timingSocket); priv->timingChannel = g_io_channel_unix_new(fd); priv->timingWatchID = g_io_add_watch(priv->timingChannel, G_IO_IN, (GIOFunc)timingRead, self); return serverPort; }
GPtrArray * SlashProcNet_GetRoute6(void) { GIOChannel *myChannel = NULL; GIOStatus myIoStatus; GPtrArray *myArray = NULL; gchar *myLine = NULL; Bool parseError = FALSE; int fd = -1; static GRegex *myValuesRE = NULL; if (myValuesRE == NULL) { myValuesRE = g_regex_new("^([[:xdigit:]]{32}) ([[:xdigit:]]{2}) " "([[:xdigit:]]{32}) ([[:xdigit:]]{2}) " "([[:xdigit:]]{32}) ([[:xdigit:]]{8}) " "[[:xdigit:]]{8} [[:xdigit:]]{8} " "([[:xdigit:]]{8})\\s+(\\w+)\\s*$", 0, 0, NULL); ASSERT(myValuesRE); } /* * 1. Open pathToNetRoute6, associate it with a GIOChannel. */ if ((fd = g_open(pathToNetRoute6, O_RDONLY)) == -1) { Warning("%s: open(%s): %s\n", __func__, pathToNetRoute, g_strerror(errno)); return NULL; } myChannel = g_io_channel_unix_new(fd); myArray = g_ptr_array_new(); while ((myIoStatus = g_io_channel_read_line(myChannel, &myLine, NULL, NULL, NULL)) == G_IO_STATUS_NORMAL) { struct in6_rtmsg *myEntry = NULL; GMatchInfo *myMatchInfo = NULL; if (!g_regex_match(myValuesRE, myLine, 0, &myMatchInfo)) { parseError = TRUE; goto badIteration; } myEntry = g_new0(struct in6_rtmsg, 1); g_ptr_array_add(myArray, myEntry); MATCHEXPR(myMatchInfo, 1, Ip6StringToIn6Addr(MATCH, &myEntry->rtmsg_dst)); MATCHEXPR(myMatchInfo, 3, Ip6StringToIn6Addr(MATCH, &myEntry->rtmsg_src)); MATCHEXPR(myMatchInfo, 5, Ip6StringToIn6Addr(MATCH, &myEntry->rtmsg_gateway)); myEntry->rtmsg_dst_len = MatchToGuint64(myMatchInfo, 2, 16); myEntry->rtmsg_src_len = MatchToGuint64(myMatchInfo, 4, 16); myEntry->rtmsg_metric = MatchToGuint64(myMatchInfo, 6, 16); myEntry->rtmsg_flags = MatchToGuint64(myMatchInfo, 7, 16); MATCHEXPR(myMatchInfo, 8, myEntry->rtmsg_ifindex = NetUtil_GetIfIndex(MATCH)); badIteration: g_free(myLine); myLine = NULL; g_match_info_free(myMatchInfo); myMatchInfo = NULL; if (parseError) { break; } } if (myArray && myIoStatus != G_IO_STATUS_EOF) { g_ptr_array_free(myArray, TRUE); myArray = NULL; } g_free(myLine); myLine = NULL; close(fd); g_io_channel_unref(myChannel); return myArray; }
static int connect_session_transport(struct web_session *session) { GIOFlags flags; int sk; sk = socket(session->addr->ai_family, SOCK_STREAM | SOCK_CLOEXEC, IPPROTO_TCP); if (sk < 0) return -EIO; if (session->web->index > 0) { if (bind_socket(sk, session->web->index, session->addr->ai_family) < 0) { debug(session->web, "bind() %s", strerror(errno)); close(sk); return -EIO; } } if (session->flags & SESSION_FLAG_USE_TLS) { debug(session->web, "using TLS encryption"); session->transport_channel = g_io_channel_gnutls_new(sk); } else { debug(session->web, "no encryption"); session->transport_channel = g_io_channel_unix_new(sk); } if (!session->transport_channel) { debug(session->web, "channel missing"); close(sk); return -ENOMEM; } flags = g_io_channel_get_flags(session->transport_channel); g_io_channel_set_flags(session->transport_channel, flags | G_IO_FLAG_NONBLOCK, NULL); g_io_channel_set_encoding(session->transport_channel, NULL, NULL); g_io_channel_set_buffered(session->transport_channel, FALSE); g_io_channel_set_close_on_unref(session->transport_channel, TRUE); if (connect(sk, session->addr->ai_addr, session->addr->ai_addrlen) < 0) { if (errno != EINPROGRESS) { debug(session->web, "connect() %s", strerror(errno)); close(sk); return -EIO; } } session->transport_watch = g_io_add_watch(session->transport_channel, G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR, received_data, session); session->send_watch = g_io_add_watch(session->transport_channel, G_IO_OUT | G_IO_HUP | G_IO_NVAL | G_IO_ERR, send_data, session); return 0; }