common/tr_name.c

   1 /*
   2  * Copyright (c) 2012, JANET(UK)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * 3. Neither the name of JANET(UK) nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  31  * OF THE POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  */
  34
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <jansson.h>
  38
  39 #include <tr_name_internal.h>
  40
  41 void tr_free_name (TR_NAME *name)
  42 {
  43   if (name->buf) {
  44     free (name->buf);
  45     name->buf = NULL;
  46   }
  47
  48   free(name);
  49 }
  50
  51 TR_NAME *tr_new_name (const char *name)
  52 {
  53   TR_NAME *new;
  54
  55   new = malloc(sizeof(TR_NAME));
  56   if (new) {
  57     new->len = (int) strlen(name);
  58     new->buf = malloc(1 + (size_t) new->len);
  59     if (new->buf) {
  60       strcpy(new->buf, name);
  61     } else {
  62       free(new);
  63       new=NULL;
  64     }
  65   }
  66   return new;
  67 }
  68
  69 TR_NAME *tr_dup_name (const TR_NAME *from)
  70 {
  71   TR_NAME *to;
  72
  73   if (!from) {
  74     return NULL;
  75   }
  76
  77   if (NULL != (to = malloc(sizeof(TR_NAME)))) {
  78     to->len = from->len;
  79     if (NULL != (to->buf = malloc(1 + (size_t) to->len))) {
  80       strncpy(to->buf, from->buf, (size_t) from->len);
  81       to->buf[to->len] = 0;     /* NULL terminate for debugging printf()s */
  82     }
  83   }
  84   return to;
  85 }
  86
  87 int tr_name_cmp(const TR_NAME *one, const TR_NAME *two)
  88 {
  89   int len=one->len;
  90   int cmp=0;
  91
  92   if (two->len<one->len)
  93     len=two->len; /* len now min(one->len,two->len) */
  94
  95   cmp=strncmp(one->buf, two->buf, (size_t) len);
  96   if (cmp==0) {
  97     if (one->len<two->len)
  98       return -1;
  99     else if (one->len==two->len)
 100       return 0;
 101     else
 102       return 1;
 103   }
 104   return cmp;
 105 }
 106
 107 /**
 108  * Compare a TR_NAME with a null-terminated string.
 109  *
 110  * @param one TR_NAME to compare
 111  * @param two_str Ordinary C null-terminated string
 112  * @return 0 on match, <0 if one precedes two, >0 if two precedes one
 113  */
 114 int tr_name_cmp_str(const TR_NAME *one, const char *two_str)
 115 {
 116   TR_NAME *two=tr_new_name(two_str);
 117   int cmp=tr_name_cmp(one, two);
 118   tr_free_name(two);
 119   return cmp;
 120 }
 121
 122 /**
 123  * Compare strings, allowing one to have a single '*' as the wildcard character if it is the first character.
 124  * Leading whitespace is significant.
 125  *
 126  * @param str Fixed string to compare
 127  * @param wc_str Wildcard string to compare
 128  * @return 1 if the the string (str) matches the wildcard string (wc_str), 0 if not.
 129  *
 130  */
 131 int tr_name_prefix_wildcard_match(const TR_NAME *str, const TR_NAME *wc_str)
 132 {
 133   const char *wc_post=NULL;
 134   size_t wc_len = 0;
 135
 136   if ((!str) || (!wc_str))
 137     return 0;
 138
 139   wc_len = (size_t) wc_str->len;
 140   if (wc_len == 0)
 141     return 0;
 142
 143   if ('*' == wc_str->buf[0]) {
 144     /* Wildcard, so the actual compare will start at the second character of wc_str */
 145     wc_post = wc_str->buf + 1;
 146     wc_len--;
 147   } else if (str->len == wc_len) {
 148     /* No wildcard, but the strings are the same length so may match.
 149      * Compare the full strings. */
 150     wc_post=wc_str->buf;
 151     wc_len = (size_t) wc_str->len;
 152   } else {
 153     /* No wildcard and strings are different length, so no match */
 154     return 0;
 155   }
 156
 157   /* A match is not possible if the fixed part of the wildcard string is longer than
 158    * the string to match it against. */
 159   if (wc_len > str->len)
 160     return 0;
 161
 162   /* Now we compare the last wc_len characters of str against wc_post */
 163   return (0 == strncmp(str->buf + str->len - wc_len, wc_post, wc_len));
 164 }
 165
 166 void tr_name_strlcat(char *dest, const TR_NAME *src, size_t len)
 167 {
 168   size_t used_len;
 169   if (src->len >= len)
 170     used_len = len-1;
 171   else
 172     used_len = (size_t) src->len;
 173   if (used_len > 0)
 174     strncat(dest, src->buf, used_len);
 175   else dest[0] = '\0';
 176 }
 177
 178
 179 char * tr_name_strdup(const TR_NAME *src)
 180 {
 181   char *s = calloc(1 + (size_t) src->len, 1);
 182   if (s) {
 183     memcpy(s, src->buf, (size_t) src->len);
 184     s[src->len] = '\0';
 185   }
 186   return s;
 187 }
 188
 189 json_t *tr_name_to_json_string(const TR_NAME *src)
 190 {
 191   char *s=tr_name_strdup(src);
 192   json_t *js=json_string(s);
 193   if (s!=NULL)
 194     free(s);
 195   return js;
 196 }
 197
 198 TR_NAME *tr_name_cat(const TR_NAME *n1, const TR_NAME *n2)
 199 {
 200   char *s=malloc((size_t) n1->len + (size_t) n2->len + 1);
 201   TR_NAME *name=NULL;
 202
 203   if (s==NULL)
 204     return NULL;
 205   *s=0;
 206   strncat(s, n1->buf, (size_t) n1->len);
 207   strncat(s, n2->buf, (size_t) n2->len);
 208   name=tr_new_name(s);
 209   free(s);
 210   return name;
 211 }