开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
CONFIG.C
资源名称：840.rar　[点击查看]
上传用户：dcs7469208
上传日期：2010-01-02
资源大小：443k
文件大小：17k
源码类别：

操作系统开发

开发平台：

DOS

CONFIG.C：源码内容
  2. /****************************************************************/
  3. /*                                                              */
  4. /*                          config.c                            */
  5. /*                            DOS-C                             */
  6. /*                                                              */
  7. /*                config.sys Processing Functions               */
  8. /*                                                              */
  9. /*                      Copyright (c) 1996                      */
  10. /*                      Pasquale J. Villani                     */
  11. /*                      All Rights Reserved                     */
  12. /*                                                              */
  13. /* This file is part of DOS-C.                                  */
  14. /*                                                              */
  15. /* DOS-C is free software; you can redistribute it and/or       */
  16. /* modify it under the terms of the GNU General Public License  */
  17. /* as published by the Free Software Foundation; either version */
  18. /* 2, or (at your option) any later version.                    */
  19. /*                                                              */
  20. /* DOS-C is distributed in the hope that it will be useful, but */
  21. /* WITHOUT ANY WARRANTY; without even the implied warranty of   */
  22. /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See    */
  23. /* the GNU General Public License for more details.             */
  24. /*                                                              */
  25. /* You should have received a copy of the GNU General Public    */
  26. /* License along with DOS-C; see the file COPYING.  If not,     */
  27. /* write to the Free Software Foundation, 675 Mass Ave,         */
  28. /* Cambridge, MA 02139, USA.                                    */
  29. /****************************************************************/
  32. #include "../../hdr/portab.h"
  33. #include "globals.h"
  35. /* $Logfile:   C:/dos-c/src/kernel/config.c_v  $ */
  36. #ifdef VERSION_STRINGS
  37. static BYTE *RcsId = "$Header:   C:/dos-c/src/kernel/config.c_v   1.6   22 Jan 1998  4:09:24   patv  $";
  38. #endif
  40. /* $Log:   C:/dos-c/src/kernel/config.c_v  $
  41.  * 
  42.  *    Rev 1.6   22 Jan 1998  4:09:24   patv
  43.  * Fixed pointer problems affecting SDA
  44.  *
  45.  *    Rev 1.5   04 Jan 1998 23:15:18   patv
  46.  * Changed Log for strip utility
  47.  * 
  48.  *    Rev 1.4   04 Jan 1998 17:26:14   patv
  49.  * Corrected subdirectory bug
  50.  * 
  51.  *    Rev 1.3   16 Jan 1997 12:46:50   patv
  52.  * pre-Release 0.92 feature additions
  53.  * 
  54.  *    Rev 1.1   29 May 1996 21:03:44   patv
  55.  * bug fixes for v0.91a
  56.  * 
  57.  *    Rev 1.0   19 Feb 1996  3:22:16   patv
  58.  * Added NLS, int2f and config.sys processing
  59.  */
  60. /* $EndLog$ */
  62. #if 0
  63. #define dos_open(x,y)   _open((const char *)(x),(y))
  64. #define dos_read(x,y,z) _read((int)(x),(void *)(y),(unsigned)(z))
  65. #define dos_close       _close
  66. #endif
  68. #ifdef KDB
  69. # include <alloc.h>
  71. # define KernelAlloc(x) adjust_far((void far *)malloc((unsigned long)(x)))
  72. #endif
  74. BYTE FAR *lpBase;
  75. static BYTE FAR *lpOldLast;
  76. static COUNT nCfgLine;
  77. static COUNT nPass;
  78. static BYTE szLine[256];
  79. static BYTE szBuf[256];
  81. int     singleStep = 0;
  83. VOID Buffers(BYTE *pLine);
  84. VOID Break(BYTE *pLine);
  85. VOID Device(BYTE *pLine);
  86. VOID Files(BYTE *pLine);
  87. VOID Fcbs(BYTE *pLine);
  88. VOID Lastdrive(BYTE *pLine);
  89. VOID Country(BYTE *pLine);
  90. VOID InitPgm(BYTE *pLine);
  91. VOID Switchar(BYTE *pLine);
  92. VOID CfgFailure(BYTE *pLine);
  93. VOID Stacks(BYTE *pLine);
  94. BYTE *GetNumArg(BYTE *pLine, COUNT *pnArg);
  95. BYTE *GetStringArg(BYTE *pLine, BYTE *pszString);
  96. struct dhdr FAR *linkdev(struct dhdr FAR *dhp);
  97. UWORD 
  98. initdev (struct dhdr FAR *dhp, BYTE FAR *cmdTail);
  99. int     SkipLine(char *pLine);
  101. static VOID FAR *AlignParagraph(VOID FAR *lpPtr);
  102. #ifndef I86
  103. # define AlignParagraph(x) (x)
  104. #endif
  106. #define EOF 0x1a
  108. struct table *LookUp(struct table *p, BYTE *token);
  110. struct table
  111. {
  112. BYTE    *entry;
  113. BYTE    pass;
  114. VOID    (*func)(BYTE *pLine);
  115. };
  117. static struct table  commands[] =
  118. {
  119. {"break",       1,      Break},
  120. {"buffers",     1,      Buffers},
  121. {"command",     1,      InitPgm},
  122. {"country",     1,      Country},
  123. {"device",      2,      Device},
  124. {"fcbs",        1,      Fcbs},
  125. {"files",       1,      Files},
  126. {"lastdrive",   1,      Lastdrive },
  127. /* rem is never executed by locking out pass                    */
  128. {"rem",         0,      CfgFailure},
  129. {"shell",       1,      InitPgm},
  130. {"stacks",      1,      Stacks },
  131. {"switchar",    1,      Switchar },
  132. /* default action                                               */
  133. {"",            -1,     CfgFailure}
  134. };
  136. #ifndef KDB
  137. BYTE FAR *KernelAlloc(WORD nBytes);
  138. #endif
  139. BYTE *pLineStart;
  141. /* Do first time initialization.  Store last so that we can reset it    */
  142. /* later.                                                               */
  143. void
  144. PreConfig(void)
  145. {
  146. /* Set pass number                                              */
  147. nPass = 0;
  149. /* Initialize the base memory pointers                          */
  150. lpOldLast = lpBase = AlignParagraph((BYTE FAR *)&last);
  152. /* Begin by initializing our system buffers                     */
  153. buffers = (struct buffer FAR *)
  154. KernelAlloc(Config.cfgBuffers * sizeof(struct buffer));
  155. #ifdef DEBUG
  156. printf("Preliminary buffer allocated at 0x%04x:0x%04xn",
  157. FP_SEG(buffers), FP_OFF(buffers));
  158. #endif
  160. /* Initialize the file table                                    */
  161. f_nodes = (struct f_node FAR *)
  162. KernelAlloc(Config.cfgFiles * sizeof(struct f_node));
  163. /* sfthead = (sfttbl FAR *)&basesft; */
  164. /* FCBp = (sfttbl FAR *)&FcbSft; */
  165. FCBp = (sfttbl FAR *)
  166. KernelAlloc(sizeof(sftheader)
  167.  + Config.cfgFiles * sizeof(sft));
  168. sfthead = (sfttbl FAR *)
  169. KernelAlloc(sizeof(sftheader)
  170.  + Config.cfgFiles * sizeof(sft));
  172. #ifdef DEBUG
  173. printf("Preliminary f_node allocated at 0x%04x:0x%04xn",
  174. FP_SEG(f_nodes), FP_OFF(f_nodes));
  175. printf("Preliminary FCB table allocated at 0x%04x:0x%04xn",
  176. FP_SEG(FCBp), FP_OFF(FCBp));
  177. printf("Preliminary sft table allocated at 0x%04x:0x%04xn",
  178. FP_SEG(sfthead), FP_OFF(sfthead));
  179. #endif
  181. /* Done.  Now initialize the MCB structure                      */
  182. /* This next line is 8086 and 80x86 real mode specific          */
  183. #ifdef DEBUG
  184. printf("Preliminary  allocation completed: top at 0x%04x:0x%04xn",
  185. FP_SEG(lpBase), FP_OFF(lpBase));
  186. #endif
  188. #ifdef KDB
  189. lpBase = malloc(4096);
  190. first_mcb = FP_SEG(lpBase) + ((FP_OFF(lpBase) + 0x0f) >> 4);
  191. #else
  192. first_mcb = FP_SEG(lpBase) + ((FP_OFF(lpBase) + 0x0f) >> 4);
  193. #endif
  195. /* We expect ram_top as Kbytes, so convert to paragraphs */
  196. mcb_init((mcb FAR *)(MK_FP(first_mcb, 0)),
  197.  (ram_top << 6) - first_mcb - 1);
  198. nPass = 1;
  199. }
  202. /* Do second pass initialization.                                       */
  203. /* Also, run config.sys to load drivers.                                */
  204. void
  205. PostConfig(void)
  206. {
  207. /* Set pass number                                              */
  208. nPass = 2;
  210. /* Initialize the base memory pointers from last time.          */
  211. lpBase = AlignParagraph(lpOldLast);
  213. /* Begin by initializing our system buffers                     */
  214. buffers = (struct buffer FAR *)
  215. KernelAlloc(Config.cfgBuffers * sizeof(struct buffer));
  216. #ifdef DEBUG
  217. printf("Buffer allocated at 0x%04x:0x%04xn",
  218. FP_SEG(buffers), FP_OFF(buffers));
  219. #endif
  221. /* Initialize the file table                                    */
  222. f_nodes = (struct f_node FAR *)
  223. KernelAlloc(Config.cfgFiles * sizeof(struct f_node));
  224. /* sfthead = (sfttbl FAR *)&basesft; */
  225. /* FCBp = (sfttbl FAR *)&FcbSft; */
  226. FCBp = (sfttbl FAR *)
  227. KernelAlloc(sizeof(sftheader)
  228.  + Config.cfgFiles * sizeof(sft));
  229. sfthead = (sfttbl FAR *)
  230. KernelAlloc(sizeof(sftheader)
  231.  + Config.cfgFiles * sizeof(sft));
  233. #ifdef DEBUG
  234. printf("f_node allocated at 0x%04x:0x%04xn",
  235. FP_SEG(f_nodes), FP_OFF(f_nodes));
  236. printf("FCB table allocated at 0x%04x:0x%04xn",
  237. FP_SEG(FCBp), FP_OFF(FCBp));
  238. printf("sft table allocated at 0x%04x:0x%04xn",
  239. FP_SEG(sfthead), FP_OFF(sfthead));
  240. #endif
  241. if (Config.cfgStacks)
  242. {
  243. VOID FAR *stackBase = KernelAlloc(Config.cfgStacks * Config.cfgStackSize);
  244. init_stacks(stackBase, Config.cfgStacks, Config.cfgStackSize);
  246. #ifdef  DEBUG
  247. printf("Stacks allocated at %04x:%04xn",
  248.     FP_SEG(stackBase), FP_OFF(stackBase));
  249. #endif
  250. }
  251. #ifdef DEBUG
  252. printf("Allocation completed: top at 0x%04x:0x%04xn",
  253. FP_SEG(lpBase), FP_OFF(lpBase));
  254. #endif
  255. }
  257. /* This code must be executed after device drivers has been loaded */
  258. VOID    configDone(VOID)
  259. {
  260. COUNT   i;
  262. first_mcb = FP_SEG(lpBase) + ((FP_OFF(lpBase) + 0x0f) >> 4);
  264. /* We expect ram_top as Kbytes, so convert to paragraphs */
  265. mcb_init((mcb FAR *)(MK_FP(first_mcb, 0)),
  266.  (ram_top << 6) - first_mcb - 1);
  268. /* The standard handles should be reopened here, because
  269.    we may have loaded new console or printer drivers in CONFIG.SYS */
  270. }
  272. VOID DoConfig(VOID)
  273. {
  274. COUNT nFileDesc;
  275. COUNT nRetCode;
  276. BYTE    *pLine, *pTmp;
  277. BOOL    bEof;
  279. /* Check to see if we have a config.sys file.  If not, just     */
  280. /* exit since we don't force the user to have one.              */
  281. if((nFileDesc = dos_open((BYTE FAR *)"config.sys", 0)) < 0)
  282. {
  283. #ifdef DEBUG
  284. printf("CONFIG.SYS not foundn");
  285. #endif
  286. return;
  287. }
  289. /* Have one -- initialize.                                      */
  290. nCfgLine = 0;
  291. bEof = 0;
  292. pLine = szLine;
  294. /* Read each line into the buffer and then parse the line,      */
  295. /* do the table lookup and execute the handler for that         */
  296. /* function.                                                    */
  297. while (!bEof)
  298. {
  299. struct table *pEntry;
  300. UWORD bytesLeft = 0;
  302. if (pLine > szLine) bytesLeft = LINESIZE - (pLine - szLine);
  304. if (bytesLeft)
  305. {
  306.     fbcopy(pLine, szLine, LINESIZE - bytesLeft);
  307.     pLine = szLine + bytesLeft;
  308. }
  310. /* Read a line from config                              */
  311. /* Interrupt processing if read error or no bytes read  */
  312. if ((nRetCode = dos_read(nFileDesc, pLine, LINESIZE - bytesLeft)) <= 0) 
  313.     break;
  315. /* If the buffer was not filled completely, append a 
  316.    CTRL-Z character to mark where the file ends */
  318. if (nRetCode + bytesLeft < LINESIZE) 
  319.     szLine[nRetCode + bytesLeft] = EOF;
  321. /* Process the buffer, line by line */
  322. pLine = szLine;
  324. while (!bEof && *pLine != EOF)
  325. {
  326. for (pTmp = pLine; pTmp - szLine < LINESIZE; pTmp++)
  327. {
  328. if (*pTmp == 'r' || *pTmp == EOF) 
  329.     break;
  330. }
  332. if (pTmp - szLine >= LINESIZE)
  333.     break;
  335. if (*pTmp == EOF) 
  336.     bEof = TRUE;
  338. *pTmp = '';
  339. pLineStart = pLine;
  341. /* Skip leading white space and get verb.               */
  342. pLine = scan(pLine, szBuf);
  344. /* Translate the verb to lower case ...                 */
  345. for(pTmp = szBuf; *pTmp != ''; pTmp++)
  346. *pTmp = tolower(*pTmp);
  348. /* If the line was blank, skip it.  Otherwise, look up  */
  349. /* the verb and execute the appropriate function.       */
  350. if(*szBuf != '')
  351. {
  352. pEntry = LookUp(commands, szBuf);
  354. if(pEntry -> pass < 0 || pEntry -> pass == nPass)
  355. {        
  356. if (!singleStep || !SkipLine(pLineStart))
  357. {
  358. skipwh(pLine);
  360. if('=' != *pLine)
  361. CfgFailure(pLine);
  362. else (*(pEntry -> func))(++pLine);
  363. }
  364. }
  365. }
  366. skipLine:               nCfgLine++;
  367. pLine += strlen(pLine) + 1;
  368. }
  369. }
  370. dos_close(nFileDesc);
  371. }
  373. struct table *LookUp(struct table *p, BYTE *token)
  374. {
  375. while(*(p -> entry) != '')
  376. {
  377. if(strcmp(p -> entry, token) == 0)
  378. break;
  379. else
  380. ++p;
  381. }
  382. return p;
  383. }
  384.     
  385. BOOL    SkipLine(char *pLine)
  386. {
  387. char    kbdbuf[16];
  388. keyboard *kp = (keyboard *)kbdbuf;
  389. char    *pKbd = &kp->kb_buf[0];
  391. kp->kb_size = 12;
  392. kp->kb_count = 0;
  394. printf("%s [Y,N]?", pLine);
  395. sti(kp);
  397. pKbd = skipwh(pKbd);
  399. if (*pKbd == 'n' || *pKbd == 'N')
  400. return TRUE;        
  401.     
  402. return FALSE;
  403. }
  405. BYTE *GetNumArg(BYTE *pLine, COUNT *pnArg)
  406. {
  407. /* look for NUMBER                               */
  408. pLine = skipwh(pLine);
  409. if(!isnum(pLine))
  410. {
  411. CfgFailure(pLine);
  412. return (BYTE *)0;
  413. }
  414. return GetNumber(pLine, pnArg);
  415. }
  418. BYTE *GetStringArg(BYTE *pLine, BYTE *pszString)
  419. {
  420. /* look for STRING                               */
  421. pLine = skipwh(pLine);
  423. /* just return whatever string is there, including null         */
  424. return scan(pLine, pszString);
  425. }
  427. static VOID Buffers(BYTE *pLine)
  428. {
  429. COUNT nBuffers;
  431. /* Get the argument                                             */
  432. if(GetNumArg(pLine, &nBuffers) == (BYTE *)0)
  433. return;
  435. /* Got the value, assign either default or new value            */
  436. Config.cfgBuffers = max(Config.cfgBuffers, nBuffers);
  437. }
  439. static VOID Files(BYTE *pLine)
  440. {
  441. COUNT nFiles;
  443. /* Get the argument                                             */
  444. if(GetNumArg(pLine, &nFiles) == (BYTE *)0)
  445. return;
  447. /* Got the value, assign either default or new value            */
  448. Config.cfgFiles = max(Config.cfgFiles, nFiles);
  449. }
  451. static VOID Lastdrive(BYTE *pLine)
  452. {
  453. /* Format:   LASTDRIVE = letter         */
  454. COUNT   nFiles;
  455. BYTE    drv;
  457. pLine = skipwh(pLine);
  458. drv = *pLine & ~0x20;   
  460. if (drv < 'A' || drv > 'Z')
  461. {        
  462. CfgFailure(pLine);
  463. return;
  464. }
  465. drv -= 'A';
  466. Config.cfgLastdrive = max(Config.cfgLastdrive, drv);
  467. }
  469. static VOID Switchar(BYTE *pLine)
  470. {
  471. /* Format: SWITCHAR = character         */
  473. GetStringArg(pLine, szBuf);
  474. switchar = *szBuf;
  475. }
  477. static VOID Fcbs(BYTE *pLine)
  478. {
  479. /*  Format:     FCBS = totalFcbs [,protectedFcbs]    */
  481. if ((pLine = GetNumArg(pLine, &Config.cfgFcbs)) == 0)
  482.     return;
  484. pLine = skipwh(pLine);
  486. if (*pLine == ',')
  487.     GetNumArg(++pLine, &Config.cfgProtFcbs);
  489. if (Config.cfgProtFcbs > Config.cfgFcbs)
  490.     Config.cfgProtFcbs = Config.cfgFcbs;
  491. }
  493. static VOID Country(BYTE *pLine)
  494. {
  495. /* Format: COUNTRY = countryCode, [codePage], filename  */
  496. UWORD   ctryCode;
  497. UWORD   codePage;
  499. if ((pLine = GetNumArg(pLine, &ctryCode)) == 0)
  500.     return;
  501.     
  502. pLine = skipwh(pLine);
  503. if (*pLine == ',')
  504. {
  505. pLine = skipwh(pLine);
  507. if (*pLine == ',') 
  508. {
  509.     codePage = 0;
  510.     ++pLine;
  511. } else {
  512.     if ((pLine = GetNumArg(pLine, &codePage)) == 0)
  513. return;
  514. }
  516. pLine = skipwh(pLine);
  517. if (*pLine == ',')
  518. {
  519.     GetStringArg(++pLine, szBuf);
  520.     
  521.     if (LoadCountryInfo(szBuf, ctryCode, codePage))
  522. return;
  523. }
  524. }
  525. CfgFailure(pLine);
  526. }
  528. static VOID Stacks(BYTE *pLine)
  529. {
  530. /* Format:  STACKS = stacks [, stackSize]       */
  531. pLine = GetNumArg(pLine, &Config.cfgStacks);
  533. if (*pLine == ',')
  534.     GetNumArg(++pLine, &Config.cfgStackSize);
  536. if (Config.cfgStacks)
  537. {
  538.     if (Config.cfgStackSize < 32) Config.cfgStackSize = 32;
  539.     if (Config.cfgStackSize > 512) Config.cfgStackSize = 512;
  540.     if (Config.cfgStacks > 64) Config.cfgStacks = 64;
  541. }
  542. }
  544. static VOID InitPgm(BYTE *pLine)
  545. {
  546. /* Get the string argument that represents the new init pgm     */
  547. pLine = GetStringArg(pLine, Config.cfgInit);
  549. /* Now take whatever tail is left and add it on as a single     */
  550. /* string.                                                      */
  551. strcpy(Config.cfgInitTail, pLine);
  553. /* and add a DOS new line just to be safe                       */
  554. strcat(Config.cfgInitTail, "rn");
  555. }
  557. static VOID   Break(BYTE *pLine)
  558. {
  559. /* Format:      BREAK = (ON | OFF)      */
  560. BYTE *pTmp;
  562. GetStringArg(pLine, szBuf);
  563. break_ena = strcmp(szBuf, "OFF")? 1 : 0;
  564. }
  566. static VOID Device(BYTE *pLine)
  567. {
  568. VOID FAR *driver_ptr;
  569. BYTE *pTmp;
  570. exec_blk eb;
  571. struct dhdr FAR *dhp;
  572. struct dhdr FAR *next_dhp;
  573. UWORD dev_seg = (((ULONG)FP_SEG(lpBase) << 4) + FP_OFF(lpBase) + 0xf) >> 4;
  575. /* Get the device driver name                                   */
  576. GetStringArg(pLine, szBuf);
  578. /* The driver is loaded at the top of allocated memory.         */             
  579. /* The device driver is paragraph aligned.                      */
  580. eb.load.reloc = eb.load.load_seg = dev_seg;
  581. dhp = MK_FP(dev_seg, 0);
  583. #ifdef DEBUG
  584. printf("Loading device driver %s at segment %04xn", 
  585.        szBuf, dev_seg);
  586. #endif
  588. if (DosExec(3, &eb, szBuf) == SUCCESS)
  589. {
  590.     while(FP_OFF(dhp) != 0xFFFF)
  591.     {
  592. next_dhp = MK_FP(FP_SEG(dhp), FP_OFF(dhp -> dh_next));
  593. dhp -> dh_next = nul_dev.dh_next; 
  594. link_dhdr(&nul_dev, dhp, pLine); 
  595. dhp = next_dhp;
  596.     } 
  597. } else CfgFailure(pLine);
  598. }
  600. static VOID CfgFailure(BYTE *pLine)
  601. {
  602. BYTE *pTmp = pLineStart;
  604. printf("CONFIG.SYS error in line %dn", nCfgLine);
  605. printf(">>>%sn", pTmp);
  606. while(++pTmp != pLine)
  607. printf(" ");
  608. printf("^n");
  609. }
  611. #ifndef KDB
  612. static BYTE FAR *
  613. KernelAlloc(WORD nBytes)
  614. {
  615. BYTE FAR *lpAllocated;
  617. lpBase = AlignParagraph(lpBase);
  618. lpAllocated = lpBase;
  620. if (0x10000 - FP_OFF(lpBase) <= nBytes)
  621. {
  622. UWORD newOffs = (FP_OFF(lpBase) + nBytes) & 0xFFFF;
  623. UWORD newSeg = FP_SEG(lpBase) + 0x1000;
  625. lpBase = MK_FP(newSeg, newOffs);
  626. } else lpBase += nBytes;
  628. return lpAllocated;
  629. }
  630. #endif
  632. #ifdef I86
  633. static VOID FAR *AlignParagraph(VOID FAR *lpPtr)
  634. {
  635. ULONG lTemp;
  636. UWORD uSegVal;
  638. /* First, convert the segmented pointer to linear address */
  639. lTemp = FP_SEG(lpPtr);
  640. lTemp = (lTemp << 4) + FP_OFF(lpPtr);
  642. /* Next, round up the linear address to a paragraph boundary. */
  643. lTemp += 0x0f;
  644. lTemp &= 0xfffffff0l;
  646. /* Break it into segments.                                      */
  647. uSegVal = (UWORD)(lTemp >> 4);
  649. /* and return an adddress adjusted to the nearest paragraph     */
  650. /* boundary.                                                    */
  651. return MK_FP(uSegVal, 0);
  652. }
  653. #endif