lib/libcasper/libcasper/libcasper.h

   1 /*-
   2  * Copyright (c) 2012-2013 The FreeBSD Foundation
   3  * Copyright (c) 2015-2017 Mariusz Zaborski <oshogbo@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * This software was developed by Pawel Jakub Dawidek under sponsorship from
   7  * the FreeBSD Foundation.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  * $FreeBSD$
  31  */
  32
  33 #ifndef _LIBCASPER_H_
  34 #define _LIBCASPER_H_
  35
  36 #ifdef HAVE_CASPER
  37 #define WITH_CASPER
  38 #endif
  39
  40 #include <sys/types.h>
  41 #include <sys/nv.h>
  42
  43 #include <stdlib.h>
  44 #include <unistd.h>
  45
  46 #ifndef _NVLIST_T_DECLARED
  47 #define _NVLIST_T_DECLARED
  48 struct nvlist;
  49
  50 typedef struct nvlist nvlist_t;
  51 #endif
  52
  53 #ifndef _CAP_CHANNEL_T_DECLARED
  54 #define _CAP_CHANNEL_T_DECLARED
  55 #ifdef WITH_CASPER
  56 struct cap_channel;
  57
  58 typedef struct cap_channel cap_channel_t;
  59 #define CASPER_SUPPORT  (1)
  60 #else
  61 struct cap_channel {
  62         int cch_fd;
  63 };
  64 typedef struct cap_channel cap_channel_t;
  65 #define CASPER_SUPPORT  (0)
  66 #endif /* ! WITH_CASPER */
  67 #endif /* ! _CAP_CHANNEL_T_DECLARED */
  68
  69 /*
  70  * The functions opens unrestricted communication channel to Casper.
  71  */
  72 #ifdef WITH_CASPER
  73 cap_channel_t *cap_init(void);
  74 #else
  75 static inline cap_channel_t *
  76 cap_init(void)
  77 {
  78         cap_channel_t *chan;
  79
  80         chan = malloc(sizeof(*chan));
  81         if (chan != NULL) {
  82                 chan->cch_fd = -1;
  83         }
  84         return (chan);
  85 }
  86 #endif
  87
  88 /*
  89  * The functions to communicate with service.
  90  */
  91 #ifdef WITH_CASPER
  92 cap_channel_t   *cap_service_open(const cap_channel_t *chan, const char *name);
  93 int              cap_service_limit(const cap_channel_t *chan,
  94                     const char * const *names, size_t nnames);
  95 #else
  96 #define cap_service_open(chan, name)            (cap_init())
  97 #define cap_service_limit(chan, names, nnames)  (0)
  98 #endif
  99
 100 /*
 101  * The function creates cap_channel_t based on the given socket.
 102  */
 103 #ifdef WITH_CASPER
 104 cap_channel_t *cap_wrap(int sock);
 105 #else
 106 static inline cap_channel_t *
 107 cap_wrap(int sock)
 108 {
 109         cap_channel_t *chan;
 110
 111         chan = cap_init();
 112         if (chan != NULL) {
 113                 chan->cch_fd = sock;
 114         }
 115         return (chan);
 116 }
 117 #endif
 118
 119 /*
 120  * The function returns communication socket and frees cap_channel_t.
 121  */
 122 #ifdef WITH_CASPER
 123 int     cap_unwrap(cap_channel_t *chan);
 124 #else
 125 static inline int
 126 cap_unwrap(cap_channel_t *chan)
 127 {
 128         int fd;
 129
 130         fd = chan->cch_fd;
 131         free(chan);
 132         return (fd);
 133 }
 134 #endif
 135
 136 /*
 137  * The function clones the given capability.
 138  */
 139 #ifdef WITH_CASPER
 140 cap_channel_t *cap_clone(const cap_channel_t *chan);
 141 #else
 142 static inline cap_channel_t *
 143 cap_clone(const cap_channel_t *chan)
 144 {
 145         cap_channel_t *newchan;
 146
 147         newchan = cap_init();
 148         if (newchan == NULL) {
 149                 return (NULL);
 150         }
 151
 152         if (chan->cch_fd == -1) {
 153                 newchan->cch_fd = -1;
 154         } else {
 155                 newchan->cch_fd = dup(chan->cch_fd);
 156                 if (newchan->cch_fd < 0) {
 157                         free(newchan);
 158                         newchan = NULL;
 159                 }
 160         }
 161
 162         return (newchan);
 163 }
 164 #endif
 165
 166 /*
 167  * The function closes the given capability.
 168  */
 169 #ifdef WITH_CASPER
 170 void    cap_close(cap_channel_t *chan);
 171 #else
 172 static inline void
 173 cap_close(cap_channel_t *chan)
 174 {
 175
 176         if (chan->cch_fd >= 0) {
 177                 close(chan->cch_fd);
 178         }
 179         free(chan);
 180 }
 181 #endif
 182
 183 /*
 184  * The function returns socket descriptor associated with the given
 185  * cap_channel_t for use with select(2)/kqueue(2)/etc.
 186  */
 187 #ifdef WITH_CASPER
 188 int     cap_sock(const cap_channel_t *chan);
 189 #else
 190 #define cap_sock(chan)  (chan->cch_fd)
 191 #endif
 192
 193 /*
 194  * The function limits the given capability.
 195  * It always destroys 'limits' on return.
 196  */
 197 #ifdef WITH_CASPER
 198 int     cap_limit_set(const cap_channel_t *chan, nvlist_t *limits);
 199 #else
 200 #define cap_limit_set(chan, limits)     (0)
 201 #endif
 202
 203 /*
 204  * The function returns current limits of the given capability.
 205  */
 206 #ifdef WITH_CASPER
 207 int     cap_limit_get(const cap_channel_t *chan, nvlist_t **limitsp);
 208 #else
 209 static inline int
 210 cap_limit_get(const cap_channel_t *chan __unused, nvlist_t **limitsp)
 211 {
 212
 213         *limitsp = nvlist_create(0);
 214         return (0);
 215 }
 216 #endif
 217
 218 /*
 219  * Function sends nvlist over the given capability.
 220  */
 221 #ifdef WITH_CASPER
 222 int     cap_send_nvlist(const cap_channel_t *chan, const nvlist_t *nvl);
 223 #else
 224 #define cap_send_nvlist(chan, nvl)      (0)
 225 #endif
 226
 227 /*
 228  * Function receives nvlist over the given capability.
 229  */
 230 #ifdef WITH_CASPER
 231 nvlist_t *cap_recv_nvlist(const cap_channel_t *chan, int flags);
 232 #else
 233 #define cap_recv_nvlist(chan, flags)    (0)
 234 #endif
 235
 236 /*
 237  * Function sends the given nvlist, destroys it and receives new nvlist in
 238  * response over the given capability.
 239  */
 240 #ifdef WITH_CASPER
 241 nvlist_t *cap_xfer_nvlist(const cap_channel_t *chan, nvlist_t *nvl, int flags);
 242 #else
 243 static inline nvlist_t *
 244 cap_xfer_nvlist(const cap_channel_t *chan __unused, nvlist_t *nvl, int flags)
 245 {
 246
 247         nvlist_destroy(nvl);
 248         return (nvlist_create(flags));
 249 }
 250 #endif
 251
 252 #endif  /* !_LIBCASPER_H_ */