Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

configsys.c

Visit:

Last change on this file was 238, checked in by umoeller, 23 years ago
Misc fixes.
Property svn:eol-style set to `CRLF` Property svn:keywords set to `Author Date Id Revision`
File size: 41.4 KB

Rev	Line
[24]	1
	2	/*
	3	*@@sourcefile configsys.c:
	4	* contains helper functions for parsing and changing lines
	5	* in the CONFIG.SYS file.
	6	*
	7	* Some of these used to be in stringh.c. However, that
	8	* code was really old and was largely rewritten. Besides,
	9	* this fixes some bugs that have popped up in WarpIN.
	10	*
	11	* Usage: All OS/2 programs.
	12	*
	13	* Function prefixes (new with V0.81):
	14	* -- csys* CONFIG.SYS helper functions.
	15	*
	16	* Note: Version numbering in this file relates to XWorkplace version
	17	* numbering.
	18	*
	19	*@@added V0.9.7 (2001-01-15) [umoeller]
	20	*@@header "helpers\configsys.h"
	21	*/
	22
	23	/*
[196]	24	* Copyright (C) 1997-2002 Ulrich Mller.
[24]	25	* This file is part of the "XWorkplace helpers" source package.
	26	* This is free software; you can redistribute it and/or modify
	27	* it under the terms of the GNU General Public License as published
	28	* by the Free Software Foundation, in version 2 as it comes in the
	29	* "COPYING" file of the XWorkplace main distribution.
	30	* This program is distributed in the hope that it will be useful,
	31	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	32	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	33	* GNU General Public License for more details.
	34	*/
	35
	36	#define OS2EMX_PLAIN_CHAR
	37	// this is needed for "os2emx.h"; if this is defined,
	38	// emx will define PSZ as _signed_ char, otherwise
	39	// as unsigned char
	40
	41	#define INCL_DOSERRORS
	42	#include <os2.h>
	43
	44	#include <stdlib.h>
	45	#include <stdio.h>
	46	#include <string.h>
	47	#include <ctype.h>
	48	#include <math.h>
	49
	50	#include "setup.h" // code generation and debugging options
	51
	52	#include "helpers\dosh.h"
	53	#include "helpers\stringh.h"
	54	#include "helpers\xstring.h" // extended string helpers
	55
	56	#include "helpers\configsys.h" // CONFIG.SYS helpers
	57
	58	#pragma hdrstop
	59
	60	/*
	61	*@@category: Helpers\Control program helpers\CONFIG.SYS
	62	* CONFIG.SYS parsing and manipulation. See configsys.c.
	63	*/
	64
	65	/*
	66	*@@ csysLoadConfigSys:
	67	* loads a CONFIG.SYS file.
	68	*
	69	* If pcszFile is specified, that file is loaded.
	70	* If (pcszFile == NULL), this loads the system CONFIG.SYS
	71	* file (?:\CONFIG.SYS on the boot drive).
	72	*
	73	* If this returns NO_ERROR, the contents of the file
	74	* are put into ppszContents, which will then point
	75	* to a new buffer (which must be free()'d by the caller).
	76	*
	77	* Note that in that buffer, all \r\n pairs have been
	78	* converted to \n (as with fopen()).
	79	*/
	80
	81	APIRET csysLoadConfigSys(const char *pcszFile, // in: CONFIG.SYS filename or NULL
	82	PSZ *ppszContents)
	83	{
	84	APIRET arc = NO_ERROR;
	85
	86	CHAR szFile[CCHMAXPATH];
	87	if (pcszFile == NULL)
	88	{
	89	sprintf(szFile, "%c:\\CONFIG.SYS", doshQueryBootDrive());
	90	pcszFile = szFile;
	91	}
	92
[123]	93	if (!(arc = doshLoadTextFile(pcszFile,
[129]	94	ppszContents,
	95	NULL)))
[24]	96	{
	97	// convert all \r\n to \n
	98	XSTRING strBuf;
	99	xstrInitSet(&strBuf, *ppszContents);
	100	xstrConvertLineFormat(&strBuf,
	101	TRUE); // to C format
	102	*ppszContents = strBuf.psz;
	103	}
	104
[167]	105	return arc;
[24]	106	}
	107
	108	/*
	109	*@@ csysWriteConfigSys:
	110	*
	111	*@@added V0.9.7 (2001-01-15) [umoeller]
	112	*/
	113
	114	APIRET csysWriteConfigSys(const char *pcszFile, // in: CONFIG.SYS filename or NULL
	115	const char *pcszContents,
	116	PSZ pszBackup)
	117	{
	118	APIRET arc = NO_ERROR;
	119
	120	XSTRING strBuf;
	121
	122	CHAR szFile[CCHMAXPATH];
	123	if (pcszFile == NULL)
	124	{
	125	sprintf(szFile, "%c:\\CONFIG.SYS", doshQueryBootDrive());
	126	pcszFile = szFile;
	127	}
	128
	129	// convert all \n to \r\n
	130	xstrInitCopy(&strBuf, pcszContents, 0);
	131	xstrConvertLineFormat(&strBuf,
	132	FALSE); // C to OS/2 format
	133
	134	arc = doshWriteTextFile(pcszFile,
	135	strBuf.psz,
	136	NULL,
	137	pszBackup);
	138
	139	xstrClear(&strBuf);
	140
[167]	141	return arc;
[24]	142	}
	143
	144	/*
	145	*@@ csysFindKey:
	146	* finds pcszKey in pcszSearchIn.
	147	*
	148	* This is similar to strhistr, but this one makes sure the
	149	* key is at the beginning of a line. Spaces and tabs before
	150	* the key are tolerated.
	151	*
	152	* Returns NULL if the key was not found. Otherwise this
	153	* returns the exact pointer to pcszKey in pcszSearchIn
	154	* and puts the address of the first character of the line
	155	* (after \r or \n) into ppStartOfLine.
	156	*
	157	* Used by csysGetParameter/csysSetParameter; useful
	158	* for analyzing CONFIG.SYS settings.
	159	*
[71]	160	* Remarks:
	161	*
	162	* -- With pcszKey, you can either specify a CONFIG.SYS
	163	* key WITH an equals sign (e.g. search for "LIBPATH=")
	164	* or the key name only (e.g. "SET SHELL").
	165	*
	166	* Only in the latter case, this function makes sure
	167	* that the search key is complete; e.g. it will not
	168	* find "SET SHELLHANDLESINC=" then.
	169	*
	170	* -- If the line found starts with leading spaces,
	171	* *ppStartOfLine will still receive the start of
	172	* the line.
	173	* For example, if you're searching for "SET PATH"
	174	* and the PATH line is
	175	*
	176	+ " SET PATH=C:\os2"
	177	*
	178	* the first space in the line is written into
	179	* *ppStartOfLine.
	180	*
[24]	181	*@@changed V0.9.0 [umoeller]: fixed bug in that this would also return something if only the first chars matched
	182	*@@changed V0.9.0 [umoeller]: fixed bug which could cause character before pszSearchIn to be examined
	183	*@@changed V0.9.7 (2001-01-15) [umoeller]: moved this here from stringh.c; renamed from strhFindKey
	184	*@@changed V0.9.7 (2001-01-15) [umoeller]: now checking for tabs too
[63]	185	*@@changed V0.9.11 (2001-04-25) [umoeller]: this never found lines which had leading spaces, fixed
[71]	186	*@@changed V0.9.12 (2001-05-22) [umoeller]: added checks for key termination (SET SHELLHANDLESINC)
[24]	187	*/
	188
	189	PSZ csysFindKey(const char *pcszSearchIn, // in: text buffer to search
	190	const char *pcszKey, // in: key to search for (e.g. "PATH=")
	191	PSZ *ppStartOfLine, // out: start of line which contains pcszKey;
	192	// ptr can be NULL
	193	PBOOL pfIsAllUpperCase) // out: TRUE if key is completely in upper
	194	// case; ptr can be NULL
	195	{
	196	const char *p = pcszSearchIn;
	197	PSZ pReturn = NULL;
	198	ULONG ulKeyLength = strlen(pcszKey);
	199
[71]	200	BOOL fSearchKeyContainsEquals = (strchr(pcszKey, '=') != 0);
	201
[24]	202	do
	203	{
[71]	204	// find the key
	205	// (on first loop, p is start of buffer;
	206	// on subsequent loops, p is somewhere in bufer,
	207	// if we've found the key somewhere else)
	208	if (p = strhistr(p, pcszKey))
[24]	209	{
	210	// make sure the key is at the beginning of a line
	211	// by going backwards until we find a char != " "
	212	const char *pStartOfLine = p;
[63]	213
	214	// fixed this V0.9.11 (2001-04-25) [umoeller]
	215	while ( (pStartOfLine > pcszSearchIn)
	216	&& ( (*(pStartOfLine - 1) == ' ')
	217	\|\| (*(pStartOfLine - 1) == '\t') // allow tabs too
	218	)
[24]	219	)
[63]	220	--pStartOfLine;
[24]	221
	222	// if we're at the beginning of a line or
	223	// at the beginning of the buffer at all,
	224	// let's go on
	225	if ( (pStartOfLine == pcszSearchIn) // order fixed V0.9.0, Rdiger Ihle
	226	\|\| (*(pStartOfLine - 1) == '\r')
	227	\|\| (*(pStartOfLine - 1) == '\n')
	228	)
	229	{
	230	// OK, we're at the start of a line:
	231
[71]	232	// check the character AFTER the
	233	// key if it's a space or '=';
	234	// without this check, we'd find
	235	// SET SHELL= if caller is really
	236	// looking for SET SHELLHANDLESINC=,
	237	// but only do this check if the caller
	238	// doesn't have '=' in the search string
	239	// already
	240	// V0.9.12 (2001-05-22) [umoeller]
	241	CHAR c = *(p + ulKeyLength);
	242	if ( (fSearchKeyContainsEquals)
	243	\|\| (c == ' ')
	244	\|\| (c == '=')
	245	\|\| (c == '\n')
	246	\|\| (c == '\r')
	247	\|\| (c == '\t')
	248	)
[24]	249	{
[71]	250	// return address of key
	251	pReturn = (PSZ)p;
	252	// return start of line
	253	if (ppStartOfLine)
	254	*ppStartOfLine = (PSZ)pStartOfLine;
[24]	255
[71]	256	// test for all upper case?
	257	if (pfIsAllUpperCase)
[24]	258	{
[71]	259	ULONG ul = 0;
	260	*pfIsAllUpperCase = TRUE;
	261
	262	for (ul = 0;
	263	ul < ulKeyLength;
	264	ul++)
[24]	265	{
[71]	266	if (islower(*(p + ul)))
	267	{
	268	*pfIsAllUpperCase = FALSE;
	269	break; // for
	270	}
[24]	271	}
	272	}
	273
[71]	274	break; // do
	275	} // else search next key
[24]	276	} // else search next key
	277
[71]	278	p += ulKeyLength; // search on after this key
	279	// now skipping ulKeyLength V0.9.12 (2001-05-22) [umoeller]
[24]	280	}
	281	else
	282	// nothing more found:
	283	break;
	284	} while ((!pReturn) && (p != NULL) && (p != pcszSearchIn));
	285
[184]	286	return pReturn;
[24]	287	}
	288
	289	/*
	290	*@@ csysGetParameter:
	291	* searches pcszSearchIn for the key pcszKey and gets
	292	* its parameter.
	293	*
	294	* If found, it returns a pointer to the following
	295	* characters in pcszSearchIn and, if pszCopyTo != NULL,
	296	* copies the rest of the line to that buffer, of which
	297	* cbCopyTo specified the size.
	298	*
	299	* If the key is not found, NULL is returned.
	300	* String search is done by calling csysFindKey.
	301	* This is useful for querying CONFIG.SYS settings.
	302	*
	303	* <B>Example:</B>
	304	*
	305	* For the CONFIG.SYS line
	306	*
	307	+ PAUSEONERROR=YES
	308	*
	309	* this would return "YES" if you searched for "PAUSEONERROR=".
	310	*/
	311
	312	PSZ csysGetParameter(const char *pcszSearchIn, // in: text buffer to search
	313	const char *pcszKey, // in: key to search for (e.g. "PATH=")
	314	PSZ pszCopyTo, // out: key value
	315	ULONG cbCopyTo) // out: sizeof(*pszCopyTo)
	316	{
[123]	317	PSZ p,
[24]	318	prc = NULL;
	319
[123]	320	if (p = csysFindKey(pcszSearchIn, pcszKey, NULL, NULL))
[24]	321	{
	322	prc = p + strlen(pcszKey);
	323	if (pszCopyTo)
	324	{
	325	// copy to pszCopyTo
	326	ULONG cb;
[123]	327	PSZ pEOL;
	328	if (pEOL = strhFindEOL(prc, &cb))
[24]	329	{
	330	if (cb > cbCopyTo)
	331	cb = cbCopyTo-1;
	332	strhncpy0(pszCopyTo, prc, cb);
	333	}
	334	}
	335	}
	336
[184]	337	return prc;
[24]	338	}
	339
	340	/*
	341	*@@ csysSetParameter:
	342	* searches *ppszBuf for the key pszKey; if found, it
	343	* replaces the characters following this key up to the
	344	* end of the line with pszParam. If pszKey is not found in
	345	* *ppszBuf, it is appended to the file in a new line.
	346	*
	347	* If any changes are made, *ppszBuf is re-allocated.
	348	*
	349	* This function searches w/out case sensitivity.
	350	*
	351	* Returns a pointer to the new parameter inside the
	352	* reallocated buffer, or NULL if the key was not found
	353	* (and a new item was added).
	354	*
	355	* NOTE: This assumes that the file uses \n for line
	356	* breaks only (not \r\n).
	357	*
	358	@@changed V0.9.0 [umoeller]: changed function prototype to PSZ ppszSearchIn
	359	*@@changed V0.9.7 (2001-01-15) [umoeller]: fixed various bugs with the mem buffers
	360	*/
	361
	362	PSZ csysSetParameter(PSZ* ppszBuf, // in: text buffer to search
	363	const char *pcszKey, // in: key to search for (e.g. "PATH=")
	364	const char *pcszNewParam, // in: new parameter to set for key
	365	BOOL fRespectCase) // in: if TRUE, pszNewParam will
	366	// be converted to upper case if the found key is
	367	// in upper case also. pszNewParam should be in
	368	// lower case if you use this.
	369	{
	370	BOOL fIsAllUpperCase = FALSE;
[123]	371	PSZ pKey,
[24]	372	pReturn = NULL;
[123]	373	if (pKey = csysFindKey(*ppszBuf,
	374	pcszKey,
	375	NULL,
	376	&fIsAllUpperCase))
[24]	377	{
	378	// key found in file:
[91]	379	// ULONG ulOfs;
[24]	380
	381	// replace existing parameter
[123]	382	PSZ pOldParam;
	383	if (pOldParam = pKey + strlen(pcszKey))
	384	{
	385	// pOldParam now has the old parameter, which we
	386	// will overwrite now; pOldParam points into *ppszBuf
[24]	387
	388	ULONG ulOldParamOfs = pOldParam - *ppszBuf;
	389
[123]	390	PSZ pEOL;
	391	if (pEOL = strhFindEOL(pOldParam, NULL))
	392	{
	393	// pEOL now has first end-of-line after the parameter
[24]	394
	395	// char count to replace
	396	ULONG ulToReplace = pEOL - pOldParam;
	397
	398	XSTRING strBuf,
	399	strReplaceWith;
	400
	401	// ULONG ulOfs = 0;
	402	// PSZ pszOldParamCopy = strhSubstr(pOldParam, pEOL);
	403	/* (PSZ)malloc(cbOldParam+1);
	404	strncpy(pszOldCopy, pOldParam, cbOldParam);
	405	pszOldCopy[cbOldParam] = '\0'; */
	406
	407	xstrInitSet(&strBuf, *ppszBuf);
	408	// this must not be freed!
	409
	410	xstrInitCopy(&strReplaceWith, pcszNewParam, 0);
	411	// check for upper case desired?
	412	if ((fRespectCase) && (fIsAllUpperCase))
	413	strupr(strReplaceWith.psz);
	414
	415	xstrrpl(&strBuf,
	416	ulOldParamOfs,
	417	ulToReplace,
[63]	418	strReplaceWith.psz,
	419	strReplaceWith.ulLength); // adjusted V0.9.11 (2001-04-22) [umoeller]
[24]	420
	421	xstrClear(&strReplaceWith);
	422
	423	/* xstrFindReplaceC(&strBuf,
	424	&ulOfs,
	425	pszOldParamCopy,
	426	pszNewParam); */
	427
	428	// free(pszOldParamCopy);
	429
	430	// replace output buffer
	431	*ppszBuf = strBuf.psz;
	432	// return ptr into that
	433	pReturn = *ppszBuf + ulOldParamOfs;
	434	}
	435	}
	436	}
	437	else
	438	{
	439	// key not found: append to end of file
	440	XSTRING strContents;
	441	xstrInitCopy(&strContents, *ppszBuf, 0);
	442	/* PSZ pszNew = (PSZ)malloc(strlen(*ppszBuf)
	443	+ strlen(pcszKey)
	444	+ strlen(pszNewParam)
	445	+ 5); // 2 * \r\n + null byte
	446	*/
	447
	448	xstrcatc(&strContents, '\n');
	449	xstrcat(&strContents, pcszKey, 0);
	450	xstrcat(&strContents, pcszNewParam, 0);
	451	xstrcatc(&strContents, '\n');
	452	/* sprintf(pszNew, "%s\r\n%s%s\r\n",
	453	ppszBuf, pcszKey, pszNewParam); /
	454
	455	free(*ppszBuf);
	456	*ppszBuf = strContents.psz;
	457	}
	458
[184]	459	return pReturn;
[24]	460	}
	461
	462	/*
	463	*@@ csysDeleteLine:
	464	* this deletes the line in pszSearchIn which starts with
	465	* the key pszKey. Returns TRUE if the line was found and
	466	* deleted.
	467	*
	468	* This copies within pszSearchIn.
	469	*
	470	*@@changed V0.9.7 (2001-01-15) [umoeller]: fixed wrong beginning of line
	471	*/
	472
	473	BOOL csysDeleteLine(PSZ pszSearchIn, // in: buffer to search
	474	PSZ pszKey) // in: key to find
	475	{
	476	BOOL fIsAllUpperCase = FALSE;
	477	PSZ pStartOfLine = NULL;
[123]	478	PSZ pKey;
[24]	479	BOOL brc = FALSE;
	480
[123]	481	if (pKey = csysFindKey(pszSearchIn,
	482	pszKey,
	483	&pStartOfLine,
	484	&fIsAllUpperCase))
[24]	485	{
[123]	486	PSZ pEOL;
	487	if (pEOL = strhFindEOL(pKey, NULL))
[24]	488	{
[123]	489	// pEOL now has first end-of-line after the key;
[24]	490	// go to first character after EOL
	491	while ( (*pEOL)
	492	&& ( (*pEOL == '\n')
	493	\|\| (*pEOL == '\r')
	494	)
	495	)
	496	pEOL++;
	497
	498	// delete line by overwriting it with
	499	// the next line
	500	strcpy(pStartOfLine,
	501	pEOL);
	502	}
	503	else
	504	{
	505	// EOL not found: we must be at the end of the file
	506	*pKey = '\0';
	507	}
	508	brc = TRUE;
	509	}
	510
[167]	511	return brc;
[24]	512	}
	513
	514	/*
	515	*@@ csysManipulate:
	516	* makes a single CONFIG.SYS change according to the
	517	* CONFIGMANIP which was passed in.
	518	*
	519	* If the manipulation succeeded, NO_ERROR is returned
[71]	520	* and pstrChanged receives a new string describing
[24]	521	* what was changed. This can be:
	522	*
	523	* -- "DLL xxx": deleted a line containing "xxx".
	524	*
	525	* -- "DLP xxx": deleted part of line.
	526	*
	527	* -- "NWL xxx": added an all new line.
	528	*
	529	* -- "NWP xxx": added a new part to an existing line.
	530	*
	531	* This has been moved here from WarpIN so that C programs
	532	* can use these features as well.
	533	*
	534	* This returns:
	535	*
	536	* -- NO_ERROR: changed OK, or nothing happened.
	537	*
	538	* -- CFGERR_NOSEPARATOR: with CFGRPL_ADDLEFT or CFGRPL_ADDRIGHT
	539	* modes, no "=" character was found.
	540	*
	541	* -- CFGERR_MANIPULATING: error in string handling. This should
	542	* never happen, and if it does, it's a bug.
	543	*
	544	* Preconditions:
	545	*
	546	* -- This assumes that the line breaks are represented
[71]	547	* by \n ONLY. If *ppszContents has \r\n line breaks,
	548	* they must be converted to pure \n first.
[151]	549	*
	550	*@@changed V0.9.18 (2002-03-24) [umoeller]: fixed leftover duplicate ';' chars with CFGRPL_REMOVEPART
[24]	551	*/
	552
	553	APIRET csysManipulate(PSZ *ppszContents, // in/out: CONFIG.SYS text (reallocated)
	554	PCONFIGMANIP pManip, // in: CONFIG.SYS manipulation instructions
	555	PBOOL pfDirty, // out: set to TRUE if something was changed
	556	PXSTRING pstrChanged) // out: new string describing changes (must be free'd)
	557	{
	558	APIRET arc = NO_ERROR;
	559
	560	PSZ pszCommand = 0,
	561	pszArgNew = 0;
	562	BOOL fIsAllUpperCase = FALSE;
	563
	564	// The CONFIG.SYS manipulation is a six-step process,
	565	// depending on the data in the BSCfgSysManip instance.
	566	// This is an outline what needs to be done when;
	567	// the implementation follows below.
	568
	569	// 1) First find out if a line needs to be updated or deleted
	570	// or if we only need to write a new line.
	571	// This depends on BSCfgSysManip.iReplaceMode.
	572	BOOL fFindLine = FALSE;
	573
	574	// 2) If we need to find a line, find the
	575	// line and copy it into pszLineToUpdate.
	576	// Set pInsertAt to the original line, if found.
	577	// If not found, set fInsertWRTVertical to TRUE.
	578	PSZ pInsertAt = 0;
	579	// address of that line in original buffer if (fFindLine == TRUE) and
	580	// found
	581	BOOL fInsertWRTVertical = FALSE;
	582	// TRUE means set a new pInsertAt depending on Manip.iVertical;
	583	// this is set to TRUE if (fFindLine == FALSE) or line not found
	584
	585	// 3) If a line needs to be deleted, well, delete it then.
	586	PSZ pLineToDelete = 0;
	587	// pointer to start of original line (pLineToUpdate);
	588	// points to character right after \n
	589	PSZ pszDeletedLine = 0;
	590	// copy of that line if deleted (this has the stuff between
	591	// the EOL chars, not including those)
	592
	593	// 4) If (fInsertWRTVertical == TRUE), set pInsertAt to a position in
	594	// the original buffer, depending on Manip.iVertical.
	595
	596	// 5) Compose a new line to be inserted at pInsertAt.
	597	PSZ pszLineToInsert = 0;
	598
	599	// 6) Insert that line at pInsertAt.
	600
	601	/*
	602	* Prepare data
	603	*
	604	*/
	605
	606	// First, check if the new-line string has a "=" char
[123]	607	PSZ pSep;
	608	if (pSep = strchr(pManip->pszNewLine, '='))
[24]	609	{
	610	// yes: separate in two strings
	611	pszCommand = strhSubstr(pManip->pszNewLine, pSep);
	612	pszArgNew = strdup(pSep+1);
	613	}
	614	else
	615	{
	616	// no:
	617	pszCommand = strdup(pManip->pszNewLine);
	618	pszArgNew = 0;
	619	}
	620
	621	/*
	622	* GO!!
	623	*
	624	*/
	625
	626	// **** 1): do we need to search for a line?
	627	switch (pManip->iReplaceMode)
	628	{
	629	case CFGRPL_ADD:
	630	fFindLine = FALSE;
	631	fInsertWRTVertical = TRUE; // always find new position
	632	break;
	633
	634	case CFGRPL_UNIQUE:
	635	case CFGRPL_ADDLEFT:
	636	case CFGRPL_ADDRIGHT:
	637	case CFGRPL_REMOVELINE:
	638	case CFGRPL_REMOVEPART:
	639	fFindLine = TRUE; // search line first; this sets
	640	// fInsertWRTVertical if not found
	641	break;
	642	}
	643
	644	// **** 2): search line, if needed
	645	if (fFindLine)
	646	{
	647	PSZ pKeyFound = 0,
	648	// address of key found
	649	pStartOfLineWithKeyFound = 0,
	650	// pointer to that line in original buffer; NULL if not found
	651	pszSearch = *ppszContents;
	652
	653	do // while ((pManip->pszUniqueSearchString2) && (pszSearch));
	654	{
	655	pKeyFound = csysFindKey(pszSearch, // CONFIG.SYS text
	656	pszCommand, // stuff to search for
	657	&pStartOfLineWithKeyFound,
	658	&fIsAllUpperCase);
[71]	659	// returns beginning of line
[24]	660
	661	if (!pKeyFound)
	662	break;
	663	else
	664	if (pManip->pszUniqueSearchString2)
	665	{
	666	// UNIQUE(xxx) mode:
	667	// find end of line
	668	PSZ pEOL = strhFindEOL(pKeyFound, NULL);
	669
	670	// find "="
	671	PSZ p = strchr(pKeyFound, '=');
	672	if (p && p < pEOL)
	673	{
	674	// find UNIQUE(xxx) substring in line
	675	p = strhistr(p, pManip->pszUniqueSearchString2);
	676	if (p && p < pEOL)
	677	// found: OK, keep pLineToUpdate
	678	break;
	679	else
	680	pKeyFound = NULL; // V0.9.7 (2001-01-15) [umoeller]
	681	}
	682
	683	// else: search on
	684	pszSearch = pEOL;
	685	}
	686	} while ((pManip->pszUniqueSearchString2) && (pszSearch));
	687
	688	if (pKeyFound)
	689	{
	690	// line found:
	691	pLineToDelete = pStartOfLineWithKeyFound;
	692	pInsertAt = pStartOfLineWithKeyFound;
	693	}
	694	else
	695	// line not found:
	696	// insert new line then,
	697	// respecting the iVertical flag,
	698	// unless we are in "remove" mode
	699	if ( (pManip->iReplaceMode != CFGRPL_REMOVELINE)
	700	&& (pManip->iReplaceMode != CFGRPL_REMOVEPART)
	701	)
	702	fInsertWRTVertical = TRUE;
	703	}
	704
	705	// **** 3): delete original line (OK)
	706	if (pLineToDelete)
	707	{
	708	// pLineToDelete is only != NULL if we searched and found a line above
	709	// and points to the character right after \n;
	710	// find end of this line
	711	PSZ pEOL = strhFindEOL(pLineToDelete, NULL);
	712
	713	// make a copy of the line to be deleted;
	714	// this might be needed later
	715	pszDeletedLine = strhSubstr(pLineToDelete, pEOL);
	716
	717	// pEOL now points to the \n char or the terminating 0 byte;
	718	// if not null byte, advance pointer
	719	while (*pEOL == '\n')
	720	pEOL++;
	721
	722	// overwrite beginning of line with next line;
	723	// the buffers overlap, but this works
	724	strcpy(pLineToDelete, pEOL);
	725
	726	// we've made changes...
	727	*pfDirty = TRUE;
	728	}
	729
	730	// **** 4):
	731	if (fInsertWRTVertical)
	732	{
	733	// this is only TRUE if a) we didn't search for a line
	734	// or b) we did search, but we didn't find a line
	735	// (but never with CFGRPL_REMOVE* mode);
	736	// we need to find a new vertical position in CONFIG.SYS then
	737	// and set pInsertAt to the beginning of a line (after \n)
	738	switch (pManip->iVertical)
	739	{
	740	case CFGVRT_BOTTOM:
	741	// insert at the very bottom (default)
	742	pInsertAt = ppszContents + strlen(ppszContents);
	743	break;
	744
	745	case CFGVRT_TOP:
	746	// insert at the very top
	747	pInsertAt = *ppszContents;
	748	break;
	749
	750	case CFGVRT_BEFORE:
	751	{
	752	// Manip.pszSearchString has the search string
	753	// before whose line we must insert
[123]	754	PSZ pFound;
	755	if (pFound = strhistr(*ppszContents,
	756	pManip->pszVerticalSearchString))
[24]	757	{
	758	// search string found:
	759	// find beginning of line
	760	while ( (pFound > *ppszContents)
	761	&& (*pFound != '\n')
	762	)
	763	pFound--;
	764
	765	if (pFound > *ppszContents)
	766	// we're on the \n char now:
	767	pFound++;
	768
	769	pInsertAt = pFound;
	770	}
	771	else
	772	// search string not found: insert at top then
	773	pInsertAt = *ppszContents;
	774	break; }
	775
	776	case CFGVRT_AFTER:
	777	{
	778	// Manip.pszSearchString has the search string
	779	// after whose line we must insert
[123]	780	PSZ pFound;
	781	if (pFound = strhistr(*ppszContents,
	782	pManip->pszVerticalSearchString))
[24]	783	{
	784	// search string found:
	785	// find end of line
	786	pInsertAt = strhFindNextLine(pFound, NULL);
	787	}
	788	else
	789	// search string not found: insert at bottom then
	790	pInsertAt = ppszContents + strlen(ppszContents);
	791	break; }
	792	}
	793	}
	794
	795	// **** 5): compose new line
	796	switch (pManip->iReplaceMode)
	797	{
	798	case CFGRPL_ADD:
	799	case CFGRPL_UNIQUE:
	800	// that's easy, the new line is simply given
	801	pszLineToInsert = strdup(pManip->pszNewLine);
	802	break;
	803
	804	case CFGRPL_REMOVELINE:
	805	// that's easy, just leave pszLineToInsert = 0;
	806	break;
	807
	808	case CFGRPL_REMOVEPART:
	809	if (pszDeletedLine)
	810	{
	811	// parse the line which we removed above,
	812	// find the part which was to be removed,
	813	// and set pszLineToInsert to the rest of that
	814	PSZ pArgToDel = 0;
	815	// find the subpart to look for
	816	if ((pArgToDel = strhistr(pszDeletedLine, pszArgNew)))
	817	{
[151]	818	// ULONG ulOfs = 0;
[24]	819	// pArgToDel now has the position of the
	820	// part to be deleted in the old part
[151]	821	/* pszLineToInsert = strdup(pszDeletedLine);
[24]	822	strhFindReplace(&pszLineToInsert,
	823	&ulOfs,
	824	pszArgNew, // search string
	825	""); // replacement string
[151]	826	*/
	827
	828	// V0.9.18 (2002-03-24) [umoeller]
	829	// the above left duplicate ";" characters in the line
	830	ULONG ulArgNewLen = strlen(pszArgNew);
	831	ULONG cbFirst, cb;
	832	PSZ pAfter = pArgToDel + ulArgNewLen;
	833	while (*pAfter == ';')
	834	++pAfter;
	835
	836	// now recompose
	837	cbFirst = pArgToDel - pszDeletedLine;
	838	cb = cbFirst // length up to pArgToDel
	839	+ strlen(pAfter) // length of remainder
	840	+ 1; // null terminator;
	841	if (pszLineToInsert = (PSZ)malloc(cb))
	842	{
	843	if (cbFirst)
	844	memcpy(pszLineToInsert, pszDeletedLine, cbFirst);
	845	strcpy(pszLineToInsert + cbFirst,
	846	pAfter);
	847	}
	848	else
	849	arc = ERROR_NOT_ENOUGH_MEMORY;
[24]	850	}
	851	else
	852	// subpart not found:
	853	// reinsert the old line
	854	pszLineToInsert = strdup(pszDeletedLine);
	855	}
	856	// else line to be deleted was not found: leave pszLineToInsert = 0;
	857	break;
	858
	859	case CFGRPL_ADDLEFT:
	860	case CFGRPL_ADDRIGHT:
	861	// add something to the left or right of the existing
	862	// argument:
	863	// check if we found a line above
	864	if (pszDeletedLine)
	865	{
	866	PSZ pszCommandOld = 0,
	867	pszArgOld = 0;
	868	// yes: split the existing line
	869	pSep = strchr(pszDeletedLine, '=');
	870	if (pSep)
	871	{
	872	// "=" found: separate in two strings
	873	pszCommandOld = strhSubstr(pszDeletedLine, pSep);
	874	pszArgOld = strdup(pSep+1);
	875	}
	876	else
	877	{
	878	// no "=" found: that's strange
	879	/* throw(BSConfigExcpt(CFGEXCPT_NOSEPARATOR,
	880	strdup(pszDeletedLine))); */
	881	arc = CFGERR_NOSEPARATOR;
	882	break;
	883	}
	884
	885	if ((pszCommandOld) && (pszArgOld))
	886	{
	887	// does the new arg exist in old arg already?
	888	if (strhistr(pszArgOld, pszArgNew) == 0)
	889	{
	890	// no: go!
	891	ULONG cbCommandOld = strlen(pszCommandOld);
	892	ULONG cbArgOld = strlen(pszArgOld);
	893	ULONG cbArgNew = strlen(pszArgNew); // created at the very top
	894
	895	// compose new line
	896	pszLineToInsert = (PSZ)malloc(cbCommandOld
	897	+ cbArgOld
	898	+ cbArgNew
	899	+ 5);
	900
	901	if (pManip->iReplaceMode == CFGRPL_ADDLEFT)
	902	// add new arg to the left:
	903	sprintf(pszLineToInsert,
	904	"%s=%s;%s",
	905	pszCommandOld,
	906	pszArgNew,
	907	pszArgOld);
	908	else
	909	// add new arg to the right:
	910	if (*(pszArgOld + cbArgOld - 1) == ';')
	911	// old arg has terminating ";" already:
	912	sprintf(pszLineToInsert,
	913	"%s=%s%s",
	914	pszCommandOld,
	915	pszArgOld,
	916	pszArgNew);
	917	else
	918	// we need to append a ";":
	919	sprintf(pszLineToInsert,
	920	"%s=%s;%s",
	921	pszCommandOld,
	922	pszArgOld,
	923	pszArgNew);
	924	} // end if (stristr(pszArgOld, pszArgNew) == 0)
	925	else
	926	// exists already:
	927	// reinsert the line we deleted above
	928	pszLineToInsert = strdup(pszDeletedLine);
	929
	930	free(pszCommandOld);
	931	free(pszArgOld);
	932	}
	933	} // end if (pszDeletedLine)
	934	else
	935	// line was not found: add a new one then
	936	// (the position has been determined above)
	937	pszLineToInsert = strdup(pManip->pszNewLine);
	938	break;
	939	}
	940
	941	// **** 6): insert new line at pInsertAt
	942	if ((pszLineToInsert) && (arc == NO_ERROR))
	943	{
	944	PSZ pszInsert2 = NULL;
	945	PSZ pszNew = NULL;
	946	ULONG cbInsert = strlen(pszLineToInsert);
	947	BOOL fLineBreakNeeded = FALSE;
	948
	949	// check if the char before pInsertAt is EOL
	950	if (pInsertAt > *ppszContents)
	951	if (*(pInsertAt-1) != '\n')
	952	fLineBreakNeeded = TRUE;
	953
	954	if (fLineBreakNeeded)
	955	{
	956	// not EOL (this might be the case if we're
	957	// appending to the very bottom of CONFIG.SYS)
	958	pszInsert2 = (PSZ)malloc(cbInsert + 5);
	959	// insert an extra line break then
	960	*pszInsert2 = '\n';
	961	memcpy(pszInsert2 + 1, pszLineToInsert, cbInsert);
	962	strcpy(pszInsert2 + cbInsert + 1, "\n");
	963	}
	964	else
	965	{
	966	// OK:
	967	pszInsert2 = (PSZ)malloc(cbInsert + 3);
	968	memcpy(pszInsert2, pszLineToInsert, cbInsert);
	969	strcpy(pszInsert2 + cbInsert, "\n");
	970	}
	971
	972	pszNew = strhins(*ppszContents, // source
	973	(pInsertAt - *ppszContents), // offset
	974	pszInsert2); // insertion string
	975	if (pszNew)
	976	{
	977	free(pszInsert2);
	978	free(*ppszContents);
	979	*ppszContents = pszNew;
	980
	981	// we've made changes...
	982	*pfDirty = TRUE;
	983	}
	984	else
	985	arc = CFGERR_MANIPULATING;
	986	}
	987	else
	988	if ( (pManip->iReplaceMode != CFGRPL_REMOVELINE)
	989	&& (pManip->iReplaceMode != CFGRPL_REMOVEPART)
	990	)
	991	arc = CFGERR_MANIPULATING;
	992
	993	if (arc == NO_ERROR)
	994	{
	995	// finally, create log entries for Undo().
	996	// This uses the first three characters of the
	997	// each log entry to signify what happend:
	998	// -- "DLL": deleted line
	999	// -- "DLP": deleted part of line
	1000	// -- "NWL": added an all new line
	1001	// -- "NWP": added a new part to an existing line
	1002	// There may be several log entries per manipulator
	1003	// if a line was deleted and then re-inserted (i.e. updated).
	1004
	1005	if (pstrChanged)
	1006	{
	1007	switch (pManip->iReplaceMode)
	1008	{
	1009	case CFGRPL_UNIQUE:
	1010	if (pszDeletedLine)
	1011	{
	1012	// did we delete a line?
	1013	xstrcat(pstrChanged, "DLL ", 0);
	1014	xstrcat(pstrChanged, pszDeletedLine, 0);
	1015	xstrcatc(pstrChanged, '\n');
	1016	}
	1017
	1018	// no break, because we also added something
	1019	goto LABEL_CFGRPL_ADD ;
	1020	// VAC gives us warnings otherwise...
	1021
	1022	case CFGRPL_ADD:
	1023	LABEL_CFGRPL_ADD:
	1024	if (pszLineToInsert)
	1025	{
	1026	// added a line:
	1027	xstrcat(pstrChanged, "NWL ", 0);
	1028	xstrcat(pstrChanged, pszLineToInsert, 0);
	1029	xstrcatc(pstrChanged, '\n');
	1030	}
	1031	break;
	1032
	1033	case CFGRPL_ADDLEFT:
	1034	case CFGRPL_ADDRIGHT:
	1035	if (pszDeletedLine)
	1036	{
	1037	// a line was found and updated:
	1038	// store the new part only
	1039	xstrcat(pstrChanged, "NWP ", 0);
	1040	xstrcat(pstrChanged, pManip->pszNewLine, 0);
	1041	}
	1042	else
	1043	{
	1044	xstrcat(pstrChanged, "NWL ", 0);
	1045	xstrcat(pstrChanged, pszLineToInsert, 0);
	1046	}
	1047	xstrcatc(pstrChanged, '\n');
	1048	break;
	1049
	1050	case CFGRPL_REMOVELINE:
	1051	if (pszDeletedLine)
	1052	{
	1053	// did we delete a line?
	1054	xstrcat(pstrChanged, "DLL ", 0);
	1055	xstrcat(pstrChanged, pszDeletedLine, 0);
	1056	xstrcatc(pstrChanged, '\n');
	1057	}
	1058	break;
	1059
	1060	case CFGRPL_REMOVEPART:
	1061	if (pszDeletedLine)
	1062	{
[47]	1063	// did we delete a part?
[24]	1064	xstrcat(pstrChanged, "DLP ", 0);
	1065	xstrcat(pstrChanged, pManip->pszNewLine, 0);
	1066	xstrcatc(pstrChanged, '\n');
	1067	}
	1068	break;
	1069	}
	1070	} // end if (pstrChanged)
	1071	}
	1072
	1073	// clean up
	1074	if (pszCommand)
	1075	free(pszCommand);
	1076	if (pszArgNew)
	1077	free(pszArgNew);
	1078	if (pszDeletedLine)
	1079	free(pszDeletedLine);
	1080	if (pszLineToInsert)
	1081	free(pszLineToInsert);
	1082
[167]	1083	return arc;
[24]	1084	}
	1085
[117]	1086	/* ******************************************************************
	1087	*
	1088	* Swappath
	1089	*
	1090	********************************************************************/
	1091
	1092	extern CHAR G_szSwapperFilename[CCHMAXPATH] = "";
	1093
	1094	/*
	1095	*@@ csysParseSwapPath:
	1096	*
	1097	*@@added V0.9.9 (2001-02-08) [umoeller]
	1098	*@@changed V0.9.16 (2001-11-10) [umoeller]: moved to helpers
	1099	*/
	1100
	1101	BOOL csysParseSwapPath(const char *pcszConfigSys, // in: if NULL, this gets loaded
	1102	PSZ pszSwapPath, // out: swapper directory
	1103	PULONG pulMinFree, // out: min free
	1104	PULONG pulMinSize) // out: min size
	1105	{
	1106	BOOL brc = FALSE;
	1107
	1108	PSZ pszConfigSysTemp = 0;
	1109
	1110	if (!pcszConfigSys)
	1111	{
	1112	// not specified: load it
	1113	if (csysLoadConfigSys(NULL, &pszConfigSysTemp) == NO_ERROR)
	1114	pcszConfigSys = pszConfigSysTemp;
	1115	}
	1116
	1117	if (pcszConfigSys)
	1118	{
	1119	// parse SWAPPATH command
	1120	PSZ p;
	1121	if (p = csysGetParameter(pcszConfigSys, "SWAPPATH=", NULL, 0))
	1122	{
	1123	CHAR szSwap[CCHMAXPATH];
	1124	ULONG ulMinFree = 2048, ulMinSize = 2048;
	1125	// int iScanned;
	1126	sscanf(p,
	1127	"%s %d %d",
	1128	&szSwap, &ulMinFree, &ulMinSize);
	1129
	1130	if (pszSwapPath)
	1131	strcpy(pszSwapPath, szSwap);
	1132	if (pulMinFree)
	1133	*pulMinFree = ulMinFree;
	1134	if (pulMinSize)
	1135	*pulMinSize = ulMinSize;
	1136
	1137	if (G_szSwapperFilename[0] == '\0')
	1138	{
	1139	// first call: copy to global so that the swapper
	1140	// monitors will always use the old one, in case
	1141	// the user changes this
	1142	strcpy(G_szSwapperFilename, szSwap);
	1143	if (G_szSwapperFilename[strlen(G_szSwapperFilename)-1] != '\\')
	1144	strcat(G_szSwapperFilename, "\\");
	1145	strcat(G_szSwapperFilename, "swapper.dat");
	1146	}
	1147
	1148	brc = TRUE;
	1149	}
	1150	}
	1151
	1152	if (pszConfigSysTemp)
	1153	free(pszConfigSysTemp);
	1154
[167]	1155	return brc;
[117]	1156	}
	1157
	1158	/*
	1159	*@@ csysQuerySwapperSize:
	1160	* returns the current size of the swap file
	1161	* in bytes.
	1162	*
	1163	*@@added V0.9.9 (2001-02-08) [umoeller]
	1164	*@@changed V0.9.16 (2001-11-10) [umoeller]: moved to helpers
	1165	*/
	1166
	1167	ULONG csysQuerySwapperSize(VOID)
	1168	{
	1169	ULONG ulrc = 0;
	1170
	1171	if (G_szSwapperFilename[0] == '\0')
	1172	{
	1173	// first call: compose the path
	1174	csysParseSwapPath(NULL,
	1175	NULL,
	1176	NULL,
	1177	NULL);
	1178	}
	1179
	1180	if (G_szSwapperFilename[0])
	1181	doshQueryPathSize(G_szSwapperFilename, &ulrc);
	1182
[238]	1183	return ulrc;
[117]	1184	}
	1185
[63]	1186	// testcase
[24]	1187
[63]	1188	/* int main()
	1189	{
	1190	PSZ pszContents = NULL;
	1191	if (0 == csysLoadConfigSys(NULL, &pszContents))
	1192	{
	1193	CHAR szValue[1000];
	1194	PSZ pszValue = csysGetParameter(pszContents,
	1195	"IFS=",
	1196	szValue,
	1197	sizeof(szValue));
	1198	if (pszValue)
	1199	printf("Value: %s", szValue);
	1200	}
	1201
[238]	1202	return 0;
[63]	1203	} */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/helpers/configsys.c

Download in other formats: