From patchwork Tue Jun 9 16:26:36 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stijn Devriendt X-Patchwork-Id: 1306081 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=googlegroups.com (client-ip=2a00:1450:4864:20::439; helo=mail-wr1-x439.google.com; envelope-from=swupdate+bncbclnzfwotyirbsxq733akgqezfs577q@googlegroups.com; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=googlegroups.com header.i=@googlegroups.com header.a=rsa-sha256 header.s=20161025 header.b=gQF0vmsy; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=nTOtAR9J; dkim-atps=neutral Received: from mail-wr1-x439.google.com (mail-wr1-x439.google.com [IPv6:2a00:1450:4864:20::439]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 49hFrH525yz9sRN for ; Wed, 10 Jun 2020 02:26:54 +1000 (AEST) Received: by mail-wr1-x439.google.com with SMTP id c14sf8788817wrm.15 for ; Tue, 09 Jun 2020 09:26:54 -0700 (PDT) ARC-Seal: i=2; a=rsa-sha256; t=1591720011; cv=pass; d=google.com; s=arc-20160816; b=ybJFGrFfkS3MBsaYrKMSozJ0Di9qCJlWizR8VWKS07s9/dPu3TtXv7lsWJ0T0jQnli 1HRJDZXlSEPOEiHhdudpP/oGcGwpS6QO0oVCQyteA5xINKcR4gjG5w6AeryfaRrBfAD/ w9yAakSwE6ppSEsMYus2g6RN330N74hgW1YamzciUz594rTvAerHHYvJmwyx2dks29nz pC4yp4cCqqzPx8eRpRGviIThYnL8ViRwX5psaMdwDDWjjULRiv4JY6XJQMW6A0WrjM2Z RNTU6lMCkme4ruAsxJOdyeMQJfyDc7s3huuN+5ZlUS5H7USUzarvipx4JbIEBi338ZMN AWnw== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-unsubscribe:list-subscribe:list-archive:list-help:list-post :list-id:mailing-list:precedence:references:in-reply-to:message-id :date:subject:cc:to:from:mime-version:sender:dkim-signature :dkim-signature; bh=llIMwikN3ylfBl3CXoLyDUIyhzSUAd6aZm36o1q1TjU=; b=psbLT7t0I8MKKIq3bKHlvYoM3YQp8R/DlDADQHg86pEeU9FsKVr4eWsQhutU+/J6OE sc1IEh55j0CkuDO5NqHUFxCSnnhoYSjIFpaUbQbT//HggSjnnsPSs8y2s1Jh45QQpgoz iblnQ0gof1Jz7FL35BhUaoF4+BlBTQkVlhOZmXZG6aznFXUkx/fnJT5EQoYZ39yRdVCB ErLtn5J5/B0CXcNkEvi8o9AeLWFM9GD4J57eW3jX3KaoAMpVREpmm3dWkvYqznpZJPBb ehfh05aH1Z8mfqjf7eJBygk4cnro82l2r15czE/bC0/H2JMKaX/quTpkXd0aYAmewe9Z 8RHg== ARC-Authentication-Results: i=2; gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=Au3LEd7h; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::62a as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlegroups.com; s=20161025; h=sender:mime-version:from:to:cc:subject:date:message-id:in-reply-to :references:x-original-sender:x-original-authentication-results :precedence:mailing-list:list-id:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=llIMwikN3ylfBl3CXoLyDUIyhzSUAd6aZm36o1q1TjU=; b=gQF0vmsyA+Tx3pABz8a/8ezSxCrbvJhHre/nLbhpxjWzsR8uxkgG87DOHdmx2zEQMz aDHO/tD8WRV9967M+TNFSz5i9NixbQImVbPwZmBqc42EAfb8AQ65/c5C1uqrFlfByH9k GuzDMZ0SgfWrDMmaAqVmfU4BjoIl+GAkbo7SRLmDAMUBgIVuCKj+uv3+nm7QobNdc5Ua aC1BQVWPJizSWLFEmJ81SGMLUYB2ooZnjrXwTV8+PAxTIrVR8HnS43n0zfl4Tra+8jIU 3Mxd+qsN7PABjMKjYV8WIpblUihZYy2C2kRrS3eYern4fi5QOQUbytoFov5+fzTFD29/ 5e+g== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:from:to:cc:subject:date:message-id:in-reply-to :references:x-original-sender:x-original-authentication-results :precedence:mailing-list:list-id:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=llIMwikN3ylfBl3CXoLyDUIyhzSUAd6aZm36o1q1TjU=; b=nTOtAR9Jsdio1TkNR0/FeFPNQA+beTQ4Dtd+bwk9tL42xaaSPNl+OTcmBtldq/q/Ds 6S4fm4yZZER19GYcgadIfWJKXRUriCXzHAI5BKA0DBKnrgTENRYAVcCPOcMCQqANc5mF GRFKeWC5Lm2JKoeRp34s1dzBBLhP4Qobf3fZ/BjUmTyAwr39NWgUeEnpmpz6L2fLBaHO fTtwknhGt+DFTlAo7VFL/z6NlbZc3gQ9AgMHWvDQME/vN7pybLkc8DitcfxXp0ePVFs1 L4TR5JDq3E2IXkli44u0ClBZdXJI7dBbKEOqnwJ6dCBMCvNIQ1zDB0dxxcsB/sq7Ady8 ywHg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=sender:x-gm-message-state:mime-version:from:to:cc:subject:date :message-id:in-reply-to:references:x-original-sender :x-original-authentication-results:precedence:mailing-list:list-id :x-spam-checked-in-group:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=llIMwikN3ylfBl3CXoLyDUIyhzSUAd6aZm36o1q1TjU=; b=Rf8GDlAqXZq+4HvPQ1Xc7a6TbKAoZuG1OyFpLAi39g4FjwVvGKEKKA5At/1EpobGsH bFBuGkdMhcrkQ1PgV6jx5wcRSzZXPQcFRtKchgiUpOHA8n0xE3rTGgL4rNkYc3dToBCU qEh7sMbH55IIFlk+aIRivJeLE1LdnujXmgG1pjcv7j/fnBmk4jPCKwv0f5ORvke80CUK gF4XVDh7vCsm+403PXE3qWkJbas54Wo5Rm1/5LFPvFnOhTv5e3dX2etZR7xH31YuFOv/ Fs1ZyAkqE/SryCegwmQ+mSsIrlh879tklmVloNAIC7cL/syzikdmfB0TYJTOt9fBk9Vt fF8w== Sender: swupdate@googlegroups.com X-Gm-Message-State: AOAM531qiALdXrYGJsHDiJApZmvHeLlszAN5VVvs+yOfbGvzTc/pRHhj akdv4FT2JFRt8UHiT/uUECc= X-Google-Smtp-Source: ABdhPJzP9pMlkUUL0hJat4Gddib0/jFhRpJk1i4mrSQFthRd2xUQJJ3tjAXmZqRl69cYmGyj6WqOag== X-Received: by 2002:a1c:998c:: with SMTP id b134mr5142497wme.78.1591720010948; Tue, 09 Jun 2020 09:26:50 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: swupdate@googlegroups.com Received: by 2002:a1c:62d6:: with SMTP id w205ls1816107wmb.1.canary-gmail; Tue, 09 Jun 2020 09:26:50 -0700 (PDT) X-Received: by 2002:a1c:6509:: with SMTP id z9mr5175078wmb.144.1591720010110; Tue, 09 Jun 2020 09:26:50 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1591720010; cv=none; d=google.com; s=arc-20160816; b=U77awFeqHHQS2XHjG2P3n9Ie6s/sX6w619HHOlPMfBF7pjudejoQVlpskC95HR0F+g J/VglCa/qnbRy8urMq7nq/kI1MbWYo8rj0fFjvOmDjiv2ApTZB+7J2RvXMCwj1LqxZ83 ZJ+fWo6+RU5MTlXVfZMb/YFQRnBYgE+WzKBLs5WeGbzcUpPDJoXA+bYCmELVO9iOimeS l4troMrsILcAYvwp8K/t1VHg9ha47JLn5hh50HRtVXddiBbVQ55LVoC9Z0X7XFv80U11 0DY+nvCk2rG0ZX1+m4D8WNTFbXwgWRzzWuJMXlbR1iDB6sBSFac1wtTU2BGnytFRPgID IAog== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=kNEGeoIivLOih1IS9PiqfmezEzGOJu5rPWwSBFD1+7k=; b=ksmZgYsTbxSCFXxoPzxloHbz5Il5bWj95cBuUkpkkDH7erzhiAYm5XesbHL2O5olCC cAyP8pTqD/XDKYrQP6uwmZ4jgYVpvvjzCeKGUw/PMA4C0xHp2PDWwJGApCWwr1w6rLgL FlVuzFOTajED6LQCPzFJ/kS1JA7MuiBkWzQGVzJTQZ5WC8hBPG3Bh/hFx7xd8N48VVgy qbpCVIUXb63FVq5PqmGDPHD2xlXP98sFeK6NTUTMSa3KjJvw3MH1rUamcMmFAICsOqEK hQaSb1TESbARzt22jQ8bQliugWj+SALpWHZ/b1kHVTadtTHFnAzhtzMWCVAQXONUy/K7 GJcw== ARC-Authentication-Results: i=1; gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=Au3LEd7h; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::62a as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Received: from mail-ej1-x62a.google.com (mail-ej1-x62a.google.com. [2a00:1450:4864:20::62a]) by gmr-mx.google.com with ESMTPS id q72si174332wme.1.2020.06.09.09.26.50 for (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 09 Jun 2020 09:26:50 -0700 (PDT) Received-SPF: pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::62a as permitted sender) client-ip=2a00:1450:4864:20::62a; Received: by mail-ej1-x62a.google.com with SMTP id n24so23076913ejd.0 for ; Tue, 09 Jun 2020 09:26:50 -0700 (PDT) X-Received: by 2002:a17:906:ce28:: with SMTP id sd8mr17741322ejb.280.1591720009680; Tue, 09 Jun 2020 09:26:49 -0700 (PDT) Received: from localhost.localdomain (ptr-dv4l9au8mfcs6krkuj6.18120a2.ip6.access.telenet.be. [2a02:1811:ce13:ba00:485e:9916:929:292]) by smtp.googlemail.com with ESMTPSA id b4sm13383983ejp.40.2020.06.09.09.26.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 09 Jun 2020 09:26:48 -0700 (PDT) From: Stijn Devriendt To: HIGHGuY@gmail.com, sbabic@denx.de Cc: tomas@aparicio.me, swupdate@googlegroups.com, Stijn Devriendt Subject: [swupdate] [PATCH 1/4] Add semver library Date: Tue, 9 Jun 2020 18:26:36 +0200 Message-Id: <20200609162639.14788-1-sde@unmatched.eu> X-Mailer: git-send-email 2.17.1 In-Reply-To: <92475f7e-b76d-bcfc-7909-7e4ac52037bc@denx.de> References: <92475f7e-b76d-bcfc-7909-7e4ac52037bc@denx.de> X-Original-Sender: HIGHGuY@gmail.com X-Original-Authentication-Results: gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=Au3LEd7h; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::62a as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Precedence: list Mailing-list: list swupdate@googlegroups.com; contact swupdate+owners@googlegroups.com List-ID: X-Spam-Checked-In-Group: swupdate@googlegroups.com X-Google-Group-Id: 605343134186 List-Post: , List-Help: , List-Archive: , List-Unsubscribe: , Originally from: https://github.com/h2non/semver.c.git Original commit: bd1db234a68f305ed10268bd023df1ad672061d7 License: MIT Signed-off-by: Stijn Devriendt --- core/Makefile | 3 +- core/semver.c | 638 +++++++++++++++++++++++++++++++++++++++++++++++ include/semver.h | 105 ++++++++ 3 files changed, 745 insertions(+), 1 deletion(-) create mode 100644 core/semver.c create mode 100644 include/semver.h diff --git a/core/Makefile b/core/Makefile index a1d5f09..ad94120 100644 --- a/core/Makefile +++ b/core/Makefile @@ -23,4 +23,5 @@ obj-y += swupdate.o \ progress_thread.o \ parsing_library.o \ artifacts_versions.o \ - swupdate_dict.o + swupdate_dict.o \ + semver.o diff --git a/core/semver.c b/core/semver.c new file mode 100644 index 0000000..77a11ba --- /dev/null +++ b/core/semver.c @@ -0,0 +1,638 @@ +/* + * semver.c + * + * Copyright (c) 2015-2017 Tomas Aparicio + * MIT licensed + */ + +#include +#include +#include +#include "semver.h" + +#define SLICE_SIZE 50 +#define DELIMITER "." +#define PR_DELIMITER "-" +#define MT_DELIMITER "+" +#define NUMBERS "0123456789" +#define ALPHA "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" +#define DELIMITERS DELIMITER PR_DELIMITER MT_DELIMITER +#define VALID_CHARS NUMBERS ALPHA DELIMITERS + +static const size_t MAX_SIZE = sizeof(char) * 255; +static const int MAX_SAFE_INT = (unsigned int) -1 >> 1; + +/** + * Define comparison operators, storing the + * ASCII code per each symbol in hexadecimal notation. + */ + +enum operators { + SYMBOL_GT = 0x3e, + SYMBOL_LT = 0x3c, + SYMBOL_EQ = 0x3d, + SYMBOL_TF = 0x7e, + SYMBOL_CF = 0x5e +}; + +/** + * Private helpers + */ + +/* + * Remove [begin:len-begin] from str by moving len data from begin+len to begin. + * If len is negative cut out to the end of the string. + */ +static int +strcut (char *str, int begin, int len) { + size_t l; + l = strlen(str); + + if((int)l < 0 || (int)l > MAX_SAFE_INT) return -1; + + if (len < 0) len = l - begin + 1; + if (begin + len > (int)l) len = l - begin; + memmove(str + begin, str + begin + len, l - len + 1 - begin); + + return len; +} + +static int +contains (const char c, const char *matrix, size_t len) { + size_t x; + for (x = 0; x < len; x++) + if ((char) matrix[x] == c) return 1; + return 0; +} + +static int +has_valid_chars (const char *str, const char *matrix) { + size_t i, len, mlen; + len = strlen(str); + mlen = strlen(matrix); + + for (i = 0; i < len; i++) + if (contains(str[i], matrix, mlen) == 0) + return 0; + + return 1; +} + +static int +binary_comparison (int x, int y) { + if (x == y) return 0; + if (x > y) return 1; + return -1; +} + +static int +parse_int (const char *s) { + int valid, num; + valid = has_valid_chars(s, NUMBERS); + if (valid == 0) return -1; + + num = strtol(s, NULL, 10); + if (num > MAX_SAFE_INT) return -1; + + return num; +} + +/* + * Return a string allocated on the heap with the content from sep to end and + * terminate buf at sep. + */ +static char * +parse_slice (char *buf, char sep) { + char *pr, *part; + int plen; + + /* Find separator in buf */ + pr = strchr(buf, sep); + if (pr == NULL) return NULL; + /* Length from separator to end of buf */ + plen = strlen(pr); + + /* Copy from buf into new string */ + part = (char*)calloc(plen + 1, sizeof(*part)); + if (part == NULL) return NULL; + memcpy(part, pr + 1, plen); + /* Null terminate new string */ + part[plen] = '\0'; + + /* Terminate buf where separator was */ + *pr = '\0'; + + return part; +} + +/** + * Parses a string as semver expression. + * + * Returns: + * + * `0` - Parsed successfully + * `-1` - In case of error + */ + +int +semver_parse (const char *str, semver_t *ver) { + int valid, res; + size_t len; + char *buf; + valid = semver_is_valid(str); + if (!valid) return -1; + + len = strlen(str); + buf = (char*)calloc(len + 1, sizeof(*buf)); + if (buf == NULL) return -1; + strcpy(buf, str); + + ver->metadata = parse_slice(buf, MT_DELIMITER[0]); + ver->prerelease = parse_slice(buf, PR_DELIMITER[0]); + + res = semver_parse_version(buf, ver); + free(buf); +#if DEBUG > 0 + printf("[debug] semver.c %s = %d.%d.%d, %s %s\n", str, ver->major, ver->minor, ver->patch, ver->prerelease, ver->metadata); +#endif + return res; +} + +/** + * Parses a given string as semver expression. + * + * Returns: + * + * `0` - Parsed successfully + * `-1` - Parse error or invalid + */ + +int +semver_parse_version (const char *str, semver_t *ver) { + size_t len; + int index, value; + char *slice, *next, *endptr; + slice = (char *) str; + index = 0; + + while (slice != NULL && index++ < 4) { + next = strchr(slice, DELIMITER[0]); + if (next == NULL) + len = strlen(slice); + else + len = next - slice; + if (len > SLICE_SIZE) return -1; + + /* Cast to integer and store */ + value = strtol(slice, &endptr, 10); + if (endptr != next && *endptr != '\0') return -1; + + switch (index) { + case 1: ver->major = value; break; + case 2: ver->minor = value; break; + case 3: ver->patch = value; break; + } + + /* Continue with the next slice */ + if (next == NULL) + slice = NULL; + else + slice = next + 1; + } + + return 0; +} + +static int +compare_prerelease (char *x, char *y) { + char *lastx, *lasty, *xptr, *yptr, *endptr; + int xlen, ylen, xisnum, yisnum, xnum, ynum; + int xn, yn, min, res; + if (x == NULL && y == NULL) return 0; + if (y == NULL && x) return -1; + if (x == NULL && y) return 1; + + lastx = x; + lasty = y; + xlen = strlen(x); + ylen = strlen(y); + + while (1) { + if ((xptr = strchr(lastx, DELIMITER[0])) == NULL) + xptr = x + xlen; + if ((yptr = strchr(lasty, DELIMITER[0])) == NULL) + yptr = y + ylen; + + xnum = strtol(lastx, &endptr, 10); + xisnum = endptr == xptr ? 1 : 0; + ynum = strtol(lasty, &endptr, 10); + yisnum = endptr == yptr ? 1 : 0; + + if (xisnum && !yisnum) return -1; + if (!xisnum && yisnum) return 1; + + if (xisnum && yisnum) { + /* Numerical comparison */ + if (xnum != ynum) return xnum < ynum ? -1 : 1; + } else { + /* String comparison */ + xn = xptr - lastx; + yn = yptr - lasty; + min = xn < yn ? xn : yn; + if ((res = strncmp(lastx, lasty, min))) return res < 0 ? -1 : 1; + if (xn != yn) return xn < yn ? -1 : 1; + } + + lastx = xptr + 1; + lasty = yptr + 1; + if (lastx == x + xlen + 1 && lasty == y + ylen + 1) break; + if (lastx == x + xlen + 1) return -1; + if (lasty == y + ylen + 1) return 1; + } + + return 0; +} + +int +semver_compare_prerelease (semver_t x, semver_t y) { + return compare_prerelease(x.prerelease, y.prerelease); +} + +/** + * Performs a major, minor and patch binary comparison (x, y). + * This function is mostly used internally + * + * Returns: + * + * `0` - If versiona are equal + * `1` - If x is higher than y + * `-1` - If x is lower than y + */ + +int +semver_compare_version (semver_t x, semver_t y) { + int res; + + if ((res = binary_comparison(x.major, y.major)) == 0) { + if ((res = binary_comparison(x.minor, y.minor)) == 0) { + return binary_comparison(x.patch, y.patch); + } + } + + return res; +} + +/** + * Compare two semantic versions (x, y). + * + * Returns: + * - `1` if x is higher than y + * - `0` if x is equal to y + * - `-1` if x is lower than y + */ + +int +semver_compare (semver_t x, semver_t y) { + int res; + + if ((res = semver_compare_version(x, y)) == 0) { + return semver_compare_prerelease(x, y); + } + + return res; +} + +/** + * Performs a `greater than` comparison + */ + +int +semver_gt (semver_t x, semver_t y) { + return semver_compare(x, y) == 1; +} + +/** + * Performs a `lower than` comparison + */ + +int +semver_lt (semver_t x, semver_t y) { + return semver_compare(x, y) == -1; +} + +/** + * Performs a `equality` comparison + */ + +int +semver_eq (semver_t x, semver_t y) { + return semver_compare(x, y) == 0; +} + +/** + * Performs a `non equal to` comparison + */ + +int +semver_neq (semver_t x, semver_t y) { + return semver_compare(x, y) != 0; +} + +/** + * Performs a `greater than or equal` comparison + */ + +int +semver_gte (semver_t x, semver_t y) { + return semver_compare(x, y) >= 0; +} + +/** + * Performs a `lower than or equal` comparison + */ + +int +semver_lte (semver_t x, semver_t y) { + return semver_compare(x, y) <= 0; +} + +/** + * Checks if version `x` can be satisfied by `y` + * performing a comparison with caret operator. + * + * See: https://docs.npmjs.com/misc/semver#caret-ranges-1-2-3-0-2-5-0-0-4 + * + * Returns: + * + * `1` - Can be satisfied + * `0` - Cannot be satisfied + */ + +int +semver_satisfies_caret (semver_t x, semver_t y) { + /* Major versions must always match. */ + if (x.major == y.major) { + /* If major version is 0, minor versions must match */ + if (x.major == 0) { + /* If minor version is 0, patch must match */ + if (x.minor == 0){ + return (x.minor == y.minor) && (x.patch == y.patch); + } + /* If minor version is not 0, patch must be >= */ + else if (x.minor == y.minor){ + return x.patch >= y.patch; + } + else{ + return 0; + } + } + else if (x.minor > y.minor){ + return 1; + } + else if (x.minor == y.minor) + { + return x.patch >= y.patch; + } + else { + return 0; + } + } + return 0; +} + +/** + * Checks if version `x` can be satisfied by `y` + * performing a comparison with tilde operator. + * + * See: https://docs.npmjs.com/misc/semver#tilde-ranges-1-2-3-1-2-1 + * + * Returns: + * + * `1` - Can be satisfied + * `0` - Cannot be satisfied + */ + +int +semver_satisfies_patch (semver_t x, semver_t y) { + return x.major == y.major + && x.minor == y.minor; +} + +/** + * Checks if both versions can be satisfied + * based on the given comparison operator. + * + * Allowed operators: + * + * - `=` - Equality + * - `>=` - Higher or equal to + * - `<=` - Lower or equal to + * - `<` - Lower than + * - `>` - Higher than + * - `^` - Caret comparison (see https://docs.npmjs.com/misc/semver#caret-ranges-1-2-3-0-2-5-0-0-4) + * - `~` - Tilde comparison (see https://docs.npmjs.com/misc/semver#tilde-ranges-1-2-3-1-2-1) + * + * Returns: + * + * `1` - Can be satisfied + * `0` - Cannot be satisfied + */ + +int +semver_satisfies (semver_t x, semver_t y, const char *op) { + int first, second; + /* Extract the comparison operator */ + first = op[0]; + second = op[1]; + + /* Caret operator */ + if (first == SYMBOL_CF) + return semver_satisfies_caret(x, y); + + /* Tilde operator */ + if (first == SYMBOL_TF) + return semver_satisfies_patch(x, y); + + /* Strict equality */ + if (first == SYMBOL_EQ) + return semver_eq(x, y); + + /* Greater than or equal comparison */ + if (first == SYMBOL_GT) { + if (second == SYMBOL_EQ) { + return semver_gte(x, y); + } + return semver_gt(x, y); + } + + /* Lower than or equal comparison */ + if (first == SYMBOL_LT) { + if (second == SYMBOL_EQ) { + return semver_lte(x, y); + } + return semver_lt(x, y); + } + + return 0; +} + +/** + * Free heep allocated memory of a given semver. + * This is just a convenient function that you + * should call when you're done. + */ + +void +semver_free (semver_t *x) { + if (x->metadata) { + free(x->metadata); + x->metadata = NULL; + } + if (x->prerelease) { + free(x->prerelease); + x->prerelease = NULL; + } +} + +/** + * Renders + */ + +static void +concat_num (char * str, int x, char * sep) { + char buf[SLICE_SIZE] = {0}; + if (sep == NULL) sprintf(buf, "%d", x); + else sprintf(buf, "%s%d", sep, x); + strcat(str, buf); +} + +static void +concat_char (char * str, char * x, char * sep) { + char buf[SLICE_SIZE] = {0}; + sprintf(buf, "%s%s", sep, x); + strcat(str, buf); +} + +/** + * Render a given semver as string + */ + +void +semver_render (semver_t *x, char *dest) { + concat_num(dest, x->major, NULL); + concat_num(dest, x->minor, DELIMITER); + concat_num(dest, x->patch, DELIMITER); + if (x->prerelease) concat_char(dest, x->prerelease, PR_DELIMITER); + if (x->metadata) concat_char(dest, x->metadata, MT_DELIMITER); +} + +/** + * Version bump helpers + */ + +void +semver_bump (semver_t *x) { + x->major++; +} + +void +semver_bump_minor (semver_t *x) { + x->minor++; +} + +void +semver_bump_patch (semver_t *x) { + x->patch++; +} + +/** + * Helpers + */ + +static int +has_valid_length (const char *s) { + return strlen(s) <= MAX_SIZE; +} + +/** + * Checks if a given semver string is valid + * + * Returns: + * + * `1` - Valid expression + * `0` - Invalid + */ + +int +semver_is_valid (const char *s) { + return has_valid_length(s) + && has_valid_chars(s, VALID_CHARS); +} + +/** + * Removes non-valid characters in the given string. + * + * Returns: + * + * `0` - Valid + * `-1` - Invalid input + */ + +int +semver_clean (char *s) { + size_t i, len, mlen; + int res; + if (has_valid_length(s) == 0) return -1; + + len = strlen(s); + mlen = strlen(VALID_CHARS); + + for (i = 0; i < len; i++) { + if (contains(s[i], VALID_CHARS, mlen) == 0) { + res = strcut(s, i, 1); + if(res == -1) return -1; + --len; --i; + } + } + + return 0; +} + +static int +char_to_int (const char * str) { + int buf; + size_t i,len, mlen; + buf = 0; + len = strlen(str); + mlen = strlen(VALID_CHARS); + + for (i = 0; i < len; i++) + if (contains(str[i], VALID_CHARS, mlen)) + buf += (int) str[i]; + + return buf; +} + +/** + * Render a given semver as numeric value. + * Useful for ordering and filtering. + */ + +int +semver_numeric (semver_t *x) { + int num; + char buf[SLICE_SIZE * 3]; + memset(&buf, 0, SLICE_SIZE * 3); + + if (x->major) concat_num(buf, x->major, NULL); + if (x->major || x->minor) concat_num(buf, x->minor, NULL); + if (x->major || x->minor || x->patch) concat_num(buf, x->patch, NULL); + + num = parse_int(buf); + if(num == -1) return -1; + + if (x->prerelease) num += char_to_int(x->prerelease); + if (x->metadata) num += char_to_int(x->metadata); + + return num; +} diff --git a/include/semver.h b/include/semver.h new file mode 100644 index 0000000..1b48670 --- /dev/null +++ b/include/semver.h @@ -0,0 +1,105 @@ +/* + * semver.h + * + * Copyright (c) 2015-2017 Tomas Aparicio + * MIT licensed + */ + +#ifndef __SEMVER_H +#define __SEMVER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef SEMVER_VERSION +#define SEMVER_VERSION "0.2.0" +#endif + +/** + * semver_t struct + */ + +typedef struct semver_version_s { + int major; + int minor; + int patch; + char * metadata; + char * prerelease; +} semver_t; + +/** + * Set prototypes + */ + +int +semver_satisfies (semver_t x, semver_t y, const char *op); + +int +semver_satisfies_caret (semver_t x, semver_t y); + +int +semver_satisfies_patch (semver_t x, semver_t y); + +int +semver_compare (semver_t x, semver_t y); + +int +semver_compare_version (semver_t x, semver_t y); + +int +semver_compare_prerelease (semver_t x, semver_t y); + +int +semver_gt (semver_t x, semver_t y); + +int +semver_gte (semver_t x, semver_t y); + +int +semver_lt (semver_t x, semver_t y); + +int +semver_lte (semver_t x, semver_t y); + +int +semver_eq (semver_t x, semver_t y); + +int +semver_neq (semver_t x, semver_t y); + +int +semver_parse (const char *str, semver_t *ver); + +int +semver_parse_version (const char *str, semver_t *ver); + +void +semver_render (semver_t *x, char *dest); + +int +semver_numeric (semver_t *x); + +void +semver_bump (semver_t *x); + +void +semver_bump_minor (semver_t *x); + +void +semver_bump_patch (semver_t *x); + +void +semver_free (semver_t *x); + +int +semver_is_valid (const char *s); + +int +semver_clean (char *s); + +#ifdef __cplusplus +} +#endif + +#endif From patchwork Tue Jun 9 16:26:37 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stijn Devriendt X-Patchwork-Id: 1306082 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=googlegroups.com (client-ip=2a00:1450:4864:20::13b; helo=mail-lf1-x13b.google.com; envelope-from=swupdate+bncbclnzfwotyirbs7q733akgqenhm5dkq@googlegroups.com; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=googlegroups.com header.i=@googlegroups.com header.a=rsa-sha256 header.s=20161025 header.b=Vts6dazf; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=TeXJv3RV; dkim-atps=neutral Received: from mail-lf1-x13b.google.com (mail-lf1-x13b.google.com [IPv6:2a00:1450:4864:20::13b]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 49hFrJ1G1wz9sT5 for ; Wed, 10 Jun 2020 02:26:56 +1000 (AEST) Received: by mail-lf1-x13b.google.com with SMTP id a17sf6964697lfr.9 for ; Tue, 09 Jun 2020 09:26:56 -0700 (PDT) ARC-Seal: i=2; a=rsa-sha256; t=1591720012; cv=pass; d=google.com; s=arc-20160816; b=kjPHwojsyViUJVU0JtQQesKkK/Wg9Dgd6l7x68tXm210LvR2MBkRhYiUZGaY3KB3Nk VfrrVlRxKgEpBSitZJRCt5vCU4DB1tbq3kjkIB3S9v+8B/eUtIGMoIBlDOa9HCmr9p7Y KX7bNPU83Nlzuj4GDkPsdKBViQlRcF2UPIOI+DLaUymZVTklw60ZdJeJvoH2B9/5F1Gz LmDDGmsq+5Wz+qGZyyUhY8VoUYHWbCGWpjCyK7XUlWnGpuwhjgNy/tr5qGnlkPBv2f96 MbHAiqRCvUTuFXR8cUfUmEJ+MznAEeuTXryD5yP2jtQ7WgQcp33G1werPVZO2TCmZMkQ gg4Q== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-unsubscribe:list-subscribe:list-archive:list-help:list-post :list-id:mailing-list:precedence:references:in-reply-to:message-id :date:subject:cc:to:from:mime-version:sender:dkim-signature :dkim-signature; bh=RNt4L2b9S1D4QXud2p+rKx9mflRf/xNkFknGR6hECbs=; b=E3qw4ZBpizH7SR6y9KihVfGhH7dugld1aGhSrjtDZoZyBJ2CRJ52CZ0bQr4RZ5jecD bJ8ipGwOG/Sac0LP3Ea1Djjf7pSeygjeuxjWixNZSJ+yr0burfWiUU5VLUKoiRAO8Y20 JF9/T+C6E0sQxPb9Nha3nV+dnfaYMp5Mx9OzCOHyMxhOjQi96pXpGH8a6nV6+Nw2NdoB YCD5L9fVp6u2864HVRKD8PQX2Ta6OY7CeZjUez+TIpYCxSsq/4JU+CCcaEtg1rC+mfB0 7aksxcmgu/+aJNePOi9JwGJpOa0cVTsL6bLerDqtXXCbK/QTYAgJElFQr/tqINb7khW6 rw7A== ARC-Authentication-Results: i=2; gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=CKHBYJO1; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::642 as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlegroups.com; s=20161025; h=sender:mime-version:from:to:cc:subject:date:message-id:in-reply-to :references:x-original-sender:x-original-authentication-results :precedence:mailing-list:list-id:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=RNt4L2b9S1D4QXud2p+rKx9mflRf/xNkFknGR6hECbs=; b=Vts6dazf2xO4IrPQAyAa9tLspqp9sVWrtQXl9zwGdE3nbrunLuoxuHb2B13o5kw+0l XoSMmdK6Rp7zqapa1igorPtlIAjxFpv9mEmfB4f7H4yg9wX0vSMCVUZhn/icTeMXnwtt cNJ13GVtEp/hymBr43bYYjgkz9hXK/aDUlhIDkOgcQkWs4+lfBcJBzSIa8uNFWjOIpVX JFEWWSEILEcp45wieNaJ8/rzRlTZbwv4Ne0X0gQgcE+t228bmJZEG9tUwdL1X/lCcQ6C XLA0aCMQb42zExMHAxybetw2jhmfK3HtIVn0Rm+B8a8K/wckeGobLf+U0y+T+fXAWQCa Dz0w== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:from:to:cc:subject:date:message-id:in-reply-to :references:x-original-sender:x-original-authentication-results :precedence:mailing-list:list-id:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=RNt4L2b9S1D4QXud2p+rKx9mflRf/xNkFknGR6hECbs=; b=TeXJv3RVR8S34MqOgF5YYuvSF0B+qIQ2KCHGisxH/98vll/YKXLU0iQOtEdKslMYIj wwb32xDpkfrWpXDllNl7HfCdalnKq0hGUAt5AydbRR4yMcRTUWRcvL8Ari88UGINTBvF KOqT0fPVTqlzjgM7q5GSOFKtxJwotMGLKeJYGLJ5oJziSxAC6BN/68aLn27EiIYnavvh y5uEwBnhBqrDzuWLtd22AvB8CJlO3h2uOwM6wET3m+WodTIAducWxXnFCcFX3erBx3PF 7SnBq9F9G/9MafI7iSdV0fUEib7TSgt/obwjR7G2vdjvmtGFpFNioo2VeWRRpvc828tS bxkg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=sender:x-gm-message-state:mime-version:from:to:cc:subject:date :message-id:in-reply-to:references:x-original-sender :x-original-authentication-results:precedence:mailing-list:list-id :x-spam-checked-in-group:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=RNt4L2b9S1D4QXud2p+rKx9mflRf/xNkFknGR6hECbs=; b=INXNdqxXjjyFCpu5oVu7LLgWe4xsGGD2cQ42//9ILBRDFwbR+E/SfNwbHjOifBWgZt Xd9zhSMGAvavwC5bKYVkDUhzpXQDVBH76hJCFLSil6Veg6DoNQCM5XVimuKipvydHH62 aariK20lhPnnPULoCNLGX7Rv2fWKJTsLm6Z0n5zsFec2ClvSyg399skwWPQH34/KMZNO HIx32lTDKB9lOEmVWTHnMAEyiPX7FcOvPDaJnpz2AI0V/cdNNzd8L3XrJi4e65rjkTiR jBmgCnicr1mGH9VVqfJXSm3V2LI/zsgD2WFnCFmKoJrCUu4mm97vv1W7VFcf2XY5Z/vt PcEw== Sender: swupdate@googlegroups.com X-Gm-Message-State: AOAM530RPkV3TEKOTHEPsvthni4pst6R79DkcChnRIScAXn6kMok0udz 0AHtrE74CC+lKVh4aIybKcs= X-Google-Smtp-Source: ABdhPJzEgALSyhACTSn835jSK0RVnvB46BBMrNzIAEaGbkPFuBDgUMgF0EqjpaMsgm4xaLDpXnharA== X-Received: by 2002:a19:3f01:: with SMTP id m1mr15707704lfa.130.1591720012051; Tue, 09 Jun 2020 09:26:52 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: swupdate@googlegroups.com Received: by 2002:a2e:b61c:: with SMTP id r28ls2437280ljn.5.gmail; Tue, 09 Jun 2020 09:26:51 -0700 (PDT) X-Received: by 2002:a2e:8744:: with SMTP id q4mr9824283ljj.91.1591720011139; Tue, 09 Jun 2020 09:26:51 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1591720011; cv=none; d=google.com; s=arc-20160816; b=R4/hjYY8J9MoOYtNFMTxfegdMJVWdvc9CAspWWjJApUu7Eq0dmc2UAIQSxxbhD60uy Q5StjJ6v4v3jFq5+AeHIe1Oz0aX1UlsOejj6zgKblixorBeAcAmEHF4478f4t9+/V889 ylS6332xE2T5UF8Pj31drHGguvs5ompiNDhHgcpOvbIpokHEJz394uUeMIxfUtoNRsMy E4bmRUJc3fSl5MERxzJvYzre7JqkZLnrB1t5CPQDocdGWXaYMoSvgeFpNmyJRlyzdTfa 7NseLi4ccdydh/ycg/VQgQD6157Hr2Z4LRmRFH9k2fW8Lo0pkCz2IX3Twulj4bZCwgnk P9nA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=Jb9LuPvAB/N2W60px+nqcgAF2Bb8ouAXrKkTJT9EvGs=; b=pimi94Jy4oSIzoe/9hXJuJExOh6KZxniMFqgcJ8Tn7IHqcvuVABmL1GjC9yi8ppMBu NbXXAe/SZ5HEJye/mVZ7dsWAVJ2qQHb8jZ+vz+hOq58P2iMGtKrYVoUE4KMlf+rmUXU2 s3VZ6zm++QiEG/hRLPenAkV8iVAMLHZfRzC9WC21cUGGQVDiKcmTIMKs7IAi8uOOYwXK sKSEcnZDIUK2zv3eJZOcqbzmLYoHePkdQmtdfLslkAm/+dKo2PFNie6BGFOnqC9ibBcV G2WRjnh3s5s1G71PbjABnQD11DFtoBzldL1IWnHyODAoMwAMAo19EJcQ1u4LuL4QXH1A R+ow== ARC-Authentication-Results: i=1; gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=CKHBYJO1; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::642 as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Received: from mail-ej1-x642.google.com (mail-ej1-x642.google.com. [2a00:1450:4864:20::642]) by gmr-mx.google.com with ESMTPS id k6si1101606ljj.6.2020.06.09.09.26.51 for (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 09 Jun 2020 09:26:51 -0700 (PDT) Received-SPF: pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::642 as permitted sender) client-ip=2a00:1450:4864:20::642; Received: by mail-ej1-x642.google.com with SMTP id l12so19271760ejn.10 for ; Tue, 09 Jun 2020 09:26:51 -0700 (PDT) X-Received: by 2002:a17:906:c187:: with SMTP id g7mr26179808ejz.446.1591720010639; Tue, 09 Jun 2020 09:26:50 -0700 (PDT) Received: from localhost.localdomain (ptr-dv4l9au8mfcs6krkuj6.18120a2.ip6.access.telenet.be. [2a02:1811:ce13:ba00:485e:9916:929:292]) by smtp.googlemail.com with ESMTPSA id b4sm13383983ejp.40.2020.06.09.09.26.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 09 Jun 2020 09:26:50 -0700 (PDT) From: Stijn Devriendt To: HIGHGuY@gmail.com, sbabic@denx.de Cc: tomas@aparicio.me, swupdate@googlegroups.com, Stijn Devriendt Subject: [swupdate] [PATCH 2/4] Fix semver compilation warnings Date: Tue, 9 Jun 2020 18:26:37 +0200 Message-Id: <20200609162639.14788-2-sde@unmatched.eu> X-Mailer: git-send-email 2.17.1 In-Reply-To: <92475f7e-b76d-bcfc-7909-7e4ac52037bc@denx.de> References: <92475f7e-b76d-bcfc-7909-7e4ac52037bc@denx.de> X-Original-Sender: HIGHGuY@gmail.com X-Original-Authentication-Results: gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=CKHBYJO1; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::642 as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Precedence: list Mailing-list: list swupdate@googlegroups.com; contact swupdate+owners@googlegroups.com List-ID: X-Spam-Checked-In-Group: swupdate@googlegroups.com X-Google-Group-Id: 605343134186 List-Post: , List-Help: , List-Archive: , List-Unsubscribe: , Signed-off-by: Stijn Devriendt --- core/semver.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/core/semver.c b/core/semver.c index 77a11ba..8660104 100644 --- a/core/semver.c +++ b/core/semver.c @@ -152,7 +152,7 @@ semver_parse (const char *str, semver_t *ver) { res = semver_parse_version(buf, ver); free(buf); -#if DEBUG > 0 +#ifndef NDEBUG printf("[debug] semver.c %s = %d.%d.%d, %s %s\n", str, ver->major, ver->minor, ver->patch, ver->prerelease, ver->metadata); #endif return res; @@ -499,7 +499,7 @@ semver_free (semver_t *x) { */ static void -concat_num (char * str, int x, char * sep) { +concat_num (char * str, int x, const char * sep) { char buf[SLICE_SIZE] = {0}; if (sep == NULL) sprintf(buf, "%d", x); else sprintf(buf, "%s%d", sep, x); @@ -507,7 +507,7 @@ concat_num (char * str, int x, char * sep) { } static void -concat_char (char * str, char * x, char * sep) { +concat_char (char * str, const char * x, const char * sep) { char buf[SLICE_SIZE] = {0}; sprintf(buf, "%s%s", sep, x); strcat(str, buf); From patchwork Tue Jun 9 16:26:38 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stijn Devriendt X-Patchwork-Id: 1306083 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=googlegroups.com (client-ip=2a00:1450:4864:20::13b; helo=mail-lf1-x13b.google.com; envelope-from=swupdate+bncbclnzfwotyirbtpq733akgqex3yosgi@googlegroups.com; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=googlegroups.com header.i=@googlegroups.com header.a=rsa-sha256 header.s=20161025 header.b=ACe1Wx7M; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=Kzg/NIZU; dkim-atps=neutral Received: from mail-lf1-x13b.google.com (mail-lf1-x13b.google.com [IPv6:2a00:1450:4864:20::13b]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 49hFrJ13l4z9sT2 for ; Wed, 10 Jun 2020 02:26:56 +1000 (AEST) Received: by mail-lf1-x13b.google.com with SMTP id a10sf6906154lfo.23 for ; Tue, 09 Jun 2020 09:26:55 -0700 (PDT) ARC-Seal: i=2; a=rsa-sha256; t=1591720013; cv=pass; d=google.com; s=arc-20160816; b=UHPoaR1LEOavo6nGLV0rx0lJuoCHPwnfLnh8a44WHYv2iQ16t2D51pea7dbE6psWOn 9RobkBmamwjjCdRqQXsJWwtZA+cFvt9Noe2LLIbTdUap1Tr+XKEobj25IdxevSZjjl/e PrTDwKdrAmSr5UJXbpsEGCZjzCx01attIA8H+GyT3dl36IsTzNsq1VkU5iOJyIdHvHaW OLSHHS9CwaINpbICA/fgXFpw7iZanR9hSwg62zz89UozuILmfiC1owabCsqjF3fZezrf qDhbTxLylwMomc4l+A++/7JVU77QA12nuHvZvMAjiJ2mcNS1SArcEgKHyrJ1DMlY9bw6 uvxw== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-unsubscribe:list-subscribe:list-archive:list-help:list-post :list-id:mailing-list:precedence:references:in-reply-to:message-id :date:subject:cc:to:from:mime-version:sender:dkim-signature :dkim-signature; bh=/3GA+c5DEbvKetgo6fdvyoUb0PlhBIxQv559O14inyc=; b=Ry1r0sY4XxJEGuucw099EME4675/mfxjYM6wpa9RAR+bjF1jECd1Z13cyywvTalNq5 3PqOOPD6BGEKrVbNik9xFTm57LxwVN24nKl8wBxAf9JJy/0KsgGXTAsIUmxbydOB/toz Dw6gN9W7ON00kL7OUP0vCg0fE18Um63tQOdm6p1WyhP/UV3P6LFpherFj1cQUcLuI8S9 2oNOSHFrJTOK3eQN5Z9nq9GpDr4RCEzrplgRMZsBeHLSY6o2nZrE3w07q85k1fRKS7Vs pSEa1XXl3Ciukang9upejfQHw2Q9UoxjMLS3DDkFHNqfcMJprV1mcVc20nkvia/Cac43 zVxw== ARC-Authentication-Results: i=2; gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=sDsFsEIg; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::644 as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlegroups.com; s=20161025; h=sender:mime-version:from:to:cc:subject:date:message-id:in-reply-to :references:x-original-sender:x-original-authentication-results :precedence:mailing-list:list-id:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=/3GA+c5DEbvKetgo6fdvyoUb0PlhBIxQv559O14inyc=; b=ACe1Wx7MDZjROHCqOl2WqBfNoatqppUeGhdiHPEzkKOxxNUna8NY2HAD/LJu8ergSx r5jeIr514s3cyi4kGOLkRCi44dLntGqdwqSPP5zjR8s7OmFg8WeHnEije+DhVkbTp9DL NoJm2/afDPfvB09UcrqOKeaOZgJaRd+C/SfETGSj+PgK8vxKMw7T+Y3aMXoE9hd+sI7y vx32Hj0jQ1PSba5sNynC5pLHcX1l5WJVu6zoTM/2wHSgEoXbW1u9Zyv8gStx4FTA3U3T pO7FbQ6YoRCkMyNS9SMeXrDen6G9uBJLqCG0TnYuDQv2kY4Lb2Po+nMsu3qbkD7n1Lw9 RzQA== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:from:to:cc:subject:date:message-id:in-reply-to :references:x-original-sender:x-original-authentication-results :precedence:mailing-list:list-id:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=/3GA+c5DEbvKetgo6fdvyoUb0PlhBIxQv559O14inyc=; b=Kzg/NIZUVqI6cOsJK/h/2o++SI62YSnunOnw5BDWVia/IPJuQLwlV7i4TwjH92A4RK RVxgGSdtfkxUMzEL1xPyTzbUewZqrU/X0wNwAl5IQkOJ1zNrJ//3qzlhOcCph3LN1vwh 14GEbZm5LT9WTF9XAKoI+LPPrMhzuub7Ec/YqLvwxYJB4KXFfm67csezVzpaReXmiOuA kZXUE1KGSiVq5H7k5VeiSS82pV5Ki1kq5curLY72eN7ucCo1umaZumAygBLA/O/Q+9dq rEBoNnpPtSsqop3K9URjNDiHP6B3uZcMF0RHlJfGFWUQGpKcjIL05+2T2NY+KfgAstQN ec1w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=sender:x-gm-message-state:mime-version:from:to:cc:subject:date :message-id:in-reply-to:references:x-original-sender :x-original-authentication-results:precedence:mailing-list:list-id :x-spam-checked-in-group:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=/3GA+c5DEbvKetgo6fdvyoUb0PlhBIxQv559O14inyc=; b=sJy5rfKXcyFmJghkdHi1dP5Y0mqLdNyXyUrNUFPMMq6OL1+7F2X8/BDJmk0tkn33am UXevQHb5OR83x62ZldQRUt2Ipp+P9EFpdjBLh6SnM3g42b8HQi2SrxYL5d7Ff5DmMjmB TrzF1p0ZRzB5pVY0G78VXHhzagYraLaLLTnJhmM9HoUGvA6zPpo+0ut1YHrKxMOK/bJo gxp4MwXg1UexB80Y26MtGX2cTgparjBmJ3opTKWzVCgkHQc9zWZnWR7d92EiwmcPf/vB KzIhvQ8z9zPZ4OeHDWd5E0+zAVFErzK7jqKYe+pxtQEb+nK+Ixr9jyFGmtI2aNLahS7n lD0w== Sender: swupdate@googlegroups.com X-Gm-Message-State: AOAM532qXGvPpJOu3kFvA5+lHQJkB5mb2Tt3omDiuV2cnSWKlTVVzrgo dQRRQT18O8afA8DOy6FSBew= X-Google-Smtp-Source: ABdhPJx/EfV89x1Dwa2jyq7ztZlhemna8Cp1l3Hgmm/5jouE83aVQCKkzVfVNF0qr4NYMykqYXy0Ow== X-Received: by 2002:a05:651c:544:: with SMTP id q4mr14742749ljp.310.1591720013352; Tue, 09 Jun 2020 09:26:53 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: swupdate@googlegroups.com Received: by 2002:a2e:89d8:: with SMTP id c24ls2435598ljk.2.gmail; Tue, 09 Jun 2020 09:26:52 -0700 (PDT) X-Received: by 2002:a2e:7303:: with SMTP id o3mr15152419ljc.100.1591720012638; Tue, 09 Jun 2020 09:26:52 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1591720012; cv=none; d=google.com; s=arc-20160816; b=aMdwCADrDtrVT3+80+DHAXpVEiXOQ9dbsnYK8FjvZZHXTBzEfy/IJnH/XyjNupTsht rSTjDIlGUGu++ZA4gpuXCQaco8jqJCXt0vsCStUI2Q3mMX5DKBS4Hm9U1OVm1h3MASFO rpzB35znkqwAs1HWMagN2XfI1nmXE74tmHZPyYiq7k6YXaao6UkzEVdv24o2nsUHpt/h +CzheYu5NUpE01f107IeaznB4VShR9GjApA7tIkMZJJ+V3vaknEpdaVWzpwJDLi8SRbT 8Kslfjz7ed6z8EtZq9uKqmw4dd+d7zO4HOIbf5JbZkh/TzIE8WdSFta4Rg4uCnbu9roU kmxg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=p68FAsbNWHzPk7tZngkKy9H/b0ghH/j/XoAVU8eJek0=; b=ng07gqkjS9iGka0ZP7TKuA83Zs/++L83G4U04ULT8icrI9nqE+zo1PIfZBHHdcnQyS XBulWyluGBglRzkJz4/3a19E91bC1LkVnFE0eLeV0bNGHqqzD18LPMI1vDaF+hdCaHw6 by2SDTDPuEr1HjtghUSmO/Yk7KBPIY+ZDGaWVljizrrDGOWtGJCO7S14nKVqQ/ExHNru 9fLN4ab/ka+hZlh5WtUafLjdAD9CeuxDORPSicTUHhA+X8lSPuKrAwTUaKxzteDZMkIn BLfmoDjwyvyS6g6zoh7eqAEuJlMCoZO/udoh5/ds+Pjc1vbRZ0MSeFP4ghkXp20awJXD bDTA== ARC-Authentication-Results: i=1; gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=sDsFsEIg; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::644 as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Received: from mail-ej1-x644.google.com (mail-ej1-x644.google.com. [2a00:1450:4864:20::644]) by gmr-mx.google.com with ESMTPS id o28si731354lfc.2.2020.06.09.09.26.52 for (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 09 Jun 2020 09:26:52 -0700 (PDT) Received-SPF: pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::644 as permitted sender) client-ip=2a00:1450:4864:20::644; Received: by mail-ej1-x644.google.com with SMTP id o15so23049592ejm.12 for ; Tue, 09 Jun 2020 09:26:52 -0700 (PDT) X-Received: by 2002:a17:906:7e19:: with SMTP id e25mr14319212ejr.319.1591720012178; Tue, 09 Jun 2020 09:26:52 -0700 (PDT) Received: from localhost.localdomain (ptr-dv4l9au8mfcs6krkuj6.18120a2.ip6.access.telenet.be. [2a02:1811:ce13:ba00:485e:9916:929:292]) by smtp.googlemail.com with ESMTPSA id b4sm13383983ejp.40.2020.06.09.09.26.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 09 Jun 2020 09:26:51 -0700 (PDT) From: Stijn Devriendt To: HIGHGuY@gmail.com, sbabic@denx.de Cc: tomas@aparicio.me, swupdate@googlegroups.com, Stijn Devriendt Subject: [swupdate] [PATCH 3/4] Cleanup input string to be semantic-version compliant Date: Tue, 9 Jun 2020 18:26:38 +0200 Message-Id: <20200609162639.14788-3-sde@unmatched.eu> X-Mailer: git-send-email 2.17.1 In-Reply-To: <92475f7e-b76d-bcfc-7909-7e4ac52037bc@denx.de> References: <92475f7e-b76d-bcfc-7909-7e4ac52037bc@denx.de> X-Original-Sender: HIGHGuY@gmail.com X-Original-Authentication-Results: gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=sDsFsEIg; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::644 as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Precedence: list Mailing-list: list swupdate@googlegroups.com; contact swupdate+owners@googlegroups.com List-ID: X-Spam-Checked-In-Group: swupdate@googlegroups.com X-Google-Group-Id: 605343134186 List-Post: , List-Help: , List-Archive: , List-Unsubscribe: , Signed-off-by: Stijn Devriendt --- core/artifacts_versions.c | 6 ++++++ core/swupdate.c | 3 +++ parser/parser.c | 4 ++++ 3 files changed, 13 insertions(+) diff --git a/core/artifacts_versions.c b/core/artifacts_versions.c index 6fe5d60..d7be3ce 100644 --- a/core/artifacts_versions.c +++ b/core/artifacts_versions.c @@ -25,6 +25,7 @@ #include "swupdate.h" #include "parselib.h" #include "swupdate_settings.h" +#include "semver.h" /* * Read versions of components from a file, if provided @@ -66,6 +67,9 @@ static int read_sw_version_file(struct swupdate_cfg *sw) } strlcpy(swcomp->name, name, sizeof(swcomp->name)); strlcpy(swcomp->version, version, sizeof(swcomp->version)); + + semver_clean(swcomp->version); + LIST_INSERT_HEAD(&sw->installed_sw_list, swcomp, next); TRACE("Installed %s: Version %s", swcomp->name, @@ -118,6 +122,8 @@ static int versions_settings(void *setting, void *data) GET_FIELD_STRING(LIBCFG_PARSER, elem, "name", swcomp->name); GET_FIELD_STRING(LIBCFG_PARSER, elem, "version", swcomp->version); + semver_clean(swcomp->version); + LIST_INSERT_HEAD(&sw->installed_sw_list, swcomp, next); TRACE("Installed %s: Version %s", swcomp->name, diff --git a/core/swupdate.c b/core/swupdate.c index 74dfbbe..565f76b 100644 --- a/core/swupdate.c +++ b/core/swupdate.c @@ -47,6 +47,7 @@ #include "swupdate_settings.h" #include "pctl.h" #include "state.h" +#include "semver.h" #ifdef CONFIG_SYSTEMD #include @@ -792,11 +793,13 @@ int main(int argc, char **argv) swcfg.globals.no_downgrading = 1; strlcpy(swcfg.globals.minimum_version, optarg, sizeof(swcfg.globals.minimum_version)); + semver_clean(swcfg.globals.minimum_version); break; case 'R': swcfg.globals.no_reinstalling = 1; strlcpy(swcfg.globals.current_version, optarg, sizeof(swcfg.globals.current_version)); + semver_clean(swcfg.globals.current_version); break; case 'M': swcfg.globals.no_transaction_marker = 1; diff --git a/parser/parser.c b/parser/parser.c index 31efe46..3a2d826 100644 --- a/parser/parser.c +++ b/parser/parser.c @@ -24,6 +24,7 @@ #include "parsers.h" #include "swupdate_dict.h" #include "lua_util.h" +#include "semver.h" #define MODULE_NAME "PARSER" @@ -273,6 +274,9 @@ static int parse_common_attributes(parsertype p, void *elem, struct img_type *im GET_FIELD_STRING(p, elem, "name", image->id.name); GET_FIELD_STRING(p, elem, "version", image->id.version); + + semver_clean(image->id.version); + GET_FIELD_STRING(p, elem, "filename", image->fname); GET_FIELD_STRING(p, elem, "path", image->path); GET_FIELD_STRING(p, elem, "volume", image->volname); From patchwork Tue Jun 9 16:26:39 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Stijn Devriendt X-Patchwork-Id: 1306084 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=googlegroups.com (client-ip=2a00:1450:4864:20::43e; helo=mail-wr1-x43e.google.com; envelope-from=swupdate+bncbclnzfwotyirbtxq733akgqepmypydy@googlegroups.com; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=googlegroups.com header.i=@googlegroups.com header.a=rsa-sha256 header.s=20161025 header.b=rVFrni54; dkim=pass (2048-bit key; unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20161025 header.b=HHT/n2eP; dkim-atps=neutral Received: from mail-wr1-x43e.google.com (mail-wr1-x43e.google.com [IPv6:2a00:1450:4864:20::43e]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 49hFrK2Ys6z9sRK for ; Wed, 10 Jun 2020 02:26:57 +1000 (AEST) Received: by mail-wr1-x43e.google.com with SMTP id n6sf8827910wrv.6 for ; Tue, 09 Jun 2020 09:26:57 -0700 (PDT) ARC-Seal: i=2; a=rsa-sha256; t=1591720014; cv=pass; d=google.com; s=arc-20160816; b=iQ8DxjaanlPLy15oGDcA3PeYaZ6ysPtch+xn+7vmNwcXt2B6Q0pAvsQGM9dwANXFBb /gjraWX+nHnaH6URFjT+XCK5FV2xuzXSWWXXRhjNxr7+TDLrhEmR9vLvFSfN/PEOw7d/ 0K2zbGGHxW+57h8wTtdD8UNL7v6sUUMIYSu21GvQp3zVReefKDFDSGLfAy6A1HGq4INd KvzyB3Z+WZUQDtvyoRjrx/Xd5vGyU5CSwQe6OawkF9ZTty8VJ2FvL7MIjJ71xG/gx6Ia xdyjxwv/DwDXGJ5VOJ5SGBbna1MBBNvCgC7TAX8Hen2vSA8HVieN4mOsIvzO48/aOHWx DLGA== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-unsubscribe:list-subscribe:list-archive:list-help:list-post :list-id:mailing-list:precedence:references:in-reply-to:message-id :date:subject:cc:to:from:mime-version:sender:dkim-signature :dkim-signature; bh=ofbql+9aDM9z3INDZJrN/H4u/mrkhKBpBzHaU8pZMWg=; b=fcdN6QmocMjBiXXIvkgDV2wIG+qRBWmn/Btm7547Bh6uOXj4iPeBPwC0uGdAPV+noV eYIKKxrMXJ79xw2GDVM7Tt0LeMpKKPKeIWcsxMF5o8LvAIjPNUR4H0s8XVDcI1wOhjEE 6vdigIeezxBeH19kRj6j7L3h/m5IQ25P2Uzn3qACq47wCjowFQ2oVlZEFGjYYU9mUKq+ yFy/8q4Z5pCIpqnbGxeQh9EEz5YervaQhAjxW3HQKQ0mwAZkHgsYAhoyUnK7QiVL2cSl gRsRPDK+xIK8GzKhwnXH9Q7uSJKW09E/HVH4oetLedNydnZbuHkrurkGLxScMp8WJgTJ eifw== ARC-Authentication-Results: i=2; gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=f67Z0OeT; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::633 as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=googlegroups.com; s=20161025; h=sender:mime-version:from:to:cc:subject:date:message-id:in-reply-to :references:x-original-sender:x-original-authentication-results :precedence:mailing-list:list-id:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=ofbql+9aDM9z3INDZJrN/H4u/mrkhKBpBzHaU8pZMWg=; b=rVFrni54KFGAxiEU3JJxm/oq+/90EJYxMbGDk3Zw8Nf/s7qPOtDju/+7q8LOeUs+rB G2LghtHNBKZP6QVifmi9TVNccI2o/9nooW9mcweZ2L7J1xkcW8stBymy0UppuS6HFBLW MEh9qLnJptt96jObuGCVUxFRHDhudZlXTBabonahcIgTRe12164VbLP/Gd3WJPenIXtR CxHBdgBpt3NHroUJ3ILyMF/KuYANIl8b4ewNyd7MHqDd4RgCW8Y4fzgKHXENmbuhf7UG TNO9pCx6S8KvzjMXgvGqcXP0swejXz9bO4fkEr/okjDBgWlhPBre2B3hrs3GAjR1AYt7 V2qA== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=mime-version:from:to:cc:subject:date:message-id:in-reply-to :references:x-original-sender:x-original-authentication-results :precedence:mailing-list:list-id:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=ofbql+9aDM9z3INDZJrN/H4u/mrkhKBpBzHaU8pZMWg=; b=HHT/n2ePXfvjCPNFHauX4Fzv1u7QA7SjHbt2JNSABJcoTd00cQY1bLN40W8peOe/oz /zBTf+Tuzpd5gKOr+4U2/zW+iOdojrcknFr0WVLlMgEAnQjgotvln7g3AJy2K4AQMoQV WoMqeDtrRId7s5t+5NzF2zDbOKT1hHVgseOvUMYFOrqowJ7Wj8YQ5kthVpltERymIvgH gXnxS4xX45ddRp0cOfiTG857tQOkZybP/5AoIC9HKr+ozMQJVOf8lqHyyF77poCeQSGR OD6EcsxHy+AbsDAjOn6bRA9/QANgc3AN4uC0a8pmY7odczkT9XUkamPxncD9ovPDNs7v uxLA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=sender:x-gm-message-state:mime-version:from:to:cc:subject:date :message-id:in-reply-to:references:x-original-sender :x-original-authentication-results:precedence:mailing-list:list-id :x-spam-checked-in-group:list-post:list-help:list-archive :list-subscribe:list-unsubscribe; bh=ofbql+9aDM9z3INDZJrN/H4u/mrkhKBpBzHaU8pZMWg=; b=f7Rp3l/cj3P1mmrFv/MzH0wiDZBHKGtiq/j3MeZNl3pIBwuw8zSHG6F8cNN3nPKrs9 Na0/AOVJG5ZqB/iR5E+juLt6zXY5oB/ak6OcdATuLn9VQIfvOSAGNMbrSkOV7tmx/sTG ngNexY39hvn/sMNeuspkCyh4aVpqh8GQ0C5llIVd/UWt7bTYKQ8kpzxzzMjy5vo6iyWT 8ha29xflIiXIRDCBP+Xz3QGia2TZS2cm4HpjssXsmjxdXzWMX16fl0CpRxlVdeuHQZSU icPYS0oaL6IIYcKE/52+TM5fDKNG64DBGR8Oxjwp0TZo8QhvoyxFHYXfx4qGX0EaSJZm GngA== Sender: swupdate@googlegroups.com X-Gm-Message-State: AOAM531M//7nMR3t1P4Idazfv+WfqLc/qb7DyvjP7C+4jzwnMSt1lUMI bg0kLqUUsk7dxE6MfcWRWRA= X-Google-Smtp-Source: ABdhPJzha8iAW1kL/ypKg2Vfn0ARCltDIrCAaILQ3BkimTSug1x7rhaxBkbNyhbwepLCHaSVj/tgyw== X-Received: by 2002:a5d:4490:: with SMTP id j16mr5827635wrq.276.1591720014320; Tue, 09 Jun 2020 09:26:54 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: swupdate@googlegroups.com Received: by 2002:adf:db45:: with SMTP id f5ls4551849wrj.0.gmail; Tue, 09 Jun 2020 09:26:53 -0700 (PDT) X-Received: by 2002:adf:dd06:: with SMTP id a6mr5546111wrm.142.1591720013529; Tue, 09 Jun 2020 09:26:53 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1591720013; cv=none; d=google.com; s=arc-20160816; b=E4oJR6xV7GS4pNqd5RTLh/Mzu3x8inJqKVyufykyhoz/uuXO5B+ut5sJDMmchmw3mX HOWKscQ337lkzZC5ag/C6R6sV0wbawnN1mQAV273d7RKr/QREu14kYKdOmtdXVLQj2LJ k7UXt1ndmSP4s2HJDPY8yDDKVVD91RYAK55b3AGlFyxQ+LS7tQKjMxHL3czbLPf+GNfg ZfxnxFUZ/sQiXwNh1BQaKgu4FZ4JS9t5lCY5cojp+MbpUpUz92PeauXSK7LvHbdVFqyv hHGKsDoLitAlLldvduGdR3heyFRBLMs9lgYk7Tc6gmh8WFT+iXWK7sOefo01a/n80Kch Dglw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=nxZ1Z8e+IELw0Wq3RDRlLTGHxmxcdLh8A+aacXeAGQE=; b=SYClodN3Y+A+fVcooKMMmYCsxNl9iLkRvdsP+An1tMZWpjML6PUl8m+gsg9GvQQx1x sQPwjKK4EzyglE1xOgOIVppigFkRxUdhl+pMMZdq/LZIwaRx2O0CKIREi/vuzrGcJx7H A6xUpUvlrwzk5Jl49DjRaelzxf4VvkvUT4ct4AQBERF55vcVpgIJzdx65cOzxr8DdK0Y jXxZ8h0FFu7CpGChGo82gj1gGmMPB3Ye09Ip625XoBNF4iXFtOrz9GWkfTgX7GYw19Ha ErQHSv2dYMWHmbdL1HdN9hdvn3YyYBGX5FQcpcTGCoZzCYlajE3YkWgsfDSi3tqV2gpO c1Bg== ARC-Authentication-Results: i=1; gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=f67Z0OeT; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::633 as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Received: from mail-ej1-x633.google.com (mail-ej1-x633.google.com. [2a00:1450:4864:20::633]) by gmr-mx.google.com with ESMTPS id o195si190346wme.0.2020.06.09.09.26.53 for (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 09 Jun 2020 09:26:53 -0700 (PDT) Received-SPF: pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::633 as permitted sender) client-ip=2a00:1450:4864:20::633; Received: by mail-ej1-x633.google.com with SMTP id dr13so3867916ejc.3 for ; Tue, 09 Jun 2020 09:26:53 -0700 (PDT) X-Received: by 2002:a17:907:4030:: with SMTP id nr24mr19055411ejb.247.1591720013268; Tue, 09 Jun 2020 09:26:53 -0700 (PDT) Received: from localhost.localdomain (ptr-dv4l9au8mfcs6krkuj6.18120a2.ip6.access.telenet.be. [2a02:1811:ce13:ba00:485e:9916:929:292]) by smtp.googlemail.com with ESMTPSA id b4sm13383983ejp.40.2020.06.09.09.26.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 09 Jun 2020 09:26:52 -0700 (PDT) From: Stijn Devriendt To: HIGHGuY@gmail.com, sbabic@denx.de Cc: tomas@aparicio.me, swupdate@googlegroups.com, Stijn Devriendt Subject: [swupdate] [PATCH 4/4] Compare versions according to semver Date: Tue, 9 Jun 2020 18:26:39 +0200 Message-Id: <20200609162639.14788-4-sde@unmatched.eu> X-Mailer: git-send-email 2.17.1 In-Reply-To: <92475f7e-b76d-bcfc-7909-7e4ac52037bc@denx.de> References: <92475f7e-b76d-bcfc-7909-7e4ac52037bc@denx.de> X-Original-Sender: HIGHGuY@gmail.com X-Original-Authentication-Results: gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=f67Z0OeT; spf=pass (google.com: domain of highguy@gmail.com designates 2a00:1450:4864:20::633 as permitted sender) smtp.mailfrom=highguy@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Precedence: list Mailing-list: list swupdate@googlegroups.com; contact swupdate+owners@googlegroups.com List-ID: X-Spam-Checked-In-Group: swupdate@googlegroups.com X-Google-Group-Id: 605343134186 List-Post: , List-Help: , List-Archive: , List-Unsubscribe: , Still, fallback to legacy versioning scheme if needed. Signed-off-by: Stijn Devriendt --- core/artifacts_versions.c | 60 ++++++++++++++++++++++++++++++++++++++- core/parser.c | 11 +++---- include/util.h | 2 +- 3 files changed, 64 insertions(+), 9 deletions(-) diff --git a/core/artifacts_versions.c b/core/artifacts_versions.c index d7be3ce..492b3de 100644 --- a/core/artifacts_versions.c +++ b/core/artifacts_versions.c @@ -160,6 +160,18 @@ void get_sw_versions(char __attribute__ ((__unused__)) *cfgname, } #endif +static const char ACCEPTED_CHARS[] = "0123456789."; + +static bool is_oldstyle_version(const char* version_string) +{ + while (*version_string) + { + if (strchr(ACCEPTED_CHARS, *version_string) == NULL) + return false; + } + return true; +} + /* * convert a version string into a number * version string is in the format: @@ -170,7 +182,7 @@ void get_sw_versions(char __attribute__ ((__unused__)) *cfgname, * Also major.minor or major.minor.revision are allowed * The conversion generates a 64 bit value that can be compared */ -__u64 version_to_number(const char *version_string) +static __u64 version_to_number(const char *version_string) { char **versions = NULL; char **ver; @@ -195,3 +207,49 @@ __u64 version_to_number(const char *version_string) return version; } + +/* + * Compare 2 versions. + * + * Mind that this function accepts both version types: + * - old-style: major.minor.revision.buildinfo + * - semantic versioning: major.minor.patch[-prerelease][+buildinfo] + * see https://semver.org + * + * Returns -1, 0 or 1 of left is respectively lower than, equal to or greater than right. + */ +int compare_versions(const char* left_version, const char* right_version) +{ + if (is_oldstyle_version(left_version) && is_oldstyle_version(right_version)) + { + __u64 left_u64 = version_to_number(left_version); + __u64 right_u64 = version_to_number(right_version); + + if (left_u64 < right_u64) + return 1; + else if (left_u64 > right_u64) + return -1; + else + return 0; + } + else + { + semver_t left_sem = {}; + semver_t right_sem = {}; + int comparison; + + /* There's no error checking here. + * Oldstyle code also defaults to treating unparseable version as 0. + * Failed semver_parse also leads to 0.0.0 if properly initialized. + */ + semver_parse(left_version, &left_sem); + semver_parse(right_version, &right_sem); + + comparison = semver_compare(left_sem, right_sem); + + semver_free(&left_sem); + semver_free(&right_sem); + + return comparison; + } +} diff --git a/core/parser.c b/core/parser.c index e7e68ea..ba0d2a6 100644 --- a/core/parser.c +++ b/core/parser.c @@ -172,15 +172,15 @@ static int is_image_higher(struct swver *sw_ver_list, return false; LIST_FOREACH(swver, sw_ver_list, next) { - __u64 minimum_version = version_to_number(swver->version); - __u64 newversion = version_to_number(img->id.version); + const char* current_version = swver->version; + const char* proposed_version = img->id.version; /* * Check if name are identical and the new version is lower * or equal. */ if (!strncmp(img->id.name, swver->name, sizeof(img->id.name)) && - (minimum_version >= newversion)) { + (compare_versions(proposed_version, current_version) < 0)) { TRACE("%s(%s) has a higher version installed, skipping...", img->id.name, img->id.version); @@ -306,10 +306,7 @@ int parse(struct swupdate_cfg *sw, const char *descfile) * newer version */ if (sw->globals.no_downgrading) { - __u64 minimum_version = version_to_number(sw->globals.minimum_version); - __u64 newversion = version_to_number(sw->version); - - if (newversion < minimum_version) { + if (compare_versions(sw->version, sw->globals.minimum_version) < 0) { ERROR("No downgrading allowed: new version %s <= installed %s", sw->version, sw->globals.minimum_version); return -EPERM; diff --git a/include/util.h b/include/util.h index 55fe70f..b665179 100644 --- a/include/util.h +++ b/include/util.h @@ -216,7 +216,7 @@ size_t snescape(char *dst, size_t n, const char *src); void freeargs (char **argv); int get_hw_revision(struct hw_type *hw); void get_sw_versions(char *cfgfname, struct swupdate_cfg *sw); -__u64 version_to_number(const char *version_string); +int compare_versions(const char* left_version, const char* right_version); int hwid_match(const char* rev, const char* hwrev); int check_hw_compatibility(struct swupdate_cfg *cfg); int count_elem_list(struct imglist *list);