Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: LGPL-2.1+ */
       2                 :            : 
       3                 :            : #include "alloc-util.h"
       4                 :            : #include "fd-util.h"
       5                 :            : #include "escape.h"
       6                 :            : #include "libmount-util.h"
       7                 :            : #include "tests.h"
       8                 :            : 
       9                 :         16 : static void test_libmount_unescaping_one(
      10                 :            :                 const char *title,
      11                 :            :                 const char *string,
      12                 :            :                 bool may_fail,
      13                 :            :                 const char *expected_source,
      14                 :            :                 const char *expected_target) {
      15                 :            :         /* A test for libmount really */
      16                 :            :         int r;
      17                 :            : 
      18         [ +  - ]:         16 :         log_info("/* %s %s */", __func__, title);
      19                 :            : 
      20         [ +  + ]:         16 :         _cleanup_(mnt_free_tablep) struct libmnt_table *table = NULL;
      21         [ +  + ]:         16 :         _cleanup_(mnt_free_iterp) struct libmnt_iter *iter = NULL;
      22         [ +  + ]:         16 :         _cleanup_fclose_ FILE *f = NULL;
      23                 :            : 
      24                 :         16 :         f = fmemopen((char*) string, strlen(string), "re");
      25         [ -  + ]:         16 :         assert_se(f);
      26                 :            : 
      27         [ -  + ]:         16 :         assert_se(libmount_parse(title, f, &table, &iter) >= 0);
      28                 :            : 
      29                 :            :         struct libmnt_fs *fs;
      30                 :            :         const char *source, *target;
      31   [ +  +  +  +  :         32 :         _cleanup_free_ char *x = NULL, *cs = NULL, *s = NULL, *ct = NULL, *t = NULL;
          +  +  +  +  +  
                      + ]
      32                 :            : 
      33                 :            :         /* We allow this call and the checks below to fail in some cases. See the case definitions below. */
      34                 :            : 
      35                 :         16 :         r = mnt_table_next_fs(table, iter, &fs);
      36   [ +  +  +  - ]:         16 :         if (r != 0 && may_fail) {
      37         [ +  - ]:          4 :                 log_error_errno(r, "mnt_table_next_fs failed: %m");
      38                 :          4 :                 return;
      39                 :            :         }
      40         [ -  + ]:         12 :         assert_se(r == 0);
      41                 :            : 
      42         [ -  + ]:         12 :         assert_se(x = cescape(string));
      43                 :            : 
      44         [ -  + ]:         12 :         assert_se(source = mnt_fs_get_source(fs));
      45         [ -  + ]:         12 :         assert_se(target = mnt_fs_get_target(fs));
      46                 :            : 
      47         [ -  + ]:         12 :         assert_se(cs = cescape(source));
      48         [ -  + ]:         12 :         assert_se(ct = cescape(target));
      49                 :            : 
      50         [ -  + ]:         12 :         assert_se(cunescape(source, UNESCAPE_RELAX, &s) >= 0);
      51         [ -  + ]:         12 :         assert_se(cunescape(target, UNESCAPE_RELAX, &t) >= 0);
      52                 :            : 
      53         [ +  - ]:         12 :         log_info("from '%s'", x);
      54         [ +  - ]:         12 :         log_info("source: '%s'", source);
      55         [ +  - ]:         12 :         log_info("source: '%s'", cs);
      56         [ +  - ]:         12 :         log_info("source: '%s'", s);
      57         [ +  - ]:         12 :         log_info("expected: '%s'", strna(expected_source));
      58         [ +  - ]:         12 :         log_info("target: '%s'", target);
      59         [ +  - ]:         12 :         log_info("target: '%s'", ct);
      60         [ +  - ]:         12 :         log_info("target: '%s'", t);
      61         [ +  - ]:         12 :         log_info("expected: '%s'", strna(expected_target));
      62                 :            : 
      63   [ +  +  -  + ]:         12 :         assert_se(may_fail || streq(source, expected_source));
      64   [ +  +  -  + ]:         12 :         assert_se(may_fail || streq(target, expected_target));
      65                 :            : 
      66         [ -  + ]:         12 :         assert_se(mnt_table_next_fs(table, iter, &fs) == 1);
      67                 :            : }
      68                 :            : 
      69                 :          4 : static void test_libmount_unescaping(void) {
      70                 :          4 :         test_libmount_unescaping_one(
      71                 :            :                         "escaped space + utf8",
      72                 :            :                         "729 38 0:59 / /tmp/„zupa\\040zębowa” rw,relatime shared:395 - tmpfs die\\040Brühe rw,seclabel",
      73                 :            :                         false,
      74                 :            :                         "die Brühe",
      75                 :            :                         "/tmp/„zupa zębowa”"
      76                 :            :         );
      77                 :            : 
      78                 :          4 :         test_libmount_unescaping_one(
      79                 :            :                         "escaped newline",
      80                 :            :                         "729 38 0:59 / /tmp/x\\012y rw,relatime shared:395 - tmpfs newline rw,seclabel",
      81                 :            :                         false,
      82                 :            :                         "newline",
      83                 :            :                         "/tmp/x\ny"
      84                 :            :         );
      85                 :            : 
      86                 :            :         /* The result of "mount -t tmpfs '' /tmp/emptysource".
      87                 :            :          * This will fail with libmount <= v2.33.
      88                 :            :          * See https://github.com/karelzak/util-linux/commit/18a52a5094.
      89                 :            :          */
      90                 :          4 :         test_libmount_unescaping_one(
      91                 :            :                         "empty source",
      92                 :            :                         "760 38 0:60 / /tmp/emptysource rw,relatime shared:410 - tmpfs  rw,seclabel",
      93                 :            :                         true,
      94                 :            :                         "",
      95                 :            :                         "/tmp/emptysource"
      96                 :            :         );
      97                 :            : 
      98                 :            :         /* The kernel leaves \r as is.
      99                 :            :          * Also see https://github.com/karelzak/util-linux/issues/780.
     100                 :            :          */
     101                 :          4 :         test_libmount_unescaping_one(
     102                 :            :                         "foo\\rbar",
     103                 :            :                         "790 38 0:61 / /tmp/foo\rbar rw,relatime shared:425 - tmpfs tmpfs rw,seclabel",
     104                 :            :                         true,
     105                 :            :                         "tmpfs",
     106                 :            :                         "/tmp/foo\rbar"
     107                 :            :         );
     108                 :          4 : }
     109                 :            : 
     110                 :          4 : int main(int argc, char *argv[]) {
     111                 :          4 :         test_setup_logging(LOG_DEBUG);
     112                 :            : 
     113                 :          4 :         test_libmount_unescaping();
     114                 :          4 :         return 0;
     115                 :            : }