src/libsystemd-bus/bus-type.c

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