home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume16 / ecu3 / part09 < prev    next >
Internet Message Format  |  1991-01-06  |  54KB
  1. From: wht@n4hgf.uucp (Warren Tucker)
  2. Newsgroups: comp.sources.misc
  3. Subject: v16i033:  ECU async comm package rev 3.0, Part09/35
  4. Message-ID: <1991Jan6.052006.27685@sparky.IMD.Sterling.COM>
  5. Date: 6 Jan 91 05:20:06 GMT
  6. Approved: kent@sparky.imd.sterling.com
  7. X-Checksum-Snefru: f724537b b2bfecec dd1dc523 3bd91963
  8.  
  9. Submitted-by: wht@n4hgf.uucp (Warren Tucker)
  10. Posting-number: Volume 16, Issue 33
  11. Archive-name: ecu3/part09
  12.  
  13. ---- Cut Here and feed the following to sh ----
  14. #!/bin/sh
  15. # This is part 09 of ecu3
  16. if touch 2>&1 | fgrep 'amc' > /dev/null
  17.  then TOUCH=touch
  18.  else TOUCH=true
  19. fi
  20. # ============= ecuutil.c ==============
  21. echo 'x - extracting ecuutil.c (Text)'
  22. sed 's/^X//' << 'SHAR_EOF' > 'ecuutil.c' &&
  23. X/*+-----------------------------------------------------------------------
  24. X    ecuutil.c -- utility routines for extended calling unit
  25. X    wht@n4hgf.Mt-Park.GA.US
  26. X
  27. X  Defined functions:
  28. X    arg_token(parsestr,termchars)
  29. X    ascii_name_to_hex(str3char)
  30. X    ascii_to_hex(ascii)
  31. X    build_arg_array(cmd,arg,arg_max_quan,narg_rtn)
  32. X    build_str_array(str,arg,str_max_quan,nstr_rtn)
  33. X    disp_line_termio(fd,text)
  34. X    disp_stat(st)
  35. X    disp_termio(ttt,text)
  36. X    errno_text(errno)
  37. X    find_shell_chars(command)
  38. X    get_curr_dir(cdir,cdir_max)
  39. X    get_home_dir(home_dir)
  40. X    hex_to_ascii_name(char_val)
  41. X    make_char_graphic(ch,incl_3char)
  42. X    make_dirs(pathname)
  43. X    make_ecu_subdir()
  44. X    mem_cpy(dest,src,len);
  45. X    mkdir(dpath,dmode)
  46. X    mode_map(mode,mode_str)
  47. X    pad_zstr_to_len(zstr,len)
  48. X    perror_errmsg(str)
  49. X    print_cwd(curdir,buf_size)
  50. X    skip_ld_break(zstr)
  51. X    str_token(parsestr,termchars)
  52. X    yes_or_no(strarg)
  53. X
  54. X------------------------------------------------------------------------*/
  55. X/*+:EDITS:*/
  56. X/*:12-04-1990-00:58-wht@n4hgf-allow alternating between str/arg_token */
  57. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  58. X
  59. X#include "ecu.h"
  60. X#include "ecuhangup.h"
  61. X#include "ecufork.h"
  62. X#include <pwd.h>
  63. X
  64. Xchar *getenv();
  65. X
  66. Xextern int errno;
  67. Xextern int rcvr_pid;        /* ==0 if rcvr process, else pid of rcvr */
  68. Xextern char curr_dir[];
  69. X
  70. Xchar *str_token_static = (char *)0;
  71. X
  72. Xchar *ascii_ctlstr =
  73. X"NULSOHSTXETXEOTENQACKBELBS HT NL VT FF CR SO SI DLEDC1DC2DC3DC4NAKSYNETBCANEM SUBESCFS GS RS US ";
  74. X
  75. X/*+-------------------------------------------------------------------------
  76. X    mem_cpy(dest,src,len) - memcpy() with non-destructive overlapping copy
  77. X--------------------------------------------------------------------------*/
  78. Xvoid
  79. Xmem_cpy(dest,src,len)
  80. Xregister char *dest;
  81. Xregister char *src;
  82. Xregister len;
  83. X{
  84. X    if(dest > src)
  85. X    {
  86. X        dest += len;
  87. X        src += len;
  88. X        while(len--)
  89. X            *--dest = *--src;
  90. X    }
  91. X    else
  92. X    {
  93. X        while(len--)
  94. X            *dest++ = *src++;
  95. X    }
  96. X}    /* end of mem_cpy */
  97. X
  98. X/*+-------------------------------------------------------------------------
  99. X    errno_text(errno)
  100. X--------------------------------------------------------------------------*/
  101. Xchar *
  102. Xerrno_text(errno)
  103. Xint errno;
  104. X{
  105. Xstatic char errant[16];
  106. X
  107. X    switch(errno)
  108. X    {
  109. X        case 0: return("0");
  110. X        case EPERM: return("EPERM");
  111. X        case ENOENT: return("ENOENT");
  112. X        case ESRCH: return("ESRCH");
  113. X        case EINTR: return("EINTR");
  114. X        case EIO: return("EIO");
  115. X        case ENXIO: return("ENXIO");
  116. X        case E2BIG: return("E2BIG");
  117. X        case ENOEXEC: return("ENOEXEC");
  118. X        case EBADF: return("EBADF");
  119. X        case ECHILD: return("ECHILD");
  120. X        case EAGAIN: return("EAGAIN");
  121. X        case ENOMEM: return("ENOMEM");
  122. X        case EACCES: return("EACCES");
  123. X        case EFAULT: return("EFAULT");
  124. X        case ENOTBLK: return("ENOTBLK");
  125. X        case EBUSY: return("EBUSY");
  126. X        case EEXIST: return("EEXIST");
  127. X        case EXDEV: return("EXDEV");
  128. X        case ENODEV: return("ENODEV");
  129. X        case ENOTDIR: return("ENOTDIR");
  130. X        case EISDIR: return("EISDIR");
  131. X        case EINVAL: return("EINVAL");
  132. X        case ENFILE: return("ENFILE");
  133. X        case EMFILE: return("EMFILE");
  134. X        case ENOTTY: return("ENOTTY");
  135. X        case ETXTBSY: return("ETXTBSY");
  136. X        case EFBIG: return("EFBIG");
  137. X        case ENOSPC: return("ENOSPC");
  138. X        case ESPIPE: return("ESPIPE");
  139. X        case EROFS: return("EROFS");
  140. X        case EMLINK: return("EMLINK");
  141. X        case EPIPE: return("EPIPE");
  142. X        case EDOM: return("EDOM");
  143. X        case ERANGE: return("ERANGE");
  144. X        default:
  145. X            sprintf(errant,"E%04u",errno);
  146. X            return(errant);
  147. X    }
  148. X
  149. X}    /* end of errno_text */
  150. X
  151. X/*+-------------------------------------------------------------------------
  152. X    skip_ld_break(zstr) - skip leading spaces and tabs
  153. X--------------------------------------------------------------------------*/
  154. Xchar *
  155. Xskip_ld_break(zstr)
  156. Xregister char *zstr;
  157. X{
  158. X    while(isspace(*zstr))
  159. X        zstr++;
  160. X    return(zstr);
  161. X}    /* end of skip_ld_break */
  162. X
  163. X/*+-------------------------------------------------------------------------
  164. X    strip_trail_break(zstr) - strip leading spaces and tabs
  165. X--------------------------------------------------------------------------*/
  166. Xvoid
  167. Xstrip_trail_break(zstr)
  168. Xchar *zstr;
  169. X{
  170. Xregister int itmp = strlen(zstr);
  171. Xregister char *zptr = zstr + itmp - 1;
  172. X
  173. X    while(itmp && isspace(*zptr))
  174. X    {
  175. X        *zptr-- = 0;
  176. X        itmp--;
  177. X    }
  178. X}    /* end of strip_trail_break */
  179. X
  180. X/*+-----------------------------------------------------------------------
  181. X    pad_zstr_to_len(zstr,len)
  182. X
  183. X  pads with spaces to specified length, unless already longer than
  184. X  len in which case the string is truncated to 'len' characters.
  185. X------------------------------------------------------------------------*/
  186. Xvoid
  187. Xpad_zstr_to_len(zstr,len)
  188. Xchar *zstr;
  189. Xint len;
  190. X{
  191. Xregister izstr;
  192. X
  193. X    izstr = strlen(zstr);
  194. X    if(izstr >= len)
  195. X        zstr[len] = 0;
  196. X    else
  197. X    {
  198. X        while(izstr < len)
  199. X            zstr[izstr++] = 0x20;
  200. X        zstr[izstr] = 0;
  201. X    }
  202. X}    /* end of pad_zstr_to_len */
  203. X
  204. X/*+-----------------------------------------------------------------------
  205. X    arg_token(parsestr,termchars)
  206. X
  207. XGet next token from string parsestr ((char *)0 on 2nd, 3rd, etc.
  208. Xcalls), where tokens are nonempty strings separated by runs of chars
  209. Xfrom termchars.  Writes nulls into parsestr to end tokens.
  210. Xtermchars need not remain constant from call to call.
  211. X
  212. XTreats multiple occurrences of a termchar as one delimiter (does not
  213. Xallow null fields).
  214. X------------------------------------------------------------------------*/
  215. Xchar *
  216. Xarg_token(parsestr,termchars)
  217. Xchar *parsestr;
  218. Xchar *termchars;
  219. X{
  220. Xregister int first = 1;
  221. Xregister char *termptr;
  222. Xregister char *parseptr;
  223. Xchar *token;
  224. X
  225. X    if(!parsestr && !str_token_static)
  226. X        return((char *)0);
  227. X
  228. X    if(parsestr)
  229. X        parseptr = parsestr;
  230. X    else
  231. X       parseptr = str_token_static;
  232. X
  233. X    while(*parseptr)
  234. X    {
  235. X        if(!strchr(termchars,*parseptr))
  236. X            break;
  237. X        parseptr++;
  238. X    }
  239. X
  240. X    if(!*parseptr)
  241. X    {
  242. X        str_token_static = (char *)0;
  243. X        return((char *)0);
  244. X    }
  245. X
  246. X    token = parseptr;
  247. X    if(*token == '\'')
  248. X    {
  249. X        token++;
  250. X        parseptr++;
  251. X        while(*parseptr)
  252. X        {
  253. X            if(*parseptr == '\'')
  254. X            {
  255. X                str_token_static = parseptr + 1;
  256. X                *parseptr = 0;
  257. X                return(token);
  258. X            }
  259. X            parseptr++;
  260. X        }
  261. X        str_token_static = (char *)0;
  262. X        return(token);
  263. X    }
  264. X    while(*parseptr)
  265. X    {
  266. X        if(strchr(termchars,*parseptr))
  267. X        {
  268. X            *parseptr = 0;
  269. X            str_token_static = parseptr + 1;
  270. X            while(*str_token_static)
  271. X            {
  272. X                if(!strchr(termchars,*str_token_static))
  273. X                    break;
  274. X                str_token_static++;
  275. X            }
  276. X            return(token);
  277. X        }
  278. X        parseptr++;
  279. X    }
  280. X    str_token_static = (char *)0;
  281. X    return(token);
  282. X}    /* end of arg_token */
  283. X
  284. X/*+-------------------------------------------------------------------------
  285. X    build_arg_array(cmd,arg,arg_max_quan,&narg)
  286. X--------------------------------------------------------------------------*/
  287. Xvoid
  288. Xbuild_arg_array(cmd,arg,arg_max_quan,narg_rtn)
  289. Xchar *cmd;
  290. Xchar **arg;
  291. Xint arg_max_quan;
  292. Xint *narg_rtn;
  293. X{
  294. Xregister itmp;
  295. Xregister narg;
  296. X
  297. X    for(itmp = 0; itmp < arg_max_quan; itmp++)
  298. X        arg[itmp] = (char *)0;
  299. X    arg[0] = arg_token(cmd," \t\r\n");
  300. X
  301. X    for(narg = 1; narg < arg_max_quan; ++narg)
  302. X    {
  303. X        if(!(arg[narg] = arg_token((char *)0," \t\r\n"))) 
  304. X            break;
  305. X    }
  306. X
  307. X    *narg_rtn = narg;
  308. X
  309. X}    /* end of build_arg_array */
  310. X
  311. X/*+-----------------------------------------------------------------------
  312. X    str_token(parsestr,termchars)
  313. X
  314. XGet next token from string parsestr ((char *)0 on 2nd, 3rd, etc.
  315. Xcalls), where tokens are nonempty strings separated by runs of chars
  316. Xfrom termchars.  Writes nulls into parsestr to end tokens.
  317. Xtermchars need not remain constant from call to call.
  318. X
  319. XTreats each occurrence of a termchar as delimiter (allows null
  320. Xfields).
  321. X------------------------------------------------------------------------*/
  322. Xchar *
  323. Xstr_token(parsestr,termchars)
  324. Xchar *parsestr;
  325. Xchar *termchars;
  326. X{
  327. Xregister char *termptr;
  328. Xregister char *parseptr;
  329. Xchar *token;
  330. X
  331. X    if(!parsestr && !str_token_static)
  332. X        return((char *)0);
  333. X
  334. X    if(parsestr)
  335. X        parseptr = parsestr;
  336. X    else
  337. X       parseptr = str_token_static;
  338. X
  339. X    while(*parseptr)
  340. X    {
  341. X        for(termptr = termchars; *termptr != 0; termptr++)
  342. X        {
  343. X            if(*parseptr == *termptr)
  344. X                goto FOUND_TERM;
  345. X        }
  346. X        if(!*termptr)
  347. X            break;
  348. X        parseptr++;
  349. X    }
  350. X
  351. X    if(!*parseptr)
  352. X    {
  353. X        str_token_static = (char *)0;
  354. X        return((char *)0);
  355. X    }
  356. X
  357. XFOUND_TERM:
  358. X    token = parseptr;
  359. X    while(*parseptr)
  360. X    {
  361. X        for(termptr = termchars; *termptr;)
  362. X        {
  363. X            if(*parseptr == *termptr++)
  364. X            {
  365. X                str_token_static = parseptr + 1;
  366. X                *parseptr = 0;
  367. X                return(token);
  368. X            }
  369. X        }
  370. X        parseptr++;
  371. X    }
  372. X    str_token_static = (char *)0;
  373. X    return(token);
  374. X}    /* end of str_token */
  375. X
  376. X/*+-------------------------------------------------------------------------
  377. X    build_str_array(str,arg,str_max_quan,&narg)
  378. X--------------------------------------------------------------------------*/
  379. Xvoid
  380. Xbuild_str_array(str,arg,str_max_quan,nstr_rtn)
  381. Xchar *str;
  382. Xchar **arg;
  383. Xint str_max_quan;
  384. Xint *nstr_rtn;
  385. X{
  386. Xregister itmp;
  387. Xregister narg;
  388. X
  389. X
  390. X    for(itmp = 0; itmp < str_max_quan; itmp++)
  391. X        arg[itmp] = (char *)0;
  392. X    arg[0] = str_token(str," \t\r\n");
  393. X
  394. X    for(narg = 1; narg < str_max_quan; ++narg)
  395. X    {
  396. X        if(!(arg[narg] = str_token((char *)0," \t\r\n"))) 
  397. X            break;
  398. X    }
  399. X
  400. X    *nstr_rtn = narg;
  401. X
  402. X}    /* end of build_str_array */
  403. X
  404. X/*+-----------------------------------------------------------------------
  405. X    make_char_graphic(character,incl_3char) - Make all chars "printable"
  406. X
  407. X  returns pointer to a static string containing printable version
  408. X  of a character.  If control char, printed as "^A", etc.
  409. X  if incl_3char set true, then space + ASCII assignment (e.g. "NUL") is
  410. X  appended to the string for non-printable graphics
  411. X------------------------------------------------------------------------*/
  412. Xchar *make_char_graphic(ch,incl_3char)
  413. Xregister char ch;
  414. Xint incl_3char;
  415. X{
  416. Xstatic char gg[16];
  417. X
  418. X    ch &= 0x7F;
  419. X    if((ch >= 0x20) && (ch < 0x7F))
  420. X    {
  421. X        gg[0] = ch; gg[1] = 0;
  422. X    }
  423. X    else
  424. X    {
  425. X        gg[0] = '^'; 
  426. X        if(ch == 0x7F)
  427. X        {
  428. X            gg[1] = '?';
  429. X            if(incl_3char)
  430. X                strcpy(&gg[2]," DEL");
  431. X            else
  432. X                gg[2] = 0;
  433. X        }
  434. X        else
  435. X        {
  436. X            gg[1] = ch + 0x40;
  437. X            if(incl_3char)
  438. X            {
  439. X                gg[2] = 0x20;
  440. X                strncpy(&gg[3],ascii_ctlstr + (ch * 3),3);
  441. X                gg[7] = 0;
  442. X            }
  443. X            else
  444. X                gg[2] = 0;
  445. X        }
  446. X    }
  447. X    return(gg);
  448. X}    /* end of make_char_graphic */
  449. X
  450. X/*+-----------------------------------------------------------------------
  451. X    disp_termio(ttt)
  452. X  display termio 'ttt' on stderr
  453. X------------------------------------------------------------------------*/
  454. Xvoid disp_termio(ttt,text)
  455. Xstruct termio *ttt;
  456. Xchar *text;
  457. X{
  458. Xregister flag;
  459. Xregister i_cc;
  460. Xregister char *cptr;
  461. Xint dbits;
  462. Xchar parity;
  463. X
  464. X    pprintf("---------> %s\n",text);
  465. X
  466. X    flag = ttt->c_iflag;
  467. X    pprintf("iflag: %07o IGNBRK:%d  BRKINT:%d  IGNPAR:%d  PARMRK:%d  INPCK:%d  ISTRIP:%d\n",
  468. X                flag,
  469. X                (flag & IGNBRK) ? 1 : 0,
  470. X                (flag & BRKINT) ? 1 : 0,
  471. X                (flag & IGNPAR) ? 1 : 0,
  472. X                (flag & PARMRK) ? 1 : 0,
  473. X                (flag & INPCK ) ? 1 : 0,
  474. X                (flag & ISTRIP) ? 1 : 0);
  475. X    pprintf(
  476. X"               INLCR:%d  IGNCR:%d  ICRNL:%d  IUCLC:%d  IXON:%d  IXANY:%d  IXOFF:%d\n",
  477. X                (flag & INLCR ) ? 1 : 0,
  478. X                (flag & IGNCR ) ? 1 : 0,
  479. X                (flag & ICRNL ) ? 1 : 0,
  480. X                (flag & IUCLC ) ? 1 : 0,
  481. X                (flag & IXON  ) ? 1 : 0,
  482. X                (flag & IXANY ) ? 1 : 0,
  483. X                (flag & IXOFF ) ? 1 : 0);
  484. X
  485. X    flag = ttt->c_oflag;
  486. X    pprintf("oflag: %07o OPOST:%d  OLCUC:%d  ONLCR:%d  OCRNL:%d  ONOCR:%d  ONLRET:%d  OFDEL:%d\n",
  487. X                flag,
  488. X                (flag & OPOST ) ? 1 : 0,
  489. X                (flag & OLCUC ) ? 1 : 0,
  490. X                (flag & ONLCR ) ? 1 : 0,
  491. X                (flag & OCRNL ) ? 1 : 0,
  492. X                (flag & ONOCR ) ? 1 : 0,
  493. X                (flag & ONLRET) ? 1 : 0,
  494. X                (flag & OFDEL ) ? 1 : 0);
  495. X
  496. X    flag = ttt->c_cflag;
  497. X    pprintf("cflag: %07o ",ttt->c_cflag);
  498. X    switch(flag & CBAUD)
  499. X    {
  500. X        case B0:    cptr = "HUP"; break;
  501. X        case B50:    cptr = "50"; break;
  502. X        case B75:    cptr = "75"; break;
  503. X        case B110:    cptr = "110"; break;
  504. X        case B134:    cptr = "134.5"; break;
  505. X        case B150:    cptr = "150"; break;
  506. X        case B200:    cptr = "200"; break;
  507. X        case B300:    cptr = "300"; break;
  508. X        case B600:    cptr = "600"; break;
  509. X        case B1200:    cptr = "1200"; break;
  510. X        case B1800:    cptr = "1800"; break;
  511. X        case B2400:    cptr = "2400"; break;
  512. X        case B4800:    cptr = "4800"; break;
  513. X        case B9600:    cptr = "9600"; break;
  514. X#if defined(B19200)
  515. X        case B19200:cptr = "19200"; break;
  516. X#endif
  517. X#if defined(B38400)
  518. X        case B38400:cptr = "38400"; break;
  519. X#endif
  520. X        default:    
  521. X            switch(flag & CBAUD)
  522. X            {
  523. X                case EXTA:    cptr = "EXTA"; break;
  524. X                case EXTB:    cptr = "EXTB"; break;
  525. X                default:    cptr = "????"; break;
  526. X            }
  527. X    }
  528. X    dbits = 5 + ((flag & CSIZE) >> 4);
  529. X    parity = (flag & PARENB) ? ((flag & PARODD) ? 'O' : 'E') : 'N';
  530. X    pprintf("%s-%d-%c-%d ",cptr,dbits,parity,(flag & CSTOPB) ? 2 : 1);
  531. X    switch(flag & CS8)
  532. X    {
  533. X        case CS8: pputs("CS8 "); break;
  534. X        case CS7: pputs("CS7 "); break;
  535. X        case CS6: pputs("CS6 "); break;
  536. X        case CS5: pputs("CS5 "); break;
  537. X    }
  538. X    pprintf("CREAD:%d  HUPCL:%d  CLOCAL:%d",
  539. X                (flag & CREAD ) ? 1 : 0,
  540. X                (flag & HUPCL ) ? 1 : 0,
  541. X                (flag & CLOCAL) ? 1 : 0);
  542. X#ifdef RTSFLOW
  543. X    pprintf(" RTSFLOW:%d  CTSFLOW:%d",
  544. X                (flag & RTSFLOW ) ? 1 : 0,
  545. X                (flag & CTSFLOW ) ? 1 : 0);
  546. X#endif
  547. X    pprintf("\n");
  548. X
  549. X    flag = ttt->c_lflag;
  550. X    pprintf("lflag: %07o ISIG:%d  ICANON:%d  XCASE:%d  ECHO:%d  ECHOE:%d\n",
  551. X                flag,
  552. X                (flag & ISIG  ) ? 1 : 0,
  553. X                (flag & ICANON) ? 1 : 0,
  554. X                (flag & XCASE ) ? 1 : 0,
  555. X                (flag & ECHO  ) ? 1 : 0,
  556. X                (flag & ECHOE ) ? 1 : 0);
  557. X    pprintf("            ECHOK:%d  ECHONL:%d  NOFLSH:%d",
  558. X                (flag & ECHOK ) ? 1 : 0,
  559. X                (flag & ECHONL) ? 1 : 0,
  560. X                (flag & NOFLSH) ? 1 : 0);
  561. X
  562. X#if defined(XCLUDE)
  563. X    pprintf("  XCLUDE:%d",(flag & XCLUDE) ? 1 : 0);
  564. X#endif
  565. X    pputs("\n");
  566. X
  567. X    pprintf("ctl chars: ");
  568. X    for(i_cc = 0; i_cc < NCC; i_cc++)
  569. X        pprintf("%02x   ",ttt->c_cc[i_cc]);
  570. X    pprintf("  (hex)\n");
  571. X    pprintf("           INTR QUIT ERAS KILL EOF  EOL  EOL2 SWTCH  VMIN-EOF VTIME-EOL\n");
  572. X
  573. X}    /* end of disp_termio */
  574. X
  575. X/*+-------------------------------------------------------------------------
  576. X    disp_stat(st)
  577. X--------------------------------------------------------------------------*/
  578. Xvoid
  579. Xdisp_stat(st)
  580. Xstruct stat *st;
  581. X{
  582. Xchar mdmap[32];
  583. X    mode_map(st->st_mode,mdmap);
  584. X    pprintf("mode: %s ",mdmap);
  585. X    pprintf("inode: %5u  dev: %3u rdev: %u,%u (0x%04x)\n",
  586. X        (uint)st->st_ino,(uint)st->st_dev,
  587. X        (ushort)st->st_rdev >> 8,(ushort)st->st_rdev & 0xFF,
  588. X        (ushort)st->st_rdev);
  589. X
  590. X}    /* end of disp_stat */
  591. X
  592. X/*+-----------------------------------------------------------------------
  593. X    disp_line_termio(fd)
  594. X
  595. XGet current termio structure for file descriptor fd
  596. Xand display on stderr
  597. X------------------------------------------------------------------------*/
  598. Xvoid
  599. Xdisp_line_termio(fd,text)
  600. Xint fd;        /* file descriptor */
  601. Xchar *text;
  602. X{
  603. Xstruct termio fd_termio;
  604. Xstruct stat fd_stat;
  605. Xchar text2[128];
  606. X
  607. X    ioctl(fd,TCGETA,&fd_termio);
  608. X    sprintf(text2,"fd: %d  %s",fd,text);
  609. X    disp_termio(&fd_termio,text2);
  610. X    fstat(fd,&fd_stat);
  611. X    disp_stat(&fd_stat);
  612. X
  613. X}    /* end of disp_line_termio */
  614. X
  615. X/*+-----------------------------------------------------------------------
  616. X    print_cwd(curdir) print and return current working directory
  617. X------------------------------------------------------------------------*/
  618. Xvoid print_cwd(curdir,buf_size)
  619. Xchar *curdir;
  620. Xint buf_size;
  621. X{
  622. X    ff(se,"%s\r\n",curr_dir);
  623. X    strncpy(curdir,curr_dir,buf_size);
  624. X}    /* end of print_cwd */
  625. X
  626. X/*+-----------------------------------------------------------------------
  627. X    dummy_call() bypass optimizer (call from another module for noop)
  628. X------------------------------------------------------------------------*/
  629. Xvoid dummy_call() { ; }
  630. X
  631. X/*+-----------------------------------------------------------------------
  632. X    ascii_name_to_hex(str3char)
  633. X
  634. X  return value of ascii ctl char name (e.g., "NUL") 0 - 0x1F
  635. X  returns -1 if input not valid
  636. X------------------------------------------------------------------------*/
  637. Xascii_name_to_hex(str3char)
  638. Xchar *str3char;
  639. X{
  640. Xregister char *cptr = ascii_ctlstr;
  641. Xregister intval;
  642. X
  643. X    for(intval = 0; intval < 0x20; intval++)
  644. X    {
  645. X        if(    (to_lower(*str3char) == to_lower(*cptr))                &&
  646. X            (to_lower(*(str3char + 1)) == to_lower(*(cptr + 1)))    &&
  647. X            ((to_lower(*(str3char + 2)) == to_lower(*(cptr + 2)))    ||
  648. X            (*(cptr + 2) == ' ')))
  649. X            return(intval);
  650. X        cptr += 3;
  651. X    }
  652. X
  653. X    return(-1);
  654. X
  655. X}    /* end of ascii_name_to_hex */
  656. X
  657. X/*+-------------------------------------------------------------------------
  658. X    ascii_to_hex(ascii)
  659. X--------------------------------------------------------------------------*/
  660. Xascii_to_hex(ascii)
  661. Xchar *ascii;
  662. X{
  663. Xint hexval;
  664. X    if(strlen(ascii) == 1)
  665. X        return(*ascii);
  666. X    else if(!strncmp(ascii,"0x",2))
  667. X    {
  668. X        sscanf(ascii + 2,"%x",&hexval);
  669. X        return(hexval & 0xFF);
  670. X    }
  671. X    else if(*ascii == '^')
  672. X        return(*(ascii + 1) & 0x1F);
  673. X    else
  674. X        return(ascii_name_to_hex(ascii));
  675. X}    /* end of ascii_to_hex */
  676. X
  677. X/*+-------------------------------------------------------------------------
  678. X    hex_to_ascii_name(char_val)
  679. X
  680. X  Returns pointer to static string containing three character ASCII
  681. X  name for control character followed by a null.
  682. X--------------------------------------------------------------------------*/
  683. Xchar *
  684. Xhex_to_ascii_name(char_val)
  685. Xchar char_val;
  686. X{
  687. Xstatic char ascii_name[4];
  688. X
  689. X    if(char_val == 0x7F)
  690. X        strcpy(ascii_name,"DEL");
  691. X    else
  692. X    {
  693. X        strncpy(ascii_name,ascii_ctlstr + (char_val * 3),3);
  694. X        ascii_name[3] = 0;
  695. X    }
  696. X
  697. X    return(ascii_name);
  698. X
  699. X}    /* end of hex_to_ascii_name */
  700. X
  701. X/*+-------------------------------------------------------------------------
  702. X    get_curr_dir(cdir,cdir_max) - get current directory into 'cdir'
  703. X--------------------------------------------------------------------------*/
  704. Xget_curr_dir(cdir,cdir_max)
  705. Xchar *cdir;
  706. Xint cdir_max;
  707. X{
  708. X#if defined(BSD)
  709. Xchar *getwd();
  710. X    return((!getwd(cdir)) ? -1 : 0);
  711. X#endif
  712. X
  713. X#if defined(M_XENIX) || defined(M_UNIX)
  714. XFILE *popen();
  715. XFILE *pipefp = popen("/bin/pwd","r");
  716. X    if(!pipefp)
  717. X        return(-1);
  718. X    fgets(cdir,cdir_max,pipefp);
  719. X    cdir[strlen(cdir) - 1] = 0;
  720. X    fclose(pipefp);
  721. X    return(0);
  722. X#endif
  723. X
  724. X}    /* end of get_curr_dir */
  725. X
  726. X/*+-----------------------------------------------------------------------
  727. X    get_home_dir(home_dir):  leave plenty of room for result!
  728. X------------------------------------------------------------------------*/
  729. Xget_home_dir(home_dir)
  730. Xchar *home_dir;
  731. X{
  732. Xstatic char home_directory[256] = "";
  733. Xstruct passwd *pwent;
  734. Xstruct passwd *getpwuid();
  735. X
  736. X    if(home_directory[0])
  737. X    {
  738. X        strcpy(home_dir,home_directory);
  739. X        return(0);
  740. X    }
  741. X
  742. X    if(!(pwent = getpwuid(getuid())))
  743. X    {
  744. X        pperror("cannot get pwent for you!!");
  745. X        hangup(HANGUP_PWENT_ERROR);
  746. X    }
  747. X    strcpy(home_directory,pwent->pw_dir);
  748. X    strcpy(home_dir,pwent->pw_dir);
  749. X    endpwent();
  750. X    return(0);
  751. X
  752. X}    /* end of get_home_dir */
  753. X
  754. X/*+-------------------------------------------------------------------------
  755. X    mkdir(dpath,dmode)
  756. X Directory-creating routines from Public Domain TAR by John Gilmore
  757. X Make a directory.  Compatible with the mkdir() system call on 4.2BSD.
  758. X--------------------------------------------------------------------------*/
  759. X#if !defined(M_UNIX) || defined(__GNUC__)
  760. X#define    TERM_SIGNAL(status)        ((status) & 0x7F)
  761. X#define TERM_COREDUMP(status)    (((status) & 0x80) != 0)
  762. X#define TERM_VALUE(status)        ((status) >> 8)
  763. Xmkdir(dpath,dmode)
  764. Xchar *dpath;
  765. Xint dmode;
  766. X{
  767. X    int cpid,status;
  768. X    struct stat statbuf;
  769. X    int (*original_sighdlr)();
  770. X
  771. X    if(stat(dpath,&statbuf) == 0)
  772. X    {
  773. X        errno = EEXIST;        /* Stat worked,so it already exists */
  774. X        return(-1);
  775. X    }
  776. X
  777. X    /* If stat fails for a reason other than non-existence,return error */
  778. X    if(errno != ENOENT)
  779. X        return(-1);
  780. X
  781. X    original_sighdlr = signal(SIGCLD,SIG_DFL);
  782. X    switch(cpid = smart_fork())
  783. X    {
  784. X
  785. X    case -1:            /* Error in fork() */
  786. X        return(-1);        /* Errno is set already */
  787. X
  788. X    case 0:                /* Child process */
  789. X        /*
  790. X         * Cheap hack to set mode of new directory.  Since this
  791. X         * child process is going away anyway,we zap its umask.
  792. X         * FIXME,this won't suffice to set SUID,SGID,etc. on this
  793. X         * directory.  Does anybody care?
  794. X         */
  795. X        status = umask(0);    /* Get current umask */
  796. X        status = umask(status | (0777 & ~dmode)); /* Set for mkdir */
  797. X        execl("/bin/mkdir","mkdir",dpath,(char *)0);
  798. X        _exit(-1);        /* Can't exec /bin/mkdir */
  799. X
  800. X    default:            /* Parent process */
  801. X        while((cpid != wait(&status)) && (cpid != -1))
  802. X            ;    /* Wait for kid to finish */
  803. X    }
  804. X
  805. X    signal(SIGCLD,original_sighdlr);
  806. X
  807. X    if(TERM_SIGNAL(status) != 0 || TERM_VALUE(status) != 0)
  808. X    {
  809. X        errno = EIO;        /* We don't know why,but */
  810. X        return(-1);        /* /bin/mkdir failed */
  811. X    }
  812. X
  813. X    return(0);
  814. X}    /* end of mkdir */
  815. X#endif
  816. X
  817. X/*+-------------------------------------------------------------------------
  818. X    make_dirs(pathname)
  819. X
  820. X  Directory-creating routines from Public Domain TAR by John Gilmore
  821. X  After a file/link/symlink/dir creation has failed, see if it's because
  822. X  some required directory was not present, and if so, create all
  823. X  required dirs.
  824. X
  825. X  returns 0 if no directory made, else # levels required to get target
  826. X--------------------------------------------------------------------------*/
  827. Xint
  828. Xmake_dirs(pathname)
  829. Xregister char *pathname;
  830. X{
  831. X    register char *p;            /* Points into path */
  832. X    int madeone = 0;            /* Did we do anything yet? */
  833. X    int save_errno = errno;        /* Remember caller's errno */
  834. X
  835. X    if(errno != ENOENT)
  836. X        return(0);        /* Not our problem */
  837. X
  838. X    for(p = strchr(pathname,'/'); p != NULL; p = strchr(p+1,'/'))
  839. X    {
  840. X        /* Avoid mkdir of empty string,if leading or double '/' */
  841. X        if(p == pathname || p[-1] == '/')
  842. X            continue;
  843. X        /* Avoid mkdir where last part of path is '.' */
  844. X        if(p[-1] == '.' && (p == pathname+1 || p[-2] == '/'))
  845. X            continue;
  846. X        *p = 0;                /* Truncate the path there */
  847. X        if( !mkdir(pathname,0777))
  848. X        {    /* Try to create it as a dir */
  849. X            madeone++;        /* Remember if we made one */
  850. X            *p = '/';
  851. X            continue;
  852. X        }
  853. X        *p = '/';
  854. X        if(errno == EEXIST)        /* Directory already exists */
  855. X            continue;
  856. X        /*
  857. X         * Some other error in the mkdir.  We return to the caller.
  858. X         */
  859. X        break;
  860. X    }
  861. X    errno = save_errno;        /* Restore caller's errno */
  862. X    return(madeone);        /* Tell them to retry if we made one */
  863. X}    /* end of make_dirs */
  864. X
  865. X/*+-------------------------------------------------------------------------
  866. X    make_ecu_subdir()
  867. Xmust be called early in execution before wierd tty states set, etc.
  868. X--------------------------------------------------------------------------*/
  869. Xvoid
  870. Xmake_ecu_subdir()
  871. X{
  872. Xint itmp;
  873. Xstruct stat fst;
  874. Xchar s256[256];
  875. X
  876. X    get_home_dir(s256);
  877. X    strcat(s256,"/.ecu");
  878. X    if((!(itmp = stat(s256,&fst))) && ((fst.st_mode & S_IFMT) != S_IFDIR))
  879. X    {
  880. X        ff(se,"~/.ecu is not a directory. Rename the file and try again.\n\n");
  881. X        exit(1);
  882. X    }
  883. X    if(itmp)        /* if stat failed, try to make the directory */
  884. X    {
  885. X        strcat(s256,"/.");
  886. X        if(make_dirs(s256))
  887. X        {
  888. X            if(stat(s256,&fst))
  889. X            {
  890. X                ff(se,"cannot make ~/.ecu subdirectory.\n");
  891. X                perror(s256);
  892. X                exit(1);
  893. X            }
  894. X        }
  895. X    }
  896. X    chmod(s256,0700);
  897. X}    /* end of make_ecu_subdir */
  898. X
  899. X/*+-------------------------------------------------------------------------
  900. X    yes_or_no(strarg)
  901. X  Returns 1 if first char is 'Y' or 'y'
  902. X    or if strarg is numeric returns the numeric value
  903. X    or if strarg is alpha == "on" returns 1
  904. X  Returns 0 otherwise
  905. X--------------------------------------------------------------------------*/
  906. Xint
  907. Xyes_or_no(strarg)
  908. Xchar *strarg;
  909. X{
  910. X    if((strcmp(strarg,"on") == 0) || (to_lower(*strarg) == 'y'))
  911. X        return(1);
  912. X    else
  913. X        return(atoi(strarg));
  914. X}    /* end of yes_or_no */
  915. X
  916. X/*+-------------------------------------------------------------------------
  917. X    find_shell_chars(command)
  918. X--------------------------------------------------------------------------*/
  919. Xint
  920. Xfind_shell_chars(command)
  921. Xchar *command;
  922. X{
  923. Xregister schar;
  924. Xregister cchar;
  925. Xregister char *scptr;
  926. Xstatic char shell_chars[] = "\"~;*?'`{}[]$";
  927. X
  928. X    while(cchar = *command++)
  929. X    {
  930. X        scptr = shell_chars;
  931. X        while(schar = *scptr++)
  932. X            if(schar == cchar)
  933. X                return(1);
  934. X    }
  935. X    return(0);
  936. X}    /* end of find_shell_chars */
  937. X
  938. X/*+-------------------------------------------------------------------------
  939. X    perror_errmsg(str)
  940. X--------------------------------------------------------------------------*/
  941. Xvoid
  942. Xperror_errmsg(str)
  943. Xchar *str;
  944. X{
  945. Xextern char errmsg[];
  946. Xextern char *sys_errlist[];
  947. Xextern int sys_nerr;
  948. Xextern int errno;
  949. X
  950. X    if(errno > sys_nerr)
  951. X        sprintf(errmsg,"%s: error %d",str,errno);
  952. X    else
  953. X        sprintf(errmsg,"%s: %s",str,sys_errlist[errno]);
  954. X}    /* end of perror_errmsg */
  955. X
  956. X/*+-----------------------------------------------------------------------
  957. X    mode_map(mode,mode_str)    build drwxrwxrwx string
  958. X------------------------------------------------------------------------*/
  959. Xchar *
  960. Xmode_map(mode,mode_str)
  961. Xunsigned short mode;
  962. Xchar *mode_str;
  963. X{
  964. Xregister unsigned ftype = mode & S_IFMT;
  965. Xregister char *rtn;
  966. Xstatic char result[12];
  967. X
  968. X    rtn = (mode_str) ? mode_str : result;
  969. X
  970. X    /*          drwxrwxrwx */
  971. X    /*          0123456789 */
  972. X    strcpy(rtn,"----------");
  973. X
  974. X    switch(ftype)
  975. X    {
  976. X        case S_IFIFO:    *rtn = 'p'; break; /* FIFO (named pipe) */
  977. X        case S_IFDIR:    *rtn = 'd'; break; /* directory */
  978. X        case S_IFCHR:    *rtn = 'c'; break; /* character special */
  979. X        case S_IFBLK:    *rtn = 'b'; break; /* block special */
  980. X        case S_IFREG:    *rtn = '-'; break; /* regular */
  981. X
  982. X#if defined(BSD)
  983. X        case S_IFLNK:    *rtn = 'l'; break; /* symbolic link */
  984. X        case S_IFSOCK:    *rtn = 's'; break; /* socket */
  985. X#endif
  986. X
  987. X#if defined (M_XENIX) || defined(M_UNIX)
  988. X        case S_IFNAM:                        /* name space entry */
  989. X            if(mode & S_INSEM)                /* semaphore */
  990. X            {
  991. X                *rtn = 's';
  992. X                break;
  993. X            }
  994. X            if(mode & S_INSHD)                /* shared memory */
  995. X            {
  996. X                *rtn = 'm';
  997. X                break;
  998. X            }
  999. X#endif
  1000. X
  1001. X        default:        *rtn = '?'; break;    /* ??? */
  1002. X    }
  1003. X
  1004. X    if(mode & 000400) *(rtn + 1) = 'r';
  1005. X    if(mode & 000200) *(rtn + 2) = 'w';
  1006. X    if(mode & 000100) *(rtn + 3) = 'x';
  1007. X    if(mode & 004000) *(rtn + 3) = 's';
  1008. X    if(mode & 000040) *(rtn + 4) = 'r';
  1009. X    if(mode & 000020) *(rtn + 5) = 'w';
  1010. X    if(mode & 000010) *(rtn + 6) = 'x';
  1011. X    if(mode & 002000) *(rtn + 6) = 's';
  1012. X    if(mode & 000004) *(rtn + 7) = 'r';
  1013. X    if(mode & 000002) *(rtn + 8) = 'w';
  1014. X    if(mode & 000001) *(rtn + 9) = 'x';
  1015. X    if(mode & 001000) *(rtn + 9) = 't';
  1016. X
  1017. X    return(rtn);
  1018. X
  1019. X}    /* end of mode_map */
  1020. X
  1021. X/*+-------------------------------------------------------------------------
  1022. X    cfree(p,num,size) - fix bug in XENIX -lmalloc
  1023. X--------------------------------------------------------------------------*/
  1024. X#if defined(M_XENIX) && defined(XENIX_MALLOC_LIB_BUG)
  1025. Xcfree(p,num,size)
  1026. Xchar *p;
  1027. Xint num;
  1028. Xint size;
  1029. X{
  1030. X    free(p);
  1031. X}    /* end of cfree */
  1032. X#endif
  1033. X
  1034. X/* end of ecuutil.c */
  1035. X/* vi: set tabstop=4 shiftwidth=4: */
  1036. SHAR_EOF
  1037. $TOUCH -am 1224223590 'ecuutil.c' &&
  1038. chmod 0644 ecuutil.c ||
  1039. echo 'restore of ecuutil.c failed'
  1040. Wc_c="`wc -c < 'ecuutil.c'`"
  1041. test 25588 -eq "$Wc_c" ||
  1042.     echo 'ecuutil.c: original size 25588, current size' "$Wc_c"
  1043. # ============= ecuwinutil.c ==============
  1044. echo 'x - extracting ecuwinutil.c (Text)'
  1045. sed 's/^X//' << 'SHAR_EOF' > 'ecuwinutil.c' &&
  1046. X/*+-------------------------------------------------------------------------
  1047. X    ecuwinutil.c - curses window utilities
  1048. X    wht@n4hgf.Mt-Park.GA.US
  1049. X
  1050. X  Defined functions:
  1051. X    clear_area(win,y,x,len)
  1052. X    clear_area_char(win,y,x,len,fillchar)
  1053. X    winbox(win)
  1054. X    window_create(title,title_x,tly,tlx,lines,cols)
  1055. X    window_setup(win,title,title_x)
  1056. X    windows_end(last_win)
  1057. X    windows_end_signal()
  1058. X    windows_start()
  1059. X    winget_single(win,nondelim_list,delim_list)
  1060. X    wingets(win,y,x,buf,bufsize,delim,edit)
  1061. X
  1062. X--------------------------------------------------------------------------*/
  1063. X/*+:EDITS:*/
  1064. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  1065. X
  1066. X#include <curses.h>
  1067. X#include "ecukey.h"
  1068. X#include "ecuxkey.h"
  1069. X#include "ecuhangup.h"
  1070. X#include "pc_scr.h"
  1071. X
  1072. X#if !defined(ushort)
  1073. X#define ushort unsigned short
  1074. X#endif
  1075. X#if !defined(uchar)
  1076. X#define uchar unsigned char
  1077. X#endif
  1078. X#if !defined(uint)
  1079. X#define uint unsigned int
  1080. X#endif
  1081. X#if !defined(ulong)
  1082. X#define ulong unsigned long
  1083. X#endif
  1084. X
  1085. X#ifdef WHT /* for testing */
  1086. Xextern int tty_is_ansi;
  1087. X#endif
  1088. Xextern int tty_is_multiscreen;
  1089. X
  1090. Xunsigned char sTL = at_TL;
  1091. Xunsigned char sTR = at_TR;
  1092. Xunsigned char sBL = at_BL;
  1093. Xunsigned char sBR = at_BR;
  1094. Xunsigned char sLT = at_LT;
  1095. Xunsigned char sRT = at_RT;
  1096. Xunsigned char sVR = at_VR;
  1097. Xunsigned char sHR = at_HR;
  1098. X
  1099. Xint windows_active = 0;
  1100. Xint ttymode_before_window_start;
  1101. X
  1102. X/*+-------------------------------------------------------------------------
  1103. X    clear_area_char(win,y,x,len,fillchar)
  1104. X--------------------------------------------------------------------------*/
  1105. Xvoid
  1106. Xclear_area_char(win,y,x,len,fillchar)
  1107. XWINDOW *win;
  1108. Xint y;
  1109. Xint x;
  1110. Xint len;
  1111. Xchar fillchar;
  1112. X{
  1113. X    wmove(win,y,x);
  1114. X    while(len-- > 0)
  1115. X        waddch(win,fillchar & 0xFF);
  1116. X    wmove(win,y,x);
  1117. X
  1118. X}    /* end of clear_area_char */
  1119. X
  1120. X/*+-------------------------------------------------------------------------
  1121. X    clear_area(win,y,x,len)
  1122. X--------------------------------------------------------------------------*/
  1123. Xvoid
  1124. Xclear_area(win,y,x,len)
  1125. XWINDOW *win;
  1126. Xint y;
  1127. Xint x;
  1128. Xint len;
  1129. X{
  1130. X    clear_area_char(win,y,x,len,' ');
  1131. X}    /* end of clear_area_char */
  1132. X
  1133. X/*+-------------------------------------------------------------------------
  1134. X    windows_start()
  1135. X--------------------------------------------------------------------------*/
  1136. Xvoid
  1137. Xwindows_start()
  1138. X{
  1139. Xextern int tty_not_char_special;
  1140. X
  1141. X    if(tty_not_char_special)
  1142. X    {
  1143. X        fprintf(stderr,"curses features unavailable\r\n");
  1144. Xabort();
  1145. X        hangup(HANGUP_TTYIN_READ_ERROR);
  1146. X    }
  1147. X
  1148. X    ttymode_before_window_start = get_ttymode();
  1149. X    ttymode(0);
  1150. X    if(!initscr())
  1151. X    {
  1152. X        fprintf(stderr,"curses init failure ... check terminal type\r\n");
  1153. X        hangup(HANGUP_USAGE);
  1154. X    }
  1155. X    savetty(); raw(); noecho(); nonl(); clear();
  1156. X#if defined(M_TERMINFO)
  1157. X    typeahead(-1);
  1158. X#endif
  1159. X    windows_active = 1;
  1160. X
  1161. X#ifdef WHT
  1162. X    if(!tty_is_ansi)
  1163. X    {
  1164. X        sTL = vanilla_TL;
  1165. X        sTR = vanilla_TR;
  1166. X        sBL = vanilla_BL;
  1167. X        sBR = vanilla_BR;
  1168. X        sLT = vanilla_LT;
  1169. X        sRT = vanilla_RT;
  1170. X        sVR = vanilla_VR;
  1171. X        sHR = vanilla_HR;
  1172. X    }
  1173. X#else
  1174. X    if(!tty_is_multiscreen)
  1175. X    {
  1176. X        sTL = vanilla_TL;
  1177. X        sTR = vanilla_TR;
  1178. X        sBL = vanilla_BL;
  1179. X        sBR = vanilla_BR;
  1180. X        sLT = vanilla_LT;
  1181. X        sRT = vanilla_RT;
  1182. X        sVR = vanilla_VR;
  1183. X        sHR = vanilla_HR;
  1184. X    }
  1185. X#endif
  1186. X
  1187. X}    /* end of windows_start */
  1188. X
  1189. X/*+-------------------------------------------------------------------------
  1190. X    windows_end(last_win)
  1191. X--------------------------------------------------------------------------*/
  1192. Xvoid
  1193. Xwindows_end(last_win)
  1194. XWINDOW *last_win;
  1195. X{
  1196. X    if(last_win)
  1197. X        wrefresh(last_win);
  1198. X/*
  1199. X    resetty();
  1200. X*/
  1201. X    endwin();
  1202. X    tcap_cursor(LINES - 1,0);
  1203. X    ttymode(ttymode_before_window_start);
  1204. X    windows_active = 0;
  1205. X}    /* end of windows_end */
  1206. X
  1207. X/*+-------------------------------------------------------------------------
  1208. X    windows_end2()
  1209. X--------------------------------------------------------------------------*/
  1210. Xvoid
  1211. Xwindows_end2()
  1212. X{
  1213. X    endwin();
  1214. X    ttymode(ttymode_before_window_start);
  1215. X    windows_active = 0;
  1216. X}    /* end of windows_end2 */
  1217. X
  1218. X/*+-------------------------------------------------------------------------
  1219. X    windows_end_signal() -- called by hangup()
  1220. X--------------------------------------------------------------------------*/
  1221. Xvoid
  1222. Xwindows_end_signal()
  1223. X{
  1224. X    windows_end2();
  1225. X}    /* end of windows_end_signal */
  1226. X
  1227. X/*+-------------------------------------------------------------------------
  1228. X    winbox(win)
  1229. X--------------------------------------------------------------------------*/
  1230. Xvoid
  1231. Xwinbox(win)
  1232. XWINDOW *win;
  1233. X{
  1234. X
  1235. X    box(win,sVR,sHR);
  1236. X    wmove(win,0,0); waddch(win,(unsigned)sTL);
  1237. X    wmove(win,win->_maxy - 1,0); waddch(win,(unsigned)sBL);
  1238. X    wmove(win,win->_maxy - 1,win->_maxx - 1); waddch(win,(unsigned)sBR);
  1239. X    wmove(win,0,win->_maxx - 1); waddch(win,(unsigned)sTR);
  1240. X
  1241. X}    /* end of winbox */
  1242. X
  1243. X/*+-------------------------------------------------------------------------
  1244. X    window_setup(win,title,title_x)
  1245. X--------------------------------------------------------------------------*/
  1246. Xvoid
  1247. Xwindow_setup(win,title,title_x)
  1248. XWINDOW *win;
  1249. Xchar *title;
  1250. X{
  1251. Xregister stand = (title_x < 0);
  1252. X
  1253. X    if(stand)
  1254. X        title_x = -title_x;
  1255. X
  1256. X    scrollok(win,0);        /* do not scroll */
  1257. X    winbox(win);
  1258. X    wmove(win,0,title_x);
  1259. X    if(stand)
  1260. X        wstandout(win);
  1261. X    waddch(win,'[');
  1262. X    wprintw(win," %s ",title);
  1263. X    waddch(win,']');
  1264. X    if(stand)
  1265. X        wstandend(win);
  1266. X}    /* end of window_setup */
  1267. X
  1268. X/*+-------------------------------------------------------------------------
  1269. X    window_create(title,title_x,tly,tlx,lines,cols)
  1270. Xif title_x negative, make title "stand" out
  1271. X--------------------------------------------------------------------------*/
  1272. XWINDOW *
  1273. Xwindow_create(title,title_x,tly,tlx,lines,cols)
  1274. Xchar *title;
  1275. X{
  1276. Xregister WINDOW *nwin = newwin(lines,cols,tly,tlx);
  1277. X    
  1278. X    if(nwin)
  1279. X        window_setup(nwin,title,title_x);
  1280. X    return(nwin);
  1281. X}    /* end of window_create */
  1282. X
  1283. X/*+-------------------------------------------------------------------------
  1284. X    wingets
  1285. X numchars = wingets(win,y,x,buf,bufsize,&delim,edit)
  1286. X
  1287. XThis procedure reads a string from win and returns the number
  1288. Xof characters read.  -1 is returned if an abort is signaled by the
  1289. Xkeyboard user.
  1290. X--------------------------------------------------------------------------*/
  1291. Xint
  1292. Xwingets(win,y,x,buf,bufsize,delim,edit)
  1293. XWINDOW *win;
  1294. Xint y;
  1295. Xregister x;
  1296. Xregister char *buf;
  1297. Xint bufsize;    /* includes room for null..field is 1 less */
  1298. Xregister uchar *delim;
  1299. Xint edit;
  1300. X{
  1301. Xregister count = 0;
  1302. Xregister pos = 0;
  1303. Xint insert_mode = 0;
  1304. X
  1305. X
  1306. X    bufsize--;
  1307. X    clear_area_char(win,y,x,bufsize,'_');
  1308. X    if(edit)
  1309. X    {
  1310. X        waddstr(win,buf);
  1311. X        count = pos = strlen(buf);
  1312. X    }
  1313. X    else
  1314. X        *buf = 0;
  1315. X    wmove(win,y,x + pos);
  1316. X
  1317. X    while(1)
  1318. X    {
  1319. X        wrefresh(win);
  1320. X        *delim = ttygetc(1);
  1321. X        if((*delim < 0x20) || (*delim >= 0x7F))
  1322. X        {
  1323. X            switch(*delim)
  1324. X            {
  1325. X                case CR:
  1326. X                    *delim = NL;
  1327. X                case NL:
  1328. X                    wrefresh(win);
  1329. X                    return(count);
  1330. X
  1331. X                case BS:
  1332. X                    if(count)
  1333. X                    {
  1334. X                        if(count == pos)
  1335. X                        {
  1336. X                            *(buf + --count) = 0;
  1337. X                            wmove(win,y,x + count);
  1338. X                            waddch(win,'_');
  1339. X                            wmove(win,y,x + count);
  1340. X                            pos--;
  1341. X                        }
  1342. X                        else
  1343. X                        {
  1344. X                            if(!pos)
  1345. X                                continue;
  1346. X                            mem_cpy(buf + pos - 1,buf + pos,count - pos);
  1347. X                            *(buf + --count) = 0;
  1348. X                            wmove(win,y,x + --pos);
  1349. X                            waddstr(win,buf + pos);
  1350. X                            waddch(win,'_');
  1351. X                            wmove(win,y,x + pos);
  1352. X                        }
  1353. X                    }
  1354. X                    continue;
  1355. X
  1356. X                case XFcurlf:
  1357. X                    if(pos)
  1358. X                        wmove(win,y,x + --pos);
  1359. X                    continue;
  1360. X
  1361. X                case XFcurrt:
  1362. X                    if(pos < count)
  1363. X                        wmove(win,y,x + ++pos);
  1364. X                    continue;
  1365. X
  1366. X                case XFins:
  1367. X                    insert_mode = !insert_mode;
  1368. X                    continue;
  1369. X
  1370. X                case ESC:
  1371. X                    return(-1);
  1372. X
  1373. X                case CTL_U:
  1374. X                    clear_area_char(win,y,x,bufsize,'_');
  1375. X                    count = 0;
  1376. X                    pos = 0;
  1377. X                    continue;
  1378. X
  1379. X                default:
  1380. X                    *(buf + pos) = 0;
  1381. X                    wrefresh(win);
  1382. X                    return(-1);
  1383. X            }    /* end of switch(*delim) */
  1384. X            /*NOTREACHED*/
  1385. X        }        /* end of if read delimiter */
  1386. X
  1387. X        if(count == bufsize)
  1388. X        {
  1389. X            ring_bell();
  1390. X            continue;
  1391. X        }
  1392. X
  1393. X        if(insert_mode && (pos != count))
  1394. X        {
  1395. X            waddch(win,*delim);
  1396. X            waddstr(win,buf + pos);
  1397. X            mem_cpy(buf + pos + 1,buf + pos,count - pos);
  1398. X            *(buf + pos++) = *delim;
  1399. X            *(buf + ++count) = 0;
  1400. X            wmove(win,y,x + pos);
  1401. X        }
  1402. X        else
  1403. X        {
  1404. X            waddch(win,*delim);
  1405. X            *(buf + pos) = *delim;
  1406. X            if(pos == count)
  1407. X                *(buf + ++count) = 0;
  1408. X            pos++;
  1409. X        }
  1410. X    }    /* end of while can get character */
  1411. X                    
  1412. X}    /* end of wingets */
  1413. X
  1414. X/*+-------------------------------------------------------------------------
  1415. X    winget_single(win,nondelim_list,delim_list)
  1416. X
  1417. XThis procedure assumes cursor is positioned, repeats reading a non-echoing
  1418. Xcharacter from the keyboard until it matches a character in nondelim_list
  1419. Xor delim_list.  delim_list is expected to contain printable characters
  1420. Xand no upper-case characters.
  1421. X
  1422. XIf no match occurs, the bell is rung and the keyboard is read again.
  1423. X
  1424. XIf the input character matches a character in delim_list, the index (0-n)
  1425. Xof the character in delim_list is returned.  If a match occurs, an
  1426. Xupper-case version of the matching character is placed in the window.
  1427. X
  1428. XIf the input character matches a character in nondelim_list, the character
  1429. Xis returned or'ed with 0x1000
  1430. X
  1431. X--------------------------------------------------------------------------*/
  1432. Xint
  1433. Xwinget_single(win,nondelim_list,delim_list)
  1434. XWINDOW *win;
  1435. Xregister char *nondelim_list;
  1436. Xregister char *delim_list;
  1437. X{
  1438. Xregister itmp;
  1439. Xregister nlen = strlen(nondelim_list);
  1440. Xregister dlen = strlen(delim_list);
  1441. Xregister ichar;
  1442. X
  1443. X    wrefresh(win);
  1444. X
  1445. X    while(1)
  1446. X    {
  1447. X        ichar = to_lower(ttygetc(1));
  1448. X        for(itmp = 0; itmp < nlen; itmp++)
  1449. X        {
  1450. X            if(ichar == nondelim_list[itmp])
  1451. X            {
  1452. X                waddch(win,to_upper(ichar));
  1453. X                wrefresh(win);
  1454. X                return(itmp);
  1455. X            }
  1456. X        }
  1457. X        for(itmp = 0; itmp < dlen; itmp++)
  1458. X        {
  1459. X            if(ichar == delim_list[itmp])
  1460. X                return(ichar | 0x1000);
  1461. X        }
  1462. X        ring_bell();
  1463. X    }
  1464. X
  1465. X}    /* end of winget_single */
  1466. X
  1467. X/* end of ecuwinutil.c */
  1468. X/* vi: set tabstop=4 shiftwidth=4: */
  1469. SHAR_EOF
  1470. $TOUCH -am 1224223690 'ecuwinutil.c' &&
  1471. chmod 0644 ecuwinutil.c ||
  1472. echo 'restore of ecuwinutil.c failed'
  1473. Wc_c="`wc -c < 'ecuwinutil.c'`"
  1474. test 9536 -eq "$Wc_c" ||
  1475.     echo 'ecuwinutil.c: original size 9536, current size' "$Wc_c"
  1476. # ============= ecuxenix.c ==============
  1477. echo 'x - extracting ecuxenix.c (Text)'
  1478. sed 's/^X//' << 'SHAR_EOF' > 'ecuxenix.c' &&
  1479. X/*+-----------------------------------------------------------------
  1480. X    ecuxenix.c -- very machine/OS dependent functions
  1481. X    wht@n4hgf.Mt-Park.GA.US
  1482. X
  1483. X  Defined functions:
  1484. X    morse_bell(xbell_type,count)
  1485. X    rename(from,to)
  1486. X    send_bell_fd(fd,count,nap_msec)
  1487. X    send_get_response(token,narg,arg)
  1488. X    set_bell_fd(fd,pitch,duration)
  1489. X    set_default_escape_prompt()
  1490. X    show_escape_prompt()
  1491. X    signal_name_text(sig)
  1492. X    xbell(type,count)
  1493. X    xbell_fd(fd,type,count)
  1494. X    bell_alarm(xbell_type)
  1495. X    bell_notify(xbell_type)
  1496. X    kbd_escape(xkey)
  1497. X
  1498. X  This module is a grab bag for historical reasons.  Needs reorg.
  1499. X------------------------------------------------------------------*/
  1500. X/*+:EDITS:*/
  1501. X/*:12-04-1990-03:55-wht@n4hgf-bell_notify only if on multiscreen */
  1502. X/*:09-19-1990-19:36-wht@n4hgf-ecu_log_event now gets pid for log from caller */
  1503. X/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */
  1504. X
  1505. X#include "ecu.h"
  1506. X#include "ecukey.h"
  1507. X#include "ecufkey.h"
  1508. X#include "ecuxkey.h"
  1509. X#include "ecufork.h"
  1510. X#include "esd.h"
  1511. X
  1512. X#if defined(MORSE)
  1513. X/* the space between # and include defeats make depend from seeing this */
  1514. X# include <local/morse_dvr.h>
  1515. X#endif
  1516. X
  1517. Xchar *get_ttyname();
  1518. X
  1519. Xextern char curr_dir[]; /* current working key defns */
  1520. Xextern KDE keyset_table[];
  1521. Xextern char keyset_name[];
  1522. Xextern int want_bell_notify;    /* want bell notify */
  1523. Xextern int rcvr_pid;
  1524. Xextern int interrupt;
  1525. Xextern int tty_is_multiscreen;
  1526. X
  1527. XESD *icmd_prompt;        /* interactive command prompt */
  1528. Xint icmd_prompt_len;
  1529. X
  1530. X/*+-------------------------------------------------------------------------
  1531. X    show_escape_prompt()
  1532. Xreturns number of character positions written to screen
  1533. X--------------------------------------------------------------------------*/
  1534. Xshow_escape_prompt()
  1535. X{
  1536. Xchar prompt_last;
  1537. X
  1538. X    prompt_last = 'd';    /* dummy */
  1539. X    if(icmd_prompt->cb)
  1540. X        prompt_last = *(icmd_prompt->pb + icmd_prompt->cb - 1);
  1541. X
  1542. X    icmd_prompt_len = 0;
  1543. X    shmx_make_rcvr_sleep(1);
  1544. X    if(!(colors_current & 0xFFFF0000L) || !(colors_current & 0xFFFFL))
  1545. X        setcolor(colors_normal);
  1546. X    else
  1547. X        setcolor(colors_current);
  1548. X    tcap_stand_out();
  1549. X    if(icmd_prompt->cb)
  1550. X    {
  1551. X        ff(se," %s",icmd_prompt->pb);
  1552. X        icmd_prompt_len += icmd_prompt->cb + 1;
  1553. X    }
  1554. X    if(isalnum(prompt_last))
  1555. X    {
  1556. X        fputs(" %",se);
  1557. X        icmd_prompt_len += 2;
  1558. X    }
  1559. X    tcap_stand_end();
  1560. X    fputc(' ',se);
  1561. X    icmd_prompt_len++;
  1562. X    fflush(so);
  1563. X    return(icmd_prompt_len);
  1564. X
  1565. X}    /* end of show_escape_prompt */
  1566. X
  1567. X/*+-------------------------------------------------------------------------
  1568. X    set_default_escape_prompt()
  1569. X--------------------------------------------------------------------------*/
  1570. Xvoid
  1571. Xset_default_escape_prompt()
  1572. X{
  1573. Xregister char *cptr;
  1574. Xchar *getenv();
  1575. X
  1576. X    if((cptr = getenv("ECUPROMPT")) != (char *)0)
  1577. X    {
  1578. X        strncpy(icmd_prompt->pb,cptr,icmd_prompt->maxcb);
  1579. X        *(icmd_prompt->pb + icmd_prompt->maxcb - 1) = 0;
  1580. X        icmd_prompt->cb = strlen(icmd_prompt->pb);
  1581. X        null_terminate_esd(icmd_prompt);
  1582. X    }
  1583. X
  1584. X}    /* end of set_default_escape_prompt */
  1585. X
  1586. X/*+-------------------------------------------------------------------------
  1587. X    kbd_escape() -- xmtr got extended key -- process it
  1588. Xreturns(1)
  1589. X--------------------------------------------------------------------------*/
  1590. Xkbd_escape(xkey)
  1591. Xuchar xkey;
  1592. X{
  1593. Xregister itmp;
  1594. Xregister backspace_count;
  1595. Xregister KDE *tkde;
  1596. Xuchar icmd_buf[128];
  1597. X
  1598. X    if((xkey >= XF_ALTA) && (xkey <= XF_ALTZ))
  1599. X    {
  1600. X    char alt_key_proc_name[8];
  1601. X    char *arg = alt_key_proc_name;
  1602. X    int narg = 1;
  1603. X    int rcvr_alive = (rcvr_pid > 0);
  1604. X        sprintf(alt_key_proc_name,"alt_%c",xkey - XF_ALTA + 'a');
  1605. X        if(rcvr_alive)
  1606. X            kill_rcvr_process(SIGUSR1);
  1607. X        ttymode(2);
  1608. X        ttyflush(0);
  1609. X        if(do_proc(narg,&arg))
  1610. X            ring_bell();
  1611. X        interrupt = 0;
  1612. X        proc_file_reset();
  1613. X        ttymode(1);
  1614. X        if(rcvr_alive)
  1615. X            start_rcvr_process(0);
  1616. X        return(1);
  1617. X    }
  1618. X
  1619. X    switch(xkey)
  1620. X    {
  1621. X        case XFhome:     /* home key pressed ? */
  1622. X            backspace_count = show_escape_prompt();
  1623. XGET_ICMD:
  1624. X            ttygets(icmd_buf,sizeof(icmd_buf),2);
  1625. X            switch(icmd_buf[0])
  1626. X            {
  1627. X            case XFhome:
  1628. X            case XFend:
  1629. X            case XFpgup:
  1630. X            case XFpgdn:
  1631. X            case XFcurup:
  1632. X            case XFcurdn:
  1633. X                if(icmd_history_manager(icmd_buf[0],icmd_buf,sizeof(icmd_buf)))
  1634. X                    goto GET_ICMD;
  1635. X            }
  1636. X            if(!icmd_buf[0] || (icmd_buf[0] == ESC))
  1637. X            {
  1638. X                while(backspace_count--)
  1639. X                    ff(se,"\b \b");
  1640. X                break;
  1641. X            }
  1642. X            if(icmd(icmd_buf))
  1643. X                hangup(HANGUP_OK);
  1644. X            break;
  1645. X
  1646. X        default:
  1647. X            if((itmp = xf_to_KDEt(xkey)) < 0)
  1648. X            {
  1649. X                ring_bell();
  1650. X                break;
  1651. X            }
  1652. X            tkde = &keyset_table[itmp];
  1653. X            if((itmp = tkde->count) > 0)
  1654. X            {
  1655. X            register char *cptr = tkde->str;
  1656. X                while(itmp--)
  1657. X                    lputc(*cptr++);
  1658. X            }
  1659. X            else if(tkde->count < 0)
  1660. X            {
  1661. X                switch(tkde->count)
  1662. X                {
  1663. X                    case KACT_LOCAL_SHELL:
  1664. X                        fputs("\r\n",se);
  1665. X                        tcap_stand_out();
  1666. X                        ff(se," local shell in %s ",curr_dir);
  1667. X                        tcap_stand_end();
  1668. X                        ff(se,"\r\n");
  1669. X                        shell("!");
  1670. X                        break;
  1671. X                    case KACT_REDISPLAY:
  1672. X                        redisplay_rcvr_screen();
  1673. X                }
  1674. X            }
  1675. X            else
  1676. X                ring_bell();
  1677. X            break;
  1678. X    }
  1679. X    return(1);
  1680. X}    /* end of kbd_escape */
  1681. X
  1682. X/*+-------------------------------------------------------------------------
  1683. X    set_bell_fd(fd,pitch,duration)
  1684. XExample: 1B 5B 3D 34 30 30 30 3B 31 42 | .[=4000;1B
  1685. X--------------------------------------------------------------------------*/
  1686. Xvoid
  1687. Xset_bell_fd(fd,pitch,duration)
  1688. Xint fd;
  1689. Xint pitch;
  1690. Xint duration;
  1691. X{
  1692. Xchar bell_cmd[32];
  1693. X
  1694. X    if(!tty_is_multiscreen)
  1695. X    {
  1696. X        ring_bell();
  1697. X        return;
  1698. X    }
  1699. X
  1700. X    sprintf(bell_cmd,"\033[=%d;%dB",pitch,duration);
  1701. X    write(fd,bell_cmd,strlen(bell_cmd));
  1702. X}    /* end of set_bell_fd */
  1703. X
  1704. X/*+-------------------------------------------------------------------------
  1705. X    send_bell_fd(fd,count,nap_msec)
  1706. X--------------------------------------------------------------------------*/
  1707. Xvoid
  1708. Xsend_bell_fd(fd,count,nap_msec)
  1709. Xregister fd;
  1710. Xregister count;
  1711. Xregister nap_msec;
  1712. X{
  1713. Xstatic char bellch = 0x07;
  1714. X
  1715. X    if(!tty_is_multiscreen)
  1716. X    {
  1717. X        ring_bell();
  1718. X        return;
  1719. X    }
  1720. X
  1721. X    if(count)
  1722. X    {
  1723. X        while(count--)
  1724. X        {
  1725. X            write(fd,&bellch,1);    
  1726. X            nap((long)nap_msec);
  1727. X        }
  1728. X    }
  1729. X}    /* end of send_bell_fd */
  1730. X
  1731. X/*+-------------------------------------------------------------------------
  1732. X    xbell_fd(fd,type,count)
  1733. X--------------------------------------------------------------------------*/
  1734. Xvoid
  1735. Xxbell_fd(fd,type,count)
  1736. Xregister fd;
  1737. Xregister type;
  1738. Xregister count;
  1739. X{
  1740. Xregister itmp;
  1741. X
  1742. X    if(!tty_is_multiscreen)
  1743. X    {
  1744. X        ring_bell();
  1745. X        return;
  1746. X    }
  1747. X
  1748. X    if(count)
  1749. X    {
  1750. X        while(count--)
  1751. X        {
  1752. X            switch(type)
  1753. X            {
  1754. X                case XBELL_DONE:        /* octaves */
  1755. X                    set_bell_fd(fd,1000,1);
  1756. X                    send_bell_fd(fd,1,100);
  1757. X                    set_bell_fd(fd,2000,1);
  1758. X                    send_bell_fd(fd,1,100);
  1759. X                    set_bell_fd(fd,4000,1);
  1760. X                    send_bell_fd(fd,1,100);
  1761. X                    break;
  1762. X                case XBELL_ATTENTION:        /* morse .-.-.- ATTENTION */
  1763. X                    for(itmp = 0; itmp < 3; itmp++)
  1764. X                    {
  1765. X                        set_bell_fd(fd,2000,1);
  1766. X                        send_bell_fd(fd,1,140);
  1767. X                        set_bell_fd(fd,2000,3);
  1768. X                        send_bell_fd(fd,1,340);
  1769. X                    }
  1770. X                    break;
  1771. X                case XBELL_C:        /* morse -.-. C */
  1772. X                    for(itmp = 0; itmp < 2; itmp++)
  1773. X                    {
  1774. X                        set_bell_fd(fd,2000,3);
  1775. X                        send_bell_fd(fd,1,320);
  1776. X                        set_bell_fd(fd,2000,1);
  1777. X                        send_bell_fd(fd,1,120);
  1778. X                    }
  1779. X                    break;
  1780. X                case XBELL_3T:        /* 3 morse T's */
  1781. X                    set_bell_fd(fd,2000,3);
  1782. X                    send_bell_fd(fd,3,460);
  1783. X                    break;
  1784. X                default:
  1785. X                    set_bell_fd(fd,2000,4);
  1786. X                    send_bell_fd(fd,1,100);
  1787. X                    break;
  1788. X            }
  1789. X        }
  1790. X    }
  1791. X                
  1792. X    set_bell_fd(fd,4000,1);
  1793. X    
  1794. X}    /* end of xbell_fd */
  1795. X
  1796. X/*+-------------------------------------------------------------------------
  1797. X    morse_bell(xbell_type,count)
  1798. X--------------------------------------------------------------------------*/
  1799. X#if defined(MORSE)
  1800. Xmorse_bell(xbell_type,count)
  1801. Xint xbell_type;
  1802. Xint count;
  1803. X{
  1804. Xregister morse_fd;
  1805. Xint morse_frequency = 600;
  1806. Xchar morse_char;
  1807. Xstatic int morse_ticks = 0;
  1808. Xextern int errno;
  1809. X
  1810. X    if(!tty_is_multiscreen)
  1811. X    {
  1812. X        ring_bell();
  1813. X        return;
  1814. X    }
  1815. X
  1816. X    if(!morse_ticks)
  1817. X    {
  1818. X    char *hzstr;
  1819. X    char *getenv();
  1820. X    int hz;
  1821. X        if(!(hzstr = getenv("HZ")))
  1822. X            hz = 50;
  1823. X        else
  1824. X            hz = atoi(hzstr);
  1825. X        morse_ticks = hz / 25;
  1826. X    }
  1827. X
  1828. X    if((morse_fd = open("/dev/morse",O_WRONLY,0)) < 0)
  1829. X        return(-1);
  1830. X
  1831. X    ioctl(morse_fd,MORSE_SET_SPEED,&morse_ticks);
  1832. X    ioctl(morse_fd,MORSE_SET_FREQUENCY,&morse_frequency);
  1833. X    switch(xbell_type)
  1834. X    {
  1835. X        case XBELL_DONE:
  1836. X            morse_char = 'd';
  1837. X/*
  1838. X            morse_frequency = 400;
  1839. X            ioctl(morse_fd,MORSE_SET_FREQUENCY,&morse_frequency);
  1840. X*/
  1841. X            break;
  1842. X        case XBELL_ATTENTION:
  1843. X            morse_char = '.';
  1844. X            break;
  1845. X        case XBELL_C:
  1846. X            morse_char = 'c';
  1847. X            break;
  1848. X        case XBELL_3T:
  1849. X            morse_char = 'o';
  1850. X            break;
  1851. X        default:
  1852. X            morse_char = BT;
  1853. X            break;
  1854. X    }
  1855. X    while(count--)
  1856. X        write(morse_fd,&morse_char,1);
  1857. X    close(morse_fd);
  1858. X    return(0);
  1859. X}    /* end of morse_bell */
  1860. X#endif
  1861. X
  1862. X/*+-------------------------------------------------------------------------
  1863. X    xbell(type,count)
  1864. X--------------------------------------------------------------------------*/
  1865. Xvoid
  1866. Xxbell(type,count)
  1867. Xint type;
  1868. Xint count;
  1869. X{
  1870. X    if(!tty_is_multiscreen)
  1871. X    {
  1872. X        ring_bell();
  1873. X        return;
  1874. X    }
  1875. X
  1876. X#if defined(MORSE)
  1877. X    if(morse_bell(type,count))
  1878. X#endif
  1879. X        xbell_fd(1,type,count);
  1880. X}    /* end of xbell */
  1881. X
  1882. X/*+-------------------------------------------------------------------------
  1883. X    bell_alarm(xbell_type)
  1884. X  Under XENIX 2.2.1, ring bell on multiscreens;
  1885. X  if morse driver included, use it
  1886. X--------------------------------------------------------------------------*/
  1887. Xint
  1888. Xbell_alarm(xbell_type)
  1889. Xint xbell_type;
  1890. X{
  1891. Xregister notify_fd;
  1892. Xregister fork_pid;
  1893. Xstatic long notify_time = 0L;
  1894. Xchar *ttname;
  1895. Xchar devname[64];
  1896. Xint devnum;
  1897. Xint ttnum;
  1898. Xlong time(long *);
  1899. X
  1900. X    if(!tty_is_multiscreen)
  1901. X    {
  1902. X        ring_bell();
  1903. X        return;
  1904. X    }
  1905. X
  1906. X/* if happened less than 15 secs ago, forget it */
  1907. X    if((time((long *)0) - notify_time) < 15L)
  1908. X        return(0);
  1909. X
  1910. X    notify_time = time((long *)0);
  1911. X
  1912. X#if defined(MORSE)
  1913. X    if(morse_bell(xbell_type,1))
  1914. X    {
  1915. X#endif
  1916. X        if((fork_pid = smart_fork()) != 0)
  1917. X        {
  1918. X#if defined(FORK_DEBUG)
  1919. X            sprintf(devname,"DEBUG bell notify pid %d",fork_pid);
  1920. X            ecu_log_event(getpid(),devname);    /* bell notify */
  1921. X#endif
  1922. X            return(fork_pid > 0);
  1923. X        }
  1924. X
  1925. X        for(devnum = 1; devnum < 13; devnum++)
  1926. X        {
  1927. X            if(devnum == ttnum)        /* don't bell notify ecu's tty */
  1928. X                continue;
  1929. X            sprintf(devname,"/dev/tty%02d",devnum);
  1930. X            if((notify_fd = open(devname,O_WRONLY,0)) >= 0)
  1931. X            {
  1932. X                xbell_fd(notify_fd,xbell_type,1);
  1933. X                close(notify_fd);
  1934. X            }
  1935. X        }
  1936. X
  1937. X        _exit(0);        /* end of child tine (of the fork, naturally) */
  1938. X#if defined(MORSE)
  1939. X    }
  1940. X#endif
  1941. X}    /* end of bell_alarm */
  1942. X
  1943. X/*+-------------------------------------------------------------------------
  1944. X    bell_notify(xbell_type)
  1945. X--------------------------------------------------------------------------*/
  1946. Xvoid
  1947. Xbell_notify(xbell_type)
  1948. Xint xbell_type;
  1949. X{
  1950. Xextern int tty_is_multiscreen;
  1951. X
  1952. X    if(tty_is_multiscreen && want_bell_notify)
  1953. X        bell_alarm(xbell_type);
  1954. X
  1955. X}    /* end of bell_notify */
  1956. X
  1957. X/*+-------------------------------------------------------------------------
  1958. X    signal_name_text(sig)
  1959. X--------------------------------------------------------------------------*/
  1960. Xchar *
  1961. Xsignal_name_text(sig)
  1962. Xint sig;
  1963. X{
  1964. Xregister char *cptr;
  1965. Xstatic char sigunknown[20];
  1966. X
  1967. X    sig &= 0x7F;
  1968. X    switch(sig)
  1969. X    {
  1970. X        case SIGHUP:    cptr = "SIGHUP"; break;
  1971. X        case SIGINT:    cptr = "SIGINT"; break;
  1972. X        case SIGQUIT:    cptr = "SIGQUIT"; break;
  1973. X        case SIGILL:    cptr = "SIGILL"; break;
  1974. X        case SIGTRAP:    cptr = "SIGTRAP"; break;
  1975. X#ifdef SIGABRT
  1976. X        case SIGABRT:    cptr = "SIGABRT"; break;
  1977. X#else
  1978. X        case SIGIOT:    cptr = "SIGIOT"; break;
  1979. X#endif
  1980. X        case SIGEMT:    cptr = "SIGEMT"; break;
  1981. X        case SIGFPE:    cptr = "SIGFPE"; break;
  1982. X        case SIGKILL:    cptr = "SIGKILL"; break;
  1983. X        case SIGBUS:    cptr = "SIGBUS"; break;
  1984. X        case SIGSEGV:    cptr = "SIGSEGV"; break;
  1985. X        case SIGSYS:    cptr = "SIGSYS"; break;
  1986. X        case SIGPIPE:    cptr = "SIGPIPE"; break;
  1987. X        case SIGALRM:    cptr = "SIGALRM"; break;
  1988. X        case SIGTERM:    cptr = "SIGTERM"; break;
  1989. X        case SIGUSR1:    cptr = "SIGUSR1"; break;
  1990. X        case SIGUSR2:    cptr = "SIGUSR2"; break;
  1991. X        case SIGCLD:    cptr = "SIGCLD"; break;
  1992. X        case SIGPWR:    cptr = "SIGPWR"; break;
  1993. X#if    defined(SIGSTOP)
  1994. X        case SIGSTOP:   cptr = "SIGSTOP"; break;
  1995. X#endif
  1996. X#if    defined(SIGTSOP)
  1997. X        case SIGTSTP:   cptr = "SIGTSTP"; break;
  1998. X#endif
  1999. X#if    defined(SIGCONT)
  2000. X        case SIGCONT:   cptr = "SIGCONT"; break;
  2001. X#endif
  2002. X#if    defined(SIGTTIN)
  2003. X        case SIGTTIN:   cptr = "SIGTTIN"; break;
  2004. X#endif
  2005. X#if    defined(SIGTTOU)
  2006. X        case SIGTTOU:   cptr = "SIGTTOU"; break;
  2007. X#endif
  2008. X        default:
  2009. X            sprintf(sigunknown,"SIGNAL %u",sig);
  2010. X            return(sigunknown);
  2011. X    }
  2012. X    return(cptr);
  2013. X
  2014. X}    /* end of signal_name_text */
  2015. X
  2016. X/*+-------------------------------------------------------------------------
  2017. X    rename(from,to)
  2018. X--------------------------------------------------------------------------*/
  2019. X#if !defined(M_UNIX) || defined(__GNUC__)
  2020. Xrename(from,to)
  2021. Xchar *from;
  2022. Xchar *to;
  2023. X{
  2024. Xstruct stat ss;
  2025. Xextern int errno;
  2026. X
  2027. X    if(stat(to,&ss) == 0)    /* if to exists, flunk */
  2028. X    {
  2029. X        errno = EEXIST;    /* fake "file exists" error */
  2030. X        return(-1);
  2031. X    }
  2032. X    if(link(from,to))    /* if cannot link, flunk */
  2033. X        return(-1);
  2034. X    if(unlink(from))    /* if cannot unlink, flunk */
  2035. X        return(-1);
  2036. X    return(0);
  2037. X}    /* end of rename */
  2038. X#endif
  2039. X
  2040. X/*+-------------------------------------------------------------------------
  2041. X    send_get_response(token,narg,arg)
  2042. X--------------------------------------------------------------------------*/
  2043. Xvoid
  2044. Xsend_get_response(token,narg,arg)
  2045. Xint token;
  2046. Xint narg;
  2047. Xchar **arg;
  2048. X{
  2049. Xregister itmp;
  2050. Xregister char *cptr;
  2051. Xint iarg;
  2052. Xint mode = atoi(arg[1]);
  2053. XLRWT lr;
  2054. Xchar buf[1024];
  2055. XFILE *fplog;
  2056. Xchar *fname = "ecu.sgr.log";
  2057. Xint rcvr_alive = (rcvr_pid > 0);
  2058. X
  2059. X    if(narg < 3)
  2060. X    {
  2061. X        fputs("   usage: sgr mode cmd\r\n",se);
  2062. X        fputs("mode = 0 for sanitized response, 1 == raw\r\n",se);
  2063. X        fputs("cmd = 'Send' style string (see /usr/lib/uucp/Dialers)\r\n",se);
  2064. X        return;
  2065. X    }
  2066. X    if((fplog = fopen(fname,"a")) == NULL)
  2067. X    {
  2068. X        fputs("\r\n",se);
  2069. X        perror(fname);
  2070. X        fputs("\r\n",se);
  2071. X        return;
  2072. X    }
  2073. X
  2074. X    mode &= 0x0F;
  2075. X    if(rcvr_alive)
  2076. X        kill_rcvr_process(SIGUSR1);
  2077. X
  2078. X    lr.to1 = 10 * 1000L;
  2079. X    lr.to2 = 2 * 1000L;
  2080. X    lr.raw_flag = 0x80 + mode; /* allow interrupts */
  2081. X    lr.buffer = buf;
  2082. X    lr.bufsize = sizeof(buf);
  2083. X    lr.delim = (char *)0;
  2084. X    lr.echo = 0;
  2085. X    interrupt = 0;
  2086. X
  2087. X    fputs("\r\n",se);
  2088. X
  2089. X    fprintf(fplog,"\nMode: %d Stimulus: %s",mode,arg[2]);
  2090. X    fputs("Response: \r\n",se);
  2091. X    fputs("\nResponse: \n",fplog);
  2092. X    respond(arg[2]);
  2093. X    lgets_timeout(&lr);
  2094. X    itmp = lr.count;
  2095. X    cptr = strchr(buf,'\n') + 1;
  2096. X    itmp -= (int)(cptr - buf);
  2097. X    hex_dump_fp(fplog,cptr,itmp,(char *)0,(itmp <= 16));
  2098. X    fclose(fplog);
  2099. X
  2100. X    itmp = lr.count;
  2101. X    cptr = buf;
  2102. X    while(itmp--)
  2103. X    {
  2104. X        if(*cptr == '\n')
  2105. X            fputc('\r',se);
  2106. X        fputc(*cptr++,se);
  2107. X    }
  2108. X        
  2109. X    if(rcvr_alive)
  2110. X        start_rcvr_process(0);
  2111. X}    /* end of send_get_response */
  2112. X
  2113. X/* end of ecuxenix.c */
  2114. X/* vi: set tabstop=4 shiftwidth=4: */
  2115. SHAR_EOF
  2116. $TOUCH -am 1224223690 'ecuxenix.c' &&
  2117. chmod 0644 ecuxenix.c ||
  2118. echo 'restore of ecuxenix.c failed'
  2119. Wc_c="`wc -c < 'ecuxenix.c'`"
  2120. test 14176 -eq "$Wc_c" ||
  2121.     echo 'ecuxenix.c: original size 14176, current size' "$Wc_c"
  2122. true || echo 'restore of ecuxfer.c failed'
  2123. echo End of part 9, continue with part 10
  2124. exit 0
  2125. --------------------------------------------------------------------
  2126. Warren Tucker, TuckerWare emory!n4hgf!wht or wht@n4hgf.Mt-Park.GA.US
  2127. Hacker Extraordinaire  d' async PADs,  pods,  proteins and protocols
  2128.  
  2129. exit 0 # Just in case...
  2130. -- 
  2131. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2132. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2133. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2134. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2135.