6659 nvlist_free(NULL) is a no-op

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 #include <sys/types.h>
  27 #include <sys/param.h>
  28 #include <sys/errno.h>
  29 
  30 #ifdef _KERNEL
  31 #include <sys/sunddi.h>
  32 #include <fs/fs_reparse.h>
  33 #else
  34 #include <string.h>
  35 #include <limits.h>
  36 #include <sys/fs_reparse.h>
  37 
  38 #define strfree(str)            free((str))
  39 #endif
  40 
  41 static char *reparse_skipspace(char *cp);
  42 static int reparse_create_nvlist(const char *string, nvlist_t *nvl);
  43 static int reparse_add_nvpair(char *token, nvlist_t *nvl);
  44 static boolean_t reparse_validate_svctype(char *svc_str);
  45 static int reparse_validate_create_nvlist(const char *string, nvlist_t *nvl);
  46 
  47 /* array of characters not allowed in service type string */
  48 static char svctype_invalid_chars[] = { '{', '}', 0 };
  49 
  50 /*
  51  * reparse_init()
  52  *
  53  * Function to allocate a new name-value pair list.
  54  * Caller needs to call reparse_free() to free memory
  55  * used by the list when done.
  56  *
  57  * Return pointer to new list else return NULL.
  58  */
  59 nvlist_t *
  60 reparse_init(void)
  61 {
  62         nvlist_t *nvl;
  63 
  64         /*
  65          * Service type is unique, only one entry
  66          * of each service type is allowed
  67          */
  68         if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0))
  69                 return (NULL);
  70 
  71         return (nvl);
  72 }
  73 
  74 /*
  75  * reparse_free()
  76  *
  77  * Function to free memory of a nvlist allocated previously
  78  * by reparse_init().
  79  */
  80 void
  81 reparse_free(nvlist_t *nvl)
  82 {
  83         if (nvl)
  84                 nvlist_free(nvl);
  85 }
  86 
  87 /*
  88  * reparse_parse()
  89  *
  90  * Parse the specified string and populate the nvlist with the svc_types
  91  * and data from the 'string'.  The string could be read from the reparse
  92  * point symlink body. This routine will allocate memory that must be
  93  * freed by reparse_free().
  94  *
  95  * If ok return 0 and the nvlist is populated, otherwise return error code.
  96  */
  97 int
  98 reparse_parse(const char *string, nvlist_t *nvl)
  99 {
 100         int err;
 101 
 102         if (string == NULL || nvl == NULL)
 103                 return (EINVAL);
 104 
 105         if ((err = reparse_validate(string)) != 0)
 106                 return (err);
 107 
 108         if ((err = reparse_create_nvlist(string, nvl)) != 0)
 109                 return (err);
 110 
 111         return (0);
 112 }
 113 
 114 static char *
 115 reparse_skipspace(char *cp)
 116 {
 117         while ((*cp) && (*cp == ' ' || *cp == '\t'))
 118                 cp++;
 119         return (cp);
 120 }
 121 
 122 static boolean_t
 123 reparse_validate_svctype(char *svc_str)
 124 {
 125         int nx, ix, len;
 126 
 127         if (svc_str == NULL)
 128                 return (B_FALSE);
 129 
 130         len = strlen(svc_str);
 131         for (ix = 0; ix < len; ix++) {
 132                 for (nx = 0; nx < sizeof (svctype_invalid_chars); nx++) {
 133                         if (svc_str[ix] == svctype_invalid_chars[nx])
 134                                 return (B_FALSE);
 135                 }
 136         }
 137         return (B_TRUE);
 138 }
 139 
 140 static boolean_t
 141 reparse_validate_svc_token(char *svc_token)
 142 {
 143         char save_c, *cp;
 144 
 145         if (svc_token == NULL)
 146                 return (B_FALSE);
 147         if ((cp = strchr(svc_token, ':')) == NULL)
 148                 return (B_FALSE);
 149 
 150         save_c = *cp;
 151         *cp = '\0';
 152 
 153         /*
 154          * make sure service type and service data are non-empty string.
 155          */
 156         if (strlen(svc_token) == 0 || strlen(cp + 1) == 0) {
 157                 *cp = save_c;
 158                 return (B_FALSE);
 159         }
 160 
 161         *cp = save_c;
 162         return (B_TRUE);
 163 }
 164 
 165 /*
 166  * Format of reparse data:
 167  * @{REPARSE@{servicetype:data} [@{servicetype:data}] ...}
 168  * REPARSE_TAG_STR@{REPARSE_TOKEN} [@{REPARSE_TOKEN}] ... REPARSE_TAG_END
 169  *
 170  * Validating reparse data:
 171  *      . check for valid length of reparse data
 172  *      . check for valid reparse data format
 173  * Return 0 if OK else return error code.
 174  */
 175 int
 176 reparse_validate(const char *string)
 177 {
 178         return (reparse_validate_create_nvlist(string, NULL));
 179 }
 180 
 181 /*
 182  * reparse_validate_create_nvlist
 183  *
 184  * dual-purpose function:
 185  *     . Validate a reparse data string.
 186  *     . Validate a reparse data string and parse the data
 187  *       into a nvlist.
 188  */
 189 static int
 190 reparse_validate_create_nvlist(const char *string, nvlist_t *nvl)
 191 {
 192         int err, tcnt;
 193         char *reparse_data, save_c, save_e, *save_e_ptr, *cp, *s_str, *e_str;
 194 
 195         if (string == NULL)
 196                 return (EINVAL);
 197 
 198         if (strlen(string) >= MAXREPARSELEN)
 199                 return (ENAMETOOLONG);
 200 
 201         if ((reparse_data = strdup(string)) == NULL)
 202                 return (ENOMEM);
 203 
 204         /* check FS_REPARSE_TAG_STR */
 205         if (strncmp(reparse_data, FS_REPARSE_TAG_STR,
 206             strlen(FS_REPARSE_TAG_STR))) {
 207                 strfree(reparse_data);
 208                 return (EINVAL);
 209         }
 210 
 211         /* locate FS_REPARSE_TAG_END_CHAR */
 212         if ((cp = strrchr(reparse_data, FS_REPARSE_TAG_END_CHAR)) == NULL) {
 213                 strfree(reparse_data);
 214                 return (EINVAL);
 215         }
 216         save_e = *cp;
 217         save_e_ptr = cp;
 218         *cp = '\0';
 219 
 220         e_str = cp;
 221         cp++;           /* should point to NULL, or spaces */
 222 
 223         cp = reparse_skipspace(cp);
 224         if (*cp) {
 225                 *save_e_ptr = save_e;
 226                 strfree(reparse_data);
 227                 return (EINVAL);
 228         }
 229 
 230         /* skip FS_REPARSE_TAG_STR */
 231         s_str = reparse_data + strlen(FS_REPARSE_TAG_STR);
 232 
 233         /* skip spaces after FS_REPARSE_TAG_STR */
 234         s_str = reparse_skipspace(s_str);
 235 
 236         tcnt = 0;
 237         while (s_str < e_str) {
 238                 /* check FS_TOKEN_START_STR */
 239                 if (strncmp(s_str, FS_TOKEN_START_STR,
 240                     strlen(FS_TOKEN_START_STR))) {
 241                         *save_e_ptr = save_e;
 242                         strfree(reparse_data);
 243                         return (EINVAL);
 244                 }
 245 
 246                 /* skip over FS_TOKEN_START_STR */
 247                 s_str += strlen(FS_TOKEN_START_STR);
 248 
 249                 /* locate FS_TOKEN_END_STR */
 250                 if ((cp = strstr(s_str, FS_TOKEN_END_STR)) == NULL) {
 251                         *save_e_ptr = save_e;
 252                         strfree(reparse_data);
 253                         return (EINVAL);
 254                 }
 255 
 256                 tcnt++;
 257                 save_c = *cp;
 258                 *cp = '\0';
 259 
 260                 /* check for valid characters in service type */
 261                 if (reparse_validate_svctype(s_str) == B_FALSE) {
 262                         *cp = save_c;
 263                         *save_e_ptr = save_e;
 264                         strfree(reparse_data);
 265                         return (EINVAL);
 266                 }
 267 
 268                 if (strlen(s_str) == 0) {
 269                         *cp = save_c;
 270                         *save_e_ptr = save_e;
 271                         strfree(reparse_data);
 272                         return (EINVAL);
 273                 }
 274 
 275                 if (reparse_validate_svc_token(s_str) == B_FALSE) {
 276                         *cp = save_c;
 277                         *save_e_ptr = save_e;
 278                         strfree(reparse_data);
 279                         return (EINVAL);
 280                 }
 281 
 282                 /* create a nvpair entry */
 283                 if (nvl != NULL &&
 284                     (err = reparse_add_nvpair(s_str, nvl)) != 0) {
 285                         *cp = save_c;
 286                         *save_e_ptr = save_e;
 287                         strfree(reparse_data);
 288                         return (err);
 289                 }
 290 
 291                 *cp = save_c;
 292 
 293                 /* skip over FS_TOKEN_END_STR */
 294                 cp += strlen(FS_TOKEN_END_STR);
 295                 cp = reparse_skipspace(cp);
 296                 s_str = cp;
 297         }
 298         *save_e_ptr = save_e;
 299         strfree(reparse_data);
 300 
 301         return (tcnt ? 0 : EINVAL);
 302 }
 303 
 304 static int
 305 reparse_add_nvpair(char *token, nvlist_t *nvl)
 306 {
 307         int err;
 308         char save_c, *cp;
 309 
 310         if ((cp = strchr(token, ':')) == NULL)
 311                 return (EINVAL);
 312 
 313         save_c = *cp;
 314         *cp = '\0';
 315         err = nvlist_add_string(nvl, token, cp + 1);
 316         *cp = save_c;
 317 
 318         return (err);
 319 }
 320 
 321 static int
 322 reparse_create_nvlist(const char *string, nvlist_t *nvl)
 323 {
 324         if (nvl == NULL)
 325                 return (EINVAL);
 326 
 327         return (reparse_validate_create_nvlist(string, nvl));
 328 }
--- EOF ---