/****************************************************************/
/* */
/* dosnames.c */
/* DOS-C */
/* */
/* Generic parsing functions for file name specifications */
/* */
/* Copyright (c) 1994 */
/* Pasquale J. Villani */
/* All Rights Reserved */
/* */
/* This file is part of DOS-C. */
/* */
/* DOS-C is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version */
/* 2, or (at your option) any later version. */
/* */
/* DOS-C is distributed in the hope that it will be useful, but */
/* WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See */
/* the GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public */
/* License along with DOS-C; see the file COPYING. If not, */
/* write to the Free Software Foundation, 675 Mass Ave, */
/* Cambridge, MA 02139, USA. */
/* */
/****************************************************************/
#include "../../hdr/portab.h"
/* $Logfile: D:/dos-c/src/fs/dosnames.c_v $ */
#ifndef IPL
static BYTE *dosnamesRcsId = "$Header: D:/dos-c/src/fs/dosnames.c_v 1.4 29 May 1996 21:15:12 patv $";
#endif
/*
* $Log: D:/dos-c/src/fs/dosnames.c_v $
*
* Rev 1.4 29 May 1996 21:15:12 patv
* bug fixes for v0.91a
*
* Rev 1.3 19 Feb 1996 3:20:08 patv
* Added NLS, int2f and config.sys processing
*
* Rev 1.2 01 Sep 1995 17:48:44 patv
* First GPL release.
*
* Rev 1.1 30 Jul 1995 20:50:26 patv
* Eliminated version strings in ipl
*
* Rev 1.0 02 Jul 1995 8:05:56 patv
* Initial revision.
*
*/
#include "globals.h"
#define PathSep(c) ((c)=='/'||(c)=='\\')
#define DriveChar(c) (((c)>='A'&&(c)<='Z')||((c)>='a'&&(c)<='z'))
static BOOL bFileChar(UCOUNT uChar);
VOID XlateLcase (BYTE *szFname, COUNT nChars);
VOID DosTrimPath (BYTE FAR *lpszPathNamep);
static BOOL bFileChar(UCOUNT uChar)
{
BYTE *pszValChar = ".\"/\\[]:|<>+=;,", *pszPtr;
/* Null is not a valid character */
if(NULL == uChar)
return FALSE;
/* Loop through invalid character set */
for (pszPtr = pszValChar; *pszPtr != NULL; pszPtr++)
if(uChar == *pszPtr)
return FALSE;
/* Not in excluded set, it's ok. */
return TRUE;
}
/* Should be converted to a portable version after v1.0 is released. */
VOID
XlateLcase (BYTE *szFname, COUNT nChars)
{
while(nChars--)
{
if(*szFname >= 'a' && *szFname <= 'z')
*szFname -= ('a' - 'A');
++szFname;
}
}
/* "Sometimes a cigar is just a cigar" - Sigmund Freud */
COUNT
DosNames(BYTE FAR *lpszFileName, struct dosnames FAR *lpDosname)
{
COUNT nCharCount;
BYTE FAR *lpszPath, FAR *lpszPathSep;
BYTE FAR *lpszWork;
/* Initialize the structure */
lpDosname -> dn_drive = default_drive;
*lpDosname -> dn_network =
*lpDosname -> dn_path =
*lpDosname -> dn_name = '\0';
lpszPath = lpDosname -> dn_path;
/* Start by cheking for a drive specifier ... */
if(DriveChar(*lpszFileName) && ':' == lpszFileName[1])
{
/* found a drive, fetch it and bump pointer past drive */
lpDosname -> dn_drive = *lpszFileName - 'A';
if(lpDosname -> dn_drive > 26)
lpDosname -> dn_drive -= ('a' - 'A');
lpszFileName += 2;
}
/* or for a network name specifier */
else if ('\\' == lpszFileName[1])
{
/* bump past network '\\' specifier */
lpszFileName += 2;
/* and copy network name */
for(lpszWork = lpDosname -> dn_network, nCharCount = 0;
nCharCount < NAMEMAX
&& bFileChar(*lpszFileName)
&& !PathSep(*lpszFileName);
++nCharCount)
{
*lpszWork++ = *lpszFileName++;
*lpszWork = '\0';
}
}
/* Loop through the name we got until a null terminator */
for(nCharCount = 0, lpszPath = lpszWork = lpDosname -> dn_path;
nCharCount < NAMEMAX;
++nCharCount)
{
if(!bFileChar(*lpszFileName)
&& !PathSep(*lpszFileName)
&& '.' != *lpszFileName)
break;
/* Mark the path seperator for later use. We need to */
/* split the file and the path later, so we always mark */
/* last place we saw one. */
/* NB: we mark the path because we're going to null */
/* terminate there later */
if(PathSep(*lpszFileName))
{
lpszWork = lpszPath;
*lpszPath++ = '\\';
++lpszFileName;
}
else
*lpszPath++ = *lpszFileName++;
}
*lpszPath = '\0';
/* Now that we got the path, let's seperate the file name from */
/* the dir name. */
if(lpDosname -> dn_path == lpszWork)
{
/* We never moved off the path, either it starts from */
/* root and has only a file or it's just a specifier */
/* for root. It may also be a null */
if(NULL == *lpDosname -> dn_path)
return SUCCESS;
if('\\' == *lpDosname -> dn_path)
{
if(NULL == lpDosname -> dn_path[1])
/* Done, just exit */
return SUCCESS;
/* copy the file name and return */
fstrncpy(lpDosname -> dn_name,
(lpDosname -> dn_path + 1),
FNAME_SIZE + FEXT_SIZE + 1);
lpDosname -> dn_path[1] = NULL;
return SUCCESS;
}
else
{
/* just a file specifier, make the path '.' */
fstrncpy(lpDosname -> dn_name, lpDosname -> dn_path,
FNAME_SIZE + FEXT_SIZE + 1);
fstrncpy(lpDosname -> dn_path, (BYTE FAR *)".", 1);
return SUCCESS;
}
}
else
{
/* Copy out the name and put a null in at the last */
/* place we saw a seperator. */
*lpszWork++ = NULL;
fstrncpy(lpDosname -> dn_name, lpszWork,
FNAME_SIZE + FEXT_SIZE + 1);
/* Clean up before leaving */
DosTrimPath(lpDosname -> dn_path);
return SUCCESS;
}
}
BOOL
IsDevice (BYTE *pszFileName)
{
struct dosnames Dosname;
COUNT nLen = min(strlen(pszFileName),8);
REG struct dhdr FAR *dhp = (struct dhdr FAR *)&nul_dev;
/* break up the name first */
DosNames((BYTE FAR *)pszFileName, (struct dosnames FAR *)&Dosname);
/* Test 1 - does it start with a \dev or /dev */
if((fstrcmp(Dosname.dn_name, (BYTE FAR *)"/dev") == 0)
|| (fstrcmp(Dosname.dn_name, (BYTE FAR *)"\\dev") == 0))
return TRUE;
/* Test 2 - is it on the device chain? */
for(; -1l != (LONG)dhp; dhp = dhp -> dh_next)
{
BYTE cBuffer[8];
COUNT nIdx;
/* Skip if block device */
if(!(dhp -> dh_attr & ATTR_CHAR))
continue;
/* copy to cBuffer and space fill */
for(nIdx = 0;
Dosname.dn_name[nIdx] != '.' && nIdx < nLen; ++nIdx)
cBuffer[nIdx] = Dosname.dn_name[nIdx];
for(; nIdx > 8; ++nIdx)
cBuffer[nIdx] = ' ';
/* now compare */
if(fstrncmp((BYTE FAR *)cBuffer, dhp -> dh_name, 8) == 0)
return TRUE;
}
return FALSE;
}
VOID
DosTrimPath (BYTE FAR *lpszPathNamep)
{
BYTE FAR *lpszLast, FAR *lpszNext;
COUNT nChars, flDotDot;
for(lpszLast = lpszNext = lpszPathNamep, nChars = 0;
*lpszNext != '\0' && nChars < NAMEMAX; )
{
/* Initialize flag for loop. */
flDotDot = FALSE;
/* If we are at a path seperator, check for extra path */
/* seperator, '.' and '..' to reduce. */
if(*lpszNext == '\\')
{
/* If it's '\', just move everything down one. */
if(*(lpszNext + 1) == '\\')
fstrncpy(lpszNext, lpszNext + 1, NAMEMAX);
/* also ckech for '.' and '..' and move down */
/* as appropriate. */
else if(*(lpszNext + 1) == '.')
{
if(*(lpszNext + 2) == '.'
&& *(lpszNext + 3) == '\\')
{
fstrncpy(lpszLast, lpszNext + 3, NAMEMAX);
/* bump back to the last */
/* seperator. */
lpszNext = lpszLast;
/* set lpszLast to the last one */
if(lpszLast <= lpszPathNamep)
continue;
do
{
--lpszLast;
}
while(lpszLast != lpszPathNamep
&& *lpszLast != '\\');
flDotDot = TRUE;
}
/* Note: we skip strange stuff that */
/* starts with '.' */
else if(*(lpszNext + 2) == '\\')
{
fstrncpy(lpszNext, lpszNext + 2, NAMEMAX);
}
/* If we're at theend of a string, just */
/* exit. */
else if(*(lpszNext + 2) == NULL)
return;
}
else
{
/* No '.' or '\' so mark it and bump */
/* past */
lpszLast = lpszNext++;
continue;
}
/* Done. Now set last to next to mark this */
/* instance of path seperator. */
if(!flDotDot)
lpszLast = lpszNext;
}
else
/* For all other cases, bump lpszNext for the */
/* next check */
++lpszNext;
}
}
