lib/ntdll/rtl/dos8dot3.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2002 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /* $Id$
  20  *
  21  * COPYRIGHT:       See COPYING in the top level directory
  22  * PROJECT:         ReactOS system libraries
  23  * FILE:            lib/ntdll/rtl/dos8dot3.c
  24  * PURPOSE:         Short name (8.3 name) functions
  25  * PROGRAMMER:      Eric Kohl
  26  */
  27
  28 /* INCLUDES ******************************************************************/
  29
  30 #include <ddk/ntddk.h>
  31 #include <ntos/minmax.h>
  32
  33 //#define NDEBUG
  34 #include <ntdll/ntdll.h>
  35
  36
  37 /* CONSTANTS *****************************************************************/
  38
  39 const PWCHAR RtlpShortIllegals = L" ;+=[]',\"*\\<>/?:|";
  40
  41
  42 /* FUNCTIONS *****************************************************************/
  43
  44 static BOOLEAN
  45 RtlpIsShortIllegal(WCHAR Char)
  46 {
  47   int i;
  48
  49   for (i = 0; RtlpShortIllegals[i]; i++)
  50     {
  51       if (Char == RtlpShortIllegals[i])
  52         return(TRUE);
  53     }
  54
  55   return(FALSE);
  56 }
  57
  58
  59 /*
  60  * @implemented
  61  */
  62 VOID STDCALL
  63 RtlGenerate8dot3Name(IN PUNICODE_STRING Name,
  64                      IN BOOLEAN AllowExtendedCharacters,
  65                      IN OUT PGENERATE_NAME_CONTEXT Context,
  66                      OUT PUNICODE_STRING Name8dot3)
  67 {
  68   WCHAR NameBuffer[8];
  69   WCHAR ExtBuffer[4];
  70   USHORT StrLength;
  71   USHORT NameLength;
  72   USHORT ExtLength;
  73   USHORT CopyLength;
  74   USHORT DotPos;
  75   USHORT i, j;
  76   USHORT CurrentIndex;
  77
  78   memset(NameBuffer, 0, sizeof(NameBuffer));
  79   memset(ExtBuffer, 0, sizeof(ExtBuffer));
  80
  81   StrLength = Name->Length / sizeof(WCHAR);
  82
  83   DPRINT("StrLength: %hu\n", StrLength);
  84
  85   /* Find last dot in Name */
  86   DotPos = 0;
  87   for (i = 0; i < StrLength; i++)
  88     {
  89       if (Name->Buffer[i] == L'.')
  90         {
  91           DotPos = i;
  92         }
  93     }
  94
  95   if (DotPos == 0)
  96     {
  97       DotPos = i;
  98     }
  99
 100   DPRINT("DotPos: %hu\n", DotPos);
 101
 102   /* Copy name (6 valid characters max) */
 103   for (i = 0, NameLength = 0; NameLength < 6 && i < DotPos; i++)
 104     {
 105       if ((!RtlpIsShortIllegal(Name->Buffer[i])) &&
 106           (Name->Buffer[i] != L'.'))
 107         {
 108           NameBuffer[NameLength++] = RtlUpcaseUnicodeChar(Name->Buffer[i]);
 109         }
 110     }
 111   DPRINT("NameBuffer: '%.08S'\n", NameBuffer);
 112   DPRINT("NameLength: %hu\n", NameLength);
 113
 114   /* Copy extension (4 valid characters max) */
 115   if (DotPos < StrLength)
 116     {
 117       for (i = DotPos, ExtLength = 0; ExtLength < 4 && i < StrLength; i++)
 118         {
 119           if (!RtlpIsShortIllegal(Name->Buffer[i]))
 120             {
 121               ExtBuffer[ExtLength++] = RtlUpcaseUnicodeChar(Name->Buffer[i]);
 122             }
 123         }
 124     }
 125
 126   DPRINT("ExtBuffer: '%.04S'\n", ExtBuffer);
 127   DPRINT("ExtLength: %hu\n", ExtLength);
 128
 129   /* Determine next index */
 130   CurrentIndex = Context->LastIndexValue;
 131   CopyLength = min(NameLength, (CurrentIndex < 10) ? 6 : 5);
 132
 133   if ((Context->NameLength == CopyLength) &&
 134       (wcsncmp(Context->NameBuffer, NameBuffer, CopyLength) == 0) &&
 135       (Context->ExtensionLength == ExtLength) &&
 136       (wcsncmp(Context->ExtensionBuffer, ExtBuffer, ExtLength) == 0))
 137     CurrentIndex++;
 138   else
 139     CurrentIndex = 1;
 140
 141   DPRINT("CurrentIndex: %hu\n", CurrentIndex);
 142
 143   /* Build the short name */
 144   for (i = 0; i < CopyLength; i++)
 145     {
 146       Name8dot3->Buffer[i] = NameBuffer[i];
 147     }
 148
 149   Name8dot3->Buffer[i++] = L'~';
 150   if (CurrentIndex >= 10)
 151     Name8dot3->Buffer[i++] = (CurrentIndex / 10) + L'0';
 152   Name8dot3->Buffer[i++] = (CurrentIndex % 10) + L'0';
 153
 154   for (j = 0; j < ExtLength; i++, j++)
 155     {
 156       Name8dot3->Buffer[i] = ExtBuffer[j];
 157     }
 158
 159   Name8dot3->Length = i * sizeof(WCHAR);
 160
 161   DPRINT("Name8dot3: '%wZ'\n", Name8dot3);
 162
 163   /* Update context */
 164   Context->NameLength = CopyLength;
 165   for (i = 0; i < CopyLength; i++)
 166     {
 167       Context->NameBuffer[i] = NameBuffer[i];
 168     }
 169
 170   Context->ExtensionLength = ExtLength;
 171   for (i = 0; i < ExtLength; i++)
 172     {
 173       Context->ExtensionBuffer[i] = ExtBuffer[i];
 174     }
 175
 176   Context->LastIndexValue = CurrentIndex;
 177 }
 178
 179
 180 /*
 181  * @implemented
 182  */
 183 BOOLEAN STDCALL
 184 RtlIsNameLegalDOS8Dot3(IN PUNICODE_STRING UnicodeName,
 185                        IN PANSI_STRING AnsiName,
 186                        OUT PBOOLEAN SpacesFound)
 187 {
 188   PANSI_STRING name = AnsiName;
 189   ANSI_STRING DummyString;
 190   CHAR Buffer[12];
 191   char *str;
 192   ULONG Length;
 193   ULONG i;
 194   NTSTATUS Status;
 195   BOOLEAN HasSpace = FALSE;
 196   BOOLEAN HasDot = FALSE;
 197
 198   if (UnicodeName->Length > 24)
 199     {
 200       return(FALSE); /* name too long */
 201     }
 202
 203   if (!name)
 204     {
 205       name = &DummyString;
 206       name->Length = 0;
 207       name->MaximumLength = 12;
 208       name->Buffer = Buffer;
 209     }
 210
 211   Status = RtlUpcaseUnicodeStringToCountedOemString(name,
 212                                                     UnicodeName,
 213                                                     FALSE);
 214   if (!NT_SUCCESS(Status))
 215     {
 216       return(FALSE);
 217     }
 218
 219   Length = name->Length;
 220   str = name->Buffer;
 221
 222   if (!(Length == 1 && *str == '.') &&
 223       !(Length == 2 && *str == '.' && *(str + 1) == '.'))
 224     {
 225       for (i = 0; i < Length; i++, str++)
 226         {
 227           switch (*str)
 228             {
 229               case ' ':
 230                 HasSpace = TRUE;
 231                 break;
 232
 233               case '.':
 234                 if ((HasDot) ||                 /* two or more dots */
 235                     (i == 0) ||                 /* dot is first char */
 236                     (i + 1 == Length) ||        /* dot is last char */
 237                     (Length - i > 4) ||         /* more than 3 chars of extension */
 238                     (HasDot == FALSE && i > 8)) /* name is longer than 8 chars */
 239                   return(FALSE);
 240                 HasDot = TRUE;
 241                 break;
 242             }
 243         }
 244     }
 245
 246   /* Name is longer than 8 chars and does not have an extension */
 247   if (Length > 8 && HasDot == FALSE)
 248     {
 249       return(FALSE);
 250     }
 251
 252   if (SpacesFound)
 253     *SpacesFound = HasSpace;
 254
 255   return(TRUE);
 256 }
 257
 258 /* EOF */