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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Modem编程 > 查看源码
main.c
资源名称：minicom-1.83.tar.gz　[点击查看]
上传用户：tianjinjs
上传日期：2007-01-05
资源大小：309k
文件大小：14k
源码类别：

Modem编程

开发平台：

Unix_Linux

main.c：源码内容
  1. /*
  2.  * main.c main loop of emulator.
  3.  *
  4.  * This file is part of the minicom communications package,
  5.  * Copyright 1991-1995 Miquel van Smoorenburg.
  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
  10.  * 2 of the License, or (at your option) any later version.
  11.  *
  12.  * fmg 1/11/94 color mods
  13.  * jl  22.06.97 log it when DCD drops
  14.  * jl  02.06.98 added call duration to the "Gone offline" log line
  15.  * jl  14.06.99 moved lockfile creation to before serial port opening
  16.  *
  17.  */
  18. #include "port.h"
  19. #include "minicom.h"
  20. #include "patchlevel.h"
  21. #include "intl.h"
  22. #if defined(__linux__) || (defined(BSD) && (BSD >= 199306))
  23. #include <errno.h>
  24. #endif
  26. static jmp_buf albuf;
  28. /* Compile SCCS ID into executable. */
  29. char *Version = SCCS_ID;
  31. void curs_status();
  33. /*
  34.  * Return the last part of a filename.
  35.  */
  36. char *mbasename(s)
  37. char *s;
  38. {
  39.   char *p;
  40.   
  41.   if((p = strrchr(s, '/')) == (char *)NULL)
  42.    p = s;
  43.   else
  44.    p++;
  45.   return(p);
  46. }
  48. /*
  49.  * Leave.
  50.  */
  51. void leave(s)
  52. char *s;
  53. {
  54.   if (stdwin) wclose(stdwin, 1);
  55.   if (portfd > 0) {
  56. m_restorestate(portfd);
  57. close(portfd);
  58.   }
  59.   set_privs();
  60.   if (lockfile[0]) unlink(lockfile);
  61.   if (P_CALLIN[0]) (void) fastsystem(P_CALLIN, CNULL, CNULL, CNULL);
  62.   if (real_uid) chown(dial_tty, (uid_t)portuid, (gid_t)portgid);
  63.   fprintf(stderr, "%s", s);
  64.   exit(1);
  65. }
  67. /*
  68.  * Return text describing command-key.
  69.  */
  70. char *esc_key()
  71. {
  72.   static char buf[16];
  74.   if (!alt_override && P_ESCAPE[0] == '^' && P_ESCAPE[1] != '[') {
  75. sprintf(buf, "CTRL-%c ", P_ESCAPE[1]);
  76. return(buf);
  77.   }
  78. #if defined(_COHERENT) || defined(i386) || defined(__i386__)
  79.   sprintf(buf, "ALT-");
  80. #else
  81.   sprintf(buf, "Meta-");
  82. #endif
  83.   return(buf);
  84. }
  86. /*ARGSUSED*/
  87. static void get_alrm(dummy)
  88. int dummy;
  89. {
  90.   (void)dummy;
  91.   longjmp(albuf, 1);
  92. }
  94. /*
  95.  * Open the terminal.
  96.  */
  97. int open_term(doinit)
  98. int doinit;
  99. {
  100.   struct stat stt;
  101.   char buf[128];
  102.   int fd, n = 0;
  103.   int pid;
  104.   int mask;
  105. #if defined(__linux__) || (defined(BSD) && (BSD >= 199306))
  106.   int s_errno;
  107. #endif
  109.   /* Upgrade our status. */
  110.   set_privs();
  112.   /* First see if the lock file directory is present. */
  113.   if (P_LOCK[0] && stat(P_LOCK, &stt) == 0)
  114.    snprintf(lockfile, sizeof(lockfile), "%s/LCK..%s", P_LOCK, mbasename(dial_tty));
  115.   else
  116. lockfile[0] = 0;
  118.   if (doinit >= 0 && lockfile[0] && (fd = open(lockfile, O_RDONLY)) >= 0) {
  119. n = read(fd, buf, 127);
  120. close(fd);
  121. if (n > 0) {
  122. pid = -1;
  123. if (n == 4)
  124. /* Kermit-style lockfile. */
  125. pid = *(int *)buf;
  126. else {
  127. /* Ascii lockfile. */
  128. buf[n] = 0;
  129. sscanf(buf, "%d", &pid);
  130. }
  131. if (pid > 0 && kill((pid_t)pid, 0) < 0 &&
  132. errno == ESRCH) {
  133.     fprintf(stderr, _("Lockfile is stale. Overriding it..n"));
  134.     sleep(1);
  135.     unlink(lockfile);
  136. } else
  137.     n = 0;
  138. }
  139. if (n == 0) {
  140.    if (stdwin != NIL_WIN) wclose(stdwin, 1);
  141.    fprintf(stderr, _("Device %s is locked.n"), dial_tty);
  142. drop_privs();
  143. return(-1);
  144. }
  145.   }
  147.   if (doinit >= 0 && lockfile[0]) {
  148.    /* Create lockfile compatible with UUCP-1.2 */
  149. mask = umask(022);
  150. #ifdef _COH3
  151. if ((fd = creat(lockfile, 0666)) < 0) {
  152. #else
  153.    if ((fd = open(lockfile, O_WRONLY | O_CREAT | O_EXCL, 0666)) < 0) {
  154. #endif
  155.    if (stdwin != NIL_WIN) wclose(stdwin, 1);
  156.    fprintf(stderr, _("Cannot create lockfile. Sorry.n"));
  157. drop_privs();
  158. return(-1);
  159.    }
  160. (void) umask(mask);
  161. (void) chown(lockfile, (uid_t)real_uid, (gid_t)real_gid);
  162.    snprintf(buf, sizeof(buf), "%10ld minicom %.20sn", (long)getpid(), username);
  163.    write(fd, buf, strlen(buf));
  164.    close(fd);
  165.   }
  167.   /* Run a special program to disable callin if needed. */
  168.   if (doinit > 0 && P_CALLOUT[0]) {
  169. if(fastsystem(P_CALLOUT, CNULL, CNULL, CNULL) < 0) {
  170.    if (stdwin != NIL_WIN) wclose(stdwin, 1);
  171.    fprintf(stderr, _("Could not setup for dial out.n"));
  172.    if (lockfile[0]) unlink(lockfile);
  173. drop_privs();
  174. return(-1);
  175.    }
  176.   }
  178.   /* Now open the tty device. */
  179.   if (setjmp(albuf) == 0) {
  180. portfd = -1;
  181. signal(SIGALRM, get_alrm);
  182. alarm(4);
  183. #if defined(O_NDELAY) && defined(F_SETFL)
  184. portfd = open(dial_tty, O_RDWR|O_NDELAY);
  185. if (portfd >= 0){
  186. /* Cancel the O_NDELAY flag. */
  187. n = fcntl(portfd, F_GETFL, 0);
  188. (void) fcntl(portfd, F_SETFL, n & ~O_NDELAY);
  189. }
  190. #else
  191. portfd = open(dial_tty, O_RDWR);
  192. #endif
  193. if (portfd >= 0) {
  194. if (doinit >= 0) m_savestate(portfd);
  195. port_init();
  196. }
  197.   }
  198. #if defined(__linux__) || (defined(BSD) && (BSD >= 199306))
  199.   s_errno = errno;
  200. #endif
  201.   alarm(0);
  202.   signal(SIGALRM, SIG_IGN);
  203.   if (portfd < 0) {
  204. if (doinit >= 0) {
  205.    if (stdwin != NIL_WIN) wclose(stdwin, 1);
  206. #if defined(__linux__) || (defined(BSD) && (BSD >= 199306))
  207. fprintf(stderr, _("minicom: cannot open %s: %sn"),
  208. dial_tty, strerror(s_errno));
  209. #else
  210.    fprintf(stderr, _("minicom: cannot open %s. Sorry.n"), dial_tty);
  211. #endif
  212. if (lockfile[0]) unlink(lockfile);
  213. drop_privs();
  214. return(-1);
  215. }
  216. if (lockfile[0]) unlink(lockfile);
  217. werror(_("Cannot open %s!"), dial_tty);
  218. drop_privs();
  219. return(-1);
  220.   }
  222.   /* Remember owner of port */
  223.   stat(dial_tty, &stt);
  224.   portuid = stt.st_uid;
  225.   portgid = stt.st_gid;
  227.   /* Give it to us! */
  228.   if (real_uid != 0) chown(dial_tty, (uid_t)real_uid, (gid_t)real_gid);
  230.   /* Set CLOCAL mode */
  231.   m_nohang(portfd);
  233.   /* Set Hangup on Close if program crashes. (Hehe) */
  234.   m_hupcl(portfd, 1);
  235.   if (doinit > 0) m_flush(portfd);
  236.   drop_privs();
  237.   return(0);
  238. }
  241. /* Function to write output. */
  242. static void do_output(s, len)
  243. char *s;
  244. int len;
  245. {
  246.   char buf[256];
  247.   int f;
  249.   if (len == 0) len = strlen(s);
  251.   if (P_PARITY[0] == 'M') {
  252. for(f = 0; f < len && f < 256; f++)
  253. buf[f] = *s++ | 0x80;
  254. write(portfd, buf, f);
  255.   } else
  256. write(portfd, s, len);
  257. }
  259. /* Function to handle keypad mode switches. */
  260. static void kb_handler(a, b)
  261. int a,b;
  262. {
  263.   cursormode = b;
  264.   keypadmode = a;
  265.   if (st) curs_status();
  266. }
  268. /*
  269.  * Initialize screen and status line.
  270.  */
  271. void init_emul(type, do_init)
  272. int type;
  273. int do_init;
  274. {
  275.   int x = -1, y = -1;
  276.   char attr = 0;
  277.   int maxy;
  278.   int ypos;
  279.   extern int use_status;
  281.   if (st != NIL_WIN) {
  282.    wclose(st, 1);
  283.    tempst = 0;
  284.    st = NIL_WIN;
  285.   }
  287.   if (us != NIL_WIN) {
  288. x = us->curx; y = us->cury;
  289. attr = us->attr;
  290.    wclose(us, 0);
  291.   }
  293.   /* See if we have space for a fixed status line */
  294.   maxy = LINES - 1;
  295.   if ((use_status || LINES > 24)
  296. && P_STATLINE[0] == 'e') {
  297. if (use_status) {
  298. ypos = LINES;
  299. maxy = LINES - 1;
  300. } else {
  301. ypos = LINES - 1;
  302. maxy = LINES - 2;
  303. }
  304. st = wopen(0, ypos, COLS - 1, ypos, BNONE,
  305. st_attr, sfcolor, sbcolor, 1, 0, 1);
  306. wredraw(st, 1);
  307.   }
  309.   /* MARK updated 02/17/95 - Customizable size for history buffer */
  310.   num_hist_lines = atoi(P_HISTSIZE);
  311.   if (num_hist_lines < 0) num_hist_lines = 0;
  312.   if (num_hist_lines > 5000) num_hist_lines = 5000;
  314.   /* Open a new main window, and define the configured history buffer size. */
  315.   us = wopen(0, 0, COLS - 1, maxy,
  316.              BNONE, XA_NORMAL, tfcolor, tbcolor, 1, num_hist_lines, 0);
  318.   if (x >= 0) {
  319.    wlocate(us, x, y);
  320.    wsetattr(us, attr);
  321.   }
  323.   us->autocr = 0;
  325.   terminal = type;
  326.   lines = LINES - (st != NIL_WIN);
  327.   cols = COLS;
  328.   
  329.   /* Install and reset the terminal emulator. */
  330.   if (do_init) {
  331.    vt_install(do_output, kb_handler, us);
  332. vt_init(type, tfcolor, tbcolor, type != VT100, 0);
  333.   } else
  334. vt_pinit(us, -1, -1);
  336.   if (st != NIL_WIN) show_status();
  337. }
  339. /*
  340.  * Locate the cursor at the correct position in
  341.  * the user screen.
  342.  */
  343. static void ret_csr()
  344. {
  345.   wlocate(us, us->curx, us->cury);
  346.   wflush();
  347. }
  349. /*
  350.  * Show baudrate, parity etc.
  351.  */
  352. void mode_status()
  353. {
  354.   if (st) { /* if swich off status line - NOT print !!! (vlk@st.simbirsk.su) */
  355.     wlocate(st, 20, 0);
  356.     if (P_SHOWSPD[0] == 'l')
  357.       wprintf(st, "%6ld %s%s1", linespd, P_BITS, P_PARITY);
  358.     else
  359.       wprintf(st, "%6.6s %s%s1", P_BAUDRATE, P_BITS, P_PARITY);
  360.     ret_csr();
  361.   }
  362. }
  364. /*
  365.  * Show offline or online time.
  366.  * If real dcd is not supported, Online and Offline will be
  367.  * shown in capitals.
  368.  */
  369. void time_status()
  370. {
  371.   wlocate(st, 63, 0);
  372.   if (online < 0)
  373.    wprintf(st, " %12.12s ", P_HASDCD[0] == 'Y' ? _("Offline") : _("OFFLINE"));
  374.   else
  375.    wprintf(st," %s %02ld:%02ld", P_HASDCD[0] == 'Y' ? _("Online") : _("ONLINE"),
  376.    online / 3600, (online / 60) % 60);
  377.   
  378.   ret_csr();
  379. }
  381. /*
  382.  * Show in which mode the cursor keys are (normal or application)
  383.  */
  384. void curs_status()
  385. {
  386.   wlocate(st, 33, 0);
  387.   wprintf(st, cursormode == NORMAL ? "NOR" : "APP");
  388.   ret_csr();
  389. }
  391. time_t old_online = -1;
  393. /*
  394.  * Update the online time.
  395.  */
  396. static void updtime()
  397. {
  399.   if (old_online == online) return;
  400.   if ((P_LOGCONN[0] == 'Y') && (old_online >= 0) && (online < 0)) {
  401.     do_log(_("Gone offline (%ld:%02ld:%02ld)"),
  402.       old_online / 3600, (old_online / 60) % 60, old_online % 60);
  403.   }
  404.   old_online = online;
  405.   if (st != NIL_WIN) {
  406.    time_status();
  407.    ret_csr();
  408.   }
  409.   wflush();
  410. }
  413. /* Update the timer display. This can also be called from updown.c */
  414. void timer_update()
  415. {
  416.   static time_t t1, start;
  417.   int dcd_support = P_HASDCD[0] == 'Y';
  419.   /* See if we're online. */
  420.   if ((!dcd_support && bogus_dcd) || (dcd_support && m_getdcd(portfd))) {
  421. /* We are online at the moment. */
  422.    if (online < 0) {
  423. /* This was a transition from off to online */
  424.    time(&start);
  425.    t1 = start;
  426.    online = 0;
  427.    updtime();
  428. #if _DCDFLOW
  429. /* DCD has gotten high, we can turn on hw flow control */
  430. if (P_HASRTS[0] == 'Y')
  431. m_sethwf(portfd, 1);
  432. #endif
  433.    }
  434.   } else {
  435. /* We are offline at the moment. */
  436. #if _DCDFLOW
  437. if (online >= 0) {
  438. /* DCD has dropped, turn off hw flow control. */
  439. m_sethwf(portfd, 0);
  440. }
  441. #endif
  442. if (online >= 0 && old_online >= 0) {
  443.   /* First update the timer for call duration.. */
  444.   time(&t1);
  445.   online = t1 - start;
  446.   updtime();
  447. }
  448. /* ..and THEN notify that we are now offline */
  449.    online = -1;
  450.    updtime();
  451.   }
  453.   /* Update online time */
  454.   if (online >= 0) {
  455.     time(&t1);
  456.     online = t1 - start;
  457.     if (online > (old_online + 59))
  458.       updtime();
  459.   }
  460. }
  462. /*
  463.  * Show the status line 
  464.  */
  465. void show_status()
  466. {
  467.   st->direct = 0;
  468.   wlocate(st, 0, 0);
  469.   wprintf(st, _(" %7.7sZ for help 263           263     263 Minicom %-6.6s 263       263 "),
  470.    esc_key(), ST_VERSION);
  471.   mode_status();
  472.   time_status();
  473.   curs_status();
  474.   wlocate(st, 56, 0);
  475.   switch(terminal) {
  476.    case VT100:
  477.    wputs(st, "VT102");
  478.    break;
  479.    case ANSI:
  480.    wputs(st, "ANSI");
  481.    break;
  482.   }
  483.   wredraw(st, 1);
  484.   ret_csr();
  485. }
  487. /*
  488.  * Show the name of the script running now.
  489.  */
  490. void scriptname(s)
  491. char *s;
  492. {
  493.   if (st == NIL_WIN) return;
  494.   wlocate(st, 39, 0);
  495.   if (*s == 0)
  496.    wprintf(st, "Minicom %-6.6s", ST_VERSION);
  497.   else
  498.        wprintf(st, "script %-7.7s", s);
  499.   ret_csr();
  500. }
  502. /*
  503.  * Show status line temporarily
  504.  */
  505. static void showtemp()
  506. {
  507.   if (st != NIL_WIN) return;
  509.   st = wopen(0, LINES - 1, COLS - 1, LINES - 1,
  510.                 BNONE, st_attr, sfcolor, sbcolor, 1, 0, 1);
  511.   show_status();
  512.   tempst = 1;
  513. }
  515. /*
  516.  * The main terminal loop:
  517.  * - If there are characters recieved send them
  518.  *   to the screen via the appropriate translate function.
  519.  */
  520. int do_terminal()
  521. {
  522.   char buf[128];
  523.   char *ptr;
  524.   int c;
  525.   int x;
  526.   int blen;
  527.   int zauto = 0;
  528.   char *zsig = "**30B00";
  529.   int zpos = 0;
  530. #if _HAVE_MACROS
  531.   char *s;
  532. #endif
  533.   dirflush = 0;
  535. dirty_goto:
  536.   /* Show off or online time */
  537.   updtime();
  539.   /* If the status line was shown temporarily, delete it again. */
  540.   if (tempst) {
  541.    tempst = 0;
  542.    wclose(st, 1);
  543.    st = NIL_WIN;
  544.   }
  547.   /* Auto Zmodem? */
  548.   if (P_PAUTO[0] >= 'A' && P_PAUTO[0] <= 'Z') zauto = P_PAUTO[0];
  549.   /* Set the terminal modes */
  550.   (void) setcbreak(2); /* Raw, no echo */
  552.   keyboard(KSTART, 0);
  554.   /* Main loop */
  555.   while(1) {
  556. /* See if window size changed */
  557. if (size_changed) {
  558. size_changed = 0;
  559. #if 1
  560. /* I got the resize code going again! Yeah! */
  561. wclose(us, 0);
  562. us = NIL_WIN;
  563. if (st) wclose(st, 0);
  564. st = NIL_WIN;
  565. wclose(stdwin, 0);
  566.                 if (win_init(tfcolor, tbcolor, XA_NORMAL) < 0)
  567. leave(_("Could not re-initialize window system."));
  568. init_emul(terminal, 0);
  569. #else
  570. werror(_("Resize not supported, screen may be messed up!"));
  571. #endif
  572. }
  573. /* Update the timer. */
  574. timer_update();
  576. /* Check for I/O or timer. */
  577. x = check_io(portfd, 0, 1000, buf, &blen);
  579. /*  Send data from the modem to the screen. */
  580.    if ((x & 1) == 1) {
  581.    ptr = buf;
  582.    while(blen-- > 0) {
  583. /* Auto zmodem detect */
  584. if (zauto) {
  585. if (zsig[zpos] == *ptr) zpos++;
  586.   else zpos = 0;
  587. }
  588. if (P_PARITY[0] == 'M' || P_PARITY[0] == 'S')
  589. *ptr &= 0x7f;
  590.    vt_out(*ptr++);
  591. if (zauto && zsig[zpos] == 0) {
  592. dirflush = 1;
  593. keyboard(KSTOP, 0);
  594. updown('D', zauto - 'A');
  595. dirflush = 0;
  596. zpos = 0;
  597. blen = 0;
  598. goto dirty_goto;
  599. }
  600. }
  601.    wflush();
  602.    }
  604. /* Read from the keyboard and send to modem. */
  605. if ((x & 2) == 2) {
  606. /* See which key was pressed. */
  607. c = keyboard(KGETKEY, 0);
  608. if (c < 0) c += 256; /* XXX - shouldn't happen */
  610. /* Was this a command key? */
  611. #ifndef RH_FIX
  612. if ((escape == 128 && c > 224 && c < 252) ||
  613. #else   /* filipg 8/22/97: needed to recognize Fkeys in RedHat 4.1 */
  614. if ((escape == 128 && c > 128 && c < 256) ||
  615. #endif /* RH_FIX */
  616.     (escape != 27 && c == escape) || 
  617.     (c > K_META)) {
  619. /* Stop keyserv process if we have it. */
  620.    keyboard(KSTOP, 0);
  622.    /* Restore keyboard modes */
  623.    (void) setcbreak(1); /* Cbreak, no echo */
  625.    /* Show status line temporarily */
  626.    showtemp();
  627.    if (c == escape) /* CTRL A */
  628. c = keyboard(KGETKEY, 0);
  629. if (c > K_META) c -= K_META;
  630.    if (c > 128) c -= 128;
  631.    if (c > ' ') {
  632. dirflush = 1;
  633. m_flush(0);
  634. return(c);
  635. }
  636. /* CTRLA - CTRLA means send one CTRLA */
  637. #if 0
  638. write(portfd, &c, 1);
  639. #else
  640. vt_send(c);
  641. #endif
  642. goto dirty_goto;
  643.    }
  645. /* No, just a key to be sent. */
  646. #if _HAVE_MACROS
  647. if (c >= K_F1 && c <= K_F10 && P_MACENAB[0] == 'Y') {
  648.     s = "";
  649.     switch(c) {
  650. case K_F1: s = P_MAC1; break;
  651. case K_F2: s = P_MAC2; break;
  652. case K_F3: s = P_MAC3; break;
  653. case K_F4: s = P_MAC4; break;
  654. case K_F5: s = P_MAC5; break;
  655. case K_F6: s = P_MAC6; break;
  656. case K_F7: s = P_MAC7; break;
  657. case K_F8: s = P_MAC8; break;
  658. case K_F9: s = P_MAC9; break;
  659. case K_F10: s = P_MAC10; break;
  660.     }
  661.     if (*s)
  662. mputs(s, 1);
  663.     else
  664. vt_send(c);
  665. } else
  666. #endif
  667. vt_send(c);
  668. }
  669.   }
  670. }