token, kex: Add functions to handle tokens lists

The added functions allow splitting chains of tokens separated by a
given character (usually ','), and extracting matching parts between two
chains of tokens.

The previously existing functions in kex.c were replaced by the
introduced ones.

Signed-off-by: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
Reviewed-by: Jakub Jelen <jjelen@redhat.com>

tests/unittests/CMakeLists.txt

@@ -20,6 +20,7 @@ set(LIBSSH_UNIT_TESTS
     torture_temp_file
     torture_push_pop_dir
     torture_session_keys
+    torture_tokens
 )
 
 set(LIBSSH_THREAD_UNIT_TESTS

tests/unittests/torture_tokens.c

@@ -0,0 +1,163 @@
+/*
+ * torture_tokens.c - Tests for tokens list handling
+ *
+ * This file is part of the SSH Library
+ *
+ * Copyright (c) 2019 by Red Hat, Inc.
+ *
+ * Author: Anderson Toshiyuki Sasaki <ansasaki@redhat.com>
+ *
+ * The SSH Library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ *
+ * The SSH Library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with the SSH Library; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#define LIBSSH_STATIC
+
+#include "torture.h"
+#include "libssh/token.h"
+#include "libssh/priv.h"
+
+static void torture_find_matching(UNUSED_PARAM(void **state))
+{
+    char *matching;
+
+    /* Match with single token */
+    matching = ssh_find_matching("a,b,c", "b");
+    assert_non_null(matching);
+    assert_string_equal(matching, "b");
+    SAFE_FREE(matching);
+
+    /* Match sequence, get first preferred */
+    matching = ssh_find_matching("a,b,c", "b,c");
+    assert_non_null(matching);
+    assert_string_equal(matching, "b");
+    SAFE_FREE(matching);
+
+    /* Only one token allowed */
+    matching = ssh_find_matching("c", "a,b,c");
+    assert_non_null(matching);
+    assert_string_equal(matching, "c");
+    SAFE_FREE(matching);
+
+    /* Different order in allowed and preferred; gets preferred */
+    matching = ssh_find_matching("c,b,a", "a,b,c");
+    assert_non_null(matching);
+    assert_string_equal(matching, "a");
+    SAFE_FREE(matching);
+
+    /* No matching returns NULL */
+    matching = ssh_find_matching("c,b,a", "d,e,f");
+    assert_null(matching);
+}
+
+static void torture_find_all_matching(UNUSED_PARAM(void **state))
+{
+    char *matching;
+
+    /* Match with single token */
+    matching = ssh_find_all_matching("a,b,c", "b");
+    assert_non_null(matching);
+    assert_string_equal(matching, "b");
+    SAFE_FREE(matching);
+
+    /* Match sequence, get first preferred */
+    matching = ssh_find_all_matching("a,b,c", "b,c");
+    assert_non_null(matching);
+    assert_string_equal(matching, "b,c");
+    SAFE_FREE(matching);
+
+    /* Only one token allowed */
+    matching = ssh_find_all_matching("c", "a,b,c");
+    assert_non_null(matching);
+    assert_string_equal(matching, "c");
+    SAFE_FREE(matching);
+
+    /* Different order in allowed and preferred; gets preferred */
+    matching = ssh_find_all_matching("c,b,a", "a,c,b");
+    assert_non_null(matching);
+    assert_string_equal(matching, "a,c,b");
+    SAFE_FREE(matching);
+
+    /* No matching returns NULL */
+    matching = ssh_find_all_matching("c,b,a", "d,e,f");
+    assert_null(matching);
+}
+
+static void tokenize_compare_expected(const char *chain, const char **expected,
+                                     size_t num_expected)
+{
+    struct ssh_tokens_st *tokens;
+    size_t i;
+
+    tokens = ssh_tokenize(chain, ',');
+    assert_non_null(tokens);
+
+    if (expected != NULL) {
+        assert_non_null(tokens->tokens);
+        for (i = 0; i < num_expected; i++) {
+            assert_non_null(tokens->tokens[i]);
+            assert_non_null(expected[i]);
+            assert_string_equal(tokens->tokens[i], expected[i]);
+        }
+
+        assert_null(tokens->tokens[i]);
+
+        i = 0;
+        printf("Tokenizing \"%s\" resulted in: ", chain);
+        while (tokens->tokens[i]) {
+            printf("\"%s\" ", tokens->tokens[i++]);
+        }
+        printf("\n");
+    }
+
+    ssh_tokens_free(tokens);
+}
+
+static void torture_tokens_sanity(UNUSED_PARAM(void **state))
+{
+    const char *simple[] = {"a", "b", "c"};
+    const char *colon_first[] = {"", "a", "b", "c"};
+    const char *colon_end[] = {"a", "b", "c"};
+    const char *colon_both[] = {"", "a", "b", "c"};
+    const char *single[] = {"abc"};
+    const char *empty[] = {""};
+    const char *single_colon[] = {""};
+
+    tokenize_compare_expected("a,b,c", simple, 3);
+    tokenize_compare_expected(",a,b,c", colon_first, 4);
+    tokenize_compare_expected("a,b,c,", colon_end, 3);
+    tokenize_compare_expected(",a,b,c,", colon_both, 4);
+    tokenize_compare_expected("abc", single, 1);
+    tokenize_compare_expected("", empty, 1);
+    tokenize_compare_expected(",", single_colon, 1);
+}
+
+int torture_run_tests(void)
+{
+    int rc;
+    struct CMUnitTest tests[] = {
+        cmocka_unit_test(torture_tokens_sanity),
+        cmocka_unit_test(torture_find_matching),
+        cmocka_unit_test(torture_find_all_matching),
+    };
+
+    ssh_init();
+    torture_filter_tests(tests);
+    rc = cmocka_run_group_tests(tests, NULL, NULL);
+    ssh_finalize();
+    return rc;
+}