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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet客户端 > 查看源码
tnconfig.cpp
资源名称：telnet-2.1b2-source.zip　[点击查看]
上传用户：tigerk9
上传日期：2020-03-10
资源大小：237k
文件大小：20k
源码类别：

Telnet客户端

开发平台：

Visual C++

tnconfig.cpp：源码内容
  1. ///////////////////////////////////////////////////////////////////////////////
  2. //Telnet Win32 : an ANSI telnet client.
  3. //Copyright (C) 1998-2000 Paul Brannan
  4. //Copyright (C) 1998 I.Ioannou
  5. //Copyright (C) 1997 Brad Johnson
  6. //
  7. //This program is free software; you can redistribute it and/or
  8. //modify it under the terms of the GNU General Public License
  9. //as published by the Free Software Foundation; either version 2
  10. //of the License, or (at your option) any later version.
  11. //
  12. //This program is distributed in the hope that it will be useful,
  13. //but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. //GNU General Public License for more details.
  16. //
  17. //You should have received a copy of the GNU General Public License
  18. //along with this program; if not, write to the Free Software
  19. //Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. //
  21. //I.Ioannou
  22. //roryt@hol.gr
  23. //
  24. ///////////////////////////////////////////////////////////////////////////
  26. // tnconfig.cpp
  27. // Written by Paul Brannan <pbranna@clemson.edu>
  28. // Last modified August 30, 1998
  29. //
  30. // This is a class designed for use with Brad Johnson's Console Telnet
  31. // see the file tnconfig.h for more information
  33. #include <stdlib.h>
  34. #include <string.h>
  35. #include <locale.h>
  36. #include <memory.h>
  37. #include <io.h>
  38. #include <sys/types.h>
  39. #include <sys/stat.h>
  40. #include "tnconfig.h"
  42. // Turn off the "forcing value to bool 'true' or 'false'" warning
  43. #ifdef _MSC_VER
  44. #pragma warning(disable: 4800)
  45. #endif
  47. // This is the ini variable that is used for everybody
  48. TConfig ini;
  50. TConfig::TConfig() {
  51. // set all default values
  52. startdir[0] = '';
  53. keyfile[0] = '';
  54. inifile[0] = '';
  55. dumpfile[0] = '';
  56. term[0] = '';
  57. default_config[0] = '';
  58. strcpy(printer_name, "LPT1");
  60. input_redir = 0;
  61. output_redir = 0;
  62. strip_redir = FALSE;
  64. dstrbksp = FALSE;
  65. eightbit_ansi = FALSE;
  66. vt100_mode = FALSE;
  67. disable_break = FALSE;
  68. speaker_beep = TRUE;
  69. do_beep = TRUE;
  70. preserve_colors = FALSE;
  71. wrapline = TRUE;
  72. lock_linewrap = FALSE;
  73. fast_write = TRUE;
  74. enable_mouse = TRUE;
  75. alt_erase = FALSE;
  76. wide_enable = FALSE;
  77. keyboard_paste = FALSE;
  78. set_title = TRUE;
  80. blink_bg = -1;
  81. blink_fg = 2;
  82. underline_bg = -1;
  83. underline_fg = 3;
  84. ulblink_bg = -1;
  85. ulblink_fg = 1;
  86. normal_bg = -1;
  87. normal_fg = -1;
  88. scroll_bg = 0;
  89. scroll_fg = 7;
  90. status_bg = 1;
  91. status_fg = 15;
  93. buffer_size = 2048;
  95. term_width = -1;
  96. term_height = -1;
  97. window_width = -1;
  98. window_height = -1;
  100. strcpy(escape_key, "]");
  101. strcpy(scrollback_key, "[");
  102. strcpy(dial_key, "\");
  103. strcpy(default_config, "ANSI");
  104. strcpy(term, "ansi");
  106. strcpy(scroll_mode, "DUMP");
  107. scroll_size=32000;
  108. scroll_enable=TRUE;
  110. host[0] = '';
  111. port = "23";
  113. init_varlist();
  115. aliases = NULL;
  116. }
  118. TConfig::~TConfig() {
  119. if(aliases) {
  120. for(int j = 0; j < alias_total; j++) delete[] aliases[j];
  121. delete[] aliases;
  122. }
  123. }
  125. enum ini_data_type {
  126. INI_STRING,
  127. INI_INT,
  128. INI_BOOL
  129. };
  131. enum {
  132. INIFILE,
  133. KEYFILE,
  134. DUMPFILE,
  135. DEFAULT_CONFIG,
  136. TERM,
  137. INPUT_REDIR,
  138. OUTPUT_REDIR,
  139. STRIP_REDIR,
  140. DSTRBKSP,
  141. EIGHTBIT_ANSI,
  142. VT100_MODE,
  143. DISABLE_BREAK,
  144. SPEAKER_BEEP,
  145. DO_BEEP,
  146. PRESERVE_COLORS,
  147. WRAP_LINE,
  148. LOCK_LINEWRAP,
  149. FAST_WRITE,
  150. TERM_WIDTH,
  151. TERM_HEIGHT,
  152. WINDOW_WIDTH,
  153. WINDOW_HEIGHT,
  154. WIDE_ENABLE,
  155. CTRLBREAK_AS_CTRLC,
  156. BUFFER_SIZE,
  157. SET_TITLE,
  158. BLINK_BG,
  159. BLINK_FG,
  160. UNDERLINE_BG,
  161. UNDERLINE_FG,
  162. ULBLINK_BG,
  163. ULBLINK_FG,
  164. NORMAL_BG,
  165. NORMAL_FG,
  166. SCROLL_BG,
  167. SCROLL_FG,
  168. STATUS_BG,
  169. STATUS_FG,
  170. PRINTER_NAME,
  171. ENABLE_MOUSE,
  172. ESCAPE_KEY,
  173. SCROLLBACK_KEY,
  174. DIAL_KEY,
  175. ALT_ERASE,
  176. KEYBOARD_PASTE,
  177. SCROLL_MODE,
  178. SCROLL_SIZE,
  179. SCROLL_ENABLE,
  180. SCRIPTNAME,
  181. SCRIPT_ENABLE,
  182. NETPIPE,
  183. IOPIPE,
  185. MAX_INI_VARS // must be last
  186. };
  188. struct ini_variable {
  189. char *name; // variable name
  190. char *section; // name of ini file section the variable is in
  191. enum ini_data_type data_type; // type of data
  192. void *ini_data; // pointer to data
  193. int  max_size; // max size if string
  194. };
  196. // Note: default values are set in the constructor, TConfig()
  197. ini_variable ini_varlist[MAX_INI_VARS];
  199. enum {
  200. KEYBOARD,
  201. TERMINAL,
  202. COLORS,
  203. MOUSE,
  204. PRINTER,
  205. SCROLLBACK,
  206. SCRIPTING,
  207. PIPES,
  209. MAX_INI_GROUPS // Must be last
  210. };
  212. char *ini_groups[MAX_INI_GROUPS];
  214. void TConfig::init_varlist() {
  215. static const ini_variable static_ini_varlist[MAX_INI_VARS] = {
  216. {"Inifile", NULL, INI_STRING, &inifile, sizeof(inifile)},
  217. {"Keyfile", "Keyboard", INI_STRING, &keyfile, sizeof(keyfile)},
  218. {"Dumpfile", "Terminal", INI_STRING, &dumpfile, sizeof(dumpfile)},
  219. {"Default_Config","Keyboard",   INI_STRING, &default_config, sizeof(default_config)},
  220. {"Term", "Terminal", INI_STRING, &term, sizeof(term)},
  221. {"Input_Redir", "Terminal", INI_INT, &input_redir, 0},
  222. {"Output_Redir","Terminal", INI_INT, &output_redir, 0},
  223. {"Strip_Redir", "Terminal", INI_BOOL, &strip_redir, 0},
  224. {"Destructive_Backspace","Terminal",INI_BOOL, &dstrbksp, 0},
  225. {"EightBit_Ansi","Terminal", INI_BOOL, &eightbit_ansi, 0},
  226. {"VT100_Mode", "Terminal", INI_BOOL, &vt100_mode, 0},
  227. {"Disable_Break","Terminal", INI_BOOL, &disable_break, 0},
  228. {"Speaker_Beep","Terminal", INI_BOOL, &speaker_beep, 0},
  229. {"Beep", "Terminal", INI_BOOL, &do_beep, 0},
  230. {"Preserve_Colors","Terminal", INI_BOOL, &preserve_colors, 0},
  231. {"Wrap_Line", "Terminal", INI_BOOL, &wrapline, 0},
  232. {"Lock_linewrap","Terminal", INI_BOOL, &lock_linewrap, 0},
  233. {"Fast_Write", "Terminal", INI_BOOL, &fast_write, 0},
  234. {"Term_Width", "Terminal", INI_INT, &term_width, 0},
  235. {"Term_Height", "Terminal", INI_INT, &term_height, 0},
  236. {"Window_Width","Terminal", INI_INT, &window_width, 0},
  237. {"Window_Height","Terminal", INI_INT, &window_height, 0},
  238. {"Wide_Enable", "Terminal", INI_BOOL, &wide_enable, 0},
  239. {"Ctrlbreak_as_Ctrlc","Keyboard", INI_BOOL, &ctrlbreak_as_ctrlc, 0},
  240. {"Buffer_Size", "Terminal", INI_INT, &buffer_size, 0},
  241. {"Set_Title", "Terminal", INI_BOOL, &set_title, 0},
  242. {"Blink_bg", "Colors", INI_INT, &blink_bg, 0},
  243. {"Blink_fg", "Colors", INI_INT, &blink_fg, 0},
  244. {"Underline_bg","Colors", INI_INT, &underline_bg, 0},
  245. {"Underline_fg","Colors", INI_INT, &underline_fg, 0},
  246. {"UlBlink_bg", "Colors", INI_INT, &ulblink_bg, 0},
  247. {"UlBlink_fg", "Colors", INI_INT, &ulblink_fg, 0},
  248. {"Normal_bg", "Colors", INI_INT, &normal_bg, 0},
  249. {"Normal_fg", "Colors", INI_INT, &normal_fg, 0},
  250. {"Scroll_bg", "Colors", INI_INT, &scroll_bg, 0},
  251. {"Scroll_fg", "Colors", INI_INT, &scroll_fg, 0},
  252. {"Status_bg", "Colors", INI_INT, &status_bg, 0},
  253. {"Status_fg", "Colors", INI_INT, &status_fg, 0},
  254. {"Enable_Mouse","Mouse", INI_BOOL, &enable_mouse, 0},
  255. {"Printer_Name","Printer", INI_STRING, &printer_name, sizeof(printer_name)},
  256. {"Escape_Key", "Keyboard", INI_STRING, &escape_key, 1},
  257. {"Scrollback_Key","Keyboard", INI_STRING, &scrollback_key, 1},
  258. {"Dial_Key", "Keyboard", INI_STRING, &dial_key, 1},
  259. {"Alt_Erase", "Keyboard", INI_BOOL, &alt_erase, 0},
  260. {"Keyboard_Paste","Keyboard", INI_BOOL, &keyboard_paste, 0},
  261. {"Scroll_Mode", "Scrollback", INI_STRING, &scroll_mode, sizeof(scroll_mode)},
  262. {"Scroll_Size", "Scrollback", INI_INT, &scroll_size, 0},
  263. {"Scroll_Enable","Scrollback", INI_BOOL, &scroll_enable, 0},
  264. {"Scriptname", "Scripting", INI_STRING, &scriptname, sizeof(scriptname)},
  265. {"Script_enable","Scripting", INI_BOOL, &script_enable, 0},
  266. {"Netpipe", "Pipes", INI_STRING, &netpipe, sizeof(netpipe)},
  267. {"Iopipe", "Pipes", INI_STRING, &iopipe, sizeof(iopipe)}
  268. };
  270. static const char *static_ini_groups[MAX_INI_GROUPS] = {
  271. "Keyboard",
  272. "Terminal",
  273. "Colors",
  274. "Mouse",
  275. "Printer",
  276. "Scrollback",
  277. "Scripting",
  278. "Pipes"
  279. };
  281. memcpy(ini_varlist, static_ini_varlist, sizeof(ini_varlist));
  282. memcpy(ini_groups, static_ini_groups, sizeof(ini_groups));
  283. }
  285. void TConfig::init(char *dirname, char *execname) {
  286. // Copy temporary dirname to permanent startdir
  287. strncpy(startdir, dirname, sizeof(startdir));
  288. startdir[sizeof(startdir) - 1] = 0;
  290. // Copy temp execname to permanent exename (Thomas Briggs 12/7/98)
  291. strncpy(exename, execname, sizeof(exename));
  292. exename[sizeof(exename) - 1] = 0;
  294. // Initialize INI file
  295. inifile_init();
  297. // Initialize redir
  298. // Note that this must be done early, so error messages will be printed
  299. // properly
  300. redir_init();
  302. // Initialize aliases (Paul Brannan 1/1/99)
  303. init_aliases();
  305. // Make sure the file that we're trying to work with exists
  306. int iResult = access(inifile, 04);
  308. // Thomas Briggs 9/14/98
  309. if( iResult == 0 )
  310. // Tell the user what file we are reading
  311. // We cannot print any messages before initializing telnet_redir
  312. printm(0, FALSE, MSG_CONFIG, inifile);
  313. else
  314. // Tell the user that the file doesn't exist, but later read the
  315. // file anyway simply to populate the defaults
  316. printm(0, FALSE, MSG_NOINI, inifile);
  318. init_vars(); // Initialize misc. vars
  319. keyfile_init(); // Initialize keyfile
  320. }
  322. // Alias support (Paul Brannan 1/1/99)
  323. void TConfig::init_aliases() {
  324. char *buffer;
  325. alias_total = 0;
  327. // Find the correct buffer size
  328. // FIX ME!! some implementations of Mingw32 don't have a
  329. // GetPrivateProfileSecionNames function.  What do we do about this?
  330. #ifndef __MINGW32__
  331. {
  332. int size=1024, Result = 0;
  333. for(;;) {
  334. buffer = new char[size];
  335. Result = GetPrivateProfileSectionNames(buffer, size, inifile);
  336. if(Result < size - 2) break;
  337. size *= 2;
  338. delete[] buffer;
  339. }
  340. }
  341. #else
  342. return;
  343. #endif
  345. // Find the maximum number of aliases
  346. int max = 0;
  347. char *tmp;
  348. for(tmp = buffer; *tmp != 0; tmp += strlen(tmp) + 1)
  349. max++;
  351. aliases = new char*[max];
  353. // Load the aliases into an array
  354. for(tmp = buffer; *tmp != 0; tmp += strlen(tmp) + 1) {
  355. int flag = 0;
  356. for(int j = 0; j < MAX_INI_GROUPS; j++) {
  357. if(!stricmp(ini_groups[j], tmp)) flag = 1;
  358. }
  359. if(!flag) {
  360. aliases[alias_total] = new char[strlen(tmp)+1];
  361. strcpy(aliases[alias_total], tmp);
  362. alias_total++;
  363. }
  364. }
  366. delete[] buffer;
  367. }
  369. void TConfig::print_aliases() {
  370. for(int j = 0; j < alias_total; j++) {
  371. char alias_name[20];
  372. set_string(alias_name, aliases[j], sizeof(alias_name));
  373. for(unsigned int i = strlen(alias_name); i < sizeof(alias_name) - 1; i++)
  374. alias_name[i] = ' ';
  375. alias_name[sizeof(alias_name) - 1] = 0;
  376. printit(alias_name);
  377. if((j % 4) == 3) printit("n");
  378. }
  379. printit("n");
  380. }
  382. bool find_alias(const char *alias_name) {
  383. return false;
  384. }
  386. void TConfig::print_vars() {
  387. int j;
  388. for(j = 0; j < MAX_INI_VARS; j++) {
  389. if(print_value(ini_varlist[j].name) > 40) printit("n");
  390. else if(j % 2) printit("n");
  391. else printit("t");
  392. }
  393. if(j % 2) printit("n");
  394. }
  396. // Paul Brannan 9/3/98
  397. void TConfig::print_vars(char *s) {
  398. if(!strnicmp(s, "all", 3)) { // Print out all vars
  399. print_vars();
  400. return;
  401. }
  403. // See if the group exists
  404. int j, flag;
  405. for(j = 0, flag = 0; j < MAX_INI_GROUPS; j++)
  406. if(!stricmp(ini_groups[j], s)) break;
  407. // If not, print out the value of the variable by that name
  408. if(j == MAX_INI_GROUPS) {
  409. print_value(s);
  410. printit("n");
  411. return;
  412. }
  414. // Print out the vars in the given group
  415. int count = 0;
  416. for(j = 0; j < MAX_INI_VARS; j++) {
  417. if(ini_varlist[j].section == NULL) continue;
  418. if(!stricmp(ini_varlist[j].section, s)) {
  419. if(print_value(ini_varlist[j].name) > 40) printit("n");
  420. else if(count % 2) printit("n");
  421. else printit("t");
  422. count++;
  423. }
  424. }
  425. if(count % 2) printit("n");
  426. }
  428. // Paul Brannan 9/3/98
  429. void TConfig::print_groups() {
  430. for(int j = 0; j < MAX_INI_GROUPS; j++) {
  431. char group_name[20];
  432. set_string(group_name, ini_groups[j], sizeof(group_name));
  433. for(unsigned int i = strlen(group_name); i < sizeof(group_name) - 1; i++)
  434. group_name[i] = ' ';
  435. group_name[sizeof(group_name) - 1] = 0;
  436. printit(group_name);
  437. if((j % 4) == 3) printit("n");
  438. }
  439. printit("n");
  440. }
  442. // Ioannou : The index in the while causes segfaults if there is no match
  443. // changes to for(), and strcmp to stricmp (prompt gives rong names)
  445. bool TConfig::set_value(const char *var, const char *value) {
  446.    //int j = 0;
  447.    //while(strcmp(var, ini_varlist[j].name) && j < MAX_INI_VARS) j++;
  448.    for (int j = 0; j < MAX_INI_VARS; j++)
  449.    {
  450.       if (stricmp(var, ini_varlist[j].name) == 0)
  451.       {
  452.          switch(ini_varlist[j].data_type) {
  453.             case INI_STRING:
  454.                set_string((char *)ini_varlist[j].ini_data, value,
  455.                   ini_varlist[j].max_size);
  456.                break;
  457.             case INI_INT:
  458.                *(int *)ini_varlist[j].ini_data = atoi(value);
  459.                break;
  460.             case INI_BOOL:
  461.                set_bool((bool *)ini_varlist[j].ini_data, value);
  462.                break;
  463.          }
  464.          // j = MAX_INI_VARS;
  465.  return TRUE;
  466.       }
  467.    }
  468.    return FALSE;
  469. }
  471. int TConfig::print_value(const char *var) {
  472. //int j = 0;
  473. //while(strcmp(var, ini_varlist[j].name) && j < MAX_INI_VARS) j++;
  474. int Result = 0;
  475. for (int j = 0; j < MAX_INI_VARS; j++)
  476. {
  477. if (stricmp(var, ini_varlist[j].name) == 0)
  478. {
  479. char var_name[25];
  480. set_string(var_name, var, sizeof(var_name));
  481. for(unsigned int i = strlen(var_name); i < sizeof(var_name) - 1; i++)
  482. var_name[i] = ' ';
  483. var_name[sizeof(var_name) - 1] = 0;
  484. Result = sizeof(var_name);
  486. printit(var_name);
  487. printit("t");
  488. Result = Result / 8 + 8;
  490. switch(ini_varlist[j].data_type) {
  491.             case INI_STRING:
  492. printit((char *)ini_varlist[j].ini_data);
  493. Result += strlen((char *)ini_varlist[j].ini_data);
  494. break;
  495.             case INI_INT:
  496. char buffer[20]; // this may not be safe
  497. // Ioannou : Paul this was _itoa, but Borland needs itoa !!
  498. itoa(*(int *)ini_varlist[j].ini_data, buffer, 10);
  499. printit(buffer);
  500. Result += strlen(buffer);
  501. break;
  502.             case INI_BOOL:
  503. if(*(bool *)ini_varlist[j].ini_data == true) {
  504. printit("on");
  505. Result += 2;
  506. } else {
  507. printit("off");
  508. Result += 3;
  509. }
  510. }
  511. // printit("n");
  512. j = MAX_INI_VARS;
  513. }
  514. }
  515. return Result;
  516. }
  518. void TConfig::init_vars() {
  519. char buffer[4096];
  520. for(int j = 0; j < MAX_INI_VARS; j++) {
  521. if(ini_varlist[j].section != NULL) {
  522. GetPrivateProfileString(ini_varlist[j].section, ini_varlist[j].name, "",
  523. buffer, sizeof(buffer), inifile);
  524. if(*buffer != 0) set_value(ini_varlist[j].name, buffer);
  525. }
  526. }
  527. }
  529. void TConfig::inifile_init() {
  530. // B. K. Oxley 9/16/98
  531. char* env_telnet_ini = getenv (ENV_TELNET_INI);
  532. if (env_telnet_ini && *env_telnet_ini) {
  533. strncpy (inifile, env_telnet_ini, sizeof(inifile));
  534. return;
  535. }
  537. strcpy(inifile, startdir);
  538. if (sizeof(inifile) >= strlen(inifile)+strlen("telnet.ini")) {
  539. strcat(inifile,"telnet.ini"); // add the default filename to the path
  540. } else {
  541. // if there is not enough room set the path to nothing
  542. strcpy(inifile,"");
  543. }
  544. }
  546. void TConfig::keyfile_init() {
  547. // check to see if there is a key config file environment variable.
  548. char *k;
  549. if ((k = getenv(ENV_TELNET_CFG)) == NULL){
  550. // if there is no environment variable
  551. GetPrivateProfileString("Keyboard", "Keyfile", "", keyfile,
  552. sizeof(keyfile), inifile);
  553. if(keyfile == 0 || *keyfile == 0) {
  554. // and there is no profile string
  555. strcpy(keyfile, startdir);
  556. if (sizeof(keyfile) >= strlen(keyfile)+strlen("telnet.cfg")) {
  557. struct stat buf;
  559. strcat(keyfile,"telnet.cfg"); // add the default filename to the path
  560. if(stat(keyfile, &buf) != 0) {
  561. char *s = keyfile + strlen(keyfile) - strlen("telnet.cfg");
  562. strcpy(s, "keys.cfg");
  563. }
  564. } else {
  565. // if there is not enough room set the path to nothing
  566. strcpy(keyfile,"");
  567. }
  569. // Vassili Bourdo (vassili_bourdo@softhome.net)
  570. } else {
  571. // check that keyfile really exists
  572. if( access(keyfile,04) == -1 ) {
  573. //it does not...
  574. char pathbuf[MAX_PATH], *fn;
  575. //substitute keyfile path with startdir path
  576. if((fn = strrchr(keyfile,'\'))) strcpy(keyfile,fn);
  577. strcat(strcpy(pathbuf,startdir),keyfile);
  578. //check that startdirkeyfile does exist
  579. if( access(pathbuf,04) == -1 ) {
  580. //it does not...
  581. //so, look for it in all paths
  582. _searchenv(keyfile, "PATH", pathbuf);
  583. if( *pathbuf == 0 ) //no luck - revert it to INI file value
  584. GetPrivateProfileString("Keyboard", "Keyfile", "",
  585. keyfile, sizeof(keyfile), inifile);
  586. } else {
  587. strcpy(keyfile, pathbuf);
  588. }
  589. }
  590. }
  591. ////
  593. } else {
  594. // set the keyfile to the value of the environment variable
  595. strncpy(keyfile, k, sizeof(keyfile));
  596. }
  597. }
  599. void TConfig::redir_init() {
  600. // check to see if the environment variable 'TELNET_REDIR' is not 0;
  601. char* p = getenv(ENV_TELNET_REDIR);
  602. if (p) {
  603. input_redir = output_redir = atoi(p);
  604. if((p = getenv(ENV_INPUT_REDIR))) input_redir = atoi(p);
  605. if((p = getenv(ENV_OUTPUT_REDIR))) output_redir = atoi(p);
  606. } else {
  607. input_redir = output_redir = GetPrivateProfileInt("Terminal",
  608. "Telnet_Redir", 0, inifile);
  609. input_redir = GetPrivateProfileInt("Terminal",
  610. "Input_Redir", input_redir, inifile);
  611. output_redir = GetPrivateProfileInt("Terminal",
  612. "Output_Redir", output_redir, inifile);
  613. }
  614. if ((input_redir > 1) || (output_redir > 1))
  615. setlocale(LC_CTYPE,"");
  616. // tell isprint() to not ignore local characters, if the environment
  617. // variable "LANG" has a valid value (e.g. LANG=de for german characters)
  618. // and the file LOCALE.BLL is installed somewhere along the PATH.
  619. }
  621. // Modified not to use getopt() by Paul Brannan 12/17/98
  622. bool TConfig::Process_Params(int argc, char *argv[]) {
  623. int optind = 1;
  624. char *optarg = argv[optind];
  625. char c;
  627. while(optind < argc) {
  628. if(argv[optind][0] != '-') break;
  630. // getopt
  631. c = argv[optind][1];
  632. if(argv[optind][2] == 0)
  633. optarg = argv[++optind];
  634. else
  635. optarg = &argv[optind][2];
  636. optind++;
  638. switch(c) {
  639. case 'd':
  640. set_string(dumpfile, optarg, sizeof(dumpfile));
  641. printm(0, FALSE, MSG_DUMPFILE, dumpfile);
  642. break;
  643. // added support for setting options on the command-line
  644. // (Paul Brannan 7/31/98)
  645. case '-':
  646. {
  647. int j;
  648. for(j = 0; optarg[j] != ' ' && optarg[j] != '=' && optarg[j] != 0; j++);
  649. if(optarg == 0) {
  650. printm(0, FALSE, MSG_USAGE); // print a usage message
  651. printm(0, FALSE, MSG_USAGE_1);
  652. return FALSE;
  653. }
  654. optarg[j] = 0;
  655. if(!set_value(optarg, &optarg[j+1]))
  656. printm(0, FALSE, MSG_BADVAL, optarg);
  657. }
  658. break;
  659. default:
  660. printm(0, FALSE, MSG_USAGE); // print a usage message
  661. printm(0, FALSE, MSG_USAGE_1);
  662. return FALSE;
  663. }
  664. }
  665. if(optind < argc)
  666. set_string(host, argv[optind++], sizeof(host)-1);
  667. if(!strnicmp(host, "telnet://", 9)) {
  668. // we have a URL to parse
  669. char *s, *t;
  671. for(s = host+9, t = host; *s != 0; *(t++) = *(s++));
  672. *t = 0;
  673. for(s = host; *s != ':' && *s != 0; s++);
  674. if(*s != 0) {
  675. *(s++) = 0;
  676. port = s;
  677. }
  678. }
  679. if(optind < argc)
  680. port = argv[optind++];
  682. return TRUE;
  683. }
  685. void TConfig::set_string(char *dest, const char *src, const int length) {
  686.    int l = length;
  687.    strncpy(dest, src, l);
  688.  //  dest[length-1] = '';
  689.  // Ioannou : this messes strings - is this really needed ?
  690.  // The target string, dest, might not be null-terminated
  691.  // if the length of src is length or more.
  692.  // it should be dest[length] = '' for strings with length 1
  693.  // (Escape_string etc), but doesn't work with others (like host).
  694.  // dest is long enough to avoid this in all the tested cases
  695. }
  697. // Ioannou : ignore case for true or on
  699. void TConfig::set_bool(bool *boolval, const char *str) {
  700.    if(!stricmp(str, "true")) *boolval = true;
  701.    else if(!stricmp(str, "on")) *boolval = true;
  702. else *boolval = (bool)atoi(str);
  703. }