GList* ConnmanManager::delete_invalid_services() { GHashTableIter iter; gpointer key, value; GList *list = NULL; gint valid = 0, invalid = 0; DBG3(); if(m_services == NULL) return NULL; g_hash_table_iter_init(&iter, m_services); while(g_hash_table_iter_next(&iter, &key, &value)) { ConnmanService *service = (ConnmanService *)value; if(service->get_visited() == TRUE) { valid++; /* service is valid, set visited flag to FALSE */ service->set_visited(FALSE); } else { invalid++; /* service is not valid, remove it from the table and delete it. */ DBG("delete invalid service '%s'", service->get_object_path()); list = g_list_prepend(list, g_strdup(service->get_object_path())); delete service; g_hash_table_iter_remove(&iter); } } DBG2("NETWORKS VALID '%d', INVALID '%d'", valid, invalid); return list; }
static void remb_event_manager_calc_min (RembEventManager * manager, guint default_min) { guint remb_min = 0; GstClockTime time = kms_utils_get_time_nsecs (); GstClockTime oldest_time = GST_CLOCK_TIME_NONE; GHashTableIter iter; gpointer key, v; g_hash_table_iter_init (&iter, manager->remb_hash); while (g_hash_table_iter_next (&iter, &key, &v)) { guint br = ((RembHashValue *) v)->bitrate; GstClockTime ts = ((RembHashValue *) v)->ts; if (time - ts > manager->clear_interval) { GST_TRACE ("Remove entry %" G_GUINT32_FORMAT, GPOINTER_TO_UINT (key)); g_hash_table_iter_remove (&iter); continue; } if (remb_min == 0) { remb_min = br; } else { remb_min = MIN (remb_min, br); } oldest_time = MIN (oldest_time, ts); } if (remb_min == 0 && default_min > 0) { GST_DEBUG_OBJECT (manager->pad, "Setting default value: %" G_GUINT32_FORMAT, default_min); remb_min = default_min; } manager->oldest_remb_time = oldest_time; remb_event_manager_set_min (manager, remb_min); }
static void kms_element_create_pending_pads (KmsElement * self, KmsElementPadType type) { GHashTableIter iter; gpointer key, value; GstElement *element; const gchar *templ_name; GSList *keys = NULL, *l; KMS_ELEMENT_LOCK (self); if (!kms_element_get_data_by_type (self, type, &templ_name, &element)) { KMS_ELEMENT_UNLOCK (self); return; } g_hash_table_iter_init (&iter, self->priv->pendingpads); while (g_hash_table_iter_next (&iter, &key, &value)) { PendingSrcPad *pendingpad = value; /* TODO: Discriminate pads using their description */ if (pendingpad->type != type) { continue; } keys = g_slist_prepend (keys, g_strdup (key)); g_hash_table_iter_remove (&iter); } KMS_ELEMENT_UNLOCK (self); /* Create all pending pads */ for (l = keys; l != NULL; l = l->next) { kms_element_add_src_pad (self, element, l->data, templ_name); } g_slist_free_full (keys, g_free); }
static void clear_secrets_with_flags (NMSetting *setting, GParamSpec *pspec, NMSettingClearSecretsWithFlagsFn func, gpointer user_data) { NMSettingVPNPrivate *priv = NM_SETTING_VPN_GET_PRIVATE (setting); GHashTableIter iter; const char *secret; if (priv->secrets == NULL) return; /* Iterate through secrets hash and check each entry */ g_hash_table_iter_init (&iter, priv->secrets); while (g_hash_table_iter_next (&iter, (gpointer) &secret, NULL)) { NMSettingSecretFlags flags = NM_SETTING_SECRET_FLAG_NONE; nm_setting_get_secret_flags (setting, secret, &flags, NULL); if (func (setting, pspec->name, flags, user_data) == TRUE) g_hash_table_iter_remove (&iter); } }
/** Update client timeout to be maximum of context timeouts * * @param self pointer to cka_client_t structure */ static void cka_client_scan_timeout(cka_client_t *self) { tick_t now = cka_tick_get_current(); self->cli_timeout = 0; /* Expire sessions / update client timeout */ GHashTableIter iter; gpointer val; g_hash_table_iter_init(&iter, self->cli_sessions); while( g_hash_table_iter_next(&iter, 0, &val) ) { cka_session_t *session = val; if( session->ses_timeout <= now ) { /* Expire session */ cka_session_finish(session, now); g_hash_table_iter_remove(&iter); } else if( self->cli_timeout < session->ses_timeout ) { /* Update client timeout */ self->cli_timeout = session->ses_timeout; } } if( self->cli_timeout > now ) { mce_log(LL_DEBUG, "client T%+"PRId64"; %s", now - self->cli_timeout, cka_client_identify(self)); } }
/* Evicts all cached textures for named icons */ static void st_texture_cache_evict_icons (StTextureCache *cache) { GHashTableIter iter; gpointer key; gpointer value; g_debug ("%s: Pre-evict count: %d\n", G_STRFUNC, g_hash_table_size (cache->priv->keyed_cache)); g_hash_table_iter_init (&iter, cache->priv->keyed_cache); while (g_hash_table_iter_next (&iter, &key, &value)) { const char *cache_key = key; /* This is too conservative - it takes out all cached textures * for GIcons even when they aren't named icons, but it's not * worth the complexity of parsing the key and calling * g_icon_new_for_string(); icon theme changes aren't normal */ if (g_str_has_prefix (cache_key, CACHE_PREFIX_ICON)) g_hash_table_iter_remove (&iter); } g_debug ("%s: Post-evict count: %d\n", G_STRFUNC, g_hash_table_size (cache->priv->keyed_cache)); }
void _nm_object_cache_clear (NMObject *except) { GHashTableIter iter; NMObject *obj; const char *path; char *foo; _init_cache (); g_hash_table_iter_init (&iter, cache); while (g_hash_table_iter_next (&iter, (gpointer) &path, (gpointer) &obj)) { if (obj != except) { /* Remove the callback so that if the object isn't yet released * by a client, when it does finally get unrefed, it won't trigger * the cache removal for a new object with the same path as the * one being released. */ foo = g_object_steal_data (G_OBJECT (obj), "nm-object-cache-tag"); g_free (foo); g_hash_table_iter_remove (&iter); } } }
static void jaw_impl_finalize(GObject *gobject) { JawObject *jaw_obj = JAW_OBJECT(gobject); jobject global_ac = jaw_obj->acc_context; JawImpl *jaw_impl = (JawImpl*)jaw_obj; JNIEnv *jniEnv = jaw_util_get_jni_env(); object_table_remove( jniEnv, global_ac ); (*jniEnv)->DeleteGlobalRef(jniEnv, global_ac); jaw_obj->acc_context = NULL; /* Interface finalize */ GHashTableIter iter; gpointer value; g_hash_table_iter_init(&iter, jaw_impl->ifaceTable); while (g_hash_table_iter_next(&iter, NULL, &value)) { JawInterfaceInfo *info = (JawInterfaceInfo*)value; info->finalize(info->data); g_free(info); g_hash_table_iter_remove(&iter); } if (jaw_impl->ifaceTable != NULL) { g_hash_table_unref(jaw_impl->ifaceTable); g_hash_table_destroy(jaw_obj->storedData); } /* Chain up to parent's finalize */ G_OBJECT_CLASS(jaw_impl_parent_class)->finalize(gobject); }
static void shell_xdg_migrate_process_corrections (GHashTable *corrections) { GHashTableIter iter; gpointer old_filename; gpointer new_filename; g_hash_table_iter_init (&iter, corrections); while (g_hash_table_iter_next (&iter, &old_filename, &new_filename)) { gboolean is_directory; is_directory = g_file_test (old_filename, G_FILE_TEST_IS_DIR); /* If the old filename is a directory and the new filename * is NULL, treat it as a request to remove the directory. */ if (is_directory && new_filename == NULL) shell_xdg_migrate_rmdir (old_filename); else shell_xdg_migrate_rename (old_filename, new_filename); g_hash_table_iter_remove (&iter); } }
/** * Enqueues a kernel for execution on a device. * * Internally, this function calls the clSetKernelArg() OpenCL function * for each argument defined with the ::ccl_kernel_set_arg() function, * and the executes the kernel using the clEnqueueNDRangeKernel() OpenCL * function. * * @warning This function is not thread-safe. For multi-threaded * access to the same kernel function, create multiple instances of * a kernel wrapper for the given kernel function with * ::ccl_kernel_new(), one for each thread. * * @public @memberof ccl_kernel * * @param[in] krnl A kernel wrapper object. * @param[in] cq A command queue wrapper object. * @param[in] work_dim The number of dimensions used to specify the * global work-items and work-items in the work-group. * @param[in] global_work_offset Can be used to specify an array of * `work_dim` unsigned values that describe the offset used to calculate * the global ID of a work-item. * @param[in] global_work_size An array of `work_dim` unsigned values * that describe the number of global work-items in `work_dim` * dimensions that will execute the kernel function. * @param[in] local_work_size An array of `work_dim` unsigned values * that describe the number of work-items that make up a work-group that * will execute the specified kernel. * @param[in,out] evt_wait_lst List of events that need to complete * before this command can be executed. The list will be cleared and * can be reused by client code. * @param[out] err Return location for a ::CCLErr object, or `NULL` if error * reporting is to be ignored. * @return Event wrapper object that identifies this command. * */ CCL_EXPORT CCLEvent* ccl_kernel_enqueue_ndrange(CCLKernel* krnl, CCLQueue* cq, cl_uint work_dim, const size_t* global_work_offset, const size_t* global_work_size, const size_t* local_work_size, CCLEventWaitList* evt_wait_lst, CCLErr** err) { /* Make sure krnl is not NULL. */ g_return_val_if_fail(krnl != NULL, NULL); /* Make sure cq is not NULL. */ g_return_val_if_fail(cq != NULL, NULL); /* Make sure err is NULL or it is not set. */ g_return_val_if_fail(err == NULL || *err == NULL, NULL); /* OpenCL status flag. */ cl_int ocl_status; /* OpenCL event. */ cl_event event; /* Event wrapper. */ CCLEvent* evt; /* Iterator for table of kernel arguments. */ GHashTableIter iter; gpointer arg_index_ptr, arg_ptr; /* Set pending kernel arguments. */ if (krnl->args != NULL) { g_hash_table_iter_init(&iter, krnl->args); while (g_hash_table_iter_next(&iter, &arg_index_ptr, &arg_ptr)) { cl_uint arg_index = GPOINTER_TO_UINT(arg_index_ptr); CCLArg* arg = (CCLArg*) arg_ptr; ocl_status = clSetKernelArg(ccl_kernel_unwrap(krnl), arg_index, ccl_arg_size(arg), ccl_arg_value(arg)); ccl_if_err_create_goto(*err, CCL_OCL_ERROR, CL_SUCCESS != ocl_status, ocl_status, error_handler, "%s: unable to set kernel arg %d (OpenCL error %d: %s).", CCL_STRD, arg_index, ocl_status, ccl_err(ocl_status)); g_hash_table_iter_remove(&iter); } } /* Run kernel. */ ocl_status = clEnqueueNDRangeKernel(ccl_queue_unwrap(cq), ccl_kernel_unwrap(krnl), work_dim, global_work_offset, global_work_size, local_work_size, ccl_event_wait_list_get_num_events(evt_wait_lst), ccl_event_wait_list_get_clevents(evt_wait_lst), &event); ccl_if_err_create_goto(*err, CCL_OCL_ERROR, CL_SUCCESS != ocl_status, ocl_status, error_handler, "%s: unable to enqueue kernel (OpenCL error %d: %s).", CCL_STRD, ocl_status, ccl_err(ocl_status)); /* Wrap event and associate it with the respective command queue. * The event object will be released automatically when the command * queue is released. */ evt = ccl_queue_produce_event(cq, event); /* Clear event wait list. */ ccl_event_wait_list_clear(evt_wait_lst); /* If we got here, everything is OK. */ g_assert(err == NULL || *err == NULL); goto finish; error_handler: /* If we got here there was an error, verify that it is so. */ g_assert(err == NULL || *err != NULL); /* An error occurred, return NULL to signal it. */ evt = NULL; finish: /* Return evt. */ return evt; }
void chassis_log_backend_log(chassis_log_backend_t *backend, gchar* logger_name, GLogLevelFlags level, const gchar *message) { gboolean is_duplicate = FALSE; const gchar *log_lvl_name; const gchar *logger_name_clean = (logger_name[0] == '\0') ? "global" : logger_name; const gchar *stripped_message = chassis_log_skip_topsrcdir(message); switch (level & G_LOG_LEVEL_MASK) { case G_LOG_LEVEL_CRITICAL: log_lvl_name = "critical"; break; case G_LOG_LEVEL_ERROR: log_lvl_name = "error"; break; case G_LOG_LEVEL_WARNING: log_lvl_name = "warning"; break; case G_LOG_LEVEL_MESSAGE: log_lvl_name = "message"; break; case G_LOG_LEVEL_INFO: log_lvl_name = "info"; break; case G_LOG_LEVEL_DEBUG: log_lvl_name = "debug"; break; case CHASSIS_LOG_LEVEL_BROADCAST: log_lvl_name = "*"; break; default: log_lvl_name = "unknown"; break; } chassis_log_backend_lock(backend); /* check for a duplicate message * never consider this to be a duplicate if the log level is INFO (which being used to force a message, e.g. in broadcasting) */ if (backend->last_msg->len > 0 && 0 == strcmp(backend->last_msg->str, stripped_message) && level != CHASSIS_LOG_LEVEL_BROADCAST && /* a broadcast */ backend->needs_compress) { is_duplicate = TRUE; } if (!is_duplicate || backend->last_msg_count > 100 || time(NULL) - backend->last_msg_ts > 30) { /* TODO: make these limits configurable */ if (backend->last_msg_count) { GString *logger_names = g_string_new(""); guint hash_size = g_hash_table_size(backend->last_loggers); if (hash_size > 0) { /* should be always true... */ GHashTableIter iter; gpointer key, value; guint i = 0; g_hash_table_iter_init(&iter, backend->last_loggers); while (g_hash_table_iter_next(&iter, &key, &value)) { g_string_append(logger_names, (gchar*)key); g_hash_table_iter_remove(&iter); if (++i < hash_size) { g_string_append(logger_names, ", "); } } } if (backend->needs_timestamp) { chassis_log_backend_update_timestamp(backend); g_string_append_len(backend->log_str, C(": ")); } g_string_append_printf(backend->log_str, "[%s] last message repeated %d times\n", logger_names->str, backend->last_msg_count); backend->log_func(backend, level, S(backend->log_str)); g_string_free(logger_names, TRUE); } if (backend->needs_timestamp) { chassis_log_backend_update_timestamp(backend); g_string_append_len(backend->log_str, C(": ")); } g_string_append_printf(backend->log_str, "[%s] (%s) %s", logger_name_clean, log_lvl_name, stripped_message); /* reset the last-logged message */ g_string_assign(backend->last_msg, stripped_message); backend->last_msg_count = 0; backend->last_msg_ts = time(NULL); /* ask the backend to perform the write */ backend->log_func(backend, level, S(backend->log_str)); } else { /* save the logger_name to print all of the coalesced logger sources later */ gchar *hash_logger_name = g_strdup(logger_name_clean); g_hash_table_insert(backend->last_loggers, hash_logger_name, hash_logger_name); backend->last_msg_count++; } chassis_log_backend_unlock(backend); }
/* * Read tag data from a FLAC file using the level 2 flac interface, * Note: * - if field is found but contains no info (strlen(str)==0), we don't read it */ gboolean flac_tag_read_file_tag (GFile *file, File_Tag *FileTag, GError **error) { FLAC__Metadata_Chain *chain; EtFlacReadState state; FLAC__IOCallbacks callbacks = { et_flac_read_func, NULL, /* Do not set a write callback. */ et_flac_seek_func, et_flac_tell_func, et_flac_eof_func, et_flac_read_close_func }; FLAC__Metadata_Iterator *iter; EtPicture *prev_pic = NULL; g_return_val_if_fail (file != NULL && FileTag != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); chain = FLAC__metadata_chain_new (); if (chain == NULL) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_NOMEM, "%s", g_strerror (ENOMEM)); return FALSE; } state.error = NULL; state.istream = g_file_read (file, NULL, &state.error); state.seekable = G_SEEKABLE (state.istream); if (!FLAC__metadata_chain_read_with_callbacks (chain, &state, callbacks)) { /* TODO: Provide a dedicated error enum corresponding to status. */ g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s", _("Error opening FLAC file")); et_flac_read_close_func (&state); return FALSE; } iter = FLAC__metadata_iterator_new (); if (iter == NULL) { et_flac_read_close_func (&state); g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_NOMEM, "%s", g_strerror (ENOMEM)); return FALSE; } FLAC__metadata_iterator_init (iter, chain); while (FLAC__metadata_iterator_next (iter)) { FLAC__StreamMetadata *block; block = FLAC__metadata_iterator_get_block (iter); if (block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) { const FLAC__StreamMetadata_VorbisComment *vc; GHashTable *tags; GSList *strings; GHashTableIter tags_iter; gchar *key; /* Get comments from block. */ vc = &block->data.vorbis_comment; tags = populate_tag_hash_table (vc); /* Title */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_TITLE))) { g_slist_foreach (strings, values_list_foreach, &FileTag->title); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_TITLE); } /* Artist */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_ARTIST))) { g_slist_foreach (strings, values_list_foreach, &FileTag->artist); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_ARTIST); } /* Album artist. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_ALBUM_ARTIST))) { g_slist_foreach (strings, values_list_foreach, &FileTag->album_artist); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_ALBUM_ARTIST); } /* Album. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_ALBUM))) { g_slist_foreach (strings, values_list_foreach, &FileTag->album); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_ALBUM); } /* Disc number and total discs. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_DISC_TOTAL))) { /* Only take values from the first total discs field. */ if (!et_str_empty (strings->data)) { FileTag->disc_total = et_disc_number_to_string (atoi (strings->data)); } g_slist_free_full (strings, g_free); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_DISC_TOTAL); } if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_DISC_NUMBER))) { /* Only take values from the first disc number field. */ if (!et_str_empty (strings->data)) { gchar *separator; separator = strchr (strings->data, '/'); if (separator && !FileTag->disc_total) { FileTag->disc_total = et_disc_number_to_string (atoi (separator + 1)); *separator = '\0'; } FileTag->disc_number = et_disc_number_to_string (atoi (strings->data)); } g_slist_free_full (strings, g_free); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_DISC_NUMBER); } /* Track number and total tracks. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_TRACK_TOTAL))) { /* Only take values from the first total tracks field. */ if (!et_str_empty (strings->data)) { FileTag->track_total = et_track_number_to_string (atoi (strings->data)); } g_slist_free_full (strings, g_free); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_TRACK_TOTAL); } if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_TRACK_NUMBER))) { /* Only take values from the first track number field. */ if (!et_str_empty (strings->data)) { gchar *separator; separator = strchr (strings->data, '/'); if (separator && !FileTag->track_total) { FileTag->track_total = et_track_number_to_string (atoi (separator + 1)); *separator = '\0'; } FileTag->track = et_track_number_to_string (atoi (strings->data)); } g_slist_free_full (strings, g_free); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_TRACK_NUMBER); } /* Year. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_DATE))) { g_slist_foreach (strings, values_list_foreach, &FileTag->year); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_DATE); } /* Genre. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_GENRE))) { g_slist_foreach (strings, values_list_foreach, &FileTag->genre); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_GENRE); } /* Comment. */ { GSList *descs; GSList *comments; descs = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_DESCRIPTION); comments = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_COMMENT); /* Prefer DESCRIPTION, as it is part of the spec. */ if (descs && !comments) { g_slist_foreach (descs, values_list_foreach, &FileTag->comment); } else if (descs && comments) { /* Mark the file as modified, so that comments are written * to the DESCRIPTION field on saving. */ FileTag->saved = FALSE; g_slist_foreach (descs, values_list_foreach, &FileTag->comment); g_slist_foreach (comments, values_list_foreach, &FileTag->comment); } else if (comments) { FileTag->saved = FALSE; g_slist_foreach (comments, values_list_foreach, &FileTag->comment); } g_slist_free (descs); g_slist_free (comments); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_DESCRIPTION); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_COMMENT); } /* Composer. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_COMPOSER))) { g_slist_foreach (strings, values_list_foreach, &FileTag->composer); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_COMPOSER); } /* Original artist. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_PERFORMER))) { g_slist_foreach (strings, values_list_foreach, &FileTag->orig_artist); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_PERFORMER); } /* Copyright. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_COPYRIGHT))) { g_slist_foreach (strings, values_list_foreach, &FileTag->copyright); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_COPYRIGHT); } /* URL. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_CONTACT))) { g_slist_foreach (strings, values_list_foreach, &FileTag->url); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_CONTACT); } /* Encoded by. */ if ((strings = g_hash_table_lookup (tags, ET_VORBIS_COMMENT_FIELD_ENCODED_BY))) { g_slist_foreach (strings, values_list_foreach, &FileTag->encoded_by); g_slist_free (strings); g_hash_table_remove (tags, ET_VORBIS_COMMENT_FIELD_ENCODED_BY); } /* Save unsupported fields. */ g_hash_table_iter_init (&tags_iter, tags); while (g_hash_table_iter_next (&tags_iter, (gpointer *)&key, (gpointer *)&strings)) { GSList *l; for (l = strings; l != NULL; l = g_slist_next (l)) { FileTag->other = g_list_prepend (FileTag->other, g_strconcat (key, "=", l->data, NULL)); } g_slist_free_full (strings, g_free); g_hash_table_iter_remove (&tags_iter); } if (FileTag->other) { FileTag->other = g_list_reverse (FileTag->other); } /* The hash table should now only contain keys. */ g_hash_table_unref (tags); } else if (block->type == FLAC__METADATA_TYPE_PICTURE) { /* Picture. */ const FLAC__StreamMetadata_Picture *p; GBytes *bytes; EtPicture *pic; /* Get picture data from block. */ p = &block->data.picture; bytes = g_bytes_new (p->data, p->data_length); pic = et_picture_new (p->type, (const gchar *)p->description, 0, 0, bytes); g_bytes_unref (bytes); if (!prev_pic) { FileTag->picture = pic; } else { prev_pic->next = pic; } prev_pic = pic; } } FLAC__metadata_iterator_delete (iter); FLAC__metadata_chain_delete (chain); et_flac_read_close_func (&state); #ifdef ENABLE_MP3 /* If no FLAC vorbis tag found : we try to get the ID3 tag if it exists * (but it will be deleted when rewriting the tag) */ if ( FileTag->title == NULL && FileTag->artist == NULL && FileTag->album_artist == NULL && FileTag->album == NULL && FileTag->disc_number == NULL && FileTag->disc_total == NULL && FileTag->year == NULL && FileTag->track == NULL && FileTag->track_total == NULL && FileTag->genre == NULL && FileTag->comment == NULL && FileTag->composer == NULL && FileTag->orig_artist == NULL && FileTag->copyright == NULL && FileTag->url == NULL && FileTag->encoded_by == NULL && FileTag->picture == NULL) { id3tag_read_file_tag (file, FileTag, NULL); // If an ID3 tag has been found (and no FLAC tag), we mark the file as // unsaved to rewrite a flac tag. if ( FileTag->title != NULL || FileTag->artist != NULL || FileTag->album_artist != NULL || FileTag->album != NULL || FileTag->disc_number != NULL || FileTag->disc_total != NULL || FileTag->year != NULL || FileTag->track != NULL || FileTag->track_total != NULL || FileTag->genre != NULL || FileTag->comment != NULL || FileTag->composer != NULL || FileTag->orig_artist != NULL || FileTag->copyright != NULL || FileTag->url != NULL || FileTag->encoded_by != NULL || FileTag->picture != NULL) { FileTag->saved = FALSE; } } #endif return TRUE; }
static void update_with_variant (GPid pid, GVariant *info, GError *error, gpointer user_data) { StoragedLinuxVolumeGroupObject *object = user_data; StoragedDaemon *daemon; GDBusObjectManagerServer *manager; GVariantIter *iter; GHashTableIter volume_iter; gpointer key, value; GHashTable *new_lvs; GHashTable *new_pvs; GList *objects, *l; gboolean needs_polling = FALSE; daemon = storaged_linux_volume_group_object_get_daemon (object); manager = storaged_daemon_get_object_manager (daemon); if (error) { storaged_warning ("Failed to update LVM volume group %s: %s", storaged_linux_volume_group_object_get_name (object), error->message); g_object_unref (object); return; } storaged_linux_volume_group_update (STORAGED_LINUX_VOLUME_GROUP (object->iface_volume_group), info, &needs_polling); if (!g_dbus_object_manager_server_is_exported (manager, G_DBUS_OBJECT_SKELETON (object))) g_dbus_object_manager_server_export_uniquely (manager, G_DBUS_OBJECT_SKELETON (object)); new_lvs = g_hash_table_new (g_str_hash, g_str_equal); if (g_variant_lookup (info, "lvs", "aa{sv}", &iter)) { GVariant *lv_info = NULL; while (g_variant_iter_loop (iter, "@a{sv}", &lv_info)) { const gchar *name; StoragedLinuxLogicalVolumeObject *volume; g_variant_lookup (lv_info, "name", "&s", &name); update_operations (daemon, name, lv_info, &needs_polling); if (lv_is_pvmove_volume (name)) needs_polling = TRUE; if (storaged_daemon_util_lvm2_name_is_reserved (name)) continue; volume = g_hash_table_lookup (object->logical_volumes, name); if (volume == NULL) { volume = storaged_linux_logical_volume_object_new (daemon, object, name); storaged_linux_logical_volume_object_update (volume, lv_info, &needs_polling); storaged_linux_logical_volume_object_update_etctabs (volume); g_dbus_object_manager_server_export_uniquely (manager, G_DBUS_OBJECT_SKELETON (volume)); g_hash_table_insert (object->logical_volumes, g_strdup (name), g_object_ref (volume)); } else storaged_linux_logical_volume_object_update (volume, lv_info, &needs_polling); g_hash_table_insert (new_lvs, (gchar *)name, volume); } g_variant_iter_free (iter); } g_hash_table_iter_init (&volume_iter, object->logical_volumes); while (g_hash_table_iter_next (&volume_iter, &key, &value)) { const gchar *name = key; StoragedLinuxLogicalVolumeObject *volume = value; if (!g_hash_table_contains (new_lvs, name)) { g_dbus_object_manager_server_unexport (manager, g_dbus_object_get_object_path (G_DBUS_OBJECT (volume))); g_hash_table_iter_remove (&volume_iter); g_object_unref (G_OBJECT (volume)); } } storaged_volume_group_set_needs_polling (STORAGED_VOLUME_GROUP (object->iface_volume_group), needs_polling); /* Update block objects. */ new_pvs = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify)g_variant_unref); if (g_variant_lookup (info, "pvs", "aa{sv}", &iter)) { const gchar *name; GVariant *pv_info; while (g_variant_iter_next (iter, "@a{sv}", &pv_info)) { if (g_variant_lookup (pv_info, "device", "&s", &name)) g_hash_table_insert (new_pvs, (gchar *)name, pv_info); else g_variant_unref (pv_info); } } objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (manager)); for (l = objects; l != NULL; l = l->next) { if (STORAGED_IS_LINUX_BLOCK_OBJECT (l->data)) update_block (STORAGED_LINUX_BLOCK_OBJECT (l->data), object, new_lvs, new_pvs); } g_list_free_full (objects, g_object_unref); g_hash_table_destroy (new_lvs); g_hash_table_destroy (new_pvs); g_object_unref (object); }
static void construct_resolve_slist(GHashTable *addr_table) { static const char *funcname = "construct_resolve_slist"; int addr_score_idx = 0; GHashTableIter iter; gpointer key, value; // Did we change the list? Used to decide to print new list // We get a new list if we get a new session, or we add or delete a node // from the cluster; or if we update a health score struct addr_score_s *addr_score[MAX_NODES + 1] = {NULL}; // Is there anything in node_hash_table not in addr table, // e.g. a deleted addr g_hash_table_iter_init (&iter, node_status.node_hash_table); log_print(LOG_DEBUG, SECTION_SESSION_DEFAULT, "%s: hash_table [%p], iter [%p]", funcname, node_status.node_hash_table, iter); while (g_hash_table_iter_next (&iter, &key, &value)) { // Is this address in addr_table? bool exists = g_hash_table_lookup(addr_table, key); if (!exists) { // delete the node g_hash_table_iter_remove(&iter); log_print(LOG_NOTICE, SECTION_SESSION_DEFAULT, "%s: removed from hash table: %s", funcname, key); } } // Is there anything in addr_table not in node_hash_table // e.g. an added addr g_hash_table_iter_init (&iter, addr_table); while (g_hash_table_iter_next (&iter, &key, &value)) { // Is this address in addr_table? bool exists = g_hash_table_lookup(node_status.node_hash_table, key); if (!exists) { // Add to node_hash_table set_health_status(key, value); log_print(LOG_NOTICE, SECTION_SESSION_DEFAULT, "%s: added to hash table %s :: %s", funcname, key, value); } } // Prepare a sortable array g_hash_table_iter_init (&iter, node_status.node_hash_table); addr_score_idx = 0; while (g_hash_table_iter_next (&iter, &key, &value)) { struct health_status_s *healthstatus = (struct health_status_s *)value; log_print(LOG_DEBUG, SECTION_SESSION_DEFAULT, "%s: healthstatus->curladdr: %s", funcname, healthstatus->curladdr); // We need to sort on health score, but use the addr name. addr_score[addr_score_idx] = g_new(struct addr_score_s, 1); // Save values into sortable array strncpy(addr_score[addr_score_idx]->addr, healthstatus->curladdr, IPSTR_SZ); addr_score[addr_score_idx]->score = healthstatus->score; log_print(LOG_INFO, SECTION_SESSION_DEFAULT, "%s: addr_score_idx [%d], addr [%s], score [%d]", funcname, addr_score_idx, addr_score[addr_score_idx]->addr, addr_score[addr_score_idx]->score); ++addr_score_idx; } // Randomize first; then sort and expect that the order of items with the same score (think '0') stays randomized randomize((void *)addr_score, addr_score_idx); // sort the array qsort(addr_score, addr_score_idx, sizeof(struct addr_score_s *), compare_node_score); if (addr_score[0]->score != 0) { // All connections are in some state of bad log_print(LOG_ERR, SECTION_SESSION_DEFAULT, "%s: top entry is non-zero: %s -- %d", funcname, addr_score[0]->addr, addr_score[0]->score); } // addr_score_idx is the number of addresses we processed above for (int idx = 0; idx < addr_score_idx; idx++) { log_print(LOG_DYNAMIC, SECTION_SESSION_DEFAULT, "%s: inserting into resolve_slist (%p): %s, score %d", funcname, node_status.resolve_slist, addr_score[idx]->addr, addr_score[idx]->score); node_status.resolve_slist = curl_slist_append(node_status.resolve_slist, addr_score[idx]->addr); g_free(addr_score[idx]); } }
int cr_metadata_load_xml(cr_Metadata *md, struct cr_MetadataLocation *ml, GError **err) { int result; GError *tmp_err = NULL; GHashTable *intern_hashtable; // key is checksum (pkgId) cr_HashTableKeyDupAction dupaction = md->dupaction; assert(md); assert(ml); assert(!err || *err == NULL); if (!ml->pri_xml_href) { g_set_error(err, ERR_DOMAIN, CRE_BADARG, "primary.xml file is missing"); return CRE_BADARG; } // Load metadata intern_hashtable = cr_new_metadata_hashtable(); result = cr_load_xml_files(intern_hashtable, ml->pri_xml_href, ml->fil_xml_href, ml->oth_xml_href, md->chunk, md->pkglist_ht, &tmp_err); if (result != CRE_OK) { g_critical("%s: Error encountered while parsing", __func__); g_propagate_prefixed_error(err, tmp_err, "Error encountered while parsing:"); cr_destroy_metadata_hashtable(intern_hashtable); return result; } g_debug("%s: Parsed items: %d", __func__, g_hash_table_size(intern_hashtable)); // Fill user hashtable and use user selected key GHashTableIter iter; gpointer p_key, p_value; GHashTable *ignored_keys = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); g_hash_table_iter_init (&iter, intern_hashtable); while (g_hash_table_iter_next (&iter, &p_key, &p_value)) { cr_Package *pkg = (cr_Package *) p_value; cr_Package *epkg; gpointer new_key; switch (md->key) { case CR_HT_KEY_FILENAME: new_key = cr_get_filename(pkg->location_href); break; case CR_HT_KEY_HASH: new_key = pkg->pkgId; break; case CR_HT_KEY_NAME: new_key = pkg->name; break; default: // Well, this SHOULD never happend! // (md->key SHOULD be setted only by cr_metadata_new() // and it SHOULD set only valid key values) g_critical("%s: Unknown hash table key selected", __func__); assert(0); g_set_error(err, ERR_DOMAIN, CRE_ASSERT, "Bad db type"); return CRE_ASSERT; } epkg = g_hash_table_lookup(md->ht, new_key); if (epkg) { // Such key already exists if (dupaction == CR_HT_DUPACT_KEEPFIRST) { g_debug("%s: Key \"%s\" already exists in hashtable - Keeping the first occurrence", __func__, (char *) new_key); } else { if (pkg->time_file != epkg->time_file || pkg->size_package != epkg->size_package || g_strcmp0(pkg->pkgId, epkg->pkgId) || g_strcmp0(cr_get_filename(pkg->location_href), cr_get_filename(epkg->location_href)) ) { // We got a key (checksum, filename, pkg name, ..) // which has a multiple occurences which are different. // Ignore such key g_debug("%s: Key \"%s\" is present multiple times and with " "different values. Ignoring all occurrences. " "[size_package: %"G_GINT64_FORMAT"|%"G_GINT64_FORMAT "; time_file: %"G_GINT64_FORMAT"|%"G_GINT64_FORMAT "; pkgId: %s|%s; basename: %s|%s]", __func__, (gchar *) new_key, pkg->size_package, epkg->size_package, pkg->time_file, epkg->time_file, pkg->pkgId, epkg->pkgId, cr_get_filename(pkg->location_href), cr_get_filename(epkg->location_href)); g_hash_table_insert(ignored_keys, g_strdup((gchar *) new_key), NULL); } } // Remove the package from the iterator anyway g_hash_table_iter_remove(&iter); } else { g_hash_table_insert(md->ht, new_key, p_value); g_hash_table_iter_steal(&iter); } } // Remove ignored_keys from resulting hashtable g_hash_table_iter_init(&iter, ignored_keys); while (g_hash_table_iter_next(&iter, &p_key, &p_value)) { char *key = (gchar *) p_key; g_hash_table_remove(md->ht, key); } // How much items we really use g_debug("%s: Really usable items: %d", __func__, g_hash_table_size(md->ht)); // Cleanup g_hash_table_destroy(ignored_keys); cr_destroy_metadata_hashtable(intern_hashtable); return CRE_OK; }
static gboolean load_mtp_db_idle_cb (RBMtpSource* source) { RhythmDB *db = NULL; RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source); LIBMTP_track_t *tracks = NULL; LIBMTP_album_t *albums; gboolean device_forgets_albums = TRUE; db = get_db_for_source (source); g_assert (db != NULL); albums = LIBMTP_Get_Album_List (priv->device); report_libmtp_errors (priv->device, FALSE); if (albums != NULL) { LIBMTP_album_t *album; for (album = albums; album != NULL; album = album->next) { rb_debug ("album: %s, %d tracks", album->name, album->no_tracks); g_hash_table_insert (priv->album_map, album->name, album); if (album->no_tracks != 0) { device_forgets_albums = FALSE; } } if (device_forgets_albums) { rb_debug ("stupid mtp device detected. will rebuild all albums."); } } else { rb_debug ("No albums"); device_forgets_albums = FALSE; } #ifdef HAVE_LIBMTP_030 tracks = LIBMTP_Get_Tracklisting_With_Callback (priv->device, NULL, NULL); #else tracks = LIBMTP_Get_Tracklisting (priv->device); #endif report_libmtp_errors (priv->device, FALSE); if (tracks != NULL) { LIBMTP_track_t *track; for (track = tracks; track != NULL; track = track->next) { add_mtp_track_to_db (source, db, track); if (device_forgets_albums && track->album != NULL) { add_track_to_album (source, track->album, track); } } } else { rb_debug ("No tracks"); } /* for stupid devices, remove any albums left with no tracks */ if (device_forgets_albums) { GHashTableIter iter; gpointer value; LIBMTP_album_t *album; g_hash_table_iter_init (&iter, priv->album_map); while (g_hash_table_iter_next (&iter, NULL, &value)) { int ret; album = value; if (album->no_tracks == 0) { rb_debug ("pruning empty album \"%s\"", album->name); ret = LIBMTP_Delete_Object (priv->device, album->album_id); if (ret != 0) { report_libmtp_errors (priv->device, FALSE); } g_hash_table_iter_remove (&iter); } } } g_object_unref (G_OBJECT (db)); return FALSE; }
static void lvm_update_vgs (GObject *source_obj, GAsyncResult *result, gpointer user_data) { UDisksLVM2State *state; UDisksDaemon *daemon = UDISKS_DAEMON (source_obj); GDBusObjectManagerServer *manager; GTask *task = G_TASK (result); GError *error = NULL; VGsPVsData *data = g_task_propagate_pointer (task, &error); BDLVMVGdata **vgs = NULL; BDLVMPVdata **pvs = NULL; GHashTableIter vg_name_iter; gpointer key, value; const gchar *vg_name; if (!data) { if (error) udisks_warning ("LVM2 plugin: %s", error->message); else /* this should never happen */ udisks_warning ("LVM2 plugin: failure but no error when getting VGs!"); return; } vgs = data->vgs; pvs = data->pvs; /* free the data container (but not 'vgs' and 'pvs') */ g_free (data); manager = udisks_daemon_get_object_manager (daemon); state = get_module_state (daemon); /* Remove obsolete groups */ g_hash_table_iter_init (&vg_name_iter, udisks_lvm2_state_get_name_to_volume_group (state)); while (g_hash_table_iter_next (&vg_name_iter, &key, &value)) { UDisksLinuxVolumeGroupObject *group; gboolean found = FALSE; vg_name = key; group = value; for (BDLVMVGdata **vgs_p=vgs; !found && (*vgs_p); vgs_p++) found = g_strcmp0 ((*vgs_p)->name, vg_name) == 0; if (!found) { udisks_linux_volume_group_object_destroy (group); g_dbus_object_manager_server_unexport (manager, g_dbus_object_get_object_path (G_DBUS_OBJECT (group))); g_hash_table_iter_remove (&vg_name_iter); } } /* Add new groups and update existing groups */ for (BDLVMVGdata **vgs_p=vgs; *vgs_p; vgs_p++) { UDisksLinuxVolumeGroupObject *group; GSList *vg_pvs = NULL; vg_name = (*vgs_p)->name; group = g_hash_table_lookup (udisks_lvm2_state_get_name_to_volume_group (state), vg_name); if (group == NULL) { group = udisks_linux_volume_group_object_new (daemon, vg_name); g_hash_table_insert (udisks_lvm2_state_get_name_to_volume_group (state), g_strdup (vg_name), group); } for (BDLVMPVdata **pvs_p=pvs; *pvs_p; pvs_p++) if (g_strcmp0 ((*pvs_p)->vg_name, vg_name) == 0) vg_pvs = g_slist_prepend (vg_pvs, *pvs_p); udisks_linux_volume_group_object_update (group, *vgs_p, vg_pvs); } /* this is safe to do -- all BDLVMPVdata objects are still existing because the function that frees them is scheduled in main loop by the udisks_linux_volume_group_object_update() call above */ for (BDLVMPVdata **pvs_p=pvs; *pvs_p; pvs_p++) if ((*pvs_p)->vg_name == NULL) bd_lvm_pvdata_free (*pvs_p); /* only free the containers, the contents were passed further */ g_free (vgs); g_free (pvs); }
static gboolean sysroot_populate_deployments_unlocked (RpmostreedSysroot *self, gboolean *out_changed, GError **error) { gboolean ret = FALSE; OstreeDeployment *booted = NULL; /* owned by sysroot */ g_autofree gchar *booted_id = NULL; g_autoptr(GPtrArray) deployments = NULL; g_autoptr(GHashTable) seen_osnames = NULL; GHashTableIter iter; gpointer hashkey; gpointer value; GVariantBuilder builder; guint i; gboolean sysroot_changed; gboolean repo_changed; struct stat repo_new_stat; if (!ostree_sysroot_load_if_changed (self->ot_sysroot, &sysroot_changed, self->cancellable, error)) goto out; if (fstat (ostree_repo_get_dfd (self->repo), &repo_new_stat) < 0) { glnx_set_error_from_errno (error); goto out; } repo_changed = !(self->repo_last_stat.st_mtim.tv_sec == repo_new_stat.st_mtim.tv_sec && self->repo_last_stat.st_mtim.tv_nsec == repo_new_stat.st_mtim.tv_nsec); if (repo_changed) self->repo_last_stat = repo_new_stat; if (!(sysroot_changed || repo_changed)) { ret = TRUE; if (out_changed) *out_changed = FALSE; goto out; } g_debug ("loading deployments"); g_variant_builder_init (&builder, G_VARIANT_TYPE ("aa{sv}")); seen_osnames = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL); /* Updated booted property */ booted = ostree_sysroot_get_booted_deployment (self->ot_sysroot); if (booted) { const gchar *os = ostree_deployment_get_osname (booted); g_autofree gchar *path = rpmostreed_generate_object_path (BASE_DBUS_PATH, os, NULL); rpmostree_sysroot_set_booted (RPMOSTREE_SYSROOT (self), path); booted_id = rpmostreed_deployment_generate_id (booted); } else { rpmostree_sysroot_set_booted (RPMOSTREE_SYSROOT (self), "/"); } /* Add deployment interfaces */ deployments = ostree_sysroot_get_deployments (self->ot_sysroot); for (i = 0; deployments != NULL && i < deployments->len; i++) { GVariant *variant; OstreeDeployment *deployment = deployments->pdata[i]; const char *deployment_os; variant = rpmostreed_deployment_generate_variant (deployment, booted_id, self->repo, error); if (!variant) goto out; g_variant_builder_add_value (&builder, variant); deployment_os = ostree_deployment_get_osname (deployment); /* Have we not seen this osname instance before? If so, add it * now. */ if (!g_hash_table_contains (self->os_interfaces, deployment_os)) { RPMOSTreeOS *obj = rpmostreed_os_new (self->ot_sysroot, self->repo, deployment_os, self->transaction_monitor); g_hash_table_insert (self->os_interfaces, g_strdup (deployment_os), obj); } /* Owned by deployment, hash lifetime is smaller */ g_hash_table_add (seen_osnames, (char*)deployment_os); } /* Remove dead os paths */ g_hash_table_iter_init (&iter, self->os_interfaces); while (g_hash_table_iter_next (&iter, &hashkey, &value)) { if (!g_hash_table_contains (seen_osnames, hashkey)) { g_object_run_dispose (G_OBJECT (value)); g_hash_table_iter_remove (&iter); } } rpmostree_sysroot_set_deployments (RPMOSTREE_SYSROOT (self), g_variant_builder_end (&builder)); g_debug ("finished deployments"); ret = TRUE; if (out_changed) *out_changed = TRUE; out: return ret; }
static void update_with_variant (GPid pid, GVariant *info, GError *error, gpointer user_data) { struct UpdateData *data = user_data; StorageVolumeGroup *self = data->self; GVariantIter *iter; GHashTableIter volume_iter; gpointer key, value; GHashTable *new_lvs; gboolean needs_polling = FALSE; StorageDaemon *daemon; gchar *path; daemon = storage_daemon_get (); if (!error) volume_group_update_props (self, info, &needs_polling); /* After basic props, publish group, if not already done */ if (self->need_publish) { self->need_publish = FALSE; path = storage_util_build_object_path ("/org/freedesktop/UDisks2/lvm", storage_volume_group_get_name (self), NULL); storage_daemon_publish (daemon, path, FALSE, self); g_free (path); } if (error) { g_message ("Failed to update LVM volume group %s: %s", storage_volume_group_get_name (self), error->message); g_object_unref (self); return; } if (self->info && g_variant_equal (self->info, info)) { g_debug ("%s updated without changes", self->name); g_object_unref (self); return; } if (self->info) g_variant_unref (self->info); self->info = g_variant_ref (info); new_lvs = g_hash_table_new (g_str_hash, g_str_equal); if (g_variant_lookup (info, "lvs", "aa{sv}", &iter)) { GVariant *lv_info = NULL; while (g_variant_iter_loop (iter, "@a{sv}", &lv_info)) { const gchar *name; StorageLogicalVolume *volume; g_variant_lookup (lv_info, "name", "&s", &name); update_operations (name, lv_info, &needs_polling); if (lv_is_pvmove_volume (name)) needs_polling = TRUE; if (!lv_is_visible (name)) continue; volume = g_hash_table_lookup (self->logical_volumes, name); if (volume == NULL) { volume = storage_logical_volume_new (self, name); storage_logical_volume_update (volume, self, lv_info, &needs_polling); g_hash_table_insert (self->logical_volumes, g_strdup (name), g_object_ref (volume)); } else storage_logical_volume_update (volume, self, lv_info, &needs_polling); g_hash_table_insert (new_lvs, (gchar *)name, volume); } g_variant_iter_free (iter); } g_hash_table_iter_init (&volume_iter, self->logical_volumes); while (g_hash_table_iter_next (&volume_iter, &key, &value)) { const gchar *name = key; StorageLogicalVolume *volume = value; if (!g_hash_table_contains (new_lvs, name)) { /* Volume unpublishes itself */ g_object_run_dispose (G_OBJECT (volume)); g_hash_table_iter_remove (&volume_iter); } } lvm_volume_group_set_needs_polling (LVM_VOLUME_GROUP (self), needs_polling); /* Update physical volumes. */ g_hash_table_remove_all (self->physical_volumes); if (g_variant_lookup (info, "pvs", "aa{sv}", &iter)) { const gchar *name; GVariant *pv_info; while (g_variant_iter_next (iter, "@a{sv}", &pv_info)) { if (g_variant_lookup (pv_info, "device", "&s", &name)) g_hash_table_insert (self->physical_volumes, g_strdup (name), pv_info); else g_variant_unref (pv_info); } } /* Make sure above is published before updating blocks to point at volume group */ update_all_blocks (self); if (data->done) data->done (self, data->done_user_data); g_hash_table_destroy (new_lvs); g_object_unref (self); g_free (data); }
TIMER_FOREACH(iter, timer) { if (timer->dead) g_hash_table_iter_remove(&iter); }
/** * gst_rtsp_session_pool_filter: * @pool: a #GstRTSPSessionPool * @func: (scope call) (allow-none): a callback * @user_data: (closure): user data passed to @func * * Call @func for each session in @pool. The result value of @func determines * what happens to the session. @func will be called with the session pool * locked so no further actions on @pool can be performed from @func. * * If @func returns #GST_RTSP_FILTER_REMOVE, the session will be set to the * expired state with gst_rtsp_session_set_expired() and removed from * @pool. * * If @func returns #GST_RTSP_FILTER_KEEP, the session will remain in @pool. * * If @func returns #GST_RTSP_FILTER_REF, the session will remain in @pool but * will also be added with an additional ref to the result GList of this * function.. * * When @func is %NULL, #GST_RTSP_FILTER_REF will be assumed for all sessions. * * Returns: (element-type GstRTSPSession) (transfer full): a GList with all * sessions for which @func returned #GST_RTSP_FILTER_REF. After usage, each * element in the GList should be unreffed before the list is freed. */ GList * gst_rtsp_session_pool_filter (GstRTSPSessionPool * pool, GstRTSPSessionPoolFilterFunc func, gpointer user_data) { GstRTSPSessionPoolPrivate *priv; GHashTableIter iter; gpointer key, value; GList *result; GHashTable *visited; guint cookie; g_return_val_if_fail (GST_IS_RTSP_SESSION_POOL (pool), NULL); priv = pool->priv; result = NULL; if (func) visited = g_hash_table_new_full (NULL, NULL, g_object_unref, NULL); g_mutex_lock (&priv->lock); restart: g_hash_table_iter_init (&iter, priv->sessions); cookie = priv->sessions_cookie; while (g_hash_table_iter_next (&iter, &key, &value)) { GstRTSPSession *session = value; GstRTSPFilterResult res; gboolean changed; if (func) { /* only visit each session once */ if (g_hash_table_contains (visited, session)) continue; g_hash_table_add (visited, g_object_ref (session)); g_mutex_unlock (&priv->lock); res = func (pool, session, user_data); g_mutex_lock (&priv->lock); } else res = GST_RTSP_FILTER_REF; changed = (cookie != priv->sessions_cookie); switch (res) { case GST_RTSP_FILTER_REMOVE: { gboolean removed = TRUE; if (changed) /* something changed, check if we still have the session */ removed = g_hash_table_remove (priv->sessions, key); else g_hash_table_iter_remove (&iter); if (removed) { /* if we managed to remove the session, update the cookie and * signal */ cookie = ++priv->sessions_cookie; g_mutex_unlock (&priv->lock); g_signal_emit (pool, gst_rtsp_session_pool_signals[SIGNAL_SESSION_REMOVED], 0, session); g_mutex_lock (&priv->lock); /* cookie could have changed again, make sure we restart */ changed |= (cookie != priv->sessions_cookie); } break; } case GST_RTSP_FILTER_REF: /* keep ref */ result = g_list_prepend (result, g_object_ref (session)); break; case GST_RTSP_FILTER_KEEP: default: break; } if (changed) goto restart; } g_mutex_unlock (&priv->lock); if (func) g_hash_table_unref (visited); return result; }
int bt_obex(int argc, char *argv[]) { GError *error = NULL; GOptionContext *context; /* Query current locale */ setlocale(LC_CTYPE, ""); g_type_init(); dbus_init(); context = g_option_context_new(" - a bluetooth OBEX client/server"); g_option_context_add_main_entries(context, entries, NULL); g_option_context_set_summary(context, "Version "PACKAGE_VERSION); g_option_context_set_description(context, "Server Options:\n" " -s, --server [<path>]\n" " Register self at OBEX server and use given `path` as OPP save directory\n" " If `path` does not specified - use current directory\n\n" "OPP Options:\n" " -p, --opp <name|mac> <file>\n" " Send `file` to remote device using Object Push Profile\n\n" //"Report bugs to <"PACKAGE_BUGREPORT">." "Project home page <"PACKAGE_URL">." ); if (!g_option_context_parse(context, &argc, &argv, &error)) { g_print("%s: %s\n", g_get_prgname(), error->message); g_print("Try `%s --help` for more information.\n", g_get_prgname()); exit(EXIT_FAILURE); } else if (!server_arg && !opp_arg && (!ftp_arg || strlen(ftp_arg) == 0)) { g_print("%s", g_option_context_get_help(context, FALSE, NULL)); exit(EXIT_FAILURE); } else if (server_arg && argc != 1 && (argc != 2 || strlen(argv[1]) == 0)) { g_print("%s: Invalid arguments for --server\n", g_get_prgname()); g_print("Try `%s --help` for more information.\n", g_get_prgname()); exit(EXIT_FAILURE); } else if (opp_arg && (argc != 3 || strlen(argv[1]) == 0 || strlen(argv[2]) == 0)) { g_print("%s: Invalid arguments for --opp\n", g_get_prgname()); g_print("Try `%s --help` for more information.\n", g_get_prgname()); exit(EXIT_FAILURE); } g_option_context_free(context); if (!dbus_system_connect(&error)) { g_printerr("Couldn't connect to DBus system bus: %s\n", error->message); exit(EXIT_FAILURE); } if (!dbus_session_connect(&error)) { g_printerr("Couldn't connect to DBus session bus: %s\n", error->message); exit(EXIT_FAILURE); } /* Check, that bluetooth daemon is running */ if (!intf_supported(BLUEZ_DBUS_NAME, MANAGER_DBUS_PATH, MANAGER_DBUS_INTERFACE)) { g_printerr("%s: bluez service is not found\n", g_get_prgname()); g_printerr("Did you forget to run bluetoothd?\n"); exit(EXIT_FAILURE); } /* Check, that obexd daemon is running */ if (!intf_supported(OBEXS_DBUS_NAME, OBEXMANAGER_DBUS_PATH, OBEXMANAGER_DBUS_INTERFACE)) { g_printerr("%s: obex service is not found\n", g_get_prgname()); g_printerr("Did you forget to run obexd?\n"); exit(EXIT_FAILURE); } if (server_arg) { if (argc == 2) { server_path_arg = argv[1]; } /* Check that `path` is valid */ gchar *root_folder = server_path_arg == NULL ? g_get_current_dir() : g_strdup(server_path_arg); if (!is_dir(root_folder, &error)) { exit_if_error(error); } server_transfers = g_hash_table_new(g_str_hash, g_str_equal); OBEXManager *manager = g_object_new(OBEXMANAGER_TYPE, NULL); g_signal_connect(manager, "SessionCreated", G_CALLBACK(obexmanager_session_created), NULL); g_signal_connect(manager, "SessionRemoved", G_CALLBACK(obexmanager_session_removed), NULL); g_signal_connect(manager, "TransferStarted", G_CALLBACK(obexmanager_transfer_started), NULL); g_signal_connect(manager, "TransferCompleted", G_CALLBACK(obexmanager_transfer_completed), NULL); OBEXAgent *agent = g_object_new(OBEXAGENT_TYPE, "RootFolder", root_folder, NULL); g_free(root_folder); obexmanager_register_agent(manager, OBEXAGENT_DBUS_PATH, &error); exit_if_error(error); mainloop = g_main_loop_new(NULL, FALSE); /* Add SIGTERM && SIGINT handlers */ struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = sigterm_handler; sigaction(SIGTERM, &sa, NULL); sigaction(SIGINT, &sa, NULL); g_main_loop_run(mainloop); /* Waiting for connections... */ g_main_loop_unref(mainloop); /* Stop active transfers */ GHashTableIter iter; gpointer key, value; g_hash_table_iter_init(&iter, server_transfers); while (g_hash_table_iter_next(&iter, &key, &value)) { OBEXTransfer *t = OBEXTRANSFER(value); obextransfer_cancel(t, NULL); // skip errors g_object_unref(t); g_hash_table_iter_remove(&iter); } g_hash_table_unref(server_transfers); obexmanager_unregister_agent(manager, OBEXAGENT_DBUS_PATH, &error); g_object_unref(agent); g_object_unref(manager); } else if (opp_arg) { opp_device_arg = argv[1]; opp_file_arg = argv[2]; /* Check that `file` is valid */ if (!is_file(opp_file_arg, &error)) { exit_if_error(error); } gchar * files_to_send[] = {NULL, NULL}; files_to_send[0] = g_path_is_absolute(opp_file_arg) ? g_strdup(opp_file_arg) : get_absolute_path(opp_file_arg); /* Get source address (address of adapter) */ Adapter *adapter = find_adapter(adapter_arg, &error); exit_if_error(error); gchar *src_address = g_strdup(adapter_get_address(adapter)); /* Get destination address (address of remote device) */ gchar *dst_address = NULL; if (g_regex_match_simple("^\\x{2}:\\x{2}:\\x{2}:\\x{2}:\\x{2}:\\x{2}$", opp_device_arg, 0, 0)) { dst_address = g_strdup(opp_device_arg); } else { Device *device = find_device(adapter, opp_device_arg, &error); exit_if_error(error); dst_address = g_strdup(device_get_address(device)); g_object_unref(device); } g_object_unref(adapter); /* Build arguments */ GHashTable *device_dict = g_hash_table_new(g_str_hash, g_str_equal); GValue src_v = {0}; GValue dst_v = {0}; g_value_init(&src_v, G_TYPE_STRING); g_value_init(&dst_v, G_TYPE_STRING); g_value_set_string(&src_v, src_address); g_value_set_string(&dst_v, dst_address); g_hash_table_insert(device_dict, "Source", &src_v); g_hash_table_insert(device_dict, "Destination", &dst_v); mainloop = g_main_loop_new(NULL, FALSE); OBEXClient *client = g_object_new(OBEXCLIENT_TYPE, NULL); OBEXAgent *agent = g_object_new(OBEXAGENT_TYPE, NULL); g_signal_connect(agent, "AgentReleased", G_CALLBACK(agent_released), mainloop); /* Sending file(s) */ obexclient_send_files(client, device_dict, files_to_send, OBEXAGENT_DBUS_PATH, &error); exit_if_error(error); /* Add SIGTERM && SIGINT handlers */ struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = sigterm_handler; sigaction(SIGTERM, &sa, NULL); sigaction(SIGINT, &sa, NULL); g_main_loop_run(mainloop); /* Sending files process here ?? */ g_main_loop_unref(mainloop); g_object_unref(agent); g_object_unref(client); g_value_unset(&src_v); g_value_unset(&dst_v); g_hash_table_unref(device_dict); g_free(src_address); g_free(dst_address); g_free(files_to_send[0]); files_to_send[0] = NULL; } else if (ftp_arg) { /* Get source address (address of adapter) */ Adapter *adapter = find_adapter(adapter_arg, &error); exit_if_error(error); gchar *src_address = g_strdup(adapter_get_address(adapter)); /* Get destination address (address of remote device) */ Device *device = find_device(adapter, ftp_arg, &error); exit_if_error(error); gchar *dst_address = g_strdup(device == NULL ? ftp_arg : device_get_address(device)); g_object_unref(device); g_object_unref(adapter); /* Build arguments */ GHashTable *device_dict = g_hash_table_new(g_str_hash, g_str_equal); GValue src_v = {0}; GValue dst_v = {0}; GValue target_v = {0}; g_value_init(&src_v, G_TYPE_STRING); g_value_init(&dst_v, G_TYPE_STRING); g_value_init(&target_v, G_TYPE_STRING); g_value_set_string(&src_v, src_address); g_value_set_string(&dst_v, dst_address); g_value_set_string(&target_v, "FTP"); g_hash_table_insert(device_dict, "Source", &src_v); g_hash_table_insert(device_dict, "Destination", &dst_v); g_hash_table_insert(device_dict, "Target", &target_v); OBEXClient *client = g_object_new(OBEXCLIENT_TYPE, NULL); OBEXAgent *agent = g_object_new(OBEXAGENT_TYPE, NULL); /* Create FTP session */ gchar *session_path = obexclient_create_session(client, device_dict, &error); exit_if_error(error); OBEXClientFileTransfer *ftp_session = g_object_new(OBEXCLIENT_FILE_TRANSFER_TYPE, "DBusObjectPath", session_path, NULL); g_free(session_path); g_print("FTP session opened\n"); while (TRUE) { gchar *cmd; /* cmd = readline("> "); if (cmd == NULL) { continue; } else { add_history(cmd); } */ gint f_argc; gchar **f_argv; /* Parsing command line */ if (!g_shell_parse_argv(cmd, &f_argc, &f_argv, &error)) { g_print("%s\n", error->message); g_error_free(error); error = NULL; g_free(cmd); continue; } /* Execute commands */ if (g_strcmp0(f_argv[0], "cd") == 0) { if (f_argc != 2 || strlen(f_argv[1]) == 0) { g_print("invalid arguments\n"); } else { obexclient_file_transfer_change_folder(ftp_session, f_argv[1], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } } else if (g_strcmp0(f_argv[0], "mkdir") == 0) { if (f_argc != 2 || strlen(f_argv[1]) == 0) { g_print("invalid arguments\n"); } else { obexclient_file_transfer_create_folder(ftp_session, f_argv[1], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } } else if (g_strcmp0(f_argv[0], "ls") == 0) { if (f_argc != 1) { g_print("invalid arguments\n"); } else { GPtrArray *folders = obexclient_file_transfer_list_folder(ftp_session, &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } else { for (int i = 0; i < folders->len; i++) { GHashTable *el = g_ptr_array_index(folders, i); g_print( "%s\t%llu\t%s\n", g_value_get_string(g_hash_table_lookup(el, "Type")), G_VALUE_HOLDS_UINT64(g_hash_table_lookup(el, "Size")) ? g_value_get_uint64(g_hash_table_lookup(el, "Size")) : 0, g_value_get_string(g_hash_table_lookup(el, "Name")) ); } } if (folders) g_ptr_array_unref(folders); /*obexclient_remove_session(client, obexclient_file_transfer_get_dbus_object_path(ftp_session), &error); exit_if_error(error); g_object_unref(ftp_session); session_path = obexclient_create_session(client, device_dict, &error); exit_if_error(error); ftp_session = g_object_new(OBEXCLIENT_FILE_TRANSFER_TYPE, "DBusObjectPath", session_path, NULL); g_free(session_path);*/ } } else if (g_strcmp0(f_argv[0], "get") == 0) { if (f_argc != 3 || strlen(f_argv[1]) == 0 || strlen(f_argv[2]) == 0) { g_print("invalid arguments\n"); } else { gchar *abs_dst_path = get_absolute_path(f_argv[2]); gchar *dir = g_path_get_dirname(abs_dst_path); if (!is_dir(dir, &error)) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } else { obexclient_file_transfer_get_file(ftp_session, abs_dst_path, f_argv[1], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } g_free(dir); g_free(abs_dst_path); } } else if (g_strcmp0(f_argv[0], "put") == 0) { if (f_argc != 3 || strlen(f_argv[1]) == 0 || strlen(f_argv[2]) == 0) { g_print("invalid arguments\n"); } else { gchar *abs_src_path = get_absolute_path(f_argv[1]); if (!is_file(abs_src_path, &error)) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } else { obexclient_file_transfer_put_file(ftp_session, abs_src_path, f_argv[2], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } g_free(abs_src_path); } } else if (g_strcmp0(f_argv[0], "cp") == 0) { if (f_argc != 3 || strlen(f_argv[1]) == 0 || strlen(f_argv[2]) == 0) { g_print("invalid arguments\n"); } else { obexclient_file_transfer_copy_file(ftp_session, f_argv[1], f_argv[2], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } } else if (g_strcmp0(f_argv[0], "mv") == 0) { if (f_argc != 3 || strlen(f_argv[1]) == 0 || strlen(f_argv[2]) == 0) { g_print("invalid arguments\n"); } else { obexclient_file_transfer_move_file(ftp_session, f_argv[1], f_argv[2], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } } else if (g_strcmp0(f_argv[0], "rm") == 0) { if (f_argc != 2 || strlen(f_argv[1]) == 0) { g_print("invalid arguments\n"); } else { obexclient_file_transfer_delete(ftp_session, f_argv[1], &error); if (error) { g_print("%s\n", error->message); g_error_free(error); error = NULL; } } } else if (g_strcmp0(f_argv[0], "help") == 0) { g_print( "help\t\t\tShow this message\n" "exit\t\t\tClose FTP session\n" "cd <folder>\t\tChange the current folder of the remote device\n" "mkdir <folder>\t\tCreate a new folder in the remote device\n" "ls\t\t\tList folder contents\n" "get <src> <dst>\t\tCopy the src file (from remote device) to the dst file (on local filesystem)\n" "put <src> <dst>\t\tCopy the src file (from local filesystem) to the dst file (on remote device)\n" "cp <src> <dst>\t\tCopy a file within the remote device from src file to dst file\n" "mv <src> <dst>\t\tMove a file within the remote device from src file to dst file\n" "rm <target>\t\tDeletes the specified file/folder\n" ); } else if (g_strcmp0(f_argv[0], "exit") == 0 || g_strcmp0(f_argv[0], "quit") == 0) { obexclient_remove_session(client, obexclient_file_transfer_get_dbus_object_path(ftp_session), &error); exit_if_error(error); g_strfreev(f_argv); g_free(cmd); break; } else { g_print("invalid command\n"); } g_strfreev(f_argv); g_free(cmd); } g_object_unref(agent); g_object_unref(client); g_object_unref(ftp_session); g_value_unset(&src_v); g_value_unset(&dst_v); g_value_unset(&target_v); g_hash_table_unref(device_dict); g_free(src_address); g_free(dst_address); } dbus_disconnect(); exit(EXIT_SUCCESS); }
static GstFlowReturn gst_rtp_rtx_receive_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer) { GstRtpRtxReceive *rtx = GST_RTP_RTX_RECEIVE (parent); GstRTPBuffer rtp = GST_RTP_BUFFER_INIT; GstFlowReturn ret = GST_FLOW_OK; GstBuffer *new_buffer = NULL; guint32 ssrc = 0; gpointer ssrc1 = 0; guint32 ssrc2 = 0; guint16 seqnum = 0; guint16 orign_seqnum = 0; guint8 payload_type = 0; guint8 origin_payload_type = 0; gboolean is_rtx; gboolean drop = FALSE; /* map current rtp packet to parse its header */ gst_rtp_buffer_map (buffer, GST_MAP_READ, &rtp); ssrc = gst_rtp_buffer_get_ssrc (&rtp); seqnum = gst_rtp_buffer_get_seq (&rtp); payload_type = gst_rtp_buffer_get_payload_type (&rtp); /* check if we have a retransmission packet (this information comes from SDP) */ GST_OBJECT_LOCK (rtx); rtx->last_time = GST_BUFFER_PTS (buffer); if (g_hash_table_size (rtx->seqnum_ssrc1_map) > 0) { GHashTableIter iter; gpointer key, value; g_hash_table_iter_init (&iter, rtx->seqnum_ssrc1_map); while (g_hash_table_iter_next (&iter, &key, &value)) { SsrcAssoc *assoc = value; /* remove association request if it is too old */ if (GST_CLOCK_TIME_IS_VALID (rtx->last_time) && GST_CLOCK_TIME_IS_VALID (assoc->time) && assoc->time + ASSOC_TIMEOUT < rtx->last_time) { g_hash_table_iter_remove (&iter); } } } is_rtx = g_hash_table_lookup_extended (rtx->rtx_pt_map, GUINT_TO_POINTER (payload_type), NULL, NULL); /* if the current packet is from a retransmission stream */ if (is_rtx) { /* increase our statistic */ ++rtx->num_rtx_packets; /* read OSN in the rtx payload */ orign_seqnum = GST_READ_UINT16_BE (gst_rtp_buffer_get_payload (&rtp)); origin_payload_type = GPOINTER_TO_UINT (g_hash_table_lookup (rtx->rtx_pt_map, GUINT_TO_POINTER (payload_type))); /* first we check if we already have associated this retransmission stream * to a master stream */ if (g_hash_table_lookup_extended (rtx->ssrc2_ssrc1_map, GUINT_TO_POINTER (ssrc), NULL, &ssrc1)) { GST_DEBUG_OBJECT (rtx, "packet is from retransmission stream %" G_GUINT32_FORMAT " already associated to master stream %" G_GUINT32_FORMAT, ssrc, GPOINTER_TO_UINT (ssrc1)); ssrc2 = ssrc; } else { SsrcAssoc *assoc; /* the current retransmitted packet has its rtx stream not already * associated to a master stream, so retrieve it from our request * history */ if (g_hash_table_lookup_extended (rtx->seqnum_ssrc1_map, GUINT_TO_POINTER (orign_seqnum), NULL, (gpointer *) & assoc)) { GST_DEBUG_OBJECT (rtx, "associate retransmitted stream %" G_GUINT32_FORMAT " to master stream %" G_GUINT32_FORMAT " thanks to packet %" G_GUINT16_FORMAT "", ssrc, assoc->ssrc, orign_seqnum); ssrc1 = GUINT_TO_POINTER (assoc->ssrc); ssrc2 = ssrc; /* just put a guard */ if (GPOINTER_TO_UINT (ssrc1) == ssrc2) GST_WARNING_OBJECT (rtx, "RTX receiver ssrc2_ssrc1_map bad state, " "ssrc %" G_GUINT32_FORMAT " are the same\n", ssrc); /* free the spot so that this seqnum can be used to do another * association */ g_hash_table_remove (rtx->seqnum_ssrc1_map, GUINT_TO_POINTER (orign_seqnum)); /* actually do the association between rtx stream and master stream */ g_hash_table_insert (rtx->ssrc2_ssrc1_map, GUINT_TO_POINTER (ssrc2), ssrc1); /* also do the association between master stream and rtx stream * every ssrc are unique so we can use the same hash table * for both retrieving the ssrc1 from ssrc2 and also ssrc2 from ssrc1 */ g_hash_table_insert (rtx->ssrc2_ssrc1_map, ssrc1, GUINT_TO_POINTER (ssrc2)); } else { /* we are not able to associate this rtx packet with a master stream */ GST_DEBUG_OBJECT (rtx, "drop rtx packet because its orign_seqnum %" G_GUINT16_FORMAT " is not in pending retransmission requests", orign_seqnum); drop = TRUE; } } } /* if not dropped the packet was successfully associated */ if (is_rtx && !drop) ++rtx->num_rtx_assoc_packets; GST_OBJECT_UNLOCK (rtx); /* just drop the packet if the association could not have been made */ if (drop) { gst_rtp_buffer_unmap (&rtp); gst_buffer_unref (buffer); return GST_FLOW_OK; } /* create the retransmission packet */ if (is_rtx) new_buffer = _gst_rtp_buffer_new_from_rtx (&rtp, GPOINTER_TO_UINT (ssrc1), orign_seqnum, origin_payload_type); gst_rtp_buffer_unmap (&rtp); /* push the packet */ if (is_rtx) { gst_buffer_unref (buffer); GST_LOG_OBJECT (rtx, "push packet seqnum:%" G_GUINT16_FORMAT " from a restransmission stream ssrc2:%" G_GUINT32_FORMAT " (src %" G_GUINT32_FORMAT ")", orign_seqnum, ssrc2, GPOINTER_TO_UINT (ssrc1)); ret = gst_pad_push (rtx->srcpad, new_buffer); } else { GST_LOG_OBJECT (rtx, "push packet seqnum:%" G_GUINT16_FORMAT " from a master stream ssrc: %" G_GUINT32_FORMAT, seqnum, ssrc); ret = gst_pad_push (rtx->srcpad, buffer); } return ret; }
static void get_track_list (RBMtpThread *thread, RBMtpThreadTask *task) { RBMtpTrackListCallback cb = task->callback; gboolean device_forgets_albums = TRUE; GHashTable *update_albums = NULL; LIBMTP_track_t *tracks = NULL; LIBMTP_album_t *albums; LIBMTP_album_t *album; /* get all the albums */ albums = LIBMTP_Get_Album_List (thread->device); rb_mtp_thread_report_errors (thread, FALSE); if (albums != NULL) { LIBMTP_album_t *album; for (album = albums; album != NULL; album = album->next) { if (album->name == NULL) continue; rb_debug ("album: %s, %d tracks", album->name, album->no_tracks); g_hash_table_insert (thread->albums, album->name, album); if (album->no_tracks != 0) { device_forgets_albums = FALSE; } } if (device_forgets_albums) { rb_debug ("stupid mtp device detected. will rebuild all albums."); } } else { rb_debug ("No albums"); device_forgets_albums = FALSE; } tracks = LIBMTP_Get_Tracklisting_With_Callback (thread->device, NULL, NULL); rb_mtp_thread_report_errors (thread, FALSE); if (tracks == NULL) { rb_debug ("no tracks on the device"); } else if (device_forgets_albums) { LIBMTP_track_t *track; rb_debug ("rebuilding albums"); update_albums = g_hash_table_new (g_direct_hash, g_direct_equal); for (track = tracks; track != NULL; track = track->next) { if (track->album != NULL) { gboolean new_album = FALSE; album = add_track_to_album (thread, track->album, track->item_id, track->storage_id, &new_album); g_hash_table_insert (update_albums, album, GINT_TO_POINTER (new_album)); } } rb_debug ("finished rebuilding albums"); } cb (tracks, task->user_data); /* the callback owns the tracklist */ if (device_forgets_albums) { GHashTableIter iter; gpointer album_ptr; gpointer new_album_ptr; rb_debug ("writing rebuilt albums back to the device"); g_hash_table_iter_init (&iter, update_albums); while (g_hash_table_iter_next (&iter, &album_ptr, &new_album_ptr)) { album = album_ptr; rb_debug ("writing album \"%s\"", album->name); write_album_to_device (thread, album, GPOINTER_TO_INT (new_album_ptr)); } g_hash_table_destroy (update_albums); rb_debug ("removing remaining empty albums"); g_hash_table_iter_init (&iter, thread->albums); while (g_hash_table_iter_next (&iter, NULL, &album_ptr)) { int ret; album = album_ptr; if (album->no_tracks == 0) { rb_debug ("pruning empty album \"%s\"", album->name); ret = LIBMTP_Delete_Object (thread->device, album->album_id); if (ret != 0) { rb_mtp_thread_report_errors (thread, FALSE); } g_hash_table_iter_remove (&iter); } } rb_debug ("finished updating albums on the device"); } }
static void _detect_obsolete_services(struct namespace_data_s *ns_data) { guint counter; time_t time_now, time_down, time_broken; GHashTableIter s_iterator; gpointer s_k, s_v; gchar *str_key; struct service_info_s *si; time_now = g_get_real_time()/1000000; time_down = time_now - 5; time_broken = time_now - 30; counter = 0; if (!ns_data->configured) { return; } /*move services from UP to DOWN */ g_hash_table_iter_init(&s_iterator, ns_data->local_services); while (g_hash_table_iter_next(&s_iterator, &s_k, &s_v)) { str_key = s_k; si = s_v; si->score.value = -2;/*score not set*/ if (si->score.timestamp < time_down) { gchar str_addr[STRLEN_ADDRINFO]; addr_info_to_string(&(si->addr),str_addr,sizeof(str_addr)); DEBUG("Timeout on service [%s/%s/%s] (%"G_GINT32_FORMAT" < %ld) --> DOWN", si->ns_name, si->type, str_addr, si->score.timestamp, time_down); g_hash_table_iter_steal(&s_iterator); g_hash_table_insert(ns_data->down_services, str_key, si); invalidate_conscience_service(ns_data,si); zero_service_stats(si->tags); service_tag_set_value_boolean(service_info_ensure_tag(si->tags,"tag.up"), FALSE); counter++; } } /*remove services DOWN from a long time ago */ g_hash_table_iter_init(&s_iterator, ns_data->down_services); while (g_hash_table_iter_next(&s_iterator, &s_k, &s_v)) { str_key = s_k; si = s_v; si->score.value = -2;/*score not set*/ if (si->score.timestamp < time_broken) { gchar str_addr[STRLEN_ADDRINFO]; addr_info_to_string(&(si->addr),str_addr,sizeof(str_addr)); DEBUG("Service obsolete [%s/%s/%s] --> DELETED", si->ns_name, si->type, str_addr); g_hash_table_iter_remove(&s_iterator); counter++; } else zero_service_stats(si->tags); } if (counter) DEBUG("[task_id=%s] %u services states have changed", TASK_ID, counter); }
void gfx_render(struct gfx_window *w, enum GFX_ANIM_TYPE chg, long anim_time) { //DBG("%d",chg) struct timespec now; struct gfx_callbacks *cb = gfx_callbacks(w); struct gfx_render *render = w->render; if (!cb->generate_scene) return; switch (chg) { case CHG_SWITCH_VOB_SCENE: { render->prev = render->current; render->current = cb->generate_scene(w); clock_gettime(CLOCK_REALTIME, &render->t0); memcpy(&render->t1, &render->t0, sizeof(struct timespec)); break; } case CHG_ANIMATE: { render->prev = render->current; render->current = cb->generate_scene(w); clock_gettime(CLOCK_REALTIME, &render->t0); memcpy(&render->t1, &render->t0, sizeof(struct timespec)); render->t1.tv_sec += anim_time / 1000; render->t1.tv_nsec += (anim_time % 1000)*1000; DBG("t0 %d.%d t1 %d.%d",render->t0.tv_sec ,render->t0.tv_nsec, render->t1.tv_sec ,render->t1.tv_nsec ) break; } case CHG_RERENDER: default: break; } // just render in here. clock_gettime(CLOCK_REALTIME, &now); render->t_since_ms = (now.tv_sec - render->t_frame.tv_sec) * 1000 + (now.tv_nsec - render->t_frame.tv_nsec)/1000000.0f; render->t_frame.tv_sec = now.tv_sec; render->t_frame.tv_nsec = now.tv_nsec; if (time_cmp(render->t0, render->t1) < 0 && time_cmp(render->t_frame, render->t1) < 0) { //float d = get_anim_fract(render, &now); //DBG("fract: %f",render->t_frame) gfx_render_frame(w); //w->anim_render(w, d); } else { // no anim... GHashTableIter iter; gpointer key, value; g_hash_table_iter_init (&iter, render->current->anim_set); while (g_hash_table_iter_next (&iter, &key, &value)) { float ms = render->t_since_ms; LobAnimModel *m = (LobAnimModel *)key; if (m->tick(m, &now)) { g_hash_table_iter_remove(&iter); DBG("remove %p",m); } } //printf("no anim\n"); w->single_render(w, render->current); } }