void copy_properties(ListBase *lbn, ListBase *lbo) { bProperty *prop, *propn; free_properties(lbn); /* in case we are copying to an object with props */ prop = lbo->first; while (prop) { propn = copy_property(prop); BLI_addtail(lbn, propn); prop = prop->next; } }
static int delete_pkgdb(struct pkgdb *db) { struct pkg *pkg = db->head; while (pkg) { struct pkg *next = pkg->next; free(pkg->name); free(pkg->inffile); free(pkg->description); free_properties(pkg->manifest); free(pkg); pkg = next; } db->head = db->tail = NULL; return 0; }
static void free_classes(lily_symtab *symtab, lily_class *class_iter) { while (class_iter) { lily_free(class_iter->name); if (class_iter->flags & CLS_IS_VARIANT) { lily_class *class_next = class_iter->next; lily_free(class_iter); class_iter = class_next; continue; } if (class_iter->properties != NULL) free_properties(symtab, class_iter); if (class_iter->call_chain != NULL) free_vars(symtab, class_iter->call_chain); lily_type *type_iter = class_iter->all_subtypes; lily_type *type_next; while (type_iter) { type_next = type_iter->next; lily_free(type_iter->subtypes); lily_free(type_iter); type_iter = type_next; } if (class_iter->flags & CLS_ENUM_IS_SCOPED) { /* Scoped enums pull their variants from the symtab's class chain so that parser won't find them. */ int i; for (i = 0;i < class_iter->variant_size;i++) { lily_free(class_iter->variant_members[i]->name); lily_free(class_iter->variant_members[i]); } } lily_free(class_iter->variant_members); lily_class *class_next = class_iter->next; lily_free(class_iter); class_iter = class_next; } }
static int install_package(char *pkgname, struct pkgdb *db, int options) { char url[STRLEN]; FILE *f; int rc; char inffile[STRLEN]; struct section *manifest; struct section *dep; struct section *build; struct pkg *pkg; char *description; int time; // Check if package is already installed if (!(options & FROM_FILE)) { pkg = find_package(db, pkgname); if (pkg) { if (options & UPGRADE) { if (pkg->time == pkg->avail) return 0; } else if (options & DEPENDENCY) { return 0; } else if (options & UPDATE) { if (options & VERBOSE) printf("updating package %s\n", pkgname); } else { printf("package %s is already installed\n", pkgname); return 0; } } } // Open package file printf("Fetching %s\n", pkgname); if (options & FROM_FILE) { snprintf(url, sizeof(url), "file:///%s", pkgname); } else { snprintf(url, sizeof(url), "%s/%s.pkg", db->repo, pkgname); } if (options & VERBOSE) printf("fetching package %s from %s\n", pkgname, url); f = open_url(url, "pkg"); if (!f) return 1; // Extract file from package file time = 0; rc = extract_files(url, f, inffile, options & VERBOSE, &time); fclose(f); if (rc != 0) return rc; // Read manifest if (options & VERBOSE) printf("reading manifest from %s\n", inffile); manifest = read_properties(inffile); if (!manifest) { fprintf(stderr, "%s: unable to read manifest\n", inffile); return 1; } // Add package to package database pkgname = get_property(manifest, "package", "name", pkgname); description = get_property(manifest, "package", "description", NULL); pkg = find_package(db, pkgname); if (pkg) { if (options & VERBOSE) printf("updating package %s in database\n", pkgname); if (description) { free(pkg->description); pkg->description = strdup(description); db->dirty = 1; } if (pkg->manifest) free_properties(pkg->manifest); free(pkg->inffile); } else { if (options & VERBOSE) printf("adding package %s to database\n", pkgname); pkg = add_package(db, pkgname, description); } pkg->inffile = strdup(inffile); pkg->manifest = manifest; if (time != pkg->time) { pkg->time = time; db->dirty = 1; } // Install package dependencies dep = find_section(manifest, "dependencies"); if (dep) { struct property *p; for (p = dep->properties; p; p = p->next) { if (options & VERBOSE) printf("package %s depends on %s\n", pkgname, p->name); rc = install_package(p->name, db, options | DEPENDENCY); if (rc != 0) return rc; } } if ((options & ONLY_FETCH) && !(options & DEPENDENCY)) return 0; // Run package build/installation commands if (!(options & ONLY_FETCH) || (options & DEPENDENCY)) { build = find_section(manifest, (options & ONLY_BUILD) && !(options & DEPENDENCY) ? "build" : "install"); if (build) { struct property *p; printf((options & ONLY_BUILD) && !(options & DEPENDENCY) ? "Building %s\n" : "Installing %s\n", pkgname); for (p = build->properties; p; p = p->next) { if (options & VERBOSE) printf("%s\n", p->name); rc = system(p->name); if (rc != 0) { fprintf(stderr, "%s: build failed\n", pkgname); return rc; } } } } return 0; }
lzma_block_header_decode(lzma_block *block, lzma_allocator *allocator, const uint8_t *in) { const size_t filter_count = (in[1] & 3) + 1; size_t in_size; size_t i; // Start after the Block Header Size and Block Flags fields. size_t in_pos = 2; // NOTE: We consider the header to be corrupt not only when the // CRC32 doesn't match, but also when variable-length integers // are invalid or over 63 bits, or if the header is too small // to contain the claimed information. // Initialize the filter options array. This way the caller can // safely free() the options even if an error occurs in this function. for (i = 0; i <= LZMA_FILTERS_MAX; ++i) { block->filters[i].id = LZMA_VLI_UNKNOWN; block->filters[i].options = NULL; } // Always zero for now. block->version = 0; // Validate Block Header Size and Check type. The caller must have // already set these, so it is a programming error if this test fails. if (lzma_block_header_size_decode(in[0]) != block->header_size || (unsigned int)(block->check) > LZMA_CHECK_ID_MAX) return LZMA_PROG_ERROR; // Exclude the CRC32 field. in_size = block->header_size - 4; // Verify CRC32 if (lzma_crc32(in, in_size, 0) != unaligned_read32le(in + in_size)) return LZMA_DATA_ERROR; // Check for unsupported flags. if (in[1] & 0x3C) return LZMA_OPTIONS_ERROR; // Compressed Size if (in[1] & 0x40) { return_if_error(lzma_vli_decode(&block->compressed_size, NULL, in, &in_pos, in_size)); // Validate Compressed Size. This checks that it isn't zero // and that the total size of the Block is a valid VLI. if (lzma_block_unpadded_size(block) == 0) return LZMA_DATA_ERROR; } else { block->compressed_size = LZMA_VLI_UNKNOWN; } // Uncompressed Size if (in[1] & 0x80) return_if_error(lzma_vli_decode(&block->uncompressed_size, NULL, in, &in_pos, in_size)); else block->uncompressed_size = LZMA_VLI_UNKNOWN; // Filter Flags for (i = 0; i < filter_count; ++i) { const lzma_ret ret = lzma_filter_flags_decode( &block->filters[i], allocator, in, &in_pos, in_size); if (ret != LZMA_OK) { free_properties(block, allocator); return ret; } } // Padding while (in_pos < in_size) { if (in[in_pos++] != 0x00) { free_properties(block, allocator); // Possibly some new field present so use // LZMA_OPTIONS_ERROR instead of LZMA_DATA_ERROR. return LZMA_OPTIONS_ERROR; } } return LZMA_OK; }
int add_udi(LibHalContext *hal_ctx, char *arg) { DBusError error; dbus_bool_t dev_exists = FALSE; char *udi = NULL, buf[1024]; lh_prop_t *prop; int err; if (!arg) return 21; if (*arg == '/') { udi = arg; } else { #ifdef HAVE_ASPRINTF asprintf(&udi, "/org/freedesktop/Hal/devices/%s", arg); #else udi = calloc(1, sizeof ("/org/freedesktop/Hal/devices/%s") + strlen(arg)); sprintf(udi, "/org/freedesktop/Hal/devices/%s", arg); #endif } if (udi) new_dev.udi = strdup(udi); dbus_error_init(&error); if (udi) dev_exists = libhal_device_exists(hal_ctx, udi, &error); if (dev_exists) { new_dev.real_udi = strdup(new_dev.udi); } else { new_dev.real_udi = libhal_new_device(hal_ctx, &error); if (!new_dev.real_udi) { fprintf(stderr, "%s: %s\n", error.name, error.message); LIBHAL_FREE_DBUS_ERROR (&error); free(new_dev.real_udi); return 22; } printf("tmp udi: %s\n", new_dev.real_udi); } prop = NULL; while (fgets(buf, sizeof buf, stdin)) { process_property(hal_ctx, buf, &prop); } err = add_properties(hal_ctx, &new_dev, prop); prop = free_properties(prop); if (!dev_exists) { if (!libhal_device_commit_to_gdl(hal_ctx, new_dev.real_udi, new_dev.udi, &error)) { fprintf(stderr, "%s: %s\n", error.name, error.message); LIBHAL_FREE_DBUS_ERROR (&error); free(new_dev.real_udi); err = err ? err : 23; } } printf("%s: %s\n", dev_exists ? "merged": "created", new_dev.udi); return err; }
static jboolean process_audio (GstElement *source, JNIEnv *env, jobject header) { /* will contain the properties we need to put into the given GstHeader */ AudioProperties *properties = NULL; /* GStreamer elements */ GstElement *pipeline = NULL; GstElement *decoder = NULL; GstElement *typefind = NULL; GstStateChangeReturn res; jboolean result = JNI_FALSE; properties = (AudioProperties *) g_malloc0 (sizeof (AudioProperties)); if (properties == NULL) { return result; } reset_properties(properties); /* * create the decoder element, this will decode the stream and retrieve * its properties. * We connect a signal to this element, to be informed when it is done * in decoding the stream and to get the needed informations about the * audio file. */ decoder = gst_element_factory_make ("decodebin", "decoder"); if (decoder == NULL) { free_properties(properties); return result; } /* now, we create a pipeline and fill it with the other elements */ pipeline = gst_pipeline_new ("pipeline"); if (pipeline == NULL) { gst_object_unref (GST_OBJECT (decoder)); free_properties(properties); return result; } g_signal_connect (decoder, "new-decoded-pad", G_CALLBACK (new_decoded_pad), pipeline); g_signal_connect (G_OBJECT (decoder), "element-added", G_CALLBACK (element_added), properties); /* * we get the typefind from the decodebin to catch the additional properties * that the decodebin does not expose to us */ typefind = gst_bin_get_by_name (GST_BIN (decoder), "typefind"); if (typefind != NULL) { /* * NOTE: the above is not a typo, we can live without the typefind, * just, our stream detection will not be as accurate as we would. * Anyway, if this fails, there is some problem, probabily a memory * error. */ g_signal_connect (G_OBJECT (typefind), "have-type", G_CALLBACK (typefind_callback), properties); } gst_bin_add_many (GST_BIN (pipeline), source, decoder, NULL); gst_element_link (source, decoder); /* * now, we set the pipeline playing state to pause and traverse it * to get the info we need. */ res = gst_element_set_state (pipeline, GST_STATE_PAUSED); if (res == GST_STATE_CHANGE_FAILURE) { gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (GST_OBJECT (pipeline)); free_properties(properties); return result; } res = gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE); if (res != GST_STATE_CHANGE_SUCCESS) { gst_element_set_state (pipeline, GST_STATE_NULL); gst_object_unref (GST_OBJECT (pipeline)); free_properties(properties); return result; } if (fill_info (decoder, properties)) { result = set_strings (env, properties, header); } /* free stuff */ gst_element_set_state (pipeline, GST_STATE_NULL); free_properties (properties); gst_object_unref (GST_OBJECT (pipeline)); return result; }