src/libelogind/sd-bus/bus-type.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2013 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include "bus-type.h"
  21
  22 bool bus_type_is_valid(char c) {
  23         static const char valid[] = {
  24                 SD_BUS_TYPE_BYTE,
  25                 SD_BUS_TYPE_BOOLEAN,
  26                 SD_BUS_TYPE_INT16,
  27                 SD_BUS_TYPE_UINT16,
  28                 SD_BUS_TYPE_INT32,
  29                 SD_BUS_TYPE_UINT32,
  30                 SD_BUS_TYPE_INT64,
  31                 SD_BUS_TYPE_UINT64,
  32                 SD_BUS_TYPE_DOUBLE,
  33                 SD_BUS_TYPE_STRING,
  34                 SD_BUS_TYPE_OBJECT_PATH,
  35                 SD_BUS_TYPE_SIGNATURE,
  36                 SD_BUS_TYPE_ARRAY,
  37                 SD_BUS_TYPE_VARIANT,
  38                 SD_BUS_TYPE_STRUCT,
  39                 SD_BUS_TYPE_DICT_ENTRY,
  40                 SD_BUS_TYPE_UNIX_FD
  41         };
  42
  43         return !!memchr(valid, c, sizeof(valid));
  44 }
  45
  46 #if 0 /// UNNEEDED by elogind
  47 bool bus_type_is_valid_in_signature(char c) {
  48         static const char valid[] = {
  49                 SD_BUS_TYPE_BYTE,
  50                 SD_BUS_TYPE_BOOLEAN,
  51                 SD_BUS_TYPE_INT16,
  52                 SD_BUS_TYPE_UINT16,
  53                 SD_BUS_TYPE_INT32,
  54                 SD_BUS_TYPE_UINT32,
  55                 SD_BUS_TYPE_INT64,
  56                 SD_BUS_TYPE_UINT64,
  57                 SD_BUS_TYPE_DOUBLE,
  58                 SD_BUS_TYPE_STRING,
  59                 SD_BUS_TYPE_OBJECT_PATH,
  60                 SD_BUS_TYPE_SIGNATURE,
  61                 SD_BUS_TYPE_ARRAY,
  62                 SD_BUS_TYPE_VARIANT,
  63                 SD_BUS_TYPE_STRUCT_BEGIN,
  64                 SD_BUS_TYPE_STRUCT_END,
  65                 SD_BUS_TYPE_DICT_ENTRY_BEGIN,
  66                 SD_BUS_TYPE_DICT_ENTRY_END,
  67                 SD_BUS_TYPE_UNIX_FD
  68         };
  69
  70         return !!memchr(valid, c, sizeof(valid));
  71 }
  72 #endif // 0
  73
  74 bool bus_type_is_basic(char c) {
  75         static const char valid[] = {
  76                 SD_BUS_TYPE_BYTE,
  77                 SD_BUS_TYPE_BOOLEAN,
  78                 SD_BUS_TYPE_INT16,
  79                 SD_BUS_TYPE_UINT16,
  80                 SD_BUS_TYPE_INT32,
  81                 SD_BUS_TYPE_UINT32,
  82                 SD_BUS_TYPE_INT64,
  83                 SD_BUS_TYPE_UINT64,
  84                 SD_BUS_TYPE_DOUBLE,
  85                 SD_BUS_TYPE_STRING,
  86                 SD_BUS_TYPE_OBJECT_PATH,
  87                 SD_BUS_TYPE_SIGNATURE,
  88                 SD_BUS_TYPE_UNIX_FD
  89         };
  90
  91         return !!memchr(valid, c, sizeof(valid));
  92 }
  93
  94 bool bus_type_is_trivial(char c) {
  95         static const char valid[] = {
  96                 SD_BUS_TYPE_BYTE,
  97                 SD_BUS_TYPE_BOOLEAN,
  98                 SD_BUS_TYPE_INT16,
  99                 SD_BUS_TYPE_UINT16,
 100                 SD_BUS_TYPE_INT32,
 101                 SD_BUS_TYPE_UINT32,
 102                 SD_BUS_TYPE_INT64,
 103                 SD_BUS_TYPE_UINT64,
 104                 SD_BUS_TYPE_DOUBLE
 105         };
 106
 107         return !!memchr(valid, c, sizeof(valid));
 108 }
 109
 110 bool bus_type_is_container(char c) {
 111         static const char valid[] = {
 112                 SD_BUS_TYPE_ARRAY,
 113                 SD_BUS_TYPE_VARIANT,
 114                 SD_BUS_TYPE_STRUCT,
 115                 SD_BUS_TYPE_DICT_ENTRY
 116         };
 117
 118         return !!memchr(valid, c, sizeof(valid));
 119 }
 120
 121 int bus_type_get_alignment(char c) {
 122
 123         switch (c) {
 124         case SD_BUS_TYPE_BYTE:
 125         case SD_BUS_TYPE_SIGNATURE:
 126         case SD_BUS_TYPE_VARIANT:
 127                 return 1;
 128
 129         case SD_BUS_TYPE_INT16:
 130         case SD_BUS_TYPE_UINT16:
 131                 return 2;
 132
 133         case SD_BUS_TYPE_BOOLEAN:
 134         case SD_BUS_TYPE_INT32:
 135         case SD_BUS_TYPE_UINT32:
 136         case SD_BUS_TYPE_STRING:
 137         case SD_BUS_TYPE_OBJECT_PATH:
 138         case SD_BUS_TYPE_ARRAY:
 139         case SD_BUS_TYPE_UNIX_FD:
 140                 return 4;
 141
 142         case SD_BUS_TYPE_INT64:
 143         case SD_BUS_TYPE_UINT64:
 144         case SD_BUS_TYPE_DOUBLE:
 145         case SD_BUS_TYPE_STRUCT:
 146         case SD_BUS_TYPE_STRUCT_BEGIN:
 147         case SD_BUS_TYPE_DICT_ENTRY:
 148         case SD_BUS_TYPE_DICT_ENTRY_BEGIN:
 149                 return 8;
 150         }
 151
 152         return -EINVAL;
 153 }
 154
 155 int bus_type_get_size(char c) {
 156
 157         switch (c) {
 158         case SD_BUS_TYPE_BYTE:
 159                 return 1;
 160
 161         case SD_BUS_TYPE_INT16:
 162         case SD_BUS_TYPE_UINT16:
 163                 return 2;
 164
 165         case SD_BUS_TYPE_BOOLEAN:
 166         case SD_BUS_TYPE_INT32:
 167         case SD_BUS_TYPE_UINT32:
 168         case SD_BUS_TYPE_UNIX_FD:
 169                 return 4;
 170
 171         case SD_BUS_TYPE_INT64:
 172         case SD_BUS_TYPE_UINT64:
 173         case SD_BUS_TYPE_DOUBLE:
 174                 return 8;
 175         }
 176
 177         return -EINVAL;
 178 }