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