home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / OSKBox.lzh / MAILBOX / CC / clksrv.c < prev    next >
C/C++ Source or Header  |  1992-03-28  |  8KB  |  416 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <setjmp.h>
  4. #include "mailbox.h"
  5.  
  6. #define TIMEOUT (5 * 60)    /* maximum # of seconds to wait for response */
  7.  
  8. int tnc_in, tnc_out, ctl_in, ctl_out;
  9. jmp_buf disconnected;
  10. int ok_flag, bid_flag, mid_flag;
  11. int sec;
  12.  
  13. main (argc, argv)
  14. char *argv[];
  15. {
  16.     int i, flag, flag2;
  17.  
  18.     if (argc < 2) {
  19.         printf ("No port supplied.\n");
  20.         exit (0);
  21.         }
  22.     for (i = 2; i < argc; i++) {
  23.         flag = (*argv[i] == '$');        /* use GMT */
  24.         if (flag) argv[i]++;
  25.         flag2 = (*argv[i] == '@');        /* use GMT */
  26.         if (flag2) argv[i]++;
  27.         while (clock_serve (argv[i], argv[1], flag, flag2) == 0)
  28.             sleep (60);        /* try again later */
  29.         }
  30.     }
  31.  
  32. clock_serve (mbox, port, zflag, bbflag)
  33. char *mbox, *port;
  34. {
  35.     int i, curtime, curdate, tick;
  36.     short curday;
  37.     char str[40];
  38.  
  39. printf ("clock_serve: mbox=%s port=%s zflag=%d bbflag=%d\n",mbox,port,zflag,bbflag);
  40.     ok_flag = bid_flag = mid_flag = 0;
  41.     if (!open_channel (port)) {
  42.         return (-1);
  43.         }
  44.     if (setjmp (disconnected)) {
  45.         close_channel (port);
  46.         return (-1);
  47.         }
  48.     if ((i = connect (mbox)) < 1) {
  49.         close_channel (port);
  50.         return (i);
  51.         }
  52.     get_prompt ();
  53.     if (ok_flag) {
  54.         sprintf (str, "%s\n", SID);
  55.         write_path (tnc_out, str);
  56.         get_prompt ();
  57.         }
  58.     if (bbflag) {
  59.         write_path (tnc_out, "@\n");
  60.         get_prompt ();
  61.         }
  62.  
  63.     /* next minute */
  64.     _sysdate (0, &curtime, &curdate, &curday, &tick);
  65.     sleep (61 - (curtime & 0xff));
  66.         _sysdate (0, &curtime, &curdate, &curday, &tick);
  67.     if (zflag)
  68.         ztime (&curtime, &curdate, &curday);
  69.     sprintf (str, (bbflag) ? "C %02d%02d%02d%02d%02d\n" : "C %02d%02d%02d %02d%02d\n",
  70.             (curdate >> 16) % 100,
  71.             (curdate >> 8) & 0xff,
  72.             curdate & 0xff,
  73.             (curtime >> 16) & 0xff,
  74.             (curtime >> 8) & 0xff);
  75.     write_path (tnc_out, str);
  76.     get_prompt ();
  77.     disconnect ();
  78.     close_channel (port);
  79.     return (1);
  80.     }
  81.  
  82. get_prompt ()
  83. {
  84.     char str[256];
  85.     char *f1, *f2, *f3, *f4, *p;
  86.  
  87. printf ("get_prompt\n");
  88.     while (1) {
  89.         get_line (str);
  90.         if ((f1 = strchr (str, '[')) == str && (f2 = strrchr (f1, ']')) &&
  91.                (f3 = strchr (f1, '-')) && f3 < f2 && (f4 = strrchr (f1, '-')) &&
  92.                f4 > f3) {
  93.             ok_flag = 1;
  94.             for (p = f4 + 1; p < f2; p++)
  95.                 switch (*p) {
  96.     case '$':    bid_flag++;  break;
  97.     case 'M':    mid_flag++;  break;
  98.     default:        break;
  99.                     }
  100.             }
  101.         else if ((f1 = strchr (str, '[')) == str && (f2 = strchr (f1, ']'))) {
  102.             *(f1+4) = '\0';
  103.             if (strcmp (f1+1, "MBL" == 0))
  104.                 ok_flag = bid_flag = 1;
  105.             }
  106.         if (str[strlen (str) - 1] == '>')
  107.             return;
  108.         }
  109.     }
  110.  
  111. get_line (str)
  112. char *str;
  113. {
  114.     int len;
  115.     int time = 0;
  116.     int status_disp, data_disp, data_send, data_ack, tries, state;
  117.  
  118.     time = tick ();
  119.     data_send = data_ack = -1;
  120.     while (1) {
  121.         if (data_send || data_ack) {
  122.             write_path (ctl_out, "L\n");
  123.             do read_path (ctl_in, str, 80); while (str[0] == '(');
  124. printf ("status %s\n", str);
  125.             scan_status (str, &status_disp, &data_disp, &data_send, 
  126.                                     &data_ack, &tries, &state);
  127.             if (state == 0)
  128.                 longjmp (disconnected, 2);
  129.             if (data_send || data_ack)
  130.                 time = tick ();
  131.             }
  132.         else if (_gs_rdy (ctl_in) > 0)
  133.             check_status ();
  134.         if (_gs_rdy (tnc_in) > 0) {
  135.             read_path (tnc_in, str, 256);
  136. printf ("get_line: '%s'\n", str);
  137.             return;
  138.             }
  139.         sleep (3);
  140.         if ((tick() - time) / sec > TIMEOUT) {
  141. printf ("TIMEOUT\n");
  142.             write_path (ctl_out, "D\n");
  143.             time = tick ();
  144.             }
  145.         }
  146.     }
  147.  
  148. disconnect ()
  149. {
  150. printf ("disconnect\n");
  151.     write_path (ctl_out, "D\n");
  152.     while (!check_disconnect ())
  153.         ;
  154.     }
  155.  
  156. check_status ()
  157. {
  158.     if (check_disconnect ())
  159.         longjmp (disconnected, 1);
  160.     }
  161.  
  162. check_disconnect ()
  163. {
  164.     char str[80];
  165.     char *p, w[20];
  166.     int len;
  167.  
  168.     read_path (ctl_in, str, 80);
  169. printf ("%s\n", str);
  170.     p = str;
  171.     p += scanword (p, w, 20);
  172.     p += scanword (p, w, 20);
  173.     if (strcmp (w, "CHANNEL") == 0) {
  174.         p += scanword (p, w, 20);
  175.         if (strcmp (w, "NOT") == 0) {
  176.             p += scanword (p, w, 20);
  177.             return (strcmp (w, "CONNECTED") == 0);
  178.             }
  179.         else
  180.             return 0;
  181.         }
  182.     else if (strcmp (w, "LINK") == 0) {
  183.         p += scanword (p, w, 20);
  184.         if (strcmp (w, "FAILURE") != 0)
  185.             return 0;
  186.         }
  187.     else if (strcmp (w, "DISCONNECTED") != 0)
  188.         return 0;
  189.     return 1;
  190.     }
  191.  
  192. connect (mbox)
  193. char *mbox;
  194. {
  195.     char path[30];
  196.     
  197.     strcpy (path, mbox);
  198.     return (try_connect (mbox));
  199.     }
  200.  
  201. try_connect (fpath)
  202. char *fpath;
  203. {
  204.     char str[95], w[20], *p;
  205.     int len;
  206.     int tries = 0;
  207.  
  208. printf ("try_connect %s\n", fpath);
  209.     sprintf (str, "C %s\n", fpath);
  210.     write_path (ctl_out, str);
  211.     read_path (ctl_in, str, 95);
  212. printf ("%s\n", str);
  213.     p = str + scanword (str, w, 20);
  214.     p += scanword (p, w, 20);
  215.     if (strcmp (w, "CONNECTED") == 0)
  216.         return 1;
  217.     else if (strcmp (w, "BUSY") == 0 || strcmp (w, "STATION") == 0) {
  218.         return 0;
  219.         }
  220.     else
  221.         return -1;
  222.     }
  223.  
  224. open_channel (port)
  225. char *port;
  226. {
  227.     int hostcmd;
  228.     int i, pid;
  229.     char str[40];
  230.  
  231.     strcpy (str, "/pipe/command.");
  232.     strcat (str, port);
  233.     if ((hostcmd = open (str, 2)) < 0)
  234.         return (0);
  235.     pid = getpid ();
  236.     sprintf (str, "o%d\n", pid);
  237.     write_path (hostcmd, str);
  238.     close (hostcmd);
  239.     sprintf (str, "/pipe/data_in.%d", pid);
  240.     for (i = 0; i < 10; i++) {
  241.         if ((tnc_in = open (str, 3)) != -1) break;
  242.         sleep (1);
  243.         }
  244.     if (tnc_in == -1)
  245.         return (0);
  246.     sprintf (str, "/pipe/data_out.%d", pid);
  247.     tnc_out = open (str, 3);
  248.     sprintf (str, "/pipe/ctl_in.%d", pid);
  249.     ctl_in = open (str, 3);
  250.     sprintf (str, "/pipe/ctl_out.%d", pid);
  251.     ctl_out = open (str, 3);
  252.     return (1);
  253.     }
  254.  
  255. close_channel (port)
  256. char *port;
  257. {
  258.     int hostcmd;
  259.     int i, j, pid;
  260.     char str[40];
  261.  
  262.     strcpy (str, "/pipe/command.");
  263.     strcat (str, port);
  264.     if ((hostcmd = open (str, 2)) < 0)
  265.         return (0);
  266.     pid = getpid ();
  267.     sprintf (str, "c%d\n", pid);
  268.     write_path (hostcmd, str);
  269.     close (hostcmd);
  270.     sleep (5);
  271.     drain (tnc_in);
  272.     drain (tnc_out);
  273.     drain (ctl_in);
  274.     drain (ctl_out);
  275.     close (tnc_in);
  276.     close (tnc_out);
  277.     close (ctl_in);
  278.     close (ctl_out);
  279.     sprintf (str, "/pipe/data_in.%d", pid);
  280.     for (i = 0; i < 10; i++) {
  281.         if (access (str, 0) == -1) break;
  282.         sleep (1);
  283.         }
  284.     if (i == 10) return 0;
  285.     return (1);
  286.     }
  287.  
  288. drain (path)
  289. {
  290.     int i, j;
  291.     char c;
  292.  
  293.     while ((i = _gs_rdy (path)) > 0) {
  294.         for (j = 0; j < i; j++)
  295.             read (path, &c, 1);
  296.         sleep (1);
  297.         }
  298.     }
  299.  
  300. write_path (path, str)
  301. char *str;
  302. {
  303.     write (path, str, strlen (str));
  304. if (path == tnc_out) writeln (1, str, strlen (str));
  305.     }
  306.  
  307. read_path (path, str, len)
  308. char *str;
  309. {
  310.     int i;
  311.     i = readln (path, str, len);
  312.     if (i)
  313.         str[i-1] = '\0';
  314.     return i;
  315.     }
  316.  
  317. scan_status (s, a, b, c, d, x, f)
  318. char *s;
  319. int *a, *b, *c, *d, *x, *f;
  320. {
  321.     char *p, w[20];
  322.  
  323.     p = s;
  324.     p += scanword (p, w, 20);
  325.     *a = atoi (w);
  326.     p += scanword (p, w, 20);
  327.     *b = atoi (w);
  328.     p += scanword (p, w, 20);
  329.     *c = atoi (w);
  330.     p += scanword (p, w, 20);
  331.     *d = atoi (w);
  332.     p += scanword (p, w, 20);
  333.     *x = atoi (w);
  334.     p += scanword (p, w, 20);
  335.     *f = atoi (w);
  336.     }
  337.  
  338. #asm
  339. gregorian:
  340.         link.w          a5,#0
  341.         movem.l         d1-d2/a0,-(a7)
  342.         move.l          a1,-(a7)
  343.         movea.l         d0,a0
  344.         movea.l         d1,a1
  345.         move.l          (a0),d0
  346.         move.l          (a1),d1
  347.         os9             F$Gregor
  348.         bcs               _sysret
  349.         move.l          d0,(a0)
  350.         move.l          d1,(a1)
  351.         bra.w           _sysret
  352. #endasm
  353.  
  354. ztime (time, date, weekday)
  355. int *time, *date, *weekday;
  356. {
  357.     int oneday = 60 * 60 * 24;
  358.     _julian (time, date);
  359.     *time += 60 * 60 * UTC;
  360.     if (*time >= oneday) {
  361.         *time -= oneday;
  362.         (*date)++;
  363.         *weekday = (*weekday + 1) % 7;
  364.         }
  365.     gregorian (time, date);
  366.     }
  367.  
  368. tick ()
  369. {
  370.     int time, date, i_tick;
  371.     short day;
  372.  
  373.     _sysdate (3, &time, &date, &day, &i_tick);
  374.     sec = i_tick >> 16;
  375.     return (time * sec + (i_tick & 0xFFFF));
  376.     }
  377.  
  378. scanword (s, d, len)
  379. char *s, *d;
  380. {
  381.     char *p;
  382.     int num = 0;
  383.  
  384.     while (*s && isspace (*s)) {
  385.         s++;
  386.         num++;
  387.         }
  388.     p = d;
  389.     while (*s && !isspace (*s)) {
  390.         if (p - d < len - 1) *p++ = *s;
  391.         s++;
  392.         num++;
  393.         }
  394.     *p = '\0';
  395.     return (num);
  396.     }
  397.  
  398. char *strchr (str, c)
  399. char *str;
  400. {
  401.     while (*str && *str != c)
  402.         str++;
  403.     return ((*str) ? str : 0);
  404.     }
  405.  
  406. char *strrchr (str, c)
  407. char *str;
  408. {
  409.     char *p;
  410.  
  411.     for (p = str; *p; p++) ;
  412.     while (p >= str && *p != c)
  413.         p--;
  414.     return ((p >= str) ? p : 0);
  415.     }
  416.