src/libsystemd/sd-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 bool bus_type_is_container(char c) {
 112         static const char valid[] = {
 113                 SD_BUS_TYPE_ARRAY,
 114                 SD_BUS_TYPE_VARIANT,
 115                 SD_BUS_TYPE_STRUCT,
 116                 SD_BUS_TYPE_DICT_ENTRY
 117         };
 118
 119         return !!memchr(valid, c, sizeof(valid));
 120 }
 121
 122 int bus_type_get_alignment(char c) {
 123
 124         switch (c) {
 125         case SD_BUS_TYPE_BYTE:
 126         case SD_BUS_TYPE_SIGNATURE:
 127         case SD_BUS_TYPE_VARIANT:
 128                 return 1;
 129
 130         case SD_BUS_TYPE_INT16:
 131         case SD_BUS_TYPE_UINT16:
 132                 return 2;
 133
 134         case SD_BUS_TYPE_BOOLEAN:
 135         case SD_BUS_TYPE_INT32:
 136         case SD_BUS_TYPE_UINT32:
 137         case SD_BUS_TYPE_STRING:
 138         case SD_BUS_TYPE_OBJECT_PATH:
 139         case SD_BUS_TYPE_ARRAY:
 140         case SD_BUS_TYPE_UNIX_FD:
 141                 return 4;
 142
 143         case SD_BUS_TYPE_INT64:
 144         case SD_BUS_TYPE_UINT64:
 145         case SD_BUS_TYPE_DOUBLE:
 146         case SD_BUS_TYPE_STRUCT:
 147         case SD_BUS_TYPE_STRUCT_BEGIN:
 148         case SD_BUS_TYPE_DICT_ENTRY:
 149         case SD_BUS_TYPE_DICT_ENTRY_BEGIN:
 150                 return 8;
 151         }
 152
 153         return -EINVAL;
 154 }
 155
 156 int bus_type_get_size(char c) {
 157
 158         switch (c) {
 159         case SD_BUS_TYPE_BYTE:
 160                 return 1;
 161
 162         case SD_BUS_TYPE_INT16:
 163         case SD_BUS_TYPE_UINT16:
 164                 return 2;
 165
 166         case SD_BUS_TYPE_BOOLEAN:
 167         case SD_BUS_TYPE_INT32:
 168         case SD_BUS_TYPE_UINT32:
 169         case SD_BUS_TYPE_UNIX_FD:
 170                 return 4;
 171
 172         case SD_BUS_TYPE_INT64:
 173         case SD_BUS_TYPE_UINT64:
 174         case SD_BUS_TYPE_DOUBLE:
 175                 return 8;
 176         }
 177
 178         return -EINVAL;
 179 }