Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: LGPL-2.1+ */
       2                 :            : 
       3                 :            : #include "conf-parser.h"
       4                 :            : #include "fd-util.h"
       5                 :            : #include "fileio.h"
       6                 :            : #include "fuzz.h"
       7                 :            : #include "install.h"
       8                 :            : #include "load-fragment.h"
       9                 :            : #include "string-util.h"
      10                 :            : #include "unit.h"
      11                 :            : #include "utf8.h"
      12                 :            : 
      13                 :          0 : int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
      14                 :          0 :         _cleanup_free_ char *out = NULL; /* out should be freed after g */
      15                 :            :         size_t out_size;
      16                 :          0 :         _cleanup_fclose_ FILE *f = NULL, *g = NULL;
      17                 :          0 :         _cleanup_free_ char *p = NULL;
      18                 :            :         UnitType t;
      19                 :          0 :         _cleanup_(manager_freep) Manager *m = NULL;
      20                 :            :         Unit *u;
      21                 :            :         const char *name;
      22                 :            :         long offset;
      23                 :            : 
      24         [ #  # ]:          0 :         if (size == 0)
      25                 :          0 :                 return 0;
      26                 :            : 
      27                 :          0 :         f = fmemopen_unlocked((char*) data, size, "re");
      28         [ #  # ]:          0 :         assert_se(f);
      29                 :            : 
      30         [ #  # ]:          0 :         if (read_line(f, LINE_MAX, &p) < 0)
      31                 :          0 :                 return 0;
      32                 :            : 
      33                 :          0 :         t = unit_type_from_string(p);
      34         [ #  # ]:          0 :         if (t < 0)
      35                 :          0 :                 return 0;
      36                 :            : 
      37         [ #  # ]:          0 :         if (!unit_vtable[t]->load)
      38                 :          0 :                 return 0;
      39                 :            : 
      40                 :          0 :         offset = ftell(f);
      41         [ #  # ]:          0 :         assert_se(offset >= 0);
      42                 :            : 
      43                 :          0 :         for (;;) {
      44      [ #  #  # ]:          0 :                 _cleanup_free_ char *l = NULL;
      45                 :            :                 const char *ll;
      46                 :            : 
      47         [ #  # ]:          0 :                 if (read_line(f, LONG_LINE_MAX, &l) <= 0)
      48                 :          0 :                         break;
      49                 :            : 
      50         [ #  # ]:          0 :                 ll = startswith(l, UTF8_BYTE_ORDER_MARK) ?: l;
      51                 :          0 :                 ll = ll + strspn(ll, WHITESPACE);
      52                 :            : 
      53                 :            :                 if (HAS_FEATURE_MEMORY_SANITIZER && startswith(ll, "ListenNetlink")) {
      54                 :            :                         /* ListenNetlink causes a false positive in msan,
      55                 :            :                          * let's skip this for now. */
      56                 :            :                         log_notice("Skipping test because ListenNetlink= is present");
      57                 :            :                         return 0;
      58                 :            :                 }
      59                 :            :         }
      60                 :            : 
      61         [ #  # ]:          0 :         assert_se(fseek(f, offset, SEEK_SET) == 0);
      62                 :            : 
      63                 :            :         /* We don't want to fill the logs with messages about parse errors.
      64                 :            :          * Disable most logging if not running standalone */
      65         [ #  # ]:          0 :         if (!getenv("SYSTEMD_LOG_LEVEL"))
      66                 :          0 :                 log_set_max_level(LOG_CRIT);
      67                 :            : 
      68         [ #  # ]:          0 :         assert_se(manager_new(UNIT_FILE_SYSTEM, MANAGER_TEST_RUN_MINIMAL, &m) >= 0);
      69                 :            : 
      70   [ #  #  #  #  :          0 :         name = strjoina("a.", unit_type_to_string(t));
          #  #  #  #  #  
                #  #  # ]
      71         [ #  # ]:          0 :         assert_se(unit_new_for_name(m, unit_vtable[t]->object_size, name, &u) >= 0);
      72                 :            : 
      73                 :          0 :         (void) config_parse(name, name, f,
      74                 :          0 :                             UNIT_VTABLE(u)->sections,
      75                 :            :                             config_item_perf_lookup, load_fragment_gperf_lookup,
      76                 :            :                             CONFIG_PARSE_ALLOW_INCLUDE, u);
      77                 :            : 
      78                 :          0 :         g = open_memstream_unlocked(&out, &out_size);
      79         [ #  # ]:          0 :         assert_se(g);
      80                 :            : 
      81                 :          0 :         unit_dump(u, g, "");
      82                 :          0 :         manager_dump(m, g, ">>>");
      83                 :            : 
      84                 :          0 :         return 0;
      85                 :            : }