home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / DOOR / BD2K260A.ZIP / SRC.ZIP / SRC / OUTBOUND.C < prev    next >
C/C++ Source or Header  |  1998-10-03  |  37KB  |  1,680 lines
  1. /*--------------------------------------------------------------------------*/
  2. /*                                                                          */
  3. /*                                                                          */
  4. /*      ------------         Bit-Bucket Software, Co.                       */
  5. /*      \ 10001101 /         Writers and Distributors of                    */
  6. /*       \ 011110 /          Freely Available<tm> Software.                 */
  7. /*        \ 1011 /                                                          */
  8. /*         ------                                                           */
  9. /*                                                                          */
  10. /*              (C) Copyright 1987-96, Bit Bucket Software Co.              */
  11. /*                                                                          */
  12. /*    This module has significant work from Vince Perriello, Bob Hartman,   */
  13. /*             Holger Schurig, Michael Buenter and Doug Boone               */
  14. /*                  BinkleyTerm Outbound Area Manipulation                  */
  15. /*                                                                          */
  16. /*                                                                          */
  17. /*    For complete  details  of the licensing restrictions, please refer    */
  18. /*    to the License  agreement,  which  is published in its entirety in    */
  19. /*    the MAKEFILE and BT.C, and also contained in the file LICENSE.260.    */
  20. /*                                                                          */
  21. /*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  22. /*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  23. /*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
  24. /*    NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
  25. /*    SOFTWARE CO.  AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
  26. /*    SHOULD YOU  PROCEED TO USE THIS FILE  WITHOUT HAVING  ACCEPTED THE    */
  27. /*    TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
  28. /*    AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.      */
  29. /*                                                                          */
  30. /*                                                                          */
  31. /* You can contact Bit Bucket Software Co. at any one of the following      */
  32. /* addresses:                                                               */
  33. /*                                                                          */
  34. /* Bit Bucket Software Co.        FidoNet  1:104/501, 1:343/491             */
  35. /* P.O. Box 460398                AlterNet 7:42/1491                        */
  36. /* Aurora, CO 80046               BBS-Net  86:2030/1                        */
  37. /*                                Internet f491.n343.z1.fidonet.org         */
  38. /*                                                                          */
  39. /* Please feel free to contact us at any time to share your comments about  */
  40. /* our software and/or licensing policies.                                  */
  41. /*                                                                          */
  42. /*--------------------------------------------------------------------------*/
  43.  
  44. /* Include this file before any other includes or defines! */
  45.  
  46. #include "includes.h"
  47.  
  48. extern char *mail_status_chars (unsigned int);
  49.  
  50. /* local prototypes */
  51.  
  52. static int mail_change (BINK_SAVEP, int);
  53. static int mail_delreq (BINK_SAVEP, int);
  54. static int mail_stop (BINK_SAVEP, int);
  55. static int mail_addr (BINK_SAVEP, int);
  56.  
  57. static void LOCALFUNC zoom_window (REGIONP, MAILP, MAILP);
  58. static void LOCALFUNC append_pkt (REGIONP, unsigned int, char *, char *);
  59. static int LOCALFUNC mail_addsend (ADDRP, char *, char *);
  60. static int LOCALFUNC mail_addrequest (ADDRP, char *, char *, char *);
  61. static int LOCALFUNC kill_node (char *);
  62. static void LOCALFUNC call_tries (ADDRP baddr, int *calls, int *badcalls);
  63.  
  64. /* local variables */
  65.  
  66. static int curl;
  67. static MAILP cur, oldp, oldcur;
  68.  
  69. #define ZHELPSIZE 9
  70.  
  71. int 
  72. Do_Zoom (BINK_SAVEP rp, int x)
  73. {
  74.     REGIONP zoomwin;
  75.     MAILP p;
  76.     long t_idle;
  77.     int i, c;
  78.     int changed = 0;
  79.     short z;
  80.  
  81.     x = 1;
  82.  
  83.     /* is there a window */
  84.  
  85.     if (rp == NULL)
  86.         return (0);
  87.  
  88.     zoomwin = rp->region;
  89.  
  90.     /* draw a box */
  91.  
  92.     sb_fill (zoomwin, ' ', colors.hold);
  93.     sb_box (zoomwin, boxtype, colors.hold);
  94.  
  95.     /* give it a title */
  96.  
  97.     sb_move (zoomwin, 0, 1);
  98.     sb_puts (zoomwin, MSG_TXT (M_ZOOM_TITLE));
  99.  
  100.     /* clear the inside of zoomed outbound */
  101.  
  102.     zoomwin->sr0++;
  103.     zoomwin->sr1--;
  104.     zoomwin->sc0++;
  105.     zoomwin->sc1--;
  106.     sb_fillc (zoomwin, ' ');
  107.     zoomwin->sr0--;
  108.     zoomwin->sr1++;
  109.     zoomwin->sc0--;
  110.     zoomwin->sc1++;
  111.  
  112.     /* Put the help text at the bottom of the window */
  113.  
  114.     c = (int) (zoomwin->sr1 - 1);
  115.     i = M_ZOOM_HELP;
  116.  
  117.     for (z = zoomwin->sr1 - ZHELPSIZE + 1; z < (short) c; i++, z++)
  118.     {
  119.         sb_move (zoomwin, z, 1);
  120.         sb_puts (zoomwin, MSG_TXT (i));
  121.     }
  122.  
  123.     /* is there a rescan flag? */
  124.     if (forcerescancheck ())
  125.     {
  126.         sb_move (zoomwin, 1, 2);
  127.         sb_puts (zoomwin, MSG_TXT (M_ZOOM_WAIT));
  128.         sb_show ();
  129.         xmit_reset (0);
  130.     }
  131.  
  132.     /* is there something in the outbound? */
  133.  
  134.     if (mail_top == NULL)
  135.     {
  136.         sb_move (zoomwin, 10, 10);
  137.         sb_puts (zoomwin, MSG_TXT (M_NOTHING_IN_OUTBOUND));
  138.         sb_show ();
  139.         wait_for_key (120);
  140.         return (x);
  141.     }
  142.  
  143.     p = cur = mail_top;
  144.     oldp = oldcur = NULL;
  145.     curl = 2;
  146.     zoom_window (zoomwin, p, cur);
  147.  
  148.     t_idle = timerset (6000);
  149.     while (!timeup (t_idle) && (PEEKBYTE () == (short) 0xffff))
  150.     {
  151.         if (KEYPRESS ())
  152.         {
  153.             t_idle = timerset (3000);
  154.  
  155.             c = (int) KbRemap (FOSSIL_CHAR ());
  156.  
  157.             switch ((unsigned) c)
  158.             {
  159.             case F_PEND_PGUP:
  160.                 for (i = 2; i < (zoomwin->sr1 - ZHELPSIZE); i++)
  161.                 {
  162.                     if (p->prev != NULL)
  163.                         p = p->prev;
  164.                     if (cur->prev != NULL)
  165.                         cur = cur->prev;
  166.                 }
  167.                 break;
  168.  
  169.             case F_PEND_PGDN:
  170.                 for (i = 2; i < (zoomwin->sr1 - ZHELPSIZE); i++)
  171.                 {
  172.                     if (p->next != NULL)
  173.                         p = p->next;
  174.                     if (cur->next != NULL)
  175.                         cur = cur->next;
  176.                 }
  177.                 break;
  178.  
  179.             case F_PEND_UPAR:
  180.                 if (curl > 2)
  181.                 {
  182.                     cur = cur->prev;
  183.                 }
  184.                 else
  185.                 {
  186.                     if (p->prev != NULL)
  187.                         p = cur = p->prev;
  188.                 }
  189.                 break;
  190.  
  191.             case F_PEND_DNAR:
  192.                 if (curl < (zoomwin->sr1 - 1 - ZHELPSIZE))
  193.                 {
  194.                     if (cur->next != NULL)
  195.                         cur = cur->next;
  196.                 }
  197.                 else
  198.                 {
  199.                     if (p->next != NULL)
  200.                         p = p->next;
  201.                     if (cur->next != NULL)
  202.                         cur = cur->next;
  203.                 }
  204.                 break;
  205.  
  206.             case F_PEND_HOME:
  207.                 p = cur = mail_top;
  208.                 break;
  209.  
  210.             case F_PEND_END:
  211.                 while (p->next != NULL)
  212.                 {
  213.                     p = p->next;
  214.                 }
  215.                 cur = p;
  216.                 for (i = 2; i < (zoomwin->sr1 - 1 - ZHELPSIZE); i++)
  217.                 {
  218.                     if (p->prev != NULL)
  219.                         p = p->prev;
  220.                 }
  221.                 break;
  222.  
  223.             case F_ZOOM_ADDRESS:    /* readdress */
  224.                 changed = sb_popup (10, 5, 4, 70, mail_addr, 0);
  225.                 break;
  226.  
  227.             case F_UN_CALLRIGHTNOW:
  228.             case F_ZOOM_CRASH:    /* crash */
  229.                 changed = sb_popup (10, 5, 4, 70, mail_change, (int) 'C');
  230.                 break;
  231.  
  232.             case F_ZOOM_DIRECT:/* direct */
  233.                 changed = sb_popup (10, 5, 4, 70, mail_change, (int) 'D');
  234.                 break;
  235.  
  236.             case F_UN_GETFILE:
  237.                 changed = sb_popup (10, 5, 7, 70, Do_Get, 0);
  238.                 break;
  239.  
  240.             case F_ZOOM_GET:    /* get files */
  241.                 changed = sb_popup (10, 5, 7, 70, Do_Get, 1);
  242.                 break;
  243.  
  244.             case F_ZOOM_HOLD:    /* hold */
  245.                 changed = sb_popup (10, 5, 4, 70, mail_change, (int) 'H');
  246.                 break;
  247.  
  248.             case F_ZOOM_KILLTRIES:    /* reset dial tries */
  249.                 changed = sb_popup (10, 5, 4, 70, mail_stop, 0);
  250.                 break;
  251.  
  252.             case F_ZOOM_NORMAL:/* normal */
  253.                 changed = sb_popup (10, 5, 4, 70, mail_change, (int) 'N');
  254.                 break;
  255.  
  256.             case F_UN_POLLPKT:
  257.                 changed = sb_popup (10, 5, 4, 70, Do_Poll_Packet, 0);
  258.                 break;
  259.  
  260.             case F_ZOOM_POLL:    /* poll */
  261.                 changed = sb_popup (10, 5, 5, 70, Do_Poll_Packet, 1);
  262.                 break;
  263.  
  264.             case F_ZOOM_KILLREQ:    /* delete request */
  265.                 changed = sb_popup (10, 5, 4, 70, mail_delreq, 0);
  266.                 break;
  267.  
  268.             case F_UN_SENDFILE:
  269.                 changed = sb_popup (10, 5, 6, 70, Do_Send, 0);
  270.                 break;
  271.  
  272.             case F_ZOOM_SEND:    /* send files */
  273.                 changed = sb_popup (10, 5, 6, 70, Do_Send, 1);
  274.                 break;
  275.  
  276.             case F_ZOOM_STOPMAIL:    /* stop mail */
  277.                 changed = sb_popup (10, 5, 4, 70, mail_stop, 1);
  278.                 break;
  279.  
  280.             case F_ZOOM_KILLNODE:
  281.             case F_UN_KILLNODESMAIL:
  282.                 changed = !sb_popup (10, 5, 4, 70, Do_Kill, 1);
  283.                 break;
  284.  
  285.             default:            /* Space, ESCape or Return terminates */
  286.                 c &= 0x00ff;
  287.                 if ((c == 0x20) || (c == 0x1b) || (c == 0x0d))
  288.                     return (x);
  289.                 break;
  290.             }
  291.  
  292.             if (changed != 0)
  293.             {
  294.                 sb_move (zoomwin, (short) curl, 1);
  295.                 sb_wa (zoomwin, colors.hold, 78);
  296.                 sb_move (zoomwin, 1, 2);
  297.                 sb_puts (zoomwin, MSG_TXT (M_ZOOM_WAIT));
  298.                 sb_show ();
  299.                 xmit_reset (0);
  300.                 t_idle = timerset (6000);
  301.                 x = 1;
  302.                 /* is there something in the outbound ? */
  303.                 if (mail_top == NULL)
  304.                 {
  305.                     sb_move (zoomwin, 10, 10);
  306.                     sb_puts (zoomwin, MSG_TXT (M_NOTHING_IN_OUTBOUND));
  307.                     sb_show ();
  308.                     wait_for_key (120);
  309.                     return (x);
  310.                 }
  311.                 else
  312.                 {
  313.                     oldp = oldcur = NULL;
  314.                     p = cur = mail_top;
  315.                     curl = 2;
  316.                     changed = 0;
  317.                 }
  318.             }
  319.  
  320.             if ((oldp != p) || (oldcur != cur))
  321.                 zoom_window (zoomwin, p, cur);
  322.  
  323.         }
  324.         time_release ();
  325.     }
  326.     return (x);
  327. }
  328.  
  329. static void LOCALFUNC 
  330. zoom_window (REGIONP zoomwin, MAILP p, MAILP cur)
  331. {
  332.     int i;
  333.     int calls, badcalls;
  334.     int zsize = (zoomwin->sr1) - ZHELPSIZE;
  335.  
  336.     char out_str[50];
  337.  
  338.     if (oldp == p)
  339.     {
  340.         oldcur = cur;
  341.         sb_move (zoomwin, (short) curl, 1);
  342.         sb_wa (zoomwin, colors.hold, 78);
  343.         i = 2;
  344.         while ((i < zsize) && (p != cur))
  345.         {
  346.             i++;
  347.             p = p->next;
  348.         }
  349.         sb_move (zoomwin, (short) i, 1);
  350.         sb_wa (zoomwin, colors.calling, 78);
  351.         curl = i;
  352.         sb_show ();
  353.         return;
  354.     }
  355.  
  356.     /* save old status */
  357.  
  358.     oldp = p;
  359.     oldcur = cur;
  360.  
  361.     /* give it a header */
  362.  
  363.     sb_move (zoomwin, 1, 1);
  364.     sb_puts (zoomwin, MSG_TXT (M_ZOOM_HEADER));
  365.  
  366.     sb_move (zoomwin, (short) curl, 1);
  367.     sb_wa (zoomwin, colors.hold, 78);
  368.  
  369.     for (i = 2; i < zsize; i++)
  370.     {
  371.         long age;
  372.  
  373.         if (p == NULL)
  374.             break;
  375.  
  376.         sb_move (zoomwin, (short) i, 1);
  377.  
  378.         if (p == cur)
  379.         {
  380.             sb_wa (zoomwin, colors.calling, 78);
  381.             curl = i;
  382.         }
  383.  
  384.         sprintf (out_str, " %-35s", Full_Addr_Str (&(p->mail_addr)));
  385.         sb_puts (zoomwin, out_str);
  386.  
  387.         sb_move (zoomwin, (short) i, 36);
  388.  
  389.         call_tries (&(p->mail_addr), &calls, &badcalls);
  390.  
  391.         age = (time (NULL) - p->oldest) / 86400L;
  392.  
  393.         sprintf (out_str, "%3u %9lu %3lu %5d %5d %6s ",
  394.             p->numfiles, p->mailsize, age, calls, badcalls,
  395.             mail_status_chars (p->mailtypes));
  396.  
  397.         sb_puts (zoomwin, out_str);
  398.         p = p->next;
  399.     }
  400.  
  401.     /* clear the rest of the zoomed outbound */
  402.     if (i <= zsize)
  403.     {
  404.         zoomwin->sr0 += i;
  405.         zoomwin->sr1 -= ZHELPSIZE;
  406.         zoomwin->sc0++;
  407.         zoomwin->sc1--;
  408.         sb_fillc (zoomwin, ' ');
  409.         zoomwin->sr0 -= i;
  410.         zoomwin->sr1 += ZHELPSIZE;
  411.         zoomwin->sc0--;
  412.         zoomwin->sc1++;
  413.     }
  414.  
  415.     sb_show ();
  416. }
  417.  
  418. static int 
  419. mail_change (BINK_SAVEP p, int x)
  420. {
  421.     REGIONP r;
  422.     char iname[80], oname[80], tname[80];    /* junk[80] */
  423.     char *HoldName, *result, *temp_buffer;
  424.     struct FILEINFO fileinfo;
  425.     int ihandle, ohandle;
  426.     int check;
  427.     int written = 1;
  428.     int buff_size;
  429.     int change = 0;
  430.  
  431.     if (p == NULL)
  432.         return (change);
  433.  
  434.     r = p->region;
  435.  
  436.     sb_fill (r, ' ', colors.popup);
  437.     sb_box (r, boxtype, colors.popup);
  438.  
  439.     switch ((char) x)
  440.     {
  441.     case 'C':
  442.         {
  443.             strcpy (oname, "Crash");
  444.             break;
  445.         }
  446.     case 'D':
  447.         {
  448.             strcpy (oname, "Direct");
  449.             break;
  450.         }
  451.     case 'H':
  452.         {
  453.             strcpy (oname, "Hold");
  454.             break;
  455.         }
  456.     case 'N':
  457.         {
  458.             strcpy (oname, "Normal");
  459.             x = (int) 'F';
  460.             break;
  461.         }
  462.     }
  463.  
  464.     sprintf (junk, MSG_TXT (M_ZOOM_CHANGE),
  465.         Full_Addr_Str (&(cur->mail_addr)), oname);
  466.  
  467.     sb_move (r, 0, 1);
  468.     sb_puts (r, junk);
  469.  
  470.     sb_move (r, 1, 2);
  471.     sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  472.     (void) sb_input_chars (r, 1, 22, junk, 1);
  473.  
  474.     /* If user says 'no', get out */
  475.  
  476.     if (junk[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  477.         return (change);
  478.  
  479.     if (flag_file (TEST_AND_SET, &(cur->mail_addr), 0))
  480.     {
  481.         sb_move (r, 2, 2);
  482.         sb_puts (r, MSG_TXT (M_NODE_BUSY));
  483.         wait_for_key (60);
  484.         return (0);
  485.     }
  486.  
  487.     /* first append/rename ?LO */
  488.  
  489.     HoldName = HoldAreaNameMunge (&(cur->mail_addr));
  490.     (void) sprintf (tname, "%s%s.?LO", HoldName,
  491.         Hex_Addr_Str (&(cur->mail_addr)));
  492.     (void) sprintf (oname, "%s%s.%cLO", HoldName,
  493.         Hex_Addr_Str (&(cur->mail_addr)), (char) x);
  494.  
  495.     if (!dfind (&fileinfo, tname, 0))
  496.     {
  497.         do
  498.         {
  499.             buff_size = (int) fileinfo.size;
  500.             strcpy (iname, fileinfo.name);
  501.             result = strchr (iname, '.');
  502.             result++;
  503.             if (*result != (char) x)
  504.             {
  505.                 if (cur->mail_addr.Point != 0)
  506.                 {
  507.                     (void) sprintf (iname, "%s%04x%04x.PNT\\%s",
  508.                         HoldName, cur->mail_addr.Net,
  509.                         cur->mail_addr.Node, fileinfo.name);
  510.                 }
  511.                 else
  512.                 {
  513.                     (void) sprintf (iname, "%s%s", HoldName, fileinfo.name);
  514.                 }
  515.                 if (rename (iname, oname) != 0)
  516.                 {
  517.                     temp_buffer = (char *) malloc (buff_size + 1);
  518.                     ihandle = open (iname, O_RDONLY | O_BINARY);
  519.                     ohandle = open (oname, O_APPEND | O_BINARY | O_WRONLY);
  520.                     sb_move (r, 2, 2);
  521.                     sprintf (junk, MSG_TXT (M_ZOOM_APPEND), MSG_TXT (M_ZOOM_MAIL_ATT));
  522.                     sb_puts (r, junk);
  523.                     do
  524.                     {
  525.                         check = read (ihandle, temp_buffer, buff_size);
  526.                         if (check)
  527.                             written = write (ohandle, temp_buffer, check);
  528.                     }
  529.                     while (check > 0);
  530.                     close (ihandle);
  531.                     close (ohandle);
  532.                     if (written > 0)
  533.                         unlink (iname);
  534.                     free (temp_buffer);
  535.                 }
  536.                 else
  537.                 {
  538.                     sb_move (r, 2, 2);
  539.                     sprintf (junk, MSG_TXT (M_ZOOM_RENAME), MSG_TXT (M_ZOOM_MAIL_ATT));
  540.                     sb_puts (r, junk);
  541.                 }
  542.                 change = 1;
  543.             }
  544.         }
  545.         while (!dfind (&fileinfo, NULL, 1));
  546.         (void) (dfind (&fileinfo, NULL, 2));
  547.     }
  548.  
  549.     /* now rename ?UT */
  550.  
  551.     if ((char) x == 'F')
  552.         x = (int) 'O';
  553.     (void) sprintf (tname, "%s%s.?UT", HoldName,
  554.         Hex_Addr_Str (&(cur->mail_addr)));
  555.     (void) sprintf (oname, "%s%s.%cUT", HoldName,
  556.         Hex_Addr_Str (&(cur->mail_addr)), (char) x);
  557.     if (!dfind (&fileinfo, tname, 0))
  558.     {
  559.         do
  560.         {
  561.             buff_size = (int) fileinfo.size;
  562.             strcpy (iname, fileinfo.name);
  563.             result = strchr (iname, '.');
  564.             result++;
  565.             if (*result != (char) x)
  566.             {
  567.                 if (cur->mail_addr.Point != 0)
  568.                 {
  569.                     (void) sprintf (iname, "%s%04x%04x.PNT\\%s",
  570.                         HoldName, cur->mail_addr.Net,
  571.                         cur->mail_addr.Node, fileinfo.name);
  572.                 }
  573.                 else
  574.                 {
  575.                     (void) sprintf (iname, "%s%s", HoldName, fileinfo.name);
  576.                 }
  577.                 if ((rename (iname, oname)) != 0)
  578.                 {
  579.                     if (buff_size > 60)
  580.                         append_pkt (r, buff_size, iname, oname);
  581.                 }                /* do append if rename failed */
  582.                 else
  583.                 {
  584.                     sb_move (r, 2, 2);
  585.                     sprintf (junk, MSG_TXT (M_ZOOM_RENAME), MSG_TXT (M_ZOOM_MAIL_PKT));
  586.                     sb_puts (r, junk);
  587.                 }
  588.                 change = 1;
  589.             }
  590.         }
  591.         while (!dfind (&fileinfo, NULL, 1));
  592.         (void) (dfind (&fileinfo, NULL, 2));
  593.     }                            /* end of ?UT handling */
  594.  
  595.     (void) flag_file (CLEAR_FLAG, &(cur->mail_addr), 0);
  596.     wait_for_key (60);
  597.     return (change);
  598. }
  599.  
  600. static void LOCALFUNC 
  601. append_pkt (REGIONP r, unsigned int size, char *iname, char *oname)
  602. {
  603.     int ihandle, ohandle;
  604.     struct tm *dt;
  605.     time_t now;
  606.     struct _pkthdr *header;
  607.     char *copy;
  608.     unsigned int buff_size, go;
  609.  
  610.     sb_move (r, 2, 2);
  611.     sprintf (junk, MSG_TXT (M_ZOOM_APPEND), MSG_TXT (M_ZOOM_MAIL_PKT));
  612.     sb_puts (r, junk);
  613.  
  614.     header = (struct _pkthdr *) malloc (sizeof (struct _pkthdr) + 1);
  615.  
  616.     ohandle = open (oname, O_BINARY | O_RDWR);
  617.     ihandle = open (iname, O_BINARY | O_RDONLY);
  618.  
  619.     go = read (ohandle, header, sizeof (struct _pkthdr));
  620.  
  621.     lseek (ohandle, 0L, SEEK_SET);
  622.  
  623.     /* Update the packet header to reflect that its been messed with */
  624.  
  625.     time (&now);
  626.     dt = localtime (&now);
  627.  
  628.     /* [Y2K] Ok as is.
  629.      */
  630.     header->year = dt->tm_year + 1900;
  631.     header->month = dt->tm_mon + 1;
  632.     header->day = dt->tm_mday;
  633.     header->hour = dt->tm_hour;
  634.     header->minute = dt->tm_min;
  635.     header->second = dt->tm_sec;
  636.     header->product = PRDCT_CODE;
  637.  
  638.     go = write (ohandle, header, sizeof (struct _pkthdr));
  639.  
  640.     free (header);
  641.  
  642.     lseek (ohandle, -2L, SEEK_END);
  643.     lseek (ihandle, ((long) sizeof (struct _pkthdr)), SEEK_SET);
  644.     size -= sizeof (struct _pkthdr);
  645.  
  646.     buff_size = size;
  647.     if ((copy = (char *) malloc (buff_size)) == NULL)
  648.     {
  649.         do
  650.         {
  651.             buff_size = (buff_size / 10) * 9;
  652.             copy = (char *) malloc (buff_size);
  653.         }
  654.         while (copy == NULL);
  655.     }
  656.     do
  657.     {
  658.         go = read (ihandle, copy, buff_size);
  659.         go = write (ohandle, copy, go);
  660.         size -= buff_size;
  661.         if (buff_size > size)
  662.             buff_size = size;
  663.     }
  664.     while (size > 0);
  665.     free (copy);
  666.     close (ihandle);
  667.     close (ohandle);
  668.     if (go > 0)
  669.         unlink (iname);
  670.     else
  671.     {
  672.         sb_move (r, 2, 2);
  673.         sprintf (junk, MSG_TXT (M_ZOOM_ERRAPP), MSG_TXT (M_ZOOM_MAIL_PKT));
  674.         sb_puts (r, junk);
  675.     }
  676.     return;
  677. }
  678.  
  679. static int 
  680. mail_stop (BINK_SAVEP p, int x)
  681. {
  682.     REGIONP r;
  683.     int change = 0;
  684.     char stop[80];
  685.     char *HoldName;
  686.     char sure[2];
  687.     FILE *fp;
  688.     struct FILEINFO fileinfo;
  689.  
  690.     if (p == NULL)
  691.         return (change);
  692.  
  693.     r = p->region;
  694.  
  695.     sb_fill (r, ' ', colors.popup);
  696.     sb_box (r, boxtype, colors.popup);
  697.  
  698.     if (x)
  699.         sprintf (stop, MSG_TXT (M_ZOOM_STOP),
  700.             Full_Addr_Str (&(cur->mail_addr)));
  701.     else
  702.         sprintf (stop, MSG_TXT (M_ZOOM_DELETE),
  703.             Full_Addr_Str (&(cur->mail_addr)));
  704.  
  705.     sb_move (r, 0, 1);
  706.     sb_puts (r, stop);
  707.  
  708.     sb_move (r, 1, 2);
  709.     sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  710.     (void) sb_input_chars (r, 1, 22, sure, 1);
  711.  
  712.     /* If user says 'no', get out */
  713.  
  714.     if (sure[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  715.         return (change);
  716.  
  717.     if (flag_file (TEST_AND_SET, &(cur->mail_addr), 0))
  718.     {
  719.         sb_move (r, 2, 2);
  720.         sb_puts (r, MSG_TXT (M_NODE_BUSY));
  721.         wait_for_key (60);
  722.         return (0);
  723.     }
  724.  
  725.     HoldName = HoldAreaNameMunge (&(cur->mail_addr));
  726.     (void) sprintf (stop, "%s%s.$$?", HoldName,
  727.         Hex_Addr_Str (&(cur->mail_addr)));
  728.  
  729.     if (!dfind (&fileinfo, stop, 0))
  730.     {
  731.         do
  732.         {
  733.             if (cur->mail_addr.Point != 0)
  734.             {
  735.                 (void) sprintf (stop, "%s%04x%04x.PNT\\%s",
  736.                     HoldName, cur->mail_addr.Net,
  737.                     cur->mail_addr.Node, fileinfo.name);
  738.             }
  739.             else
  740.             {
  741.                 (void) sprintf (stop, "%s%s", HoldName, fileinfo.name);
  742.             }
  743.  
  744.             unlink (stop);
  745.         }
  746.         while (!dfind (&fileinfo, NULL, 1));
  747.         (void) (dfind (&fileinfo, NULL, 2));
  748.         sb_move (r, 2, 2);
  749.         sb_puts (r, MSG_TXT (M_ZOOM_DELCOUNT));
  750.         change = 1;
  751.     }
  752.  
  753.     if (x)
  754.     {
  755.         (void) sprintf (stop, "%s%s.$$9", HoldName,
  756.             Hex_Addr_Str (&(cur->mail_addr)));
  757.         sb_move (r, 2, 2);
  758.         sb_puts (r, MSG_TXT (M_ZOOM_NOSEND));
  759.         fp = share_fopen (stop, append_ascii, DENY_WRITE);
  760.         if (fp == (FILE *) NULL)
  761.         {
  762.             sb_move (r, 2, 2);
  763.             sb_puts (r, MSG_TXT (M_ZOOM_ERRNOSEND));
  764.         }
  765.         else
  766.             change = 1;
  767.         fclose (fp);
  768.     }
  769.     (void) flag_file (CLEAR_FLAG, &(cur->mail_addr), 0);
  770.     wait_for_key (60);
  771.     return (change);
  772. }
  773.  
  774. static int 
  775. mail_delreq (BINK_SAVEP p, int x)
  776. {
  777.     REGIONP r;
  778.     int rhandle;
  779.     char req[80];
  780.     char sure[2];
  781.     char *HoldName;
  782.  
  783.     if (p == NULL)
  784.         return (0);
  785.  
  786.     r = p->region;
  787.     x = 0;
  788.  
  789.     sb_fill (r, ' ', colors.popup);
  790.     sb_box (r, boxtype, colors.popup);
  791.  
  792.     sprintf (junk, MSG_TXT (M_ZOOM_DELREQ),
  793.         Full_Addr_Str (&(cur->mail_addr)));
  794.  
  795.     sb_move (r, 0, 1);
  796.     sb_puts (r, junk);
  797.  
  798.     sb_move (r, 1, 2);
  799.     sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  800.     (void) sb_input_chars (r, 1, 22, sure, 1);
  801.  
  802.     /* If user says 'no', get out */
  803.  
  804.     if (sure[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  805.         return (x);
  806.  
  807.     if (flag_file (TEST_AND_SET, &(cur->mail_addr), 0))
  808.     {
  809.         sb_move (r, 2, 2);
  810.         sb_puts (r, MSG_TXT (M_NODE_BUSY));
  811.         wait_for_key (60);
  812.         return (0);
  813.     }
  814.  
  815.     HoldName = HoldAreaNameMunge (&(cur->mail_addr));
  816.     (void) sprintf (req, "%s%s.REQ", HoldName,
  817.         Hex_Addr_Str (&(cur->mail_addr)));
  818.  
  819.     if (dexists (req))
  820.     {
  821.         rhandle = open (req, O_RDONLY | O_BINARY);
  822.         close (rhandle);
  823.         if (rhandle == 0)
  824.         {
  825.             sb_move (r, 2, 2);
  826.             sb_puts (r, MSG_TXT (M_ZOOM_ERRREQ));
  827.         }
  828.         else
  829.         {
  830.             unlink (req);
  831.             sb_move (r, 2, 2);
  832.             sb_puts (r, MSG_TXT (M_ZOOM_DEL_REQ));
  833.             x = 1;
  834.         }
  835.         wait_for_key (60);
  836.     }
  837.     (void) flag_file (CLEAR_FLAG, &(cur->mail_addr), 0);
  838.     return (x);
  839. }
  840.  
  841. static void LOCALFUNC 
  842. append_fil (REGIONP r, unsigned int size, char *iname, char *oname,
  843.     char *desc)
  844. {
  845.     char *temp_buffer;
  846.     char temp[50];
  847.     int ihandle, ohandle;
  848.     int check;
  849.     int written = 1;
  850.  
  851.     temp_buffer = (char *) malloc (size + 1);
  852.     ihandle = open (iname, O_RDONLY | O_BINARY);
  853.     ohandle = open (oname, O_APPEND | O_BINARY | O_WRONLY);
  854.     (void) sprintf (temp, MSG_TXT (M_ZOOM_APPEND), desc);
  855.     sb_move (r, 2, 2);
  856.     sb_puts (r, temp);
  857.     do
  858.     {
  859.         check = read (ihandle, temp_buffer, size);
  860.         if (check)
  861.             written = write (ohandle, temp_buffer, check);
  862.     }
  863.     while (check > 0);
  864.     close (ihandle);
  865.     close (ohandle);
  866.     if (written > 0)
  867.         unlink (iname);
  868.     free (temp_buffer);
  869. }
  870.  
  871. static int LOCALFUNC 
  872. appren_mail (REGIONP r, ADDRP fromaddr, ADDRP toaddr,
  873.     char *ftype, char *desc)
  874. {
  875.     char iname[80], oname[80], tname[80];
  876.     char *HoldName;
  877.     struct FILEINFO fileinfo;
  878.     int buff_size;
  879.     int change = 0;
  880.  
  881.     HoldName = HoldAreaNameMunge (fromaddr);
  882.     (void) sprintf (tname, "%s%s.%s", HoldName, Hex_Addr_Str (fromaddr), ftype);
  883.     if (!dfind (&fileinfo, tname, 0))
  884.     {
  885.         do
  886.         {
  887.             buff_size = (int) fileinfo.size;
  888.             HoldName = HoldAreaNameMunge (toaddr);
  889.             (void) sprintf (oname, "%s%s.%s", HoldName, Hex_Addr_Str (toaddr),
  890.                 &(fileinfo.name[9]));
  891.             HoldName = HoldAreaNameMunge (fromaddr);
  892.             if (cur->mail_addr.Point != 0)
  893.             {
  894.                 (void) sprintf (iname, "%s%04x%04x.PNT\\%s", HoldName,
  895.                     fromaddr->Net, fromaddr->Node, fileinfo.name);
  896.             }
  897.             else
  898.             {
  899.                 (void) sprintf (iname, "%s%s", HoldName, fileinfo.name);
  900.             }
  901.             if (rename (iname, oname) != 0)
  902.             {
  903.                 if (!strcmp (desc, "?UT"))    /* mail packet */
  904.                 {
  905.                     if (buff_size > 60)
  906.                         append_pkt (r, buff_size, iname, oname);
  907.                 }
  908.                 else
  909.                     /* other file */
  910.                 {
  911.                     append_fil (r, buff_size, iname, oname, desc);
  912.                 }
  913.             }
  914.             else
  915.             {
  916.                 sprintf (iname, MSG_TXT (M_ZOOM_RENAME), desc);
  917.                 sb_move (r, 2, 2);
  918.                 sb_puts (r, iname);
  919.             }
  920.             change = 1;
  921.         }
  922.         while (!dfind (&fileinfo, NULL, 1));
  923.         (void) (dfind (&fileinfo, NULL, 2));
  924.     }
  925.     return (change);
  926. }
  927.  
  928. static int 
  929. mail_addr (BINK_SAVEP p, int x)
  930. {
  931.     REGIONP r;
  932.     char iname[80], sure[2];
  933.     ADDR addr;
  934.  
  935.     x = 0;
  936.  
  937.     if (p == NULL)
  938.         return (0);
  939.  
  940.     r = p->region;
  941.  
  942.     sb_fill (r, ' ', colors.popup);
  943.     sb_box (r, boxtype, colors.popup);
  944.  
  945.     sb_move (r, 0, 1);
  946.     sb_puts (r, MSG_TXT (M_ZOOM_DESTINATION));
  947.  
  948.     sb_move (r, 1, 2);
  949.     sb_puts (r, MSG_TXT (M_ZOOM_NEWADDR));
  950.     if (!sb_input_chars (r, 1, 18, iname, 36))
  951.     {
  952.         if (!find_address (iname, &addr))
  953.         {
  954.             return (0);
  955.         }
  956.         if (nodefind (&addr, 0))
  957.         {
  958.             sb_move (r, 1, 2);
  959.             sprintf (iname, "Node: %-18.18s - %-20.20s",
  960.                 Full_Addr_Str (&addr), newnodedes.SystemName);
  961.             sb_puts (r, iname);
  962.         }
  963.         sb_move (r, 2, 2);
  964.         sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  965.         (void) sb_input_chars (r, 2, 22, sure, 1);
  966.  
  967.         /* If user says 'no', get out */
  968.  
  969.         if (sure[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  970.             return (x);
  971.  
  972.         if (flag_file (TEST_AND_SET, &(cur->mail_addr), 0))
  973.         {
  974.             sb_move (r, 2, 2);
  975.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  976.             wait_for_key (60);
  977.             return (0);
  978.         }
  979.         if (flag_file (TEST_AND_SET, &addr, 0))
  980.         {
  981.             (void) flag_file (CLEAR_FLAG, &(cur->mail_addr), 0);
  982.             sb_move (r, 2, 2);
  983.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  984.             wait_for_key (60);
  985.             return (0);
  986.         }
  987.  
  988.         /* first append/rename ?LO */
  989.  
  990.         appren_mail (r, &(cur->mail_addr), &addr, "?LO", "mail attaches");
  991.  
  992.         /* append/rename REQ */
  993.  
  994.         appren_mail (r, &(cur->mail_addr), &addr, "REQ", "request files");
  995.  
  996.         /* now rename ?UT */
  997.  
  998.         appren_mail (r, &(cur->mail_addr), &addr, "?UT", "mail packets ");
  999.  
  1000.         (void) flag_file (CLEAR_FLAG, &addr, 0);
  1001.         (void) flag_file (CLEAR_FLAG, &(cur->mail_addr), 0);
  1002.         wait_for_key (60);
  1003.         x = 1;
  1004.     }                            /* end of address input */
  1005.     return (x);
  1006. }
  1007.  
  1008. int 
  1009. Do_Get (BINK_SAVEP p, int x)
  1010. {
  1011.     REGIONP r;
  1012.     char node[51];
  1013.     char file[51];
  1014.     char password[9];
  1015.     char flavor[2];
  1016.     char more[2];
  1017.     int busy = 0;
  1018.     int did_it = 0;
  1019.     short i;
  1020.     ADDR addr;
  1021.  
  1022.     if (p == NULL)
  1023.         return (0);
  1024.  
  1025.     r = p->region;
  1026.  
  1027.     if (x)
  1028.     {
  1029.         addr = cur->mail_addr;
  1030.  
  1031.         /* Busy the node if we can. */
  1032.  
  1033.         if (flag_file (TEST_AND_SET, &addr, 0))
  1034.         {
  1035.             sb_move (r, 2, 2);
  1036.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1037.             wait_for_key (60);
  1038.             return (-1);
  1039.         }
  1040.         busy = 1;
  1041.     }
  1042.  
  1043.     /* First fill it all with blanks */
  1044.  
  1045.     sb_fill (r, ' ', colors.popup);
  1046.  
  1047.     /* Now draw the box */
  1048.  
  1049.     sb_box (r, boxtype, colors.popup);
  1050.     sb_move (r, 0, 1);
  1051.     sb_puts (r, MSG_TXT (M_GET_FILE));
  1052.  
  1053.     /* Now do the fields */
  1054.  
  1055.     for (;;)
  1056.     {
  1057.         sb_move (r, 1, 2);
  1058.         sb_puts (r, MSG_TXT (M_ADDRESS_TO_GET_FROM));
  1059.  
  1060.         /* Display address if zoomed, ask for it if not. */
  1061.  
  1062.         if (x)
  1063.         {
  1064.             strncpy (node, Full_Addr_Str (&addr), 35);
  1065.             node[35] = '\0';
  1066.             sb_move (r, 1, 23);
  1067.             sb_puts (r, node);
  1068.         }
  1069.         else
  1070.         {
  1071.             if (sb_input_chars (r, 1, 23, node, 36))
  1072.                 break;
  1073.             if (!find_address (node, &addr))
  1074.             {
  1075.                 if (!did_it)
  1076.                     did_it = -1;
  1077.                 break;
  1078.             }
  1079.  
  1080.             /* Busy the node if we can. */
  1081.  
  1082.             if (flag_file (TEST_AND_SET, &addr, 0))
  1083.             {
  1084.                 sb_move (r, 2, 2);
  1085.                 sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1086.                 wait_for_key (60);
  1087.                 if (!did_it)
  1088.                     did_it = -1;
  1089.                 break;
  1090.             }
  1091.             busy = 1;
  1092.         }
  1093.  
  1094.         /* Ask for the filename */
  1095.  
  1096.         sb_move (r, 2, 2);
  1097.         sb_puts (r, MSG_TXT (M_FILE_TO_RECEIVE));
  1098.         if (sb_input_chars (r, 2, 23, file, 12))
  1099.             break;
  1100.  
  1101.         /* Get the password if any */
  1102.  
  1103.         sb_move (r, 3, 2);
  1104.         sb_puts (r, MSG_TXT (M_PASSWORD_TO_USE));
  1105.         (void) sb_input_chars (r, 3, 23, password, 8);
  1106.  
  1107.         /* Get the flavor or quit */
  1108.  
  1109.         sb_move (r, 4, 2);
  1110.         sb_puts (r, MSG_TXT (M_GET_FLAVOR));
  1111.         (void) sb_input_chars (r, 4, 41, flavor, 1);
  1112.  
  1113.         /* Get the file if we can */
  1114.  
  1115.         if (flavor[0] != 'Q')
  1116.         {
  1117.             if (mail_addrequest (&addr, file, password, flavor) == 0)
  1118.                 did_it = 1;
  1119.             else if (!did_it)
  1120.                 did_it = -1;
  1121.         }
  1122.  
  1123.         /* Unbusy the node */
  1124.  
  1125.         if (!x)
  1126.         {
  1127.             (void) flag_file (CLEAR_FLAG, &addr, 0);
  1128.             busy = 0;
  1129.         }
  1130.  
  1131.         /* Anything more to do? */
  1132.  
  1133.         sb_move (r, 5, 2);
  1134.         sb_puts (r, MSG_TXT (M_GET_MORE));
  1135.         (void) sb_input_chars (r, 5, 23, more, 1);
  1136.         if (more[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  1137.             break;
  1138.  
  1139.         /* Yes, clear the box. */
  1140.  
  1141.         for (i = 1; i <= 5; i++)
  1142.         {
  1143.             sb_move (r, i, 2);
  1144.             sb_puts (r, "                                                 ");
  1145.         }
  1146.     }
  1147.  
  1148.     /* If we busied something, get rid of it. */
  1149.  
  1150.     if (busy)
  1151.         (void) flag_file (CLEAR_FLAG, &addr, 0);
  1152.     return (did_it);
  1153. }
  1154.  
  1155. static int LOCALFUNC 
  1156. mail_addrequest (ADDRP pAddr, char *file, char *password, char *flavor)
  1157. {
  1158.     char *HoldName;
  1159.     char fname[100];
  1160.     FILE *f;
  1161.  
  1162.     if (flavor[0] == '\0')
  1163.         flavor[0] = 'N';
  1164.     if ((flavor[0] != 'C') && (flavor[0] != 'H') && (flavor[0] != 'N') &&
  1165.         (flavor[0] != 'D'))
  1166.         return (-3);
  1167.     if (flavor[0] == 'N')
  1168.         flavor[0] = 'F';
  1169.     flavor[1] = '\0';
  1170.  
  1171.     HoldName = HoldAreaNameMunge (pAddr);
  1172.  
  1173.     /* Now see if we should send anything back to him */
  1174.  
  1175.     (void) sprintf (fname, "%s%s.REQ", HoldName, Hex_Addr_Str (pAddr));
  1176.     if ((f = fopen (fname, append_binary)) == NULL)
  1177.         return (-2);
  1178.  
  1179.     (void) fprintf (f, "%s", file);
  1180.     if (password[0] != '\0')
  1181.     {
  1182.         (void) fprintf (f, " !%s", password);
  1183.     }
  1184.     (void) fprintf (f, "\r\n");
  1185.     (void) fclose (f);
  1186.  
  1187.     (void) mail_addsend (pAddr, "", flavor);
  1188.     return (0);
  1189. }
  1190.  
  1191. int 
  1192. Do_Poll_Packet (BINK_SAVEP p, int x)
  1193. {
  1194.     REGIONP r;
  1195.     char node[51];
  1196.     char more[2];
  1197.     int busy = 0;
  1198.     int did_it = 0;
  1199.     ADDR addr;
  1200.  
  1201.     if (p == NULL)
  1202.         return (0);
  1203.  
  1204.     r = p->region;
  1205.  
  1206.     if (x)
  1207.     {
  1208.         addr = cur->mail_addr;
  1209.  
  1210.         /* Busy the node if we can. */
  1211.  
  1212.         if (flag_file (TEST_AND_SET, &addr, 0))
  1213.         {
  1214.             sb_move (r, 2, 2);
  1215.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1216.             wait_for_key (60);
  1217.             return (-1);
  1218.         }
  1219.         busy = 1;
  1220.     }
  1221.  
  1222.     /* First fill it all with blanks */
  1223.  
  1224.     sb_fill (r, ' ', colors.popup);
  1225.  
  1226.     /* Now draw the box */
  1227.  
  1228.     sb_box (r, boxtype, colors.popup);
  1229.     sb_move (r, 0, 1);
  1230.     sb_puts (r, MSG_TXT (M_ZOOM_POLL));
  1231.  
  1232.     /* Now do the fields */
  1233.  
  1234.     sb_move (r, 1, 2);
  1235.     sb_puts (r, MSG_TXT (M_POLL_WHOM));
  1236.  
  1237.     /* Display address if zoomed, ask for it if not. */
  1238.  
  1239.     if (x)
  1240.     {
  1241.         strncpy (node, Full_Addr_Str (&addr), 39);
  1242.         node[39] = '\0';
  1243.         sb_move (r, 1, 14);
  1244.         sb_puts (r, node);
  1245.     }
  1246.     else
  1247.     {
  1248.         if (sb_input_chars (r, 1, 14, node, 40))
  1249.             goto Done;
  1250.         if (!find_address (node, &addr))
  1251.         {
  1252.             if (!did_it)
  1253.                 did_it = -1;
  1254.             goto Done;
  1255.         }
  1256.  
  1257.         /* Busy the node if we can. */
  1258.  
  1259.         if (flag_file (TEST_AND_SET, &addr, 0))
  1260.         {
  1261.             sb_move (r, 2, 2);
  1262.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1263.             wait_for_key (60);
  1264.             if (!did_it)
  1265.                 did_it = -1;
  1266.             goto Done;
  1267.         }
  1268.         busy = 1;
  1269.     }
  1270.  
  1271.     if (x)
  1272.     {
  1273.         sb_move (r, 2, 2);
  1274.         sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  1275.         if (sb_input_chars (r, 2, 22, more, 1))
  1276.             goto Done;
  1277.         if (more[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  1278.             goto Done;
  1279.     }
  1280.  
  1281.     if (mail_addsend (&addr, "", "C") == 0)
  1282.         did_it = 1;
  1283.     else if (!did_it)
  1284.         did_it = -1;
  1285. Done:
  1286.  
  1287.     /* If we busied something, get rid of it. */
  1288.  
  1289.     if (busy)
  1290.         (void) flag_file (CLEAR_FLAG, &addr, 0);
  1291.     return (did_it);
  1292. }
  1293.  
  1294. int 
  1295. Do_Send (BINK_SAVEP p, int x)
  1296. {
  1297.     REGIONP r;
  1298.     char node[51];
  1299.     char file[51];
  1300.     char flavor[2];
  1301.     char more[2];
  1302.     int busy = 0;
  1303.     int did_it = 0;
  1304.     short i;
  1305.     ADDR addr;
  1306.  
  1307.     if (p == NULL)
  1308.         return (0);
  1309.  
  1310.     r = p->region;
  1311.  
  1312.     if (x)
  1313.     {
  1314.         addr = cur->mail_addr;
  1315.  
  1316.         /* Busy the node if we can. */
  1317.  
  1318.         if (flag_file (TEST_AND_SET, &addr, 0))
  1319.         {
  1320.             sb_move (r, 2, 2);
  1321.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1322.             wait_for_key (60);
  1323.             return (-1);
  1324.         }
  1325.         busy = 1;
  1326.     }
  1327.  
  1328.     /* First fill it all with blanks */
  1329.  
  1330.     sb_fill (r, ' ', colors.popup);
  1331.  
  1332.     /* Now draw the box */
  1333.     sb_box (r, boxtype, colors.popup);
  1334.     sb_move (r, 0, 1);
  1335.     sb_puts (r, MSG_TXT (M_SEND_FILE));
  1336.  
  1337.     /* Now do the fields */
  1338.  
  1339.     for (;;)
  1340.     {
  1341.         sb_move (r, 1, 2);
  1342.         sb_puts (r, MSG_TXT (M_ADDRESS_TO_SEND_TO));
  1343.  
  1344.         /* Display address if zoomed, ask for it if not. */
  1345.  
  1346.         if (x)
  1347.         {
  1348.             strncpy (node, Full_Addr_Str (&addr), 46);
  1349.             node[46] = '\0';
  1350.             sb_move (r, 1, 22);
  1351.             sb_puts (r, node);
  1352.         }
  1353.         else
  1354.         {
  1355.             if (sb_input_chars (r, 1, 22, node, 47))
  1356.                 break;
  1357.             if (!find_address (node, &addr))
  1358.             {
  1359.                 if (!did_it)
  1360.                     did_it = -1;
  1361.                 break;
  1362.             }
  1363.  
  1364.             /* Busy the node if we can. */
  1365.  
  1366.             if (flag_file (TEST_AND_SET, &addr, 0))
  1367.             {
  1368.                 sb_move (r, 2, 2);
  1369.                 sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1370.                 wait_for_key (60);
  1371.                 if (!did_it)
  1372.                     did_it = -1;
  1373.                 break;
  1374.             }
  1375.             busy = 1;
  1376.         }
  1377.  
  1378.         /* Ask for the filename */
  1379.  
  1380.         sb_move (r, 2, 2);
  1381.         sb_puts (r, MSG_TXT (M_FILE_TO_SEND));
  1382.         if (sb_input_chars (r, 2, 22, file, 47))
  1383.             break;
  1384.  
  1385.         /* Get the flavor or quit */
  1386.  
  1387.         sb_move (r, 3, 2);
  1388.         sb_puts (r, MSG_TXT (M_SEND_FLAVOR));
  1389.         (void) sb_input_chars (r, 3, 49, flavor, 1);
  1390.  
  1391.         /* Send the file if we can */
  1392.  
  1393.         if (flavor[0] != 'Q')
  1394.         {
  1395.             if (mail_addsend (&addr, file, flavor) == 0)
  1396.                 did_it = 1;
  1397.             else if (!did_it)
  1398.                 did_it = -1;
  1399.         }
  1400.  
  1401.         /* Unbusy the node */
  1402.  
  1403.         if (!x)
  1404.         {
  1405.             (void) flag_file (CLEAR_FLAG, &addr, 0);
  1406.             busy = 0;
  1407.         }
  1408.  
  1409.         /* Anything more to do? */
  1410.  
  1411.         sb_move (r, 4, 2);
  1412.         sb_puts (r, MSG_TXT (M_SEND_MORE));
  1413.         (void) sb_input_chars (r, 4, 20, more, 1);
  1414.         if (more[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  1415.             break;
  1416.  
  1417.         /* Yes, clear the box. */
  1418.  
  1419.         for (i = 1; i <= 4; i++)
  1420.         {
  1421.             sb_move (r, i, 2);
  1422.             sb_puts (r, "                                                 ");
  1423.         }
  1424.     }
  1425.  
  1426.     /* If we busied something, get rid of it. */
  1427.  
  1428.     if (busy)
  1429.         (void) flag_file (CLEAR_FLAG, &addr, 0);
  1430.     return (did_it);
  1431. }
  1432.  
  1433. static int LOCALFUNC 
  1434. mail_addsend (ADDRP pAddr, char *file, char *flavor)
  1435. {
  1436.     char *HoldName;
  1437.     char fname[100];
  1438.     FILE *f;
  1439.  
  1440.     if (flavor[0] == '\0')
  1441.         flavor[0] = 'N';
  1442.     if ((flavor[0] != 'C') && (flavor[0] != 'H') && (flavor[0] != 'N') &&
  1443.         (flavor[0] != 'D'))
  1444.         return (-3);
  1445.     if (flavor[0] == 'N')
  1446.         flavor[0] = 'F';
  1447.     flavor[1] = '\0';
  1448.     HoldName = HoldAreaNameMunge (pAddr);
  1449.     (void) sprintf (fname, "%s%s.%sLO", HoldName,
  1450.         Hex_Addr_Str (pAddr), flavor);
  1451.     if ((f = fopen (fname, append_binary)) == NULL)
  1452.     {
  1453.         return (-2);
  1454.     }
  1455.     else
  1456.     {
  1457.         if (file[0] != '\0')
  1458.             (void) fprintf (f, "%s\r\n", file);
  1459.         (void) fclose (f);
  1460.     }
  1461.     return (0);
  1462. }
  1463.  
  1464. int 
  1465. Do_Kill (BINK_SAVEP p, int x)
  1466. {
  1467.     REGIONP r;
  1468.     char node[51];
  1469.     char sure[2];
  1470.  
  1471.     if (p != NULL)
  1472.     {
  1473.         r = p->region;
  1474.  
  1475.         /* First fill it all with blanks */
  1476.         sb_fill (r, ' ', colors.popup);
  1477.  
  1478.         /* Now draw the box */
  1479.         sb_box (r, boxtype, colors.popup);
  1480.  
  1481.         sb_move (r, 0, 1);
  1482.         sb_puts (r, MSG_TXT (M_KILL_MAIL));
  1483.  
  1484.         /* Now do the fields */
  1485.         sb_move (r, 1, 2);
  1486.         sb_puts (r, MSG_TXT (M_ADDRESS_TO_KILL));
  1487.  
  1488.         if (x)
  1489.         {
  1490.             strncpy (node, Full_Addr_Str (&cur->mail_addr), 50);
  1491.             node[50] = '\0';
  1492.             sb_move (r, 1, 19);
  1493.             sb_puts (r, node);
  1494.         }
  1495.         else if (sb_input_chars (r, 1, 19, node, 50))
  1496.             return 0;
  1497.  
  1498.         sb_move (r, 2, 2);
  1499.         sb_puts (r, MSG_TXT (M_KILL_ALL_MAIL));
  1500.         sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  1501.         (void) sb_input_chars (r, 2, 38, sure, 1);
  1502.         if (sure[0] == (char) toupper (MSG_TXT (M_YES)[0]))
  1503.             x = kill_node (node);
  1504.         else x = 0;
  1505.     }
  1506.     else x = 0;
  1507.  
  1508.     /* Return value is never checked, just use x so lint and -W3 don't get mad */
  1509.  
  1510.     return (x);
  1511. }
  1512.  
  1513. int 
  1514. Do_Poll (BINK_SAVEP p, int x)
  1515. {
  1516.     char node[51];
  1517.     REGIONP r;
  1518.  
  1519.     happy_compiler = x;            /* Makes the compiler happy! */
  1520.     if (p != NULL)
  1521.     {
  1522.         r = p->region;
  1523.  
  1524.         /* First fill it all with blanks */
  1525.  
  1526.         sb_fill (r, ' ', colors.popup);
  1527.  
  1528.         /* Now draw the box */
  1529.  
  1530.         sb_box (r, boxtype, colors.popup);
  1531.         sb_move (r, 0, 1);
  1532.         sb_puts (r, MSG_TXT (M_NODE_TO_POLL));
  1533.  
  1534.         /* Now do the fields */
  1535.  
  1536.         sb_move (r, 1, 2);
  1537.         sb_puts (r, MSG_TXT (M_POLL_WHOM));
  1538.         if (!sb_input_chars (r, 1, 14, node, 40))
  1539.         {
  1540.             return (find_address (node, &next_addr));
  1541.         }
  1542.     }
  1543.     return (FALSE);
  1544. }
  1545.  
  1546. static int LOCALFUNC 
  1547. kill_node (char *node)
  1548. {
  1549.     ADDR addr;
  1550.     char *HoldName;
  1551.     char *p;
  1552.     char fname[160];
  1553.     struct FILEINFO fileinfo = {0};
  1554.     int j;
  1555.  
  1556.     if (find_address (node, &addr))
  1557.     {
  1558.         if (flag_file (TEST_AND_SET, &addr, 0))
  1559.         {
  1560.             return (-1);
  1561.         }
  1562.  
  1563.         HoldName = HoldAreaNameMunge (&addr);
  1564.  
  1565.         (void) sprintf (fname, "%s%s.*", HoldName, Hex_Addr_Str (&addr));
  1566.         j = 0;
  1567.         while (!dfind (&fileinfo, fname, j))
  1568.         {
  1569.             j = 1;
  1570.  
  1571.             /* Don't delete the .bsy flags yet */
  1572.  
  1573.             if ((p = strchr (fileinfo.name, '.')) != NULL)
  1574.             {
  1575.                 if (strcmp (p, ".BSY") == 0)
  1576.                     continue;
  1577.             }
  1578.  
  1579.             if (addr.Point != 0)
  1580.             {
  1581.                 (void) sprintf (fname, "%s%04hx%04hx.PNT\\%s",
  1582.                     HoldName, addr.Net, addr.Node, fileinfo.name);
  1583.             }
  1584.             else
  1585.                 (void) sprintf (fname, "%s%s", HoldName, fileinfo.name);
  1586.  
  1587.             (void) unlink (fname);
  1588.         }
  1589.         if (j)
  1590.             (void) dfind (&fileinfo, NULL, 2);
  1591.  
  1592.         (void) flag_file (CLEAR_FLAG, &addr, 0);
  1593.         return (0);
  1594.     }
  1595.     /* else */
  1596.     return (-1);
  1597. }
  1598.  
  1599. static void LOCALFUNC 
  1600. call_tries (ADDRP baddr, int *calls, int *badcalls)
  1601. {
  1602.     int res;
  1603.     int i, j;
  1604.     struct FILEINFO bad_dta = {0};
  1605.     char *HoldName;
  1606.  
  1607.     char fname[128];
  1608.  
  1609.     HoldName = HoldAreaNameMunge (baddr);
  1610.     (void) sprintf (fname, "%s%s.$$?", HoldName, Hex_Addr_Str (baddr));
  1611.     j = (int) strlen (fname) - 1;            /* Point at ?          */
  1612.     res = -1;                                /* Initialize to fail  */
  1613.  
  1614.     i = 0;                                    /* This says findfirst */
  1615.     while (!dfind (&bad_dta, fname, i))        /* as long as we match */
  1616.     {
  1617.         if (isdigit (bad_dta.name[11]))        /* is there a digit?   */
  1618.         {
  1619.             fname[j] = bad_dta.name[11];    /* Yes, copy to fname  */
  1620.             res = fname[j] - '0';            /* Save it for testing */
  1621.             break;                            /* Get out of while    */
  1622.         }
  1623.         else
  1624.             i = 1;                            /* Else use findnext   */
  1625.     }
  1626.     if (i)
  1627.         (void) dfind (&bad_dta, NULL, 2);
  1628.  
  1629.     /* Initialize the return values */
  1630.  
  1631.     *calls = *badcalls = 0;
  1632.  
  1633.     /* Is it automatically ok (no .$$ file there) ? */
  1634.  
  1635.     if (res == -1)
  1636.         return;
  1637.  
  1638.     /* We now have the number of bad calls (calls with carrier) */
  1639.  
  1640.     *badcalls = res;
  1641.  
  1642.     /* Open the file and find out how many total calls were made */
  1643.  
  1644.     i = open (fname, O_RDONLY | O_BINARY);
  1645.     if (i != -1)
  1646.     {
  1647.         res = 0;
  1648.         (void) read (i, (char *) &res, sizeof (int));
  1649.         (void) close (i);
  1650.     }
  1651.  
  1652.     *calls = res;
  1653.     return;
  1654. }
  1655.     
  1656. #if 0
  1657. static char LOCALFUNC xlat_flavor (char flavor);
  1658. static char LOCALFUNC 
  1659. xlat_flavor (char flavor)
  1660. {
  1661.     char *real_flavor = "CHDN";
  1662.     char *user_flavor;
  1663.  
  1664.     user_flavor = MSG_TXT (M_CHDN_FLAGS);
  1665.     for (;;)
  1666.     {
  1667.         if (!*real_flavor)
  1668.             break;
  1669.         if (*user_flavor == flavor)
  1670.         {
  1671.             return *real_flavor;
  1672.         }
  1673.         user_flavor++;
  1674.         real_flavor++;
  1675.     }
  1676.     return (0);
  1677. }
  1678.  
  1679. #endif
  1680.