usr/src/common/fsreparse/fs_reparse.c

   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         nvlist_free(nvl);
  84 }
  85
  86 /*
  87  * reparse_parse()
  88  *
  89  * Parse the specified string and populate the nvlist with the svc_types
  90  * and data from the 'string'.  The string could be read from the reparse
  91  * point symlink body. This routine will allocate memory that must be
  92  * freed by reparse_free().
  93  *
  94  * If ok return 0 and the nvlist is populated, otherwise return error code.
  95  */
  96 int
  97 reparse_parse(const char *string, nvlist_t *nvl)
  98 {
  99         int err;
 100
 101         if (string == NULL || nvl == NULL)
 102                 return (EINVAL);
 103
 104         if ((err = reparse_validate(string)) != 0)
 105                 return (err);
 106
 107         if ((err = reparse_create_nvlist(string, nvl)) != 0)
 108                 return (err);
 109
 110         return (0);
 111 }
 112
 113 static char *
 114 reparse_skipspace(char *cp)
 115 {
 116         while ((*cp) && (*cp == ' ' || *cp == '\t'))
 117                 cp++;
 118         return (cp);
 119 }
 120
 121 static boolean_t
 122 reparse_validate_svctype(char *svc_str)
 123 {
 124         int nx, ix, len;
 125
 126         if (svc_str == NULL)
 127                 return (B_FALSE);
 128
 129         len = strlen(svc_str);
 130         for (ix = 0; ix < len; ix++) {
 131                 for (nx = 0; nx < sizeof (svctype_invalid_chars); nx++) {
 132                         if (svc_str[ix] == svctype_invalid_chars[nx])
 133                                 return (B_FALSE);
 134                 }
 135         }
 136         return (B_TRUE);
 137 }
 138
 139 static boolean_t
 140 reparse_validate_svc_token(char *svc_token)
 141 {
 142         char save_c, *cp;
 143
 144         if (svc_token == NULL)
 145                 return (B_FALSE);
 146         if ((cp = strchr(svc_token, ':')) == NULL)
 147                 return (B_FALSE);
 148
 149         save_c = *cp;
 150         *cp = '\0';
 151
 152         /*
 153          * make sure service type and service data are non-empty string.
 154          */
 155         if (strlen(svc_token) == 0 || strlen(cp + 1) == 0) {
 156                 *cp = save_c;
 157                 return (B_FALSE);
 158         }
 159
 160         *cp = save_c;
 161         return (B_TRUE);
 162 }
 163
 164 /*
 165  * Format of reparse data:
 166  * @{REPARSE@{servicetype:data} [@{servicetype:data}] ...}
 167  * REPARSE_TAG_STR@{REPARSE_TOKEN} [@{REPARSE_TOKEN}] ... REPARSE_TAG_END
 168  *
 169  * Validating reparse data:
 170  *      . check for valid length of reparse data
 171  *      . check for valid reparse data format
 172  * Return 0 if OK else return error code.
 173  */
 174 int
 175 reparse_validate(const char *string)
 176 {
 177         return (reparse_validate_create_nvlist(string, NULL));
 178 }
 179
 180 /*
 181  * reparse_validate_create_nvlist
 182  *
 183  * dual-purpose function:
 184  *     . Validate a reparse data string.
 185  *     . Validate a reparse data string and parse the data
 186  *       into a nvlist.
 187  */
 188 static int
 189 reparse_validate_create_nvlist(const char *string, nvlist_t *nvl)
 190 {
 191         int err, tcnt;
 192         char *reparse_data, save_c, save_e, *save_e_ptr, *cp, *s_str, *e_str;
 193
 194         if (string == NULL)
 195                 return (EINVAL);
 196
 197         if (strlen(string) >= MAXREPARSELEN)
 198                 return (ENAMETOOLONG);
 199
 200         if ((reparse_data = strdup(string)) == NULL)
 201                 return (ENOMEM);
 202
 203         /* check FS_REPARSE_TAG_STR */
 204         if (strncmp(reparse_data, FS_REPARSE_TAG_STR,
 205             strlen(FS_REPARSE_TAG_STR))) {
 206                 strfree(reparse_data);
 207                 return (EINVAL);
 208         }
 209
 210         /* locate FS_REPARSE_TAG_END_CHAR */
 211         if ((cp = strrchr(reparse_data, FS_REPARSE_TAG_END_CHAR)) == NULL) {
 212                 strfree(reparse_data);
 213                 return (EINVAL);
 214         }
 215         save_e = *cp;
 216         save_e_ptr = cp;
 217         *cp = '\0';
 218
 219         e_str = cp;
 220         cp++;           /* should point to NULL, or spaces */
 221
 222         cp = reparse_skipspace(cp);
 223         if (*cp) {
 224                 *save_e_ptr = save_e;
 225                 strfree(reparse_data);
 226                 return (EINVAL);
 227         }
 228
 229         /* skip FS_REPARSE_TAG_STR */
 230         s_str = reparse_data + strlen(FS_REPARSE_TAG_STR);
 231
 232         /* skip spaces after FS_REPARSE_TAG_STR */
 233         s_str = reparse_skipspace(s_str);
 234
 235         tcnt = 0;
 236         while (s_str < e_str) {
 237                 /* check FS_TOKEN_START_STR */
 238                 if (strncmp(s_str, FS_TOKEN_START_STR,
 239                     strlen(FS_TOKEN_START_STR))) {
 240                         *save_e_ptr = save_e;
 241                         strfree(reparse_data);
 242                         return (EINVAL);
 243                 }
 244
 245                 /* skip over FS_TOKEN_START_STR */
 246                 s_str += strlen(FS_TOKEN_START_STR);
 247
 248                 /* locate FS_TOKEN_END_STR */
 249                 if ((cp = strstr(s_str, FS_TOKEN_END_STR)) == NULL) {
 250                         *save_e_ptr = save_e;
 251                         strfree(reparse_data);
 252                         return (EINVAL);
 253                 }
 254
 255                 tcnt++;
 256                 save_c = *cp;
 257                 *cp = '\0';
 258
 259                 /* check for valid characters in service type */
 260                 if (reparse_validate_svctype(s_str) == B_FALSE) {
 261                         *cp = save_c;
 262                         *save_e_ptr = save_e;
 263                         strfree(reparse_data);
 264                         return (EINVAL);
 265                 }
 266
 267                 if (strlen(s_str) == 0) {
 268                         *cp = save_c;
 269                         *save_e_ptr = save_e;
 270                         strfree(reparse_data);
 271                         return (EINVAL);
 272                 }
 273
 274                 if (reparse_validate_svc_token(s_str) == B_FALSE) {
 275                         *cp = save_c;
 276                         *save_e_ptr = save_e;
 277                         strfree(reparse_data);
 278                         return (EINVAL);
 279                 }
 280
 281                 /* create a nvpair entry */
 282                 if (nvl != NULL &&
 283                     (err = reparse_add_nvpair(s_str, nvl)) != 0) {
 284                         *cp = save_c;
 285                         *save_e_ptr = save_e;
 286                         strfree(reparse_data);
 287                         return (err);
 288                 }
 289
 290                 *cp = save_c;
 291
 292                 /* skip over FS_TOKEN_END_STR */
 293                 cp += strlen(FS_TOKEN_END_STR);
 294                 cp = reparse_skipspace(cp);
 295                 s_str = cp;
 296         }
 297         *save_e_ptr = save_e;
 298         strfree(reparse_data);
 299
 300         return (tcnt ? 0 : EINVAL);
 301 }
 302
 303 static int
 304 reparse_add_nvpair(char *token, nvlist_t *nvl)
 305 {
 306         int err;
 307         char save_c, *cp;
 308
 309         if ((cp = strchr(token, ':')) == NULL)
 310                 return (EINVAL);
 311
 312         save_c = *cp;
 313         *cp = '\0';
 314         err = nvlist_add_string(nvl, token, cp + 1);
 315         *cp = save_c;
 316
 317         return (err);
 318 }
 319
 320 static int
 321 reparse_create_nvlist(const char *string, nvlist_t *nvl)
 322 {
 323         if (nvl == NULL)
 324                 return (EINVAL);
 325
 326         return (reparse_validate_create_nvlist(string, nvl));
 327 }