src/core/data.c

   1 /*
   2  * SysDB - src/core/data.c
   3  * Copyright (C) 2014 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "core/data.h"
  29
  30 #include <inttypes.h>
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 /*
  37  * public API
  38  */
  39
  40 int
  41 sdb_data_copy(sdb_data_t *dst, const sdb_data_t *src)
  42 {
  43         sdb_data_t tmp;
  44
  45         if ((! dst) || (! src))
  46                 return -1;
  47
  48         tmp = *src;
  49         switch (src->type) {
  50                 case SDB_TYPE_STRING:
  51                         tmp.data.string = strdup(src->data.string);
  52                         if (! tmp.data.string)
  53                                 return -1;
  54                         break;
  55                 case SDB_TYPE_BINARY:
  56                         tmp.data.binary.datum = malloc(src->data.binary.length);
  57                         if (! tmp.data.binary.datum)
  58                                 return -1;
  59                         memcpy(tmp.data.binary.datum, src->data.binary.datum,
  60                                         src->data.binary.length);
  61                         break;
  62         }
  63
  64         *dst = tmp;
  65         return 0;
  66 } /* sdb_data_copy */
  67
  68 void
  69 sdb_data_free_datum(sdb_data_t *datum)
  70 {
  71         if (! datum)
  72                 return;
  73
  74         switch (datum->type) {
  75                 case SDB_TYPE_STRING:
  76                         if (datum->data.string)
  77                                 free(datum->data.string);
  78                         datum->data.string = NULL;
  79                         break;
  80                 case SDB_TYPE_BINARY:
  81                         if (datum->data.binary.datum)
  82                                 free(datum->data.binary.datum);
  83                         datum->data.binary.datum = NULL;
  84                         datum->data.binary.length = 0;
  85                         break;
  86         }
  87 } /* sdb_data_free_datum */
  88
  89 size_t
  90 sdb_data_strlen(sdb_data_t *datum)
  91 {
  92         if (! datum)
  93                 return 0;
  94
  95         switch (datum->type) {
  96                 case SDB_TYPE_INTEGER:
  97                         /* log(64) */
  98                         return 20;
  99                 case SDB_TYPE_DECIMAL:
 100                         /* XXX: -0xN.NNNNNNp+NNN */
 101                         return 42;
 102                 case SDB_TYPE_STRING:
 103                         if (! datum->data.string)
 104                                 return 6; /* "NULL" */
 105                         /* in the worst case, each character needs to be escaped */
 106                         return 2 * strlen(datum->data.string) + 2;
 107                 case SDB_TYPE_DATETIME:
 108                         /* "YYYY-MM-DD HH:MM:SS +zzzz" */
 109                         return 27;
 110                 case SDB_TYPE_BINARY:
 111                         /* "\xNN" */
 112                         return 4 * datum->data.binary.length + 2;
 113         }
 114         return 0;
 115 } /* sdb_data_strlen */
 116
 117 int
 118 sdb_data_format(sdb_data_t *datum, char *buf, size_t buflen)
 119 {
 120         int ret = -1;
 121
 122         if ((! datum) || (! buf))
 123                 return -1;
 124
 125         switch (datum->type) {
 126                 case SDB_TYPE_INTEGER:
 127                         ret = snprintf(buf, buflen, "%"PRIi64, datum->data.integer);
 128                         break;
 129                 case SDB_TYPE_DECIMAL:
 130                         ret = snprintf(buf, buflen, "%a", datum->data.decimal);
 131                         break;
 132                 case SDB_TYPE_STRING:
 133                         if (! datum->data.string)
 134                                 ret = snprintf(buf, buflen, "\"NULL\"");
 135                         else {
 136                                 char tmp[2 * strlen(datum->data.string) + 1];
 137                                 size_t i, pos;
 138
 139                                 pos = 0;
 140                                 for (i = 0; i < strlen(datum->data.string); ++i) {
 141                                         char byte = datum->data.string[i];
 142
 143                                         if ((byte == '\\') || (byte == '"')) {
 144                                                 tmp[pos] = '\\';
 145                                                 ++pos;
 146                                         }
 147                                         tmp[pos] = byte;
 148                                         ++pos;
 149                                 }
 150                                 tmp[pos] = '\0';
 151                                 ret = snprintf(buf, buflen, "\"%s\"", tmp);
 152                         }
 153                         break;
 154                 case SDB_TYPE_DATETIME:
 155                         {
 156                                 char tmp[64];
 157                                 if (! sdb_strftime(tmp, sizeof(tmp), "%F %T %z",
 158                                                         datum->data.datetime))
 159                                         return -1;
 160                                 tmp[sizeof(tmp) - 1] = '\0';
 161                                 ret = snprintf(buf, buflen, "\"%s\"", tmp);
 162                         }
 163                         break;
 164                 case SDB_TYPE_BINARY:
 165                         {
 166                                 char tmp[4 * datum->data.binary.length + 1];
 167                                 size_t i, pos;
 168
 169                                 pos = 0;
 170                                 for (i = 0; i < datum->data.binary.length; ++i) {
 171                                         int byte = (int)datum->data.binary.datum[i];
 172                                         char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7',
 173                                                 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
 174
 175                                         tmp[pos] = '\\';
 176                                         tmp[pos + 1] = 'x';
 177                                         pos += 2;
 178
 179                                         if (byte > 0xf) {
 180                                                 tmp[pos] = hex[byte >> 4];
 181                                                 ++pos;
 182                                         }
 183                                         tmp[pos] = hex[byte & 0xf];
 184                                         ++pos;
 185                                 }
 186                                 tmp[pos] = '\0';
 187                                 ret = snprintf(buf, buflen, "\"%s\"", tmp);
 188                         }
 189                         break;
 190         }
 191         buf[buflen - 1] = '\0';
 192         return ret;
 193 } /* sdb_data_format */
 194
 195 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 196