src/libsystemd/sd-bus/bus-type.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 <errno.h>
  22
  23 #include "sd-bus.h"
  24
  25 #include "bus-type.h"
  26
  27 bool bus_type_is_valid(char c) {
  28         static const char valid[] = {
  29                 SD_BUS_TYPE_BYTE,
  30                 SD_BUS_TYPE_BOOLEAN,
  31                 SD_BUS_TYPE_INT16,
  32                 SD_BUS_TYPE_UINT16,
  33                 SD_BUS_TYPE_INT32,
  34                 SD_BUS_TYPE_UINT32,
  35                 SD_BUS_TYPE_INT64,
  36                 SD_BUS_TYPE_UINT64,
  37                 SD_BUS_TYPE_DOUBLE,
  38                 SD_BUS_TYPE_STRING,
  39                 SD_BUS_TYPE_OBJECT_PATH,
  40                 SD_BUS_TYPE_SIGNATURE,
  41                 SD_BUS_TYPE_ARRAY,
  42                 SD_BUS_TYPE_VARIANT,
  43                 SD_BUS_TYPE_STRUCT,
  44                 SD_BUS_TYPE_DICT_ENTRY,
  45                 SD_BUS_TYPE_UNIX_FD
  46         };
  47
  48         return !!memchr(valid, c, sizeof(valid));
  49 }
  50
  51 bool bus_type_is_valid_in_signature(char c) {
  52         static const char valid[] = {
  53                 SD_BUS_TYPE_BYTE,
  54                 SD_BUS_TYPE_BOOLEAN,
  55                 SD_BUS_TYPE_INT16,
  56                 SD_BUS_TYPE_UINT16,
  57                 SD_BUS_TYPE_INT32,
  58                 SD_BUS_TYPE_UINT32,
  59                 SD_BUS_TYPE_INT64,
  60                 SD_BUS_TYPE_UINT64,
  61                 SD_BUS_TYPE_DOUBLE,
  62                 SD_BUS_TYPE_STRING,
  63                 SD_BUS_TYPE_OBJECT_PATH,
  64                 SD_BUS_TYPE_SIGNATURE,
  65                 SD_BUS_TYPE_ARRAY,
  66                 SD_BUS_TYPE_VARIANT,
  67                 SD_BUS_TYPE_STRUCT_BEGIN,
  68                 SD_BUS_TYPE_STRUCT_END,
  69                 SD_BUS_TYPE_DICT_ENTRY_BEGIN,
  70                 SD_BUS_TYPE_DICT_ENTRY_END,
  71                 SD_BUS_TYPE_UNIX_FD
  72         };
  73
  74         return !!memchr(valid, c, sizeof(valid));
  75 }
  76
  77 bool bus_type_is_basic(char c) {
  78         static const char valid[] = {
  79                 SD_BUS_TYPE_BYTE,
  80                 SD_BUS_TYPE_BOOLEAN,
  81                 SD_BUS_TYPE_INT16,
  82                 SD_BUS_TYPE_UINT16,
  83                 SD_BUS_TYPE_INT32,
  84                 SD_BUS_TYPE_UINT32,
  85                 SD_BUS_TYPE_INT64,
  86                 SD_BUS_TYPE_UINT64,
  87                 SD_BUS_TYPE_DOUBLE,
  88                 SD_BUS_TYPE_STRING,
  89                 SD_BUS_TYPE_OBJECT_PATH,
  90                 SD_BUS_TYPE_SIGNATURE,
  91                 SD_BUS_TYPE_UNIX_FD
  92         };
  93
  94         return !!memchr(valid, c, sizeof(valid));
  95 }
  96
  97 bool bus_type_is_trivial(char c) {
  98         static const char valid[] = {
  99                 SD_BUS_TYPE_BYTE,
 100                 SD_BUS_TYPE_BOOLEAN,
 101                 SD_BUS_TYPE_INT16,
 102                 SD_BUS_TYPE_UINT16,
 103                 SD_BUS_TYPE_INT32,
 104                 SD_BUS_TYPE_UINT32,
 105                 SD_BUS_TYPE_INT64,
 106                 SD_BUS_TYPE_UINT64,
 107                 SD_BUS_TYPE_DOUBLE
 108         };
 109
 110         return !!memchr(valid, c, sizeof(valid));
 111 }
 112
 113 bool bus_type_is_container(char c) {
 114         static const char valid[] = {
 115                 SD_BUS_TYPE_ARRAY,
 116                 SD_BUS_TYPE_VARIANT,
 117                 SD_BUS_TYPE_STRUCT,
 118                 SD_BUS_TYPE_DICT_ENTRY
 119         };
 120
 121         return !!memchr(valid, c, sizeof(valid));
 122 }
 123
 124 int bus_type_get_alignment(char c) {
 125
 126         switch (c) {
 127         case SD_BUS_TYPE_BYTE:
 128         case SD_BUS_TYPE_SIGNATURE:
 129         case SD_BUS_TYPE_VARIANT:
 130                 return 1;
 131
 132         case SD_BUS_TYPE_INT16:
 133         case SD_BUS_TYPE_UINT16:
 134                 return 2;
 135
 136         case SD_BUS_TYPE_BOOLEAN:
 137         case SD_BUS_TYPE_INT32:
 138         case SD_BUS_TYPE_UINT32:
 139         case SD_BUS_TYPE_STRING:
 140         case SD_BUS_TYPE_OBJECT_PATH:
 141         case SD_BUS_TYPE_ARRAY:
 142         case SD_BUS_TYPE_UNIX_FD:
 143                 return 4;
 144
 145         case SD_BUS_TYPE_INT64:
 146         case SD_BUS_TYPE_UINT64:
 147         case SD_BUS_TYPE_DOUBLE:
 148         case SD_BUS_TYPE_STRUCT:
 149         case SD_BUS_TYPE_STRUCT_BEGIN:
 150         case SD_BUS_TYPE_DICT_ENTRY:
 151         case SD_BUS_TYPE_DICT_ENTRY_BEGIN:
 152                 return 8;
 153         }
 154
 155         return -EINVAL;
 156 }
 157
 158 int bus_type_get_size(char c) {
 159
 160         switch (c) {
 161         case SD_BUS_TYPE_BYTE:
 162                 return 1;
 163
 164         case SD_BUS_TYPE_INT16:
 165         case SD_BUS_TYPE_UINT16:
 166                 return 2;
 167
 168         case SD_BUS_TYPE_BOOLEAN:
 169         case SD_BUS_TYPE_INT32:
 170         case SD_BUS_TYPE_UINT32:
 171         case SD_BUS_TYPE_UNIX_FD:
 172                 return 4;
 173
 174         case SD_BUS_TYPE_INT64:
 175         case SD_BUS_TYPE_UINT64:
 176         case SD_BUS_TYPE_DOUBLE:
 177                 return 8;
 178         }
 179
 180         return -EINVAL;
 181 }