source/rest/buffers.cpp

   1 /*
   2  * Carla REST API Server
   3  * Copyright (C) 2018 Filipe Coelho <falktx@falktx.com>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of
   8  * the License, or any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * For a full copy of the GNU General Public License see the doc/GPL.txt file.
  16  */
  17
  18 #include "buffers.hpp"
  19 #include "CarlaMathUtils.hpp"
  20
  21 #include <cstdio>
  22 #include <cstring>
  23
  24 // -------------------------------------------------------------------------------------------------------------------
  25
  26 enum {
  27     kJsonBufSize = 4095,
  28     kStrBufSize = 1023,
  29     kSizeBufSize = 31,
  30 };
  31
  32 // static buffer to return json
  33 // NOTE size is never checked for json, the buffer is big enough in order to assume it all always fits
  34 static char jsonBuf[kJsonBufSize+1];
  35
  36 // static buffer to return size
  37 static char sizeBuf[kSizeBufSize+1];
  38
  39 // static buffer to return regular strings
  40 static char strBuf[kStrBufSize+1];
  41
  42 // -------------------------------------------------------------------------------------------------------------------
  43
  44 const char* size_buf(const char* const buf)
  45 {
  46     const std::size_t size = std::strlen(buf);
  47     std::snprintf(sizeBuf, kSizeBufSize, P_SIZE, size);
  48     sizeBuf[kSizeBufSize] = '\0';
  49     return sizeBuf;
  50 }
  51
  52 // -------------------------------------------------------------------------------------------------------------------
  53
  54 const char* str_buf_bool(const bool value)
  55 {
  56     strBuf[0] = value ? '1' : '0';
  57     strBuf[1] = '\0';
  58     return strBuf;
  59 }
  60
  61 // -------------------------------------------------------------------------------------------------------------------
  62
  63 const char* str_buf_float(const double value)
  64 {
  65     std::snprintf(strBuf, kStrBufSize, "%f", value);
  66     strBuf[kStrBufSize] = '\0';
  67     return strBuf;
  68 }
  69
  70 const char* str_buf_float_array(const double* const values, const char sep)
  71 {
  72     std::size_t bytesRead = 0;
  73     char tmpBuf[32];
  74
  75     for (int i=0; carla_isNotZero(values[i]) && bytesRead < kStrBufSize; ++i)
  76     {
  77         std::snprintf(tmpBuf, 31, "%f", values[i]);
  78         tmpBuf[31] = '\0';
  79
  80         const std::size_t size = std::strlen(tmpBuf);
  81
  82         if (bytesRead + size > kStrBufSize)
  83             break;
  84
  85         std::strncpy(strBuf+bytesRead, tmpBuf, kStrBufSize - bytesRead);
  86         bytesRead += size;
  87         strBuf[bytesRead] = sep;
  88         bytesRead += 1;
  89     }
  90
  91     strBuf[bytesRead > 0 ? bytesRead-1 : 0] = '\0';
  92     return strBuf;
  93 }
  94
  95 // -------------------------------------------------------------------------------------------------------------------
  96
  97 const char* str_buf_string(const char* const string)
  98 {
  99     std::strncpy(strBuf, string, kStrBufSize);
 100     strBuf[kStrBufSize] = '\0';
 101     return strBuf;
 102 }
 103
 104 const char* str_buf_string_array(const char* const* const array)
 105 {
 106     std::size_t bytesRead = 0;
 107
 108     for (int i=0; array[i] != nullptr && bytesRead < kStrBufSize; ++i)
 109     {
 110         const std::size_t size = std::strlen(array[i]);
 111
 112         if (bytesRead + size > kStrBufSize)
 113             break;
 114
 115         std::strncpy(strBuf+bytesRead, array[i], kStrBufSize - bytesRead);
 116         bytesRead += size;
 117         strBuf[bytesRead] = '\n';
 118         bytesRead += 1;
 119     }
 120
 121     strBuf[bytesRead > 0 ? bytesRead-1 : 0] = '\0';
 122     return strBuf;
 123 }
 124
 125 const char* str_buf_string_quoted(const char* const string)
 126 {
 127     const std::size_t size = std::strlen(string);
 128     char* strBufPtr = strBuf;
 129
 130     *strBufPtr++ = '"';
 131
 132     for (std::size_t i=0, bytesWritten=0; i < size && bytesWritten < kStrBufSize-1; ++i)
 133     {
 134         switch (string[i])
 135         {
 136         case '"':
 137         case '\\':
 138             *strBufPtr++ = '\\';
 139             ++bytesWritten;
 140             break;
 141         case '\n':
 142             *strBufPtr++ = '\\';
 143             *strBufPtr++ = 'n';;
 144             bytesWritten += 2;
 145             continue;
 146         case '\f':
 147             *strBufPtr++ = '\\';
 148             *strBufPtr++ = 'f';;
 149             bytesWritten += 2;
 150             continue;
 151         }
 152
 153         *strBufPtr++ = string[i];
 154         ++bytesWritten;
 155     }
 156
 157     *strBufPtr++ = '"';
 158     *strBufPtr++ = '\0';
 159     return strBuf;
 160 }
 161
 162 // -------------------------------------------------------------------------------------------------------------------
 163
 164 const char* str_buf_int(const int value)
 165 {
 166     std::snprintf(strBuf, kStrBufSize, "%i", value);
 167     strBuf[kStrBufSize] = '\0';
 168     return strBuf;
 169 }
 170
 171 const char* str_buf_int64(const int64_t value)
 172 {
 173     std::snprintf(strBuf, kStrBufSize, P_INT64, value);
 174     strBuf[kStrBufSize] = '\0';
 175     return strBuf;
 176 }
 177
 178 const char* str_buf_uint(const uint value)
 179 {
 180     std::snprintf(strBuf, kStrBufSize, "%u", value);
 181     strBuf[kStrBufSize] = '\0';
 182     return strBuf;
 183 }
 184
 185 const char* str_buf_uint64(const uint64_t value)
 186 {
 187     std::snprintf(strBuf, kStrBufSize, P_UINT64, value);
 188     strBuf[kStrBufSize] = '\0';
 189     return strBuf;
 190 }
 191
 192 const char* str_buf_uint_array(const uint* const values, const char sep)
 193 {
 194     std::size_t bytesRead = 0;
 195     char tmpBuf[32];
 196
 197     for (int i=0; values[i] != 0 && bytesRead < kStrBufSize; ++i)
 198     {
 199         std::snprintf(tmpBuf, 31, "%u", values[i]);
 200         tmpBuf[31] = '\0';
 201
 202         const std::size_t size = std::strlen(tmpBuf);
 203
 204         if (bytesRead + size > kStrBufSize)
 205             break;
 206
 207         std::strncpy(strBuf+bytesRead, tmpBuf, kStrBufSize - bytesRead);
 208         bytesRead += size;
 209         strBuf[bytesRead] = sep;
 210         bytesRead += 1;
 211     }
 212
 213     strBuf[bytesRead > 0 ? bytesRead-1 : 0] = '\0';
 214     return strBuf;
 215 }
 216
 217 // -------------------------------------------------------------------------------------------------------------------
 218
 219 char* json_buf_start()
 220 {
 221     std::strcpy(jsonBuf, "{");
 222     return jsonBuf + 1;
 223 }
 224
 225 char* json_buf_add(char* jsonBufPtr, const char* const key, const char* const valueBuf)
 226 {
 227     if (jsonBufPtr != jsonBuf+1)
 228         *jsonBufPtr++ = ',';
 229
 230     *jsonBufPtr++ = '"';
 231
 232     std::strcpy(jsonBufPtr, key);
 233     jsonBufPtr += std::strlen(key);
 234
 235     *jsonBufPtr++ = '"';
 236     *jsonBufPtr++ = ':';
 237
 238     std::strcpy(jsonBufPtr, valueBuf);
 239     jsonBufPtr += std::strlen(valueBuf);
 240
 241     return jsonBufPtr;
 242 }
 243
 244 template <typename T, typename Fn>
 245 char* json_buf_add_fn(char* jsonBufPtr, const char* const key, const T value, const Fn fn)
 246 {
 247     return json_buf_add(jsonBufPtr, key, fn(value));
 248 }
 249
 250 template <typename T, typename Fn>
 251 char* json_buf_add_fn_array(char* jsonBufPtr, const char* const key, const T value, const Fn fn)
 252 {
 253     return json_buf_add(jsonBufPtr, key, fn(value, ','));
 254 }
 255
 256 // -------------------------------------------------------------------------------------------------------------------
 257
 258 char* json_buf_add_bool(char* jsonBufPtr, const char* const key, const bool value)
 259 {
 260     static const char* const kTrue  = "true";
 261     static const char* const kFalse = "false";
 262     return json_buf_add_fn(jsonBufPtr, key, value ? kTrue : kFalse, str_buf_string);
 263 }
 264
 265 char* json_buf_add_float(char* jsonBufPtr, const char* const key, const double value)
 266 {
 267     return json_buf_add_fn(jsonBufPtr, key, value, str_buf_float);
 268 }
 269
 270 char* json_buf_add_float_array(char* jsonBufPtr, const char* const key, const double* const values)
 271 {
 272     return json_buf_add_fn_array(jsonBufPtr, key, values, str_buf_float_array);
 273 }
 274
 275 char* json_buf_add_string(char* jsonBufPtr, const char* const key, const char* const value)
 276 {
 277     return json_buf_add_fn(jsonBufPtr, key, value, str_buf_string_quoted);
 278 }
 279
 280 char* json_buf_add_int(char* jsonBufPtr, const char* const key, const int value)
 281 {
 282     return json_buf_add_fn(jsonBufPtr, key, value, str_buf_int);
 283 }
 284
 285 char* json_buf_add_int64(char* jsonBufPtr, const char* const key, const int64_t value)
 286 {
 287     return json_buf_add_fn(jsonBufPtr, key, value, str_buf_int64);
 288 }
 289
 290 char* json_buf_add_uint(char* jsonBufPtr, const char* const key, const uint value)
 291 {
 292     return json_buf_add_fn(jsonBufPtr, key, value, str_buf_uint);
 293 }
 294
 295 char* json_buf_add_uint_array(char* jsonBufPtr, const char* const key, const uint* const values)
 296 {
 297     return json_buf_add_fn_array(jsonBufPtr, key, values, str_buf_uint_array);
 298 }
 299
 300 char* json_buf_add_uint64(char* jsonBufPtr, const char* const key, const uint64_t value)
 301 {
 302     return json_buf_add_fn(jsonBufPtr, key, value, str_buf_uint64);
 303 }
 304
 305 const char* json_buf_end(char* jsonBufPtr)
 306 {
 307     *jsonBufPtr++ = '}';
 308     *jsonBufPtr++ = '\0';
 309     return jsonBuf;
 310 }
 311
 312 // -------------------------------------------------------------------------------------------------------------------