reactos/ntoskrnl/fs/dbcsname.c

   1 /* $Id$
   2  *
   3  * reactos/ntoskrnl/fs/dbcsname.c
   4  *
   5  */
   6
   7 #include <ntoskrnl.h>
   8
   9 /* DATA ********************************************************************/
  10
  11 static UCHAR LegalAnsiCharacterArray[] =
  12 {
  13   0,                            /* CTRL+@, 0x00 */
  14   0,                            /* CTRL+A, 0x01 */
  15   0,                            /* CTRL+B, 0x02 */
  16   0,                            /* CTRL+C, 0x03 */
  17   0,                            /* CTRL+D, 0x04 */
  18   0,                            /* CTRL+E, 0x05 */
  19   0,                            /* CTRL+F, 0x06 */
  20   0,                            /* CTRL+G, 0x07 */
  21   0,                            /* CTRL+H, 0x08 */
  22   0,                            /* CTRL+I, 0x09 */
  23   0,                            /* CTRL+J, 0x0a */
  24   0,                            /* CTRL+K, 0x0b */
  25   0,                            /* CTRL+L, 0x0c */
  26   0,                            /* CTRL+M, 0x0d */
  27   0,                            /* CTRL+N, 0x0e */
  28   0,                            /* CTRL+O, 0x0f */
  29   0,                            /* CTRL+P, 0x10 */
  30   0,                            /* CTRL+Q, 0x11 */
  31   0,                            /* CTRL+R, 0x12 */
  32   0,                            /* CTRL+S, 0x13 */
  33   0,                            /* CTRL+T, 0x14 */
  34   0,                            /* CTRL+U, 0x15 */
  35   0,                            /* CTRL+V, 0x16 */
  36   0,                            /* CTRL+W, 0x17 */
  37   0,                            /* CTRL+X, 0x18 */
  38   0,                            /* CTRL+Y, 0x19 */
  39   0,                            /* CTRL+Z, 0x1a */
  40   0,                            /* CTRL+[, 0x1b */
  41   0,                            /* CTRL+\, 0x1c */
  42   0,                            /* CTRL+], 0x1d */
  43   0,                            /* CTRL+^, 0x1e */
  44   0,                            /* CTRL+_, 0x1f */
  45   0,                            /* ` ', 0x20 */
  46   0,                            /* `!', 0x21 */
  47   FSRTL_WILD_CHARACTER,         /* `"', 0x22 */
  48   0,                            /* `#', 0x23 */
  49   0,                            /* `$', 0x24 */
  50   0,                            /* `%', 0x25 */
  51   0,                            /* `&', 0x26 */
  52   0,                            /* `'', 0x27 */
  53   0,                            /* `(', 0x28 */
  54   0,                            /* `)', 0x29 */
  55   FSRTL_WILD_CHARACTER,         /* `*', 0x2a */
  56   0,                            /* `+', 0x2b */
  57   0,                            /* `,', 0x2c */
  58   0,                            /* `-', 0x2d */
  59   0,                            /* `.', 0x2e */
  60   0,                            /* `/', 0x2f */
  61   0,                            /* `0', 0x30 */
  62   0,                            /* `1', 0x31 */
  63   0,                            /* `2', 0x32 */
  64   0,                            /* `3', 0x33 */
  65   0,                            /* `4', 0x34 */
  66   0,                            /* `5', 0x35 */
  67   0,                            /* `6', 0x36 */
  68   0,                            /* `7', 0x37 */
  69   0,                            /* `8', 0x38 */
  70   0,                            /* `9', 0x39 */
  71   0,                            /* `:', 0x3a */
  72   0,                            /* `;', 0x3b */
  73   FSRTL_WILD_CHARACTER,         /* `<', 0x3c */
  74   0,                            /* `=', 0x3d */
  75   FSRTL_WILD_CHARACTER,         /* `>', 0x3e */
  76   FSRTL_WILD_CHARACTER,         /* `?', 0x3f */
  77   FSRTL_WILD_CHARACTER,         /* `@', 0x40 */
  78   0,                            /* `A', 0x41 */
  79   0,                            /* `B', 0x42 */
  80   0,                            /* `C', 0x43 */
  81   0,                            /* `D', 0x44 */
  82   0,                            /* `E', 0x45 */
  83   0,                            /* `F', 0x46 */
  84   0,                            /* `G', 0x47 */
  85   0,                            /* `H', 0x48 */
  86   0,                            /* `I', 0x49 */
  87   0,                            /* `J', 0x4a */
  88   0,                            /* `K', 0x4b */
  89   0,                            /* `L', 0x4c */
  90   0,                            /* `M', 0x4d */
  91   0,                            /* `N', 0x4e */
  92   0,                            /* `O', 0x4f */
  93   0,                            /* `P', 0x50 */
  94   0,                            /* `Q', 0x51 */
  95   0,                            /* `R', 0x52 */
  96   0,                            /* `S', 0x53 */
  97   0,                            /* `T', 0x54 */
  98   0,                            /* `U', 0x55 */
  99   0,                            /* `V', 0x56 */
 100   0,                            /* `W', 0x57 */
 101   0,                            /* `X', 0x58 */
 102   0,                            /* `Y', 0x59 */
 103   0,                            /* `Z', 0x5a */
 104   0,                            /* `[', 0x5b */
 105   0,                            /* `\', 0x5c */
 106   0,                            /* `]', 0x5d */
 107   0,                            /* `^', 0x5e */
 108   0,                            /* `_', 0x5f */
 109   0,                            /* ``', 0x60 */
 110   0,                            /* `a', 0x61 */
 111   0,                            /* `b', 0x62 */
 112   0,                            /* `c', 0x63 */
 113   0,                            /* `d', 0x64 */
 114   0,                            /* `e', 0x65 */
 115   0,                            /* `f', 0x66 */
 116   0,                            /* `g', 0x67 */
 117   0,                            /* `h', 0x68 */
 118   0,                            /* `i', 0x69 */
 119   0,                            /* `j', 0x6a */
 120   0,                            /* `k', 0x6b */
 121   0,                            /* `l', 0x6c */
 122   0,                            /* `m', 0x6d */
 123   0,                            /* `n', 0x6e */
 124   0,                            /* `o', 0x6f */
 125   0,                            /* `p', 0x70 */
 126   0,                            /* `q', 0x71 */
 127   0,                            /* `r', 0x72 */
 128   0,                            /* `s', 0x73 */
 129   0,                            /* `t', 0x74 */
 130   0,                            /* `u', 0x75 */
 131   0,                            /* `v', 0x76 */
 132   0,                            /* `w', 0x77 */
 133   0,                            /* `x', 0x78 */
 134   0,                            /* `y', 0x79 */
 135   0,                            /* `z', 0x7a */
 136   0,                            /* `{', 0x7b */
 137   0,                            /* `|', 0x7c */
 138   0,                            /* `}', 0x7d */
 139   0,                            /* `~', 0x7e */
 140   0                             /* 0x7f */
 141 };
 142
 143 PUCHAR EXPORTED FsRtlLegalAnsiCharacterArray = LegalAnsiCharacterArray;
 144
 145
 146 /* FUNCTIONS ***************************************************************/
 147
 148 /**********************************************************************
 149  * NAME                                                 EXPORTED
 150  *      FsRtlDissectDbcs@16
 151  *
 152  *      Dissects a given path name into first and remaining part.
 153  *
 154  * ARGUMENTS
 155  *      Name
 156  *              ANSI string to dissect.
 157  *
 158  *      FirstPart
 159  *              Pointer to user supplied ANSI_STRING, that will
 160  *              later point to the first part of the original name.
 161  *
 162  *      RemainingPart
 163  *              Pointer to user supplied ANSI_STRING, that will
 164  *              later point to the remaining part of the original name.
 165  *
 166  * RETURN VALUE
 167  *      None
 168  *
 169  * EXAMPLE
 170  *      Name:           \test1\test2\test3
 171  *      FirstPart:      test1
 172  *      RemainingPart:  test2\test3
 173  *
 174  * @implemented
 175  */
 176 VOID STDCALL
 177 FsRtlDissectDbcs(IN ANSI_STRING Name,
 178                  OUT PANSI_STRING FirstPart,
 179                  OUT PANSI_STRING RemainingPart)
 180 {
 181     ULONG i;
 182     ULONG FirstLoop;
 183
 184     /* Initialize the Outputs */
 185     RtlZeroMemory(&FirstPart, sizeof(ANSI_STRING));
 186     RtlZeroMemory(&RemainingPart, sizeof(ANSI_STRING));
 187
 188     /* Bail out if empty */
 189     if (!Name.Length) return;
 190
 191     /* Ignore backslash */
 192     if (Name.Buffer[0] == '\\') {
 193         i = 1;
 194     } else {
 195         i = 0;
 196     }
 197
 198     /* Loop until we find a backslash */
 199     for (FirstLoop = i;i < Name.Length;i++) {
 200         if (Name.Buffer[i] != '\\') break;
 201         if (FsRtlIsLeadDbcsCharacter(Name.Buffer[i])) i++;
 202     }
 203
 204     /* Now we have the First Part */
 205     FirstPart->Length = (i-FirstLoop);
 206     FirstPart->MaximumLength = FirstPart->Length; /* +2?? */
 207     FirstPart->Buffer = &Name.Buffer[FirstLoop];
 208
 209     /* Make the second part if something is still left */
 210     if (i<Name.Length) {
 211         RemainingPart->Length = (Name.Length - (i+1));
 212         RemainingPart->MaximumLength = RemainingPart->Length; /* +2?? */
 213         RemainingPart->Buffer = &Name.Buffer[i+1];
 214     }
 215
 216     return;
 217 }
 218
 219
 220 /**********************************************************************
 221  * NAME                                                 EXPORTED
 222  *      FsRtlDoesDbcsContainWildCards@4
 223  *
 224  * DESCRIPTION
 225  *
 226  * ARGUMENTS
 227  *
 228  * RETURN VALUE
 229  *
 230  * @implemented
 231  */
 232 BOOLEAN STDCALL
 233 FsRtlDoesDbcsContainWildCards(IN PANSI_STRING Name)
 234 {
 235     ULONG i;
 236
 237     /* Check every character */
 238     for (i=0;i < Name->Length;i++) {
 239
 240         /* First make sure it's not the Lead DBCS */
 241         if (FsRtlIsLeadDbcsCharacter(Name->Buffer[i])) {
 242             i++;
 243         } else if (FsRtlIsAnsiCharacterWild(Name->Buffer[i])) {
 244             /* Now return if it has a Wilcard */
 245             return TRUE;
 246         }
 247     }
 248
 249     /* We didn't return above...so none found */
 250     return FALSE;
 251 }
 252
 253 /**********************************************************************
 254  * NAME                                                 EXPORTED
 255  *      FsRtlIsDbcsInExpression@8
 256  *
 257  * DESCRIPTION
 258  *
 259  * ARGUMENTS
 260  *
 261  * RETURN VALUE
 262  *
 263  * @unimplemented
 264  */
 265 BOOLEAN
 266 STDCALL
 267 FsRtlIsDbcsInExpression (
 268         DWORD   Unknown0,
 269         DWORD   Unknown1
 270         )
 271 {
 272         return FALSE;
 273 }
 274
 275
 276 /**********************************************************************
 277  * NAME                                                 EXPORTED
 278  *      FsRtlIsFatDbcsLegal@20
 279  *
 280  * DESCRIPTION
 281  *
 282  * ARGUMENTS
 283  *
 284  * RETURN VALUE
 285  *
 286  * @unimplemented
 287  */
 288 BOOLEAN
 289 STDCALL
 290 FsRtlIsFatDbcsLegal (
 291         DWORD   Unknown0,
 292         DWORD   Unknown1,
 293         DWORD   Unknown2,
 294         DWORD   Unknown3,
 295         DWORD   Unknown4
 296         )
 297 {
 298         return FALSE;
 299 }
 300
 301
 302 /**********************************************************************
 303  * NAME                                                 EXPORTED
 304  *      FsRtlIsHpfsDbcsLegal@20
 305  *
 306  * DESCRIPTION
 307  *
 308  * ARGUMENTS
 309  *
 310  * RETURN VALUE
 311  *
 312  * @unimplemented
 313  */
 314 BOOLEAN
 315 STDCALL
 316 FsRtlIsHpfsDbcsLegal (
 317         DWORD   Unknown0,
 318         DWORD   Unknown1,
 319         DWORD   Unknown2,
 320         DWORD   Unknown3,
 321         DWORD   Unknown4
 322         )
 323 {
 324         return FALSE;
 325 }
 326
 327 /* EOF */