src/libsystemd/sd-bus/test-bus-error.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2013 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include "sd-bus.h"
  22
  23 #include "bus-common-errors.h"
  24 #include "bus-error.h"
  25 #include "bus-util.h"
  26 #include "errno-list.h"
  27
  28 static void test_error(void) {
  29         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL, second = SD_BUS_ERROR_NULL;
  30         const sd_bus_error const_error = SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_FILE_EXISTS, "const error");
  31         const sd_bus_error temporarily_const_error = {
  32                 .name = SD_BUS_ERROR_ACCESS_DENIED,
  33                 .message = "oh! no",
  34                 ._need_free = -1
  35         };
  36
  37         assert_se(!sd_bus_error_is_set(&error));
  38         assert_se(sd_bus_error_set(&error, SD_BUS_ERROR_NOT_SUPPORTED, "xxx") == -EOPNOTSUPP);
  39         assert_se(streq(error.name, SD_BUS_ERROR_NOT_SUPPORTED));
  40         assert_se(streq(error.message, "xxx"));
  41         assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_NOT_SUPPORTED));
  42         assert_se(sd_bus_error_get_errno(&error) == EOPNOTSUPP);
  43         assert_se(sd_bus_error_is_set(&error));
  44         sd_bus_error_free(&error);
  45
  46         /* Check with no error */
  47         assert_se(!sd_bus_error_is_set(&error));
  48         assert_se(sd_bus_error_setf(&error, NULL, "yyy %i", -1) == 0);
  49         assert_se(error.name == NULL);
  50         assert_se(error.message == NULL);
  51         assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
  52         assert_se(sd_bus_error_get_errno(&error) == 0);
  53         assert_se(!sd_bus_error_is_set(&error));
  54
  55         assert_se(sd_bus_error_setf(&error, SD_BUS_ERROR_FILE_NOT_FOUND, "yyy %i", -1) == -ENOENT);
  56         assert_se(streq(error.name, SD_BUS_ERROR_FILE_NOT_FOUND));
  57         assert_se(streq(error.message, "yyy -1"));
  58         assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
  59         assert_se(sd_bus_error_get_errno(&error) == ENOENT);
  60         assert_se(sd_bus_error_is_set(&error));
  61
  62         assert_se(!sd_bus_error_is_set(&second));
  63         assert_se(second._need_free == 0);
  64         assert_se(error._need_free > 0);
  65         assert_se(sd_bus_error_copy(&second, &error) == -ENOENT);
  66         assert_se(second._need_free > 0);
  67         assert_se(streq(error.name, second.name));
  68         assert_se(streq(error.message, second.message));
  69         assert_se(sd_bus_error_get_errno(&second) == ENOENT);
  70         assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_FILE_NOT_FOUND));
  71         assert_se(sd_bus_error_is_set(&second));
  72
  73         sd_bus_error_free(&error);
  74         sd_bus_error_free(&second);
  75
  76         assert_se(!sd_bus_error_is_set(&second));
  77         assert_se(const_error._need_free == 0);
  78         assert_se(sd_bus_error_copy(&second, &const_error) == -EEXIST);
  79         assert_se(second._need_free == 0);
  80         assert_se(streq(const_error.name, second.name));
  81         assert_se(streq(const_error.message, second.message));
  82         assert_se(sd_bus_error_get_errno(&second) == EEXIST);
  83         assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_FILE_EXISTS));
  84         assert_se(sd_bus_error_is_set(&second));
  85         sd_bus_error_free(&second);
  86
  87         assert_se(!sd_bus_error_is_set(&second));
  88         assert_se(temporarily_const_error._need_free < 0);
  89         assert_se(sd_bus_error_copy(&second, &temporarily_const_error) == -EACCES);
  90         assert_se(second._need_free > 0);
  91         assert_se(streq(temporarily_const_error.name, second.name));
  92         assert_se(streq(temporarily_const_error.message, second.message));
  93         assert_se(sd_bus_error_get_errno(&second) == EACCES);
  94         assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_ACCESS_DENIED));
  95         assert_se(sd_bus_error_is_set(&second));
  96
  97         assert_se(!sd_bus_error_is_set(&error));
  98         assert_se(sd_bus_error_set_const(&error, "System.Error.EUCLEAN", "Hallo") == -EUCLEAN);
  99         assert_se(streq(error.name, "System.Error.EUCLEAN"));
 100         assert_se(streq(error.message, "Hallo"));
 101         assert_se(sd_bus_error_has_name(&error, "System.Error.EUCLEAN"));
 102         assert_se(sd_bus_error_get_errno(&error) == EUCLEAN);
 103         assert_se(sd_bus_error_is_set(&error));
 104         sd_bus_error_free(&error);
 105
 106         assert_se(!sd_bus_error_is_set(&error));
 107         assert_se(sd_bus_error_set_errno(&error, EBUSY) == -EBUSY);
 108         assert_se(streq(error.name, "System.Error.EBUSY"));
 109         assert_se(streq(error.message, strerror(EBUSY)));
 110         assert_se(sd_bus_error_has_name(&error, "System.Error.EBUSY"));
 111         assert_se(sd_bus_error_get_errno(&error) == EBUSY);
 112         assert_se(sd_bus_error_is_set(&error));
 113         sd_bus_error_free(&error);
 114
 115         assert_se(!sd_bus_error_is_set(&error));
 116         assert_se(sd_bus_error_set_errnof(&error, EIO, "Waldi %c", 'X') == -EIO);
 117         assert_se(streq(error.name, SD_BUS_ERROR_IO_ERROR));
 118         assert_se(streq(error.message, "Waldi X"));
 119         assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
 120         assert_se(sd_bus_error_get_errno(&error) == EIO);
 121         assert_se(sd_bus_error_is_set(&error));
 122         sd_bus_error_free(&error);
 123
 124         /* Check with no error */
 125         assert_se(!sd_bus_error_is_set(&error));
 126         assert_se(sd_bus_error_set_errnof(&error, 0, "Waldi %c", 'X') == 0);
 127         assert_se(error.name == NULL);
 128         assert_se(error.message == NULL);
 129         assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
 130         assert_se(sd_bus_error_get_errno(&error) == 0);
 131         assert_se(!sd_bus_error_is_set(&error));
 132 }
 133
 134 extern const sd_bus_error_map __start_BUS_ERROR_MAP[];
 135 extern const sd_bus_error_map __stop_BUS_ERROR_MAP[];
 136
 137 static void dump_mapping_table(void) {
 138         const sd_bus_error_map *m;
 139
 140         printf("----- errno mappings ------\n");
 141         m = __start_BUS_ERROR_MAP;
 142         while (m < __stop_BUS_ERROR_MAP) {
 143
 144                 if (m->code == BUS_ERROR_MAP_END_MARKER) {
 145                         m = ALIGN8_PTR(m+1);
 146                         continue;
 147                 }
 148
 149                 printf("%s -> %i/%s\n", strna(m->name), m->code, strna(errno_to_name(m->code)));
 150                 m++;
 151         }
 152         printf("---------------------------\n");
 153 }
 154
 155 static void test_errno_mapping_standard(void) {
 156         assert_se(sd_bus_error_set(NULL, "System.Error.EUCLEAN", NULL) == -EUCLEAN);
 157         assert_se(sd_bus_error_set(NULL, "System.Error.EBUSY", NULL) == -EBUSY);
 158         assert_se(sd_bus_error_set(NULL, "System.Error.EINVAL", NULL) == -EINVAL);
 159         assert_se(sd_bus_error_set(NULL, "System.Error.WHATSIT", NULL) == -EIO);
 160 }
 161
 162 BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map test_errors[] = {
 163         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error", 5),
 164         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-2", 52),
 165         SD_BUS_ERROR_MAP_END
 166 };
 167
 168 BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map test_errors2[] = {
 169         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-3", 33),
 170         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-4", 44),
 171         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-33", 333),
 172         SD_BUS_ERROR_MAP_END
 173 };
 174
 175 static const sd_bus_error_map test_errors3[] = {
 176         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-88", 888),
 177         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-99", 999),
 178         SD_BUS_ERROR_MAP_END
 179 };
 180
 181 static const sd_bus_error_map test_errors4[] = {
 182         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-77", 777),
 183         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-78", 778),
 184         SD_BUS_ERROR_MAP_END
 185 };
 186
 187 static const sd_bus_error_map test_errors_bad1[] = {
 188         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", 0),
 189         SD_BUS_ERROR_MAP_END
 190 };
 191
 192 static const sd_bus_error_map test_errors_bad2[] = {
 193         SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", -1),
 194         SD_BUS_ERROR_MAP_END
 195 };
 196
 197 static void test_errno_mapping_custom(void) {
 198         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error", NULL) == -5);
 199         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
 200         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-x", NULL) == -EIO);
 201         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-33", NULL) == -333);
 202
 203         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-88", NULL) == -EIO);
 204         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-99", NULL) == -EIO);
 205         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-77", NULL) == -EIO);
 206
 207         assert_se(sd_bus_error_add_map(test_errors3) > 0);
 208         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-88", NULL) == -888);
 209         assert_se(sd_bus_error_add_map(test_errors4) > 0);
 210         assert_se(sd_bus_error_add_map(test_errors4) == 0);
 211         assert_se(sd_bus_error_add_map(test_errors3) == 0);
 212
 213         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-99", NULL) == -999);
 214         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-77", NULL) == -777);
 215         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-78", NULL) == -778);
 216         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
 217         assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-y", NULL) == -EIO);
 218
 219         assert_se(sd_bus_error_set(NULL, BUS_ERROR_NO_SUCH_UNIT, NULL) == -ENOENT);
 220
 221         assert_se(sd_bus_error_add_map(test_errors_bad1) == -EINVAL);
 222         assert_se(sd_bus_error_add_map(test_errors_bad2) == -EINVAL);
 223 }
 224
 225 int main(int argc, char *argv[]) {
 226         dump_mapping_table();
 227
 228         test_error();
 229         test_errno_mapping_standard();
 230         test_errno_mapping_custom();
 231
 232         return 0;
 233 }