libpakfire: Drop pakfire_strdup

Signed-off-by: Michael Tremer <michael.tremer@ipfire.org>

diff --git a/src/libpakfire/arch.c b/src/libpakfire/arch.c
index 09d1eb148ba4ece87f17a484bcc5b08323f26d67..a488c0c055d78e4119ab66d12daec1182bab1ed1 100644 (file)
--- a/src/libpakfire/arch.c
+++ b/src/libpakfire/arch.c
@@ -140,7 +140,7 @@ PAKFIRE_EXPORT char* pakfire_arch_machine(const char* arch, const char* vendor)
        for (unsigned int i = 0; i < strlen(buffer); i++)
                buffer[i] = tolower(buffer[i]);
 
-       return pakfire_strdup(buffer);
+       return strdup(buffer);
 }
 
 static const char* __pakfire_arch_native = NULL;
@@ -152,7 +152,7 @@ PAKFIRE_EXPORT const char* pakfire_arch_native() {
                if (uname(&buf) < 0)
                        return NULL;
 
-               __pakfire_arch_native = pakfire_strdup(buf.machine);
+               __pakfire_arch_native = strdup(buf.machine);
        }
 
        return __pakfire_arch_native;

diff --git a/src/libpakfire/archive.c b/src/libpakfire/archive.c
index 546e973ef2887404e648822f184fdd81571bfc69..e2ad8bf3cbde0e0690e2258aedb65ed594e0b431 100644 (file)
--- a/src/libpakfire/archive.c
+++ b/src/libpakfire/archive.c
@@ -234,7 +234,7 @@ static archive_checksum_t* pakfire_archive_checksum_create(Pakfire pakfire, cons
        archive_checksum_t* c = calloc(1, sizeof(*c));
        if (c) {
                c->pakfire = pakfire_ref(pakfire);
-               c->filename = pakfire_strdup(filename);
+               c->filename = strdup(filename);
                c->algo = algo;
 
                int r = read_hexdigest(c->digest, sizeof(c->digest), s);
@@ -269,7 +269,7 @@ static PakfireArchiveSignature pakfire_archive_signature_create(PakfireArchive a
        if (signature) {
                signature->pakfire = pakfire_ref(archive->pakfire);
                signature->nrefs = 1;
-               signature->sigdata = pakfire_strdup(sigdata);
+               signature->sigdata = strdup(sigdata);
 
                DEBUG(signature->pakfire, "Allocated archive signature at %p\n%s\n",
                        signature, signature->sigdata);
@@ -747,7 +747,7 @@ static int archive_extract(Pakfire pakfire, struct archive* a, const char* prefi
 
 PAKFIRE_EXPORT PakfireArchive pakfire_archive_open(Pakfire pakfire, const char* path) {
        PakfireArchive archive = pakfire_archive_create(pakfire);
-       archive->path = pakfire_strdup(path);
+       archive->path = strdup(path);
 
        // Stat the file and store the result
        int r = stat(archive->path, &archive->stat);

diff --git a/src/libpakfire/file.c b/src/libpakfire/file.c
index 3207fe93e6df196166a4ce6cba0a09ad7c0aaeb0..9c7ca790547ef639fccf3c9a03cccdde21c048fa 100644 (file)
--- a/src/libpakfire/file.c
+++ b/src/libpakfire/file.c
@@ -131,7 +131,7 @@ static char* pakfire_file_format_perms(PakfireFile file) {
 
        #warning TODO SUID bits, etc...
 
-       return pakfire_strdup(buffer);
+       return strdup(buffer);
 }
 
 static char* pakfire_file_format_mtime(PakfireFile file) {
@@ -140,7 +140,7 @@ static char* pakfire_file_format_mtime(PakfireFile file) {
        char buffer[STRING_SIZE];
        strftime(buffer, sizeof(buffer), "%d %b %Y %T", timer);
 
-       return pakfire_strdup(buffer);
+       return strdup(buffer);
 }
 
 PAKFIRE_EXPORT void pakfire_file_sprintf(PakfireFile file, char* str, size_t len) {
@@ -169,7 +169,7 @@ PAKFIRE_EXPORT void pakfire_file_set_name(PakfireFile file, const char* name) {
                free(file->name);
 
        if (*name == '/') {
-               file->name = pakfire_strdup(name);
+               file->name = strdup(name);
        } else {
                asprintf(&file->name, "/%s", name);
        }
@@ -228,7 +228,7 @@ PAKFIRE_EXPORT const char* pakfire_file_get_user(PakfireFile file) {
 }
 
 PAKFIRE_EXPORT void pakfire_file_set_user(PakfireFile file, const char* user) {
-       file->user = pakfire_strdup(user);
+       file->user = strdup(user);
 }
 
 PAKFIRE_EXPORT const char* pakfire_file_get_group(PakfireFile file) {
@@ -236,7 +236,7 @@ PAKFIRE_EXPORT const char* pakfire_file_get_group(PakfireFile file) {
 }
 
 PAKFIRE_EXPORT void pakfire_file_set_group(PakfireFile file, const char* group) {
-       file->group = pakfire_strdup(group);
+       file->group = strdup(group);
 }
 
 PAKFIRE_EXPORT mode_t pakfire_file_get_mode(PakfireFile file) {
@@ -260,5 +260,5 @@ PAKFIRE_EXPORT const char* pakfire_file_get_chksum(PakfireFile file) {
 }
 
 PAKFIRE_EXPORT void pakfire_file_set_chksum(PakfireFile file, const char* chksum) {
-       file->chksum = pakfire_strdup(chksum);
+       file->chksum = strdup(chksum);
 }

diff --git a/src/libpakfire/include/pakfire/util.h b/src/libpakfire/include/pakfire/util.h
index b7876d48ff4dc38a6097452321399b0f388f2f88..3952cec29433f133b6459eda3b8eb01999880e23 100644 (file)
--- a/src/libpakfire/include/pakfire/util.h
+++ b/src/libpakfire/include/pakfire/util.h
@@ -28,9 +28,6 @@
 
 #include <pakfire/types.h>
 
-void pakfire_oom(size_t num, size_t len);
-
-char* pakfire_strdup(const char* s);
 int pakfire_string_startswith(const char* s, const char* prefix);
 
 char* pakfire_format_size(double size);

diff --git a/src/libpakfire/key.c b/src/libpakfire/key.c
index ba9346b6ee31f5f086ee7060ee32be619b2e6569..c240b02501a00099296187e7f05b6c3fba97a83b 100644 (file)
--- a/src/libpakfire/key.c
+++ b/src/libpakfire/key.c
@@ -368,7 +368,7 @@ PAKFIRE_EXPORT char* pakfire_key_export(PakfireKey key, pakfire_key_export_mode_
        mem[length] = '\0';
 
        // Copy to our own string buffer
-       char* buffer = pakfire_strdup(mem);
+       char* buffer = strdup(mem);
 
        // Release the exported key
        gpgme_free(mem);

diff --git a/src/libpakfire/package.c b/src/libpakfire/package.c
index df033c9fa684884c0d8be3003e541653aed6fc6e..a88560e326c5cfa027823d5b5639c013b5df51b8 100644 (file)
--- a/src/libpakfire/package.c
+++ b/src/libpakfire/package.c
@@ -196,7 +196,7 @@ PAKFIRE_EXPORT char* pakfire_package_get_nevra(PakfirePackage pkg) {
 
        const char* nevra = pool_solvable2str(pool, s);
 
-       return pakfire_strdup(nevra);
+       return strdup(nevra);
 }
 
 PAKFIRE_EXPORT const char* pakfire_package_get_name(PakfirePackage pkg) {
@@ -298,7 +298,7 @@ PAKFIRE_EXPORT const char* pakfire_package_get_version(PakfirePackage pkg) {
        char *e, *v, *r;
 
        split_evr(pool, pakfire_package_get_evr(pkg), &e, &v, &r);
-       return pakfire_strdup(v);
+       return strdup(v);
 }
 
 PAKFIRE_EXPORT const char* pakfire_package_get_release(PakfirePackage pkg) {
@@ -306,7 +306,7 @@ PAKFIRE_EXPORT const char* pakfire_package_get_release(PakfirePackage pkg) {
        char *e, *v, *r;
 
        split_evr(pool, pakfire_package_get_evr(pkg), &e, &v, &r);
-       return pakfire_strdup(r);
+       return strdup(r);
 }
 
 PAKFIRE_EXPORT const char* pakfire_package_get_arch(PakfirePackage pkg) {
@@ -659,7 +659,7 @@ PAKFIRE_EXPORT char* pakfire_package_get_location(PakfirePackage pkg) {
        Solvable* s = get_solvable(pkg);
 
        const char* location = solvable_get_location(s, NULL);
-       return pakfire_strdup(location);
+       return strdup(location);
 }
 
 static void pakfire_package_dump_add_line(char** str, const char* key, const char* val) {

diff --git a/src/libpakfire/pakfire.c b/src/libpakfire/pakfire.c
index 66cfd4a28c336132eb639f8276619bea686da6b8..39db934c8e424ee0c529c6d42c090078ed636655 100644 (file)
--- a/src/libpakfire/pakfire.c
+++ b/src/libpakfire/pakfire.c
@@ -149,10 +149,10 @@ PAKFIRE_EXPORT int pakfire_create(Pakfire* pakfire, const char* path, const char
 
        p->nrefs = 1;
 
-       p->path = pakfire_strdup(path);
+       p->path = strdup(path);
 
        // Set architecture
-       p->arch = pakfire_strdup(arch);
+       p->arch = strdup(arch);
 
        // Setup logging
        p->log_function = pakfire_log_syslog;
@@ -429,7 +429,7 @@ PAKFIRE_EXPORT void pakfire_set_cache_path(Pakfire pakfire, const char* path) {
        if (pakfire->cache_path)
                free(pakfire->cache_path);
 
-       pakfire->cache_path = pakfire_strdup(path);
+       pakfire->cache_path = strdup(path);
 
        DEBUG(pakfire, "Set cache path to %s\n", pakfire->cache_path);
 }

diff --git a/src/libpakfire/parser.c b/src/libpakfire/parser.c
index 755968c6419b83bf4a4bc4ed31ae64fd3801767e..60ae14079c23b3262b211403551c2eb6e83cd5b7 100644 (file)
--- a/src/libpakfire/parser.c
+++ b/src/libpakfire/parser.c
@@ -18,6 +18,7 @@
 #                                                                             #
 #############################################################################*/
 
+#include <errno.h>
 #include <regex.h>
 #include <stdlib.h>
 #include <string.h>
@@ -51,10 +52,10 @@ static char* pakfire_parser_make_namespace(PakfireParser parent, const char* nam
                if (namespace)
                        asprintf(&buffer, "%s.%s", parent->namespace, namespace);
                else
-                       buffer = pakfire_strdup(parent->namespace);
+                       buffer = strdup(parent->namespace);
        } else {
                if (namespace)
-                       buffer = pakfire_strdup(namespace);
+                       buffer = strdup(namespace);
        }
 
        return buffer;
@@ -68,7 +69,7 @@ static char* pakfire_parser_make_canonical_name(PakfireParser parser, const char
                if (r < 0)
                        return NULL;
        } else {
-               buffer = pakfire_strdup(name);
+               buffer = strdup(name);
        }
 
        return buffer;
@@ -178,13 +179,18 @@ static struct pakfire_parser_declaration* pakfire_parser_get_declaration(
 
 static int pakfire_parser_set_declaration(PakfireParser parser,
                const char* name, const char* value) {
+       if (!name)
+               return -EINVAL;
+
        // Handle when name already exists
        struct pakfire_parser_declaration* d = pakfire_parser_get_declaration(parser, name);
        if (d) {
                // Replace value
                if (d->value)
                        free(d->value);
-               d->value = pakfire_strdup(value);
+
+               if (value)
+                       d->value = strdup(value);
 
                DEBUG(parser->pakfire, "Updated declaration: %s = %s\n",
                        d->name, d->value);
@@ -205,8 +211,9 @@ static int pakfire_parser_set_declaration(PakfireParser parser,
                return -1;
 
        // Import name & value
-       d->name = pakfire_strdup(name);
-       d->value = pakfire_strdup(value);
+       d->name = strdup(name);
+       if (value)
+               d->value = strdup(value);
 
        DEBUG(parser->pakfire, "New declaration: %s = %s\n", d->name, d->value);
 
@@ -277,8 +284,11 @@ static void pakfire_parser_strip_namespace(char* s) {
 
 static struct pakfire_parser_declaration* pakfire_parser_find_declaration(
                PakfireParser parser, const char* name) {
+       char* n = NULL;
+
        // Create a working copy of the namespace
-       char* n = pakfire_strdup(parser->namespace);
+       if (parser->namespace)
+               n = strdup(parser->namespace);
 
        size_t length = ((n) ? strlen(n) : 0) + strlen(name) + 1;
        char* buffer = malloc(length + 1);
@@ -329,7 +339,7 @@ PAKFIRE_EXPORT char* pakfire_parser_expand(PakfireParser parser, const char* val
 
        char* pos = strchr(value, '%');
        if (!pos)
-               return pakfire_strdup(value);
+               return strdup(value);
 
        // Compile the regular expression
        regex_t preg;
@@ -345,7 +355,7 @@ PAKFIRE_EXPORT char* pakfire_parser_expand(PakfireParser parser, const char* val
        }
 
        // Create a working copy of the string we are expanding
-       char* buffer = pakfire_strdup(value);
+       char* buffer = strdup(value);
 
        const size_t max_groups = 2;
        regmatch_t groups[max_groups];

diff --git a/src/libpakfire/problem.c b/src/libpakfire/problem.c
index 627b4b61d3d5c12557110121cbe22c6b5265ea48..0508285e35f039bcebc89a70c39d08701ed0774a 100644 (file)
--- a/src/libpakfire/problem.c
+++ b/src/libpakfire/problem.c
@@ -201,7 +201,7 @@ static char* to_string(PakfireProblem problem) {
 
        }
 
-       return pakfire_strdup(s);
+       return strdup(s);
 }
 
 PAKFIRE_EXPORT PakfireProblem pakfire_problem_create(PakfireRequest request, Id id) {

diff --git a/src/libpakfire/relation.c b/src/libpakfire/relation.c
index 5b84fd17f01eb2f734ff69d5bdb2938ff1b07063..382080bcc85bd55858aa49a196294417c215c773 100644 (file)
--- a/src/libpakfire/relation.c
+++ b/src/libpakfire/relation.c
@@ -170,7 +170,7 @@ PAKFIRE_EXPORT char* pakfire_relation_str(PakfireRelation relation) {
 
        const char* str = pool_dep2str(pool, relation->id);
 
-       return pakfire_strdup(str);
+       return strdup(str);
 }
 
 PAKFIRE_EXPORT int pakfire_relation2queue(const PakfireRelation relation, Queue* queue, int solver_action) {

diff --git a/src/libpakfire/repo.c b/src/libpakfire/repo.c
index f15ef74979793de30dabc727ceaf9221106897d7..e36360f81a822d0763575f57c089c278a7b75d78 100644 (file)
--- a/src/libpakfire/repo.c
+++ b/src/libpakfire/repo.c
@@ -237,7 +237,7 @@ PAKFIRE_EXPORT const char* pakfire_repo_get_name(PakfireRepo repo) {
 }
 
 PAKFIRE_EXPORT void pakfire_repo_set_name(PakfireRepo repo, const char* name) {
-       repo->repo->name = pakfire_strdup(name);
+       repo->repo->name = strdup(name);
 }
 
 PAKFIRE_EXPORT const char* pakfire_repo_get_description(PakfireRepo repo) {
@@ -249,7 +249,7 @@ PAKFIRE_EXPORT int pakfire_repo_set_description(PakfireRepo repo, const char* de
                free(repo->appdata->description);
 
        if (description)
-               repo->appdata->description = pakfire_strdup(description);
+               repo->appdata->description = strdup(description);
        else
                repo->appdata->description = NULL;
 
@@ -286,7 +286,7 @@ PAKFIRE_EXPORT int pakfire_repo_set_baseurl(PakfireRepo repo, const char* baseur
                free(repo->appdata->baseurl);
 
        if (baseurl)
-               repo->appdata->baseurl = pakfire_strdup(baseurl);
+               repo->appdata->baseurl = strdup(baseurl);
        else
                repo->appdata->baseurl = NULL;
 
@@ -302,7 +302,7 @@ PAKFIRE_EXPORT int pakfire_repo_set_keyfile(PakfireRepo repo, const char* keyfil
                free(repo->appdata->keyfile);
 
        if (keyfile)
-               repo->appdata->keyfile = pakfire_strdup(keyfile);
+               repo->appdata->keyfile = strdup(keyfile);
        else
                repo->appdata->keyfile = NULL;
 
@@ -318,7 +318,7 @@ PAKFIRE_EXPORT int pakfire_repo_set_mirrorlist(PakfireRepo repo, const char* mir
                free(repo->appdata->mirrorlist);
 
        if (mirrorlist)
-               repo->appdata->mirrorlist = pakfire_strdup(mirrorlist);
+               repo->appdata->mirrorlist = strdup(mirrorlist);
        else
                repo->appdata->mirrorlist = NULL;
 
@@ -360,7 +360,7 @@ PAKFIRE_EXPORT char* pakfire_repo_get_config(PakfireRepo repo) {
        // Priority
        p += sprintf(p, "priority = %d\n", pakfire_repo_get_priority(repo));
 
-       return pakfire_strdup(buffer);
+       return strdup(buffer);
 }
 
 PAKFIRE_EXPORT int pakfire_repo_is_installed_repo(PakfireRepo repo) {

diff --git a/src/libpakfire/selector.c b/src/libpakfire/selector.c
index 2dc50547ba7d8e667d946b02e4f0eb4e0c86d9f3..8c7bc05ee08a5478fe7dc6a6a95b70fe74a39ba1 100644 (file)
--- a/src/libpakfire/selector.c
+++ b/src/libpakfire/selector.c
@@ -113,7 +113,7 @@ static void pakfire_selector_replace_filter(PakfireFilter* filter, int keyname,
 
        f->keyname = keyname;
        f->cmp_type = cmp_type;
-       f->match = pakfire_strdup(match);
+       f->match = strdup(match);
 
        *filter = f;
 }

diff --git a/src/libpakfire/solution.c b/src/libpakfire/solution.c
index 9465bd79b276915bacf5d124ed39e2d8d8f16ed4..f0a00fb85b69bdcedf17e7df86e99a76802962f9 100644 (file)
--- a/src/libpakfire/solution.c
+++ b/src/libpakfire/solution.c
@@ -111,7 +111,7 @@ static void import_elements(PakfireSolution solution) {
                        snprintf(line, STRING_SIZE - 1, _("bad solution element"));
 
                // Save line in elements array
-               *elements++ = pakfire_strdup(line);
+               *elements++ = strdup(line);
        }
 
        // Terminate array
@@ -227,5 +227,5 @@ PAKFIRE_EXPORT char* pakfire_solution_to_string(PakfireSolution solution) {
        // the last character
        assert((s + length) == p);
 
-       return pakfire_strdup(s);
+       return strdup(s);
 }

diff --git a/src/libpakfire/util.c b/src/libpakfire/util.c
index 17b007b9dd9428f8b7e0d576c80a1057972d8340..8d20ad4b619351ba9b0c19be2c874bde7716c561 100644 (file)
--- a/src/libpakfire/util.c
+++ b/src/libpakfire/util.c
@@ -35,27 +35,6 @@
 #include <pakfire/private.h>
 #include <pakfire/types.h>
 
-void pakfire_oom(size_t num, size_t len) {
-       if (num)
-               fprintf(stderr, "Out of memory allocating %zu*%zu bytes!\n", num, len);
-       else
-               fprintf(stderr, "Out of memory allocating %zu bytes!\n", len);
-
-       abort();
-       exit(1);
-}
-
-char* pakfire_strdup(const char* s) {
-       if (!s)
-               return 0;
-
-       char* r = strdup(s);
-       if (!r)
-               pakfire_oom(0, strlen(s));
-
-       return r;
-}
-
 PAKFIRE_EXPORT int pakfire_string_startswith(const char* s, const char* prefix) {
        return !strncmp(s, prefix, strlen(prefix));
 }
@@ -72,7 +51,7 @@ char* pakfire_format_size(double size) {
 
        snprintf(string, STRING_SIZE, "%.0f%s", round(size), *unit);
 
-       return pakfire_strdup(string);
+       return strdup(string);
 }
 
 #pragma GCC diagnostic push
@@ -83,7 +62,7 @@ static char* pakfire_strftime(const char* format, time_t t) {
 
        strftime(string, sizeof(string), format, tm);
 
-       return pakfire_strdup(string);
+       return strdup(string);
 }
 #pragma GCC diagnostic pop
 
@@ -95,13 +74,13 @@ PAKFIRE_EXPORT char* pakfire_path_join(const char* first, const char* second) {
        char* buffer;
 
        if (!first)
-               return pakfire_strdup(second);
+               return strdup(second);
 
        if (!second)
-               return pakfire_strdup(first);
+               return strdup(first);
 
        if (*second == '/')
-               return pakfire_strdup(second);
+               return strdup(second);
 
        asprintf(&buffer, "%s/%s", first, second);
 
@@ -130,11 +109,11 @@ PAKFIRE_EXPORT int pakfire_path_isdir(const char* path) {
 }
 
 PAKFIRE_EXPORT char* pakfire_basename(const char* path) {
-       char* name = pakfire_strdup(path);
+       char* name = strdup(path);
 
        char* r = basename(name);
        if (r)
-               r = pakfire_strdup(r);
+               r = strdup(r);
 
        free(name);
 
@@ -142,11 +121,11 @@ PAKFIRE_EXPORT char* pakfire_basename(const char* path) {
 }
 
 PAKFIRE_EXPORT char* pakfire_dirname(const char* path) {
-       char* parent = pakfire_strdup(path);
+       char* parent = strdup(path);
 
        char* r = dirname(parent);
        if (r)
-               r = pakfire_strdup(r);
+               r = strdup(r);
 
        free(parent);
 
@@ -331,7 +310,7 @@ PAKFIRE_EXPORT char** pakfire_split_string(const char* s, char delim) {
        unsigned int i = 0;
        char* p = buffer;
        while (*p) {
-               ret[i++] = pakfire_strdup(p);
+               ret[i++] = strdup(p);
 
                // Move pointer to the next string
                p += strlen(p) + 1;
@@ -359,5 +338,5 @@ PAKFIRE_EXPORT void pakfire_partition_string(const char* s, const char* delim, c
        *s1 = malloc(l);
        snprintf(*s1, l, "%s", s);
 
-       *s2 = pakfire_strdup(p + strlen(delim));
+       *s2 = strdup(p + strlen(delim));
 }