usr/src/common/smbsrv/smb_match.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 /*
  23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
  25  */
  26
  27 #if !defined(_KERNEL) && !defined(_FAKE_KERNEL)
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #else
  31 #include <sys/types.h>
  32 #include <sys/systm.h>
  33 #include <sys/sunddi.h>
  34 #endif
  35 #include <smbsrv/string.h>
  36 #include <smbsrv/smb.h>
  37
  38 /*
  39  * Maximum recursion depth for the wildcard match functions.
  40  * These functions may recurse when processing a '*'.
  41  */
  42 #define SMB_MATCH_DEPTH_MAX     32
  43
  44 struct match_priv {
  45         int depth;
  46         boolean_t ci;
  47 };
  48
  49 static int smb_match_private(const char *, const char *, struct match_priv *);
  50
  51 static const char smb_wildcards[] = "*?<>\"";
  52
  53 /*
  54  * Return B_TRUE if pattern contains wildcards
  55  */
  56 boolean_t
  57 smb_contains_wildcards(const char *pattern)
  58 {
  59
  60         return (strpbrk(pattern, smb_wildcards) != NULL);
  61 }
  62
  63 /*
  64  * NT-compatible file name match function.  [MS-FSA 3.1.4.4]
  65  * Returns TRUE if there is a match.
  66  */
  67 boolean_t
  68 smb_match(const char *p, const char *s, boolean_t ci)
  69 {
  70         struct match_priv priv;
  71         int rc;
  72
  73         /*
  74          * Optimize common patterns that match everything:
  75          * ("*", "<\"*")  That second one is the converted
  76          * form of "*.*" after smb_convert_wildcards() does
  77          * its work on it for an old LM client. Note that a
  78          * plain "*.*" never gets this far.
  79          */
  80         if (p[0] == '*' && p[1] == '\0')
  81                 return (B_TRUE);
  82         if (p[0] == '<' && p[1] == '\"' && p[2] == '*' && p[3] == '\0')
  83                 return (B_TRUE);
  84
  85         /*
  86          * Match string ".." as if "."  This is Windows behavior
  87          * (not mentioned in MS-FSA) that was determined using
  88          * the Samba masktest program.
  89          */
  90         if (s[0] == '.' && s[1] == '.' && s[2] == '\0')
  91                 s++;
  92
  93         /*
  94          * Optimize simple patterns (no wildcards)
  95          */
  96         if (NULL == strpbrk(p, smb_wildcards)) {
  97                 if (ci)
  98                         rc = smb_strcasecmp(p, s, 0);
  99                 else
 100                         rc = strcmp(p, s);
 101                 return (rc == 0);
 102         }
 103
 104         /*
 105          * Do real wildcard match.
 106          */
 107         priv.depth = 0;
 108         priv.ci = ci;
 109         rc = smb_match_private(p, s, &priv);
 110         return (rc == 1);
 111 }
 112
 113 /*
 114  * Internal file name match function.  [MS-FSA 3.1.4.4]
 115  * This does the full expression evaluation.
 116  *
 117  * '*' matches zero of more of any characters.
 118  * '?' matches exactly one of any character.
 119  * '<' matches any string up through the last dot or EOS.
 120  * '>' matches any one char not a dot, dot at EOS, or EOS.
 121  * '"' matches a dot, or EOS.
 122  *
 123  * Returns:
 124  *  1   match
 125  *  0   no-match
 126  * -1   no-match, error (illseq, too many wildcards in pattern, ...)
 127  *
 128  * Note that both the pattern and the string are in multi-byte form.
 129  *
 130  * The implementation of this is quite tricky.  First note that it
 131  * can call itself recursively, though it limits the recursion depth.
 132  * Each switch case in the while loop can basically do one of three
 133  * things: (a) return "Yes, match", (b) return "not a match", or
 134  * continue processing the match pattern.  The cases for wildcards
 135  * that may match a variable number of characters ('*' and '<') do
 136  * recursive calls, looking for a match of the remaining pattern,
 137  * starting at the current and later positions in the string.
 138  */
 139 static int
 140 smb_match_private(const char *pat, const char *str, struct match_priv *priv)
 141 {
 142         const char      *limit;
 143         char            pc;             /* current pattern char */
 144         int             rc;
 145         smb_wchar_t     wcpat, wcstr;   /* current wchar in pat, str */
 146         int             nbpat, nbstr;   /* multi-byte length of it */
 147
 148         if (priv->depth >= SMB_MATCH_DEPTH_MAX)
 149                 return (-1);
 150
 151         /*
 152          * Advance over one multi-byte char, used in cases like
 153          * '?' or '>' where "match one character" needs to be
 154          * interpreted as "match one multi-byte sequence".
 155          *
 156          * This macro needs to consume the semicolon following
 157          * each place it appears, so this is carefully written
 158          * as an if/else with a missing semicolon at the end.
 159          */
 160 #define ADVANCE(str) \
 161         if ((nbstr = smb_mbtowc(NULL, str, MTS_MB_CHAR_MAX)) < 1) \
 162                 return (-1); \
 163         else \
 164                 str += nbstr    /* no ; */
 165
 166         /*
 167          * We move pat forward in each switch case so that the
 168          * default case can move it by a whole multi-byte seq.
 169          */
 170         while ((pc = *pat) != '\0') {
 171                 switch (pc) {
 172
 173                 case '?':       /* exactly one of any character */
 174                         pat++;
 175                         if (*str != '\0') {
 176                                 ADVANCE(str);
 177                                 continue;
 178                         }
 179                         /* EOS: no-match */
 180                         return (0);
 181
 182                 case '*':       /* zero or more of any characters */
 183                         pat++;
 184                         /* Optimize '*' at end of pattern. */
 185                         if (*pat == '\0')
 186                                 return (1); /* match */
 187                         while (*str != '\0') {
 188                                 priv->depth++;
 189                                 rc = smb_match_private(pat, str, priv);
 190                                 priv->depth--;
 191                                 if (rc != 0)
 192                                         return (rc); /* match */
 193                                 ADVANCE(str);
 194                         }
 195                         continue;
 196
 197                 case '<':       /* any string up through the last dot or EOS */
 198                         pat++;
 199                         if ((limit = strrchr(str, '.')) != NULL)
 200                                 limit++;
 201                         while (*str != '\0' && str != limit) {
 202                                 priv->depth++;
 203                                 rc = smb_match_private(pat, str, priv);
 204                                 priv->depth--;
 205                                 if (rc != 0)
 206                                         return (rc); /* match */
 207                                 ADVANCE(str);
 208                         }
 209                         continue;
 210
 211                 case '>':       /* anything not a dot, dot at EOS, or EOS */
 212                         pat++;
 213                         if (*str == '.') {
 214                                 if (str[1] == '\0') {
 215                                         /* dot at EOS */
 216                                         str++;  /* ADVANCE over '.' */
 217                                         continue;
 218                                 }
 219                                 /* dot NOT at EOS: no-match */
 220                                 return (0);
 221                         }
 222                         if (*str != '\0') {
 223                                 /* something not a dot */
 224                                 ADVANCE(str);
 225                                 continue;
 226                         }
 227                         continue;
 228
 229                 case '\"':      /* dot, or EOS */
 230                         pat++;
 231                         if (*str == '.') {
 232                                 str++;  /* ADVANCE over '.' */
 233                                 continue;
 234                         }
 235                         if (*str == '\0') {
 236                                 continue;
 237                         }
 238                         /* something else: no-match */
 239                         return (0);
 240
 241                 default:        /* not a wildcard */
 242                         nbpat = smb_mbtowc(&wcpat, pat, MTS_MB_CHAR_MAX);
 243                         nbstr = smb_mbtowc(&wcstr, str, MTS_MB_CHAR_MAX);
 244                         /* make sure we advance */
 245                         if (nbpat < 1 || nbstr < 1)
 246                                 return (-1);
 247                         if (wcpat == wcstr) {
 248                                 pat += nbpat;
 249                                 str += nbstr;
 250                                 continue;
 251                         }
 252                         if (priv->ci) {
 253                                 wcpat = smb_tolower(wcpat);
 254                                 wcstr = smb_tolower(wcstr);
 255                                 if (wcpat == wcstr) {
 256                                         pat += nbpat;
 257                                         str += nbstr;
 258                                         continue;
 259                                 }
 260                         }
 261                         return (0); /* no-match */
 262                 }
 263         }
 264         return (*str == '\0');
 265 }