home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1996 October / PCO_10.ISO / filesbbs / bsrc_260.arj / SRC.ZIP / outbound.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-23  |  36.2 KB  |  1,678 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.     header->year = dt->tm_year + 1900;
  629.     header->month = dt->tm_mon + 1;
  630.     header->day = dt->tm_mday;
  631.     header->hour = dt->tm_hour;
  632.     header->minute = dt->tm_min;
  633.     header->second = dt->tm_sec;
  634.     header->product = PRDCT_CODE;
  635.  
  636.     go = write (ohandle, header, sizeof (struct _pkthdr));
  637.  
  638.     free (header);
  639.  
  640.     lseek (ohandle, -2L, SEEK_END);
  641.     lseek (ihandle, ((long) sizeof (struct _pkthdr)), SEEK_SET);
  642.     size -= sizeof (struct _pkthdr);
  643.  
  644.     buff_size = size;
  645.     if ((copy = (char *) malloc (buff_size)) == NULL)
  646.     {
  647.         do
  648.         {
  649.             buff_size = (buff_size / 10) * 9;
  650.             copy = (char *) malloc (buff_size);
  651.         }
  652.         while (copy == NULL);
  653.     }
  654.     do
  655.     {
  656.         go = read (ihandle, copy, buff_size);
  657.         go = write (ohandle, copy, go);
  658.         size -= buff_size;
  659.         if (buff_size > size)
  660.             buff_size = size;
  661.     }
  662.     while (size > 0);
  663.     free (copy);
  664.     close (ihandle);
  665.     close (ohandle);
  666.     if (go > 0)
  667.         unlink (iname);
  668.     else
  669.     {
  670.         sb_move (r, 2, 2);
  671.         sprintf (junk, MSG_TXT (M_ZOOM_ERRAPP), MSG_TXT (M_ZOOM_MAIL_PKT));
  672.         sb_puts (r, junk);
  673.     }
  674.     return;
  675. }
  676.  
  677. static int 
  678. mail_stop (BINK_SAVEP p, int x)
  679. {
  680.     REGIONP r;
  681.     int change = 0;
  682.     char stop[80];
  683.     char *HoldName;
  684.     char sure[2];
  685.     FILE *fp;
  686.     struct FILEINFO fileinfo;
  687.  
  688.     if (p == NULL)
  689.         return (change);
  690.  
  691.     r = p->region;
  692.  
  693.     sb_fill (r, ' ', colors.popup);
  694.     sb_box (r, boxtype, colors.popup);
  695.  
  696.     if (x)
  697.         sprintf (stop, MSG_TXT (M_ZOOM_STOP),
  698.             Full_Addr_Str (&(cur->mail_addr)));
  699.     else
  700.         sprintf (stop, MSG_TXT (M_ZOOM_DELETE),
  701.             Full_Addr_Str (&(cur->mail_addr)));
  702.  
  703.     sb_move (r, 0, 1);
  704.     sb_puts (r, stop);
  705.  
  706.     sb_move (r, 1, 2);
  707.     sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  708.     (void) sb_input_chars (r, 1, 22, sure, 1);
  709.  
  710.     /* If user says 'no', get out */
  711.  
  712.     if (sure[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  713.         return (change);
  714.  
  715.     if (flag_file (TEST_AND_SET, &(cur->mail_addr), 0))
  716.     {
  717.         sb_move (r, 2, 2);
  718.         sb_puts (r, MSG_TXT (M_NODE_BUSY));
  719.         wait_for_key (60);
  720.         return (0);
  721.     }
  722.  
  723.     HoldName = HoldAreaNameMunge (&(cur->mail_addr));
  724.     (void) sprintf (stop, "%s%s.$$?", HoldName,
  725.         Hex_Addr_Str (&(cur->mail_addr)));
  726.  
  727.     if (!dfind (&fileinfo, stop, 0))
  728.     {
  729.         do
  730.         {
  731.             if (cur->mail_addr.Point != 0)
  732.             {
  733.                 (void) sprintf (stop, "%s%04x%04x.PNT\\%s",
  734.                     HoldName, cur->mail_addr.Net,
  735.                     cur->mail_addr.Node, fileinfo.name);
  736.             }
  737.             else
  738.             {
  739.                 (void) sprintf (stop, "%s%s", HoldName, fileinfo.name);
  740.             }
  741.  
  742.             unlink (stop);
  743.         }
  744.         while (!dfind (&fileinfo, NULL, 1));
  745.         (void) (dfind (&fileinfo, NULL, 2));
  746.         sb_move (r, 2, 2);
  747.         sb_puts (r, MSG_TXT (M_ZOOM_DELCOUNT));
  748.         change = 1;
  749.     }
  750.  
  751.     if (x)
  752.     {
  753.         (void) sprintf (stop, "%s%s.$$9", HoldName,
  754.             Hex_Addr_Str (&(cur->mail_addr)));
  755.         sb_move (r, 2, 2);
  756.         sb_puts (r, MSG_TXT (M_ZOOM_NOSEND));
  757.         fp = share_fopen (stop, append_ascii, DENY_WRITE);
  758.         if (fp == (FILE *) NULL)
  759.         {
  760.             sb_move (r, 2, 2);
  761.             sb_puts (r, MSG_TXT (M_ZOOM_ERRNOSEND));
  762.         }
  763.         else
  764.             change = 1;
  765.         fclose (fp);
  766.     }
  767.     (void) flag_file (CLEAR_FLAG, &(cur->mail_addr), 0);
  768.     wait_for_key (60);
  769.     return (change);
  770. }
  771.  
  772. static int 
  773. mail_delreq (BINK_SAVEP p, int x)
  774. {
  775.     REGIONP r;
  776.     int rhandle;
  777.     char req[80];
  778.     char sure[2];
  779.     char *HoldName;
  780.  
  781.     if (p == NULL)
  782.         return (0);
  783.  
  784.     r = p->region;
  785.     x = 0;
  786.  
  787.     sb_fill (r, ' ', colors.popup);
  788.     sb_box (r, boxtype, colors.popup);
  789.  
  790.     sprintf (junk, MSG_TXT (M_ZOOM_DELREQ),
  791.         Full_Addr_Str (&(cur->mail_addr)));
  792.  
  793.     sb_move (r, 0, 1);
  794.     sb_puts (r, junk);
  795.  
  796.     sb_move (r, 1, 2);
  797.     sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  798.     (void) sb_input_chars (r, 1, 22, sure, 1);
  799.  
  800.     /* If user says 'no', get out */
  801.  
  802.     if (sure[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  803.         return (x);
  804.  
  805.     if (flag_file (TEST_AND_SET, &(cur->mail_addr), 0))
  806.     {
  807.         sb_move (r, 2, 2);
  808.         sb_puts (r, MSG_TXT (M_NODE_BUSY));
  809.         wait_for_key (60);
  810.         return (0);
  811.     }
  812.  
  813.     HoldName = HoldAreaNameMunge (&(cur->mail_addr));
  814.     (void) sprintf (req, "%s%s.REQ", HoldName,
  815.         Hex_Addr_Str (&(cur->mail_addr)));
  816.  
  817.     if (dexists (req))
  818.     {
  819.         rhandle = open (req, O_RDONLY | O_BINARY);
  820.         close (rhandle);
  821.         if (rhandle == 0)
  822.         {
  823.             sb_move (r, 2, 2);
  824.             sb_puts (r, MSG_TXT (M_ZOOM_ERRREQ));
  825.         }
  826.         else
  827.         {
  828.             unlink (req);
  829.             sb_move (r, 2, 2);
  830.             sb_puts (r, MSG_TXT (M_ZOOM_DEL_REQ));
  831.             x = 1;
  832.         }
  833.         wait_for_key (60);
  834.     }
  835.     (void) flag_file (CLEAR_FLAG, &(cur->mail_addr), 0);
  836.     return (x);
  837. }
  838.  
  839. static void LOCALFUNC 
  840. append_fil (REGIONP r, unsigned int size, char *iname, char *oname,
  841.     char *desc)
  842. {
  843.     char *temp_buffer;
  844.     char temp[50];
  845.     int ihandle, ohandle;
  846.     int check;
  847.     int written = 1;
  848.  
  849.     temp_buffer = (char *) malloc (size + 1);
  850.     ihandle = open (iname, O_RDONLY | O_BINARY);
  851.     ohandle = open (oname, O_APPEND | O_BINARY | O_WRONLY);
  852.     (void) sprintf (temp, MSG_TXT (M_ZOOM_APPEND), desc);
  853.     sb_move (r, 2, 2);
  854.     sb_puts (r, temp);
  855.     do
  856.     {
  857.         check = read (ihandle, temp_buffer, size);
  858.         if (check)
  859.             written = write (ohandle, temp_buffer, check);
  860.     }
  861.     while (check > 0);
  862.     close (ihandle);
  863.     close (ohandle);
  864.     if (written > 0)
  865.         unlink (iname);
  866.     free (temp_buffer);
  867. }
  868.  
  869. static int LOCALFUNC 
  870. appren_mail (REGIONP r, ADDRP fromaddr, ADDRP toaddr,
  871.     char *ftype, char *desc)
  872. {
  873.     char iname[80], oname[80], tname[80];
  874.     char *HoldName;
  875.     struct FILEINFO fileinfo;
  876.     int buff_size;
  877.     int change = 0;
  878.  
  879.     HoldName = HoldAreaNameMunge (fromaddr);
  880.     (void) sprintf (tname, "%s%s.%s", HoldName, Hex_Addr_Str (fromaddr), ftype);
  881.     if (!dfind (&fileinfo, tname, 0))
  882.     {
  883.         do
  884.         {
  885.             buff_size = (int) fileinfo.size;
  886.             HoldName = HoldAreaNameMunge (toaddr);
  887.             (void) sprintf (oname, "%s%s.%s", HoldName, Hex_Addr_Str (toaddr),
  888.                 &(fileinfo.name[9]));
  889.             HoldName = HoldAreaNameMunge (fromaddr);
  890.             if (cur->mail_addr.Point != 0)
  891.             {
  892.                 (void) sprintf (iname, "%s%04x%04x.PNT\\%s", HoldName,
  893.                     fromaddr->Net, fromaddr->Node, fileinfo.name);
  894.             }
  895.             else
  896.             {
  897.                 (void) sprintf (iname, "%s%s", HoldName, fileinfo.name);
  898.             }
  899.             if (rename (iname, oname) != 0)
  900.             {
  901.                 if (!strcmp (desc, "?UT"))    /* mail packet */
  902.                 {
  903.                     if (buff_size > 60)
  904.                         append_pkt (r, buff_size, iname, oname);
  905.                 }
  906.                 else
  907.                     /* other file */
  908.                 {
  909.                     append_fil (r, buff_size, iname, oname, desc);
  910.                 }
  911.             }
  912.             else
  913.             {
  914.                 sprintf (iname, MSG_TXT (M_ZOOM_RENAME), desc);
  915.                 sb_move (r, 2, 2);
  916.                 sb_puts (r, iname);
  917.             }
  918.             change = 1;
  919.         }
  920.         while (!dfind (&fileinfo, NULL, 1));
  921.         (void) (dfind (&fileinfo, NULL, 2));
  922.     }
  923.     return (change);
  924. }
  925.  
  926. static int 
  927. mail_addr (BINK_SAVEP p, int x)
  928. {
  929.     REGIONP r;
  930.     char iname[80], sure[2];
  931.     ADDR addr;
  932.  
  933.     x = 0;
  934.  
  935.     if (p == NULL)
  936.         return (0);
  937.  
  938.     r = p->region;
  939.  
  940.     sb_fill (r, ' ', colors.popup);
  941.     sb_box (r, boxtype, colors.popup);
  942.  
  943.     sb_move (r, 0, 1);
  944.     sb_puts (r, MSG_TXT (M_ZOOM_DESTINATION));
  945.  
  946.     sb_move (r, 1, 2);
  947.     sb_puts (r, MSG_TXT (M_ZOOM_NEWADDR));
  948.     if (!sb_input_chars (r, 1, 18, iname, 36))
  949.     {
  950.         if (!find_address (iname, &addr))
  951.         {
  952.             return (0);
  953.         }
  954.         if (nodefind (&addr, 0))
  955.         {
  956.             sb_move (r, 1, 2);
  957.             sprintf (iname, "Node: %-18.18s - %-20.20s",
  958.                 Full_Addr_Str (&addr), newnodedes.SystemName);
  959.             sb_puts (r, iname);
  960.         }
  961.         sb_move (r, 2, 2);
  962.         sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  963.         (void) sb_input_chars (r, 2, 22, sure, 1);
  964.  
  965.         /* If user says 'no', get out */
  966.  
  967.         if (sure[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  968.             return (x);
  969.  
  970.         if (flag_file (TEST_AND_SET, &(cur->mail_addr), 0))
  971.         {
  972.             sb_move (r, 2, 2);
  973.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  974.             wait_for_key (60);
  975.             return (0);
  976.         }
  977.         if (flag_file (TEST_AND_SET, &addr, 0))
  978.         {
  979.             (void) flag_file (CLEAR_FLAG, &(cur->mail_addr), 0);
  980.             sb_move (r, 2, 2);
  981.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  982.             wait_for_key (60);
  983.             return (0);
  984.         }
  985.  
  986.         /* first append/rename ?LO */
  987.  
  988.         appren_mail (r, &(cur->mail_addr), &addr, "?LO", "mail attaches");
  989.  
  990.         /* append/rename REQ */
  991.  
  992.         appren_mail (r, &(cur->mail_addr), &addr, "REQ", "request files");
  993.  
  994.         /* now rename ?UT */
  995.  
  996.         appren_mail (r, &(cur->mail_addr), &addr, "?UT", "mail packets ");
  997.  
  998.         (void) flag_file (CLEAR_FLAG, &addr, 0);
  999.         (void) flag_file (CLEAR_FLAG, &(cur->mail_addr), 0);
  1000.         wait_for_key (60);
  1001.         x = 1;
  1002.     }                            /* end of address input */
  1003.     return (x);
  1004. }
  1005.  
  1006. int 
  1007. Do_Get (BINK_SAVEP p, int x)
  1008. {
  1009.     REGIONP r;
  1010.     char node[51];
  1011.     char file[51];
  1012.     char password[9];
  1013.     char flavor[2];
  1014.     char more[2];
  1015.     int busy = 0;
  1016.     int did_it = 0;
  1017.     short i;
  1018.     ADDR addr;
  1019.  
  1020.     if (p == NULL)
  1021.         return (0);
  1022.  
  1023.     r = p->region;
  1024.  
  1025.     if (x)
  1026.     {
  1027.         addr = cur->mail_addr;
  1028.  
  1029.         /* Busy the node if we can. */
  1030.  
  1031.         if (flag_file (TEST_AND_SET, &addr, 0))
  1032.         {
  1033.             sb_move (r, 2, 2);
  1034.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1035.             wait_for_key (60);
  1036.             return (-1);
  1037.         }
  1038.         busy = 1;
  1039.     }
  1040.  
  1041.     /* First fill it all with blanks */
  1042.  
  1043.     sb_fill (r, ' ', colors.popup);
  1044.  
  1045.     /* Now draw the box */
  1046.  
  1047.     sb_box (r, boxtype, colors.popup);
  1048.     sb_move (r, 0, 1);
  1049.     sb_puts (r, MSG_TXT (M_GET_FILE));
  1050.  
  1051.     /* Now do the fields */
  1052.  
  1053.     for (;;)
  1054.     {
  1055.         sb_move (r, 1, 2);
  1056.         sb_puts (r, MSG_TXT (M_ADDRESS_TO_GET_FROM));
  1057.  
  1058.         /* Display address if zoomed, ask for it if not. */
  1059.  
  1060.         if (x)
  1061.         {
  1062.             strncpy (node, Full_Addr_Str (&addr), 35);
  1063.             node[35] = '\0';
  1064.             sb_move (r, 1, 23);
  1065.             sb_puts (r, node);
  1066.         }
  1067.         else
  1068.         {
  1069.             if (sb_input_chars (r, 1, 23, node, 36))
  1070.                 break;
  1071.             if (!find_address (node, &addr))
  1072.             {
  1073.                 if (!did_it)
  1074.                     did_it = -1;
  1075.                 break;
  1076.             }
  1077.  
  1078.             /* Busy the node if we can. */
  1079.  
  1080.             if (flag_file (TEST_AND_SET, &addr, 0))
  1081.             {
  1082.                 sb_move (r, 2, 2);
  1083.                 sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1084.                 wait_for_key (60);
  1085.                 if (!did_it)
  1086.                     did_it = -1;
  1087.                 break;
  1088.             }
  1089.             busy = 1;
  1090.         }
  1091.  
  1092.         /* Ask for the filename */
  1093.  
  1094.         sb_move (r, 2, 2);
  1095.         sb_puts (r, MSG_TXT (M_FILE_TO_RECEIVE));
  1096.         if (sb_input_chars (r, 2, 23, file, 12))
  1097.             break;
  1098.  
  1099.         /* Get the password if any */
  1100.  
  1101.         sb_move (r, 3, 2);
  1102.         sb_puts (r, MSG_TXT (M_PASSWORD_TO_USE));
  1103.         (void) sb_input_chars (r, 3, 23, password, 8);
  1104.  
  1105.         /* Get the flavor or quit */
  1106.  
  1107.         sb_move (r, 4, 2);
  1108.         sb_puts (r, MSG_TXT (M_GET_FLAVOR));
  1109.         (void) sb_input_chars (r, 4, 41, flavor, 1);
  1110.  
  1111.         /* Get the file if we can */
  1112.  
  1113.         if (flavor[0] != 'Q')
  1114.         {
  1115.             if (mail_addrequest (&addr, file, password, flavor) == 0)
  1116.                 did_it = 1;
  1117.             else if (!did_it)
  1118.                 did_it = -1;
  1119.         }
  1120.  
  1121.         /* Unbusy the node */
  1122.  
  1123.         if (!x)
  1124.         {
  1125.             (void) flag_file (CLEAR_FLAG, &addr, 0);
  1126.             busy = 0;
  1127.         }
  1128.  
  1129.         /* Anything more to do? */
  1130.  
  1131.         sb_move (r, 5, 2);
  1132.         sb_puts (r, MSG_TXT (M_GET_MORE));
  1133.         (void) sb_input_chars (r, 5, 23, more, 1);
  1134.         if (more[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  1135.             break;
  1136.  
  1137.         /* Yes, clear the box. */
  1138.  
  1139.         for (i = 1; i <= 5; i++)
  1140.         {
  1141.             sb_move (r, i, 2);
  1142.             sb_puts (r, "                                                 ");
  1143.         }
  1144.     }
  1145.  
  1146.     /* If we busied something, get rid of it. */
  1147.  
  1148.     if (busy)
  1149.         (void) flag_file (CLEAR_FLAG, &addr, 0);
  1150.     return (did_it);
  1151. }
  1152.  
  1153. static int LOCALFUNC 
  1154. mail_addrequest (ADDRP pAddr, char *file, char *password, char *flavor)
  1155. {
  1156.     char *HoldName;
  1157.     char fname[100];
  1158.     FILE *f;
  1159.  
  1160.     if (flavor[0] == '\0')
  1161.         flavor[0] = 'N';
  1162.     if ((flavor[0] != 'C') && (flavor[0] != 'H') && (flavor[0] != 'N') &&
  1163.         (flavor[0] != 'D'))
  1164.         return (-3);
  1165.     if (flavor[0] == 'N')
  1166.         flavor[0] = 'F';
  1167.     flavor[1] = '\0';
  1168.  
  1169.     HoldName = HoldAreaNameMunge (pAddr);
  1170.  
  1171.     /* Now see if we should send anything back to him */
  1172.  
  1173.     (void) sprintf (fname, "%s%s.REQ", HoldName, Hex_Addr_Str (pAddr));
  1174.     if ((f = fopen (fname, append_binary)) == NULL)
  1175.         return (-2);
  1176.  
  1177.     (void) fprintf (f, "%s", file);
  1178.     if (password[0] != '\0')
  1179.     {
  1180.         (void) fprintf (f, " !%s", password);
  1181.     }
  1182.     (void) fprintf (f, "\r\n");
  1183.     (void) fclose (f);
  1184.  
  1185.     (void) mail_addsend (pAddr, "", flavor);
  1186.     return (0);
  1187. }
  1188.  
  1189. int 
  1190. Do_Poll_Packet (BINK_SAVEP p, int x)
  1191. {
  1192.     REGIONP r;
  1193.     char node[51];
  1194.     char more[2];
  1195.     int busy = 0;
  1196.     int did_it = 0;
  1197.     ADDR addr;
  1198.  
  1199.     if (p == NULL)
  1200.         return (0);
  1201.  
  1202.     r = p->region;
  1203.  
  1204.     if (x)
  1205.     {
  1206.         addr = cur->mail_addr;
  1207.  
  1208.         /* Busy the node if we can. */
  1209.  
  1210.         if (flag_file (TEST_AND_SET, &addr, 0))
  1211.         {
  1212.             sb_move (r, 2, 2);
  1213.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1214.             wait_for_key (60);
  1215.             return (-1);
  1216.         }
  1217.         busy = 1;
  1218.     }
  1219.  
  1220.     /* First fill it all with blanks */
  1221.  
  1222.     sb_fill (r, ' ', colors.popup);
  1223.  
  1224.     /* Now draw the box */
  1225.  
  1226.     sb_box (r, boxtype, colors.popup);
  1227.     sb_move (r, 0, 1);
  1228.     sb_puts (r, MSG_TXT (M_ZOOM_POLL));
  1229.  
  1230.     /* Now do the fields */
  1231.  
  1232.     sb_move (r, 1, 2);
  1233.     sb_puts (r, MSG_TXT (M_POLL_WHOM));
  1234.  
  1235.     /* Display address if zoomed, ask for it if not. */
  1236.  
  1237.     if (x)
  1238.     {
  1239.         strncpy (node, Full_Addr_Str (&addr), 39);
  1240.         node[39] = '\0';
  1241.         sb_move (r, 1, 14);
  1242.         sb_puts (r, node);
  1243.     }
  1244.     else
  1245.     {
  1246.         if (sb_input_chars (r, 1, 14, node, 40))
  1247.             goto Done;
  1248.         if (!find_address (node, &addr))
  1249.         {
  1250.             if (!did_it)
  1251.                 did_it = -1;
  1252.             goto Done;
  1253.         }
  1254.  
  1255.         /* Busy the node if we can. */
  1256.  
  1257.         if (flag_file (TEST_AND_SET, &addr, 0))
  1258.         {
  1259.             sb_move (r, 2, 2);
  1260.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1261.             wait_for_key (60);
  1262.             if (!did_it)
  1263.                 did_it = -1;
  1264.             goto Done;
  1265.         }
  1266.         busy = 1;
  1267.     }
  1268.  
  1269.     if (x)
  1270.     {
  1271.         sb_move (r, 2, 2);
  1272.         sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  1273.         if (sb_input_chars (r, 2, 22, more, 1))
  1274.             goto Done;
  1275.         if (more[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  1276.             goto Done;
  1277.     }
  1278.  
  1279.     if (mail_addsend (&addr, "", "C") == 0)
  1280.         did_it = 1;
  1281.     else if (!did_it)
  1282.         did_it = -1;
  1283. Done:
  1284.  
  1285.     /* If we busied something, get rid of it. */
  1286.  
  1287.     if (busy)
  1288.         (void) flag_file (CLEAR_FLAG, &addr, 0);
  1289.     return (did_it);
  1290. }
  1291.  
  1292. int 
  1293. Do_Send (BINK_SAVEP p, int x)
  1294. {
  1295.     REGIONP r;
  1296.     char node[51];
  1297.     char file[51];
  1298.     char flavor[2];
  1299.     char more[2];
  1300.     int busy = 0;
  1301.     int did_it = 0;
  1302.     short i;
  1303.     ADDR addr;
  1304.  
  1305.     if (p == NULL)
  1306.         return (0);
  1307.  
  1308.     r = p->region;
  1309.  
  1310.     if (x)
  1311.     {
  1312.         addr = cur->mail_addr;
  1313.  
  1314.         /* Busy the node if we can. */
  1315.  
  1316.         if (flag_file (TEST_AND_SET, &addr, 0))
  1317.         {
  1318.             sb_move (r, 2, 2);
  1319.             sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1320.             wait_for_key (60);
  1321.             return (-1);
  1322.         }
  1323.         busy = 1;
  1324.     }
  1325.  
  1326.     /* First fill it all with blanks */
  1327.  
  1328.     sb_fill (r, ' ', colors.popup);
  1329.  
  1330.     /* Now draw the box */
  1331.     sb_box (r, boxtype, colors.popup);
  1332.     sb_move (r, 0, 1);
  1333.     sb_puts (r, MSG_TXT (M_SEND_FILE));
  1334.  
  1335.     /* Now do the fields */
  1336.  
  1337.     for (;;)
  1338.     {
  1339.         sb_move (r, 1, 2);
  1340.         sb_puts (r, MSG_TXT (M_ADDRESS_TO_SEND_TO));
  1341.  
  1342.         /* Display address if zoomed, ask for it if not. */
  1343.  
  1344.         if (x)
  1345.         {
  1346.             strncpy (node, Full_Addr_Str (&addr), 46);
  1347.             node[46] = '\0';
  1348.             sb_move (r, 1, 22);
  1349.             sb_puts (r, node);
  1350.         }
  1351.         else
  1352.         {
  1353.             if (sb_input_chars (r, 1, 22, node, 47))
  1354.                 break;
  1355.             if (!find_address (node, &addr))
  1356.             {
  1357.                 if (!did_it)
  1358.                     did_it = -1;
  1359.                 break;
  1360.             }
  1361.  
  1362.             /* Busy the node if we can. */
  1363.  
  1364.             if (flag_file (TEST_AND_SET, &addr, 0))
  1365.             {
  1366.                 sb_move (r, 2, 2);
  1367.                 sb_puts (r, MSG_TXT (M_NODE_BUSY));
  1368.                 wait_for_key (60);
  1369.                 if (!did_it)
  1370.                     did_it = -1;
  1371.                 break;
  1372.             }
  1373.             busy = 1;
  1374.         }
  1375.  
  1376.         /* Ask for the filename */
  1377.  
  1378.         sb_move (r, 2, 2);
  1379.         sb_puts (r, MSG_TXT (M_FILE_TO_SEND));
  1380.         if (sb_input_chars (r, 2, 22, file, 47))
  1381.             break;
  1382.  
  1383.         /* Get the flavor or quit */
  1384.  
  1385.         sb_move (r, 3, 2);
  1386.         sb_puts (r, MSG_TXT (M_SEND_FLAVOR));
  1387.         (void) sb_input_chars (r, 3, 49, flavor, 1);
  1388.  
  1389.         /* Send the file if we can */
  1390.  
  1391.         if (flavor[0] != 'Q')
  1392.         {
  1393.             if (mail_addsend (&addr, file, flavor) == 0)
  1394.                 did_it = 1;
  1395.             else if (!did_it)
  1396.                 did_it = -1;
  1397.         }
  1398.  
  1399.         /* Unbusy the node */
  1400.  
  1401.         if (!x)
  1402.         {
  1403.             (void) flag_file (CLEAR_FLAG, &addr, 0);
  1404.             busy = 0;
  1405.         }
  1406.  
  1407.         /* Anything more to do? */
  1408.  
  1409.         sb_move (r, 4, 2);
  1410.         sb_puts (r, MSG_TXT (M_SEND_MORE));
  1411.         (void) sb_input_chars (r, 4, 20, more, 1);
  1412.         if (more[0] != (char) toupper (MSG_TXT (M_YES)[0]))
  1413.             break;
  1414.  
  1415.         /* Yes, clear the box. */
  1416.  
  1417.         for (i = 1; i <= 4; i++)
  1418.         {
  1419.             sb_move (r, i, 2);
  1420.             sb_puts (r, "                                                 ");
  1421.         }
  1422.     }
  1423.  
  1424.     /* If we busied something, get rid of it. */
  1425.  
  1426.     if (busy)
  1427.         (void) flag_file (CLEAR_FLAG, &addr, 0);
  1428.     return (did_it);
  1429. }
  1430.  
  1431. static int LOCALFUNC 
  1432. mail_addsend (ADDRP pAddr, char *file, char *flavor)
  1433. {
  1434.     char *HoldName;
  1435.     char fname[100];
  1436.     FILE *f;
  1437.  
  1438.     if (flavor[0] == '\0')
  1439.         flavor[0] = 'N';
  1440.     if ((flavor[0] != 'C') && (flavor[0] != 'H') && (flavor[0] != 'N') &&
  1441.         (flavor[0] != 'D'))
  1442.         return (-3);
  1443.     if (flavor[0] == 'N')
  1444.         flavor[0] = 'F';
  1445.     flavor[1] = '\0';
  1446.     HoldName = HoldAreaNameMunge (pAddr);
  1447.     (void) sprintf (fname, "%s%s.%sLO", HoldName,
  1448.         Hex_Addr_Str (pAddr), flavor);
  1449.     if ((f = fopen (fname, append_binary)) == NULL)
  1450.     {
  1451.         return (-2);
  1452.     }
  1453.     else
  1454.     {
  1455.         if (file[0] != '\0')
  1456.             (void) fprintf (f, "%s\r\n", file);
  1457.         (void) fclose (f);
  1458.     }
  1459.     return (0);
  1460. }
  1461.  
  1462. int 
  1463. Do_Kill (BINK_SAVEP p, int x)
  1464. {
  1465.     REGIONP r;
  1466.     char node[51];
  1467.     char sure[2];
  1468.  
  1469.     if (p != NULL)
  1470.     {
  1471.         r = p->region;
  1472.  
  1473.         /* First fill it all with blanks */
  1474.         sb_fill (r, ' ', colors.popup);
  1475.  
  1476.         /* Now draw the box */
  1477.         sb_box (r, boxtype, colors.popup);
  1478.  
  1479.         sb_move (r, 0, 1);
  1480.         sb_puts (r, MSG_TXT (M_KILL_MAIL));
  1481.  
  1482.         /* Now do the fields */
  1483.         sb_move (r, 1, 2);
  1484.         sb_puts (r, MSG_TXT (M_ADDRESS_TO_KILL));
  1485.  
  1486.         if (x)
  1487.         {
  1488.             strncpy (node, Full_Addr_Str (&cur->mail_addr), 50);
  1489.             node[50] = '\0';
  1490.             sb_move (r, 1, 19);
  1491.             sb_puts (r, node);
  1492.         }
  1493.         else if (sb_input_chars (r, 1, 19, node, 50))
  1494.             return 0;
  1495.  
  1496.         sb_move (r, 2, 2);
  1497.         sb_puts (r, MSG_TXT (M_KILL_ALL_MAIL));
  1498.         sb_puts (r, MSG_TXT (M_ARE_YOU_SURE));
  1499.         (void) sb_input_chars (r, 2, 38, sure, 1);
  1500.         if (sure[0] == (char) toupper (MSG_TXT (M_YES)[0]))
  1501.             x = kill_node (node);
  1502.         else x = 0;
  1503.     }
  1504.     else x = 0;
  1505.  
  1506.     /* Return value is never checked, just use x so lint and -W3 don't get mad */
  1507.  
  1508.     return (x);
  1509. }
  1510.  
  1511. int 
  1512. Do_Poll (BINK_SAVEP p, int x)
  1513. {
  1514.     char node[51];
  1515.     REGIONP r;
  1516.  
  1517.     happy_compiler = x;            /* Makes the compiler happy! */
  1518.     if (p != NULL)
  1519.     {
  1520.         r = p->region;
  1521.  
  1522.         /* First fill it all with blanks */
  1523.  
  1524.         sb_fill (r, ' ', colors.popup);
  1525.  
  1526.         /* Now draw the box */
  1527.  
  1528.         sb_box (r, boxtype, colors.popup);
  1529.         sb_move (r, 0, 1);
  1530.         sb_puts (r, MSG_TXT (M_NODE_TO_POLL));
  1531.  
  1532.         /* Now do the fields */
  1533.  
  1534.         sb_move (r, 1, 2);
  1535.         sb_puts (r, MSG_TXT (M_POLL_WHOM));
  1536.         if (!sb_input_chars (r, 1, 14, node, 40))
  1537.         {
  1538.             return (find_address (node, &next_addr));
  1539.         }
  1540.     }
  1541.     return (FALSE);
  1542. }
  1543.  
  1544. static int LOCALFUNC 
  1545. kill_node (char *node)
  1546. {
  1547.     ADDR addr;
  1548.     char *HoldName;
  1549.     char *p;
  1550.     char fname[160];
  1551.     struct FILEINFO fileinfo = {0};
  1552.     int j;
  1553.  
  1554.     if (find_address (node, &addr))
  1555.     {
  1556.         if (flag_file (TEST_AND_SET, &addr, 0))
  1557.         {
  1558.             return (-1);
  1559.         }
  1560.  
  1561.         HoldName = HoldAreaNameMunge (&addr);
  1562.  
  1563.         (void) sprintf (fname, "%s%s.*", HoldName, Hex_Addr_Str (&addr));
  1564.         j = 0;
  1565.         while (!dfind (&fileinfo, fname, j))
  1566.         {
  1567.             j = 1;
  1568.  
  1569.             /* Don't delete the .bsy flags yet */
  1570.  
  1571.             if ((p = strchr (fileinfo.name, '.')) != NULL)
  1572.             {
  1573.                 if (strcmp (p, ".BSY") == 0)
  1574.                     continue;
  1575.             }
  1576.  
  1577.             if (addr.Point != 0)
  1578.             {
  1579.                 (void) sprintf (fname, "%s%04hx%04hx.PNT\\%s",
  1580.                     HoldName, addr.Net, addr.Node, fileinfo.name);
  1581.             }
  1582.             else
  1583.                 (void) sprintf (fname, "%s%s", HoldName, fileinfo.name);
  1584.  
  1585.             (void) unlink (fname);
  1586.         }
  1587.         if (j)
  1588.             (void) dfind (&fileinfo, NULL, 2);
  1589.  
  1590.         (void) flag_file (CLEAR_FLAG, &addr, 0);
  1591.         return (0);
  1592.     }
  1593.     /* else */
  1594.     return (-1);
  1595. }
  1596.  
  1597. static void LOCALFUNC 
  1598. call_tries (ADDRP baddr, int *calls, int *badcalls)
  1599. {
  1600.     int res;
  1601.     int i, j;
  1602.     struct FILEINFO bad_dta = {0};
  1603.     char *HoldName;
  1604.  
  1605.     char fname[128];
  1606.  
  1607.     HoldName = HoldAreaNameMunge (baddr);
  1608.     (void) sprintf (fname, "%s%s.$$?", HoldName, Hex_Addr_Str (baddr));
  1609.     j = (int) strlen (fname) - 1;            /* Point at ?          */
  1610.     res = -1;                                /* Initialize to fail  */
  1611.  
  1612.     i = 0;                                    /* This says findfirst */
  1613.     while (!dfind (&bad_dta, fname, i))        /* as long as we match */
  1614.     {
  1615.         if (isdigit (bad_dta.name[11]))        /* is there a digit?   */
  1616.         {
  1617.             fname[j] = bad_dta.name[11];    /* Yes, copy to fname  */
  1618.             res = fname[j] - '0';            /* Save it for testing */
  1619.             break;                            /* Get out of while    */
  1620.         }
  1621.         else
  1622.             i = 1;                            /* Else use findnext   */
  1623.     }
  1624.     if (i)
  1625.         (void) dfind (&bad_dta, NULL, 2);
  1626.  
  1627.     /* Initialize the return values */
  1628.  
  1629.     *calls = *badcalls = 0;
  1630.  
  1631.     /* Is it automatically ok (no .$$ file there) ? */
  1632.  
  1633.     if (res == -1)
  1634.         return;
  1635.  
  1636.     /* We now have the number of bad calls (calls with carrier) */
  1637.  
  1638.     *badcalls = res;
  1639.  
  1640.     /* Open the file and find out how many total calls were made */
  1641.  
  1642.     i = open (fname, O_RDONLY | O_BINARY);
  1643.     if (i != -1)
  1644.     {
  1645.         res = 0;
  1646.         (void) read (i, (char *) &res, sizeof (int));
  1647.         (void) close (i);
  1648.     }
  1649.  
  1650.     *calls = res;
  1651.     return;
  1652. }
  1653.     
  1654. #if 0
  1655. static char LOCALFUNC xlat_flavor (char flavor);
  1656. static char LOCALFUNC 
  1657. xlat_flavor (char flavor)
  1658. {
  1659.     char *real_flavor = "CHDN";
  1660.     char *user_flavor;
  1661.  
  1662.     user_flavor = MSG_TXT (M_CHDN_FLAGS);
  1663.     for (;;)
  1664.     {
  1665.         if (!*real_flavor)
  1666.             break;
  1667.         if (*user_flavor == flavor)
  1668.         {
  1669.             return *real_flavor;
  1670.         }
  1671.         user_flavor++;
  1672.         real_flavor++;
  1673.     }
  1674.     return (0);
  1675. }
  1676.  
  1677. #endif
  1678.