home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / fax-3.2.1 / lib / libfax / send.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-31  |  10.5 KB  |  444 lines
  1. /*
  2.   This file is part of the NetFax system.
  3.  
  4.   (c) Copyright 1989 by David M. Siegel and Sundar Narasimhan.
  5.       All rights reserved.
  6.  
  7.     This program is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation.
  10.  
  11.     This program is distributed in the hope that it will be useful, 
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of 
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  15.  
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19. */
  20.  
  21. #include <stdio.h>
  22. #include <termios.h>
  23. #include <fcntl.h>
  24.  
  25. #include "log.h"
  26. #include "c2proto.h"
  27. #include "response.h"
  28. #include "swap.h"
  29. #include "read.h"
  30. #include "write.h"
  31. #include "tty.h"
  32. #include "send.h"
  33.  
  34. /*
  35.   Maximum amount of data to send to the modem in one write call:
  36. */
  37. #define SEND_CHUNK 1024
  38.  
  39. /*
  40.  * Dial a number: ATDT
  41.  *
  42.  * Return codes:
  43.  *     0    ok, number has been dialed.
  44.  *    -1    dial failed.
  45.  */
  46. static int dial(f, phonenum)
  47.      FaxModem *f;
  48.      char *phonenum;
  49. { 
  50.     log(L_NOTICE, "dialing: %s", phonenum);
  51.  
  52.     init_modem_response(f);
  53.  
  54.     if (fdprintf(f->fd, "ATDT%s\r", phonenum) < 0)
  55.       return (-1);
  56.  
  57.     if (get_modem_response(f, TIMEOUT_CONNECT) < 0)
  58.       return (-1);
  59.  
  60.     /*
  61.      * Save away the last numeric result as the result of this
  62.      * dial operation.  This makes it handy to check what
  63.      * happened on the last dial.
  64.      */
  65.     f->dialer_code = f->result;
  66.  
  67.     return (0);
  68. }
  69.  
  70. /*
  71.  * Sync and dial to a remote fax machine.
  72.  *
  73.  * Return codes:
  74.  *     0    connection to remote modem has been established.
  75.  *    -1    connection failed.
  76.  */
  77. int faxmodem_initiate_call(f, dialstring)
  78.      FaxModem *f;
  79.      char *dialstring;
  80. {
  81.     if (faxmodem_sync(f, 10) < 0)
  82.       return (-1);
  83.  
  84.     /* 
  85.      * Set phase C data bit order.
  86.      *
  87.      * The interfax firmware has a bug with received data in
  88.      * bitreverse=1 mode, so I will leave it in bor=0, and fudge the
  89.      * data in software.
  90.      */
  91.     if (faxmodem_bit_reverse(f, 0) < 0) {
  92.     log(L_NOTICE, "setting modem to bit reverse failed");
  93.     return (-1);
  94.     }
  95.  
  96.     /*
  97.      * Initiate the call to the remote modem.
  98.      */
  99.     if (dial(f, dialstring) < 0) {
  100.     log(L_NOTICE, "dial failed");
  101.     return (-1);
  102.     }
  103.  
  104.     return (0);
  105. }
  106.  
  107. /* 
  108.  * Begin or continue sending: +FDT
  109.  *
  110.  * Send the appropriate commands to the fax modem to start transmission
  111.  * of a page.  After sending the start commands, the modem will respond
  112.  * with a message that ends with CONNECT.  For now, we don't parse any
  113.  * of this message, we just look for the CONNECT.  In addition, the
  114.  * modem will signal to us that we should start sending G3 data by
  115.  * issuing an XON.  Thus, we force an XOFF.  THe subsequent writes
  116.  * to the modem will not start to drain until the XON occurs.  Note
  117.  * that this part of the protocol may change, according to the most
  118.  * recent documention.
  119.  *
  120.  * Set desired transmission params with +FDT=DF,VR,WD,LN
  121.  *   DF = Data Format :     0  [1-d huffman]
  122.  *   VR = Vertical Res :     1  [196 dpi (fine)]
  123.  *   WD = width :         0  [ 1728 pixels]
  124.  *   LN = page length :        2  [ Unlimited ]
  125.  *
  126.  * Return codes:
  127.  *     0    ok, proceed with sending data
  128.  *    -1    setup failed, not ready to send.
  129.  */
  130. static int start_xmit(f, df, vr, wd, ln)
  131.      FaxModem *f;
  132.      int df, vr, wd, ln;
  133. {
  134.     log(L_NOTICE, "setting xmit params: %d %d %d %d", df, vr, wd, ln);
  135.  
  136.     if (fdprintf(f->fd, "AT+FDT=%d,%d,%d,%d\r", df, vr, wd, ln) < 0)
  137.       return (-1);
  138.  
  139.     /*
  140.      * Wait for the output to the modem to complete, and then stop
  141.      * all further output (via an XOFF).  The modem will eventually
  142.      * respond with an XON, allowing the data transmission to begin.
  143.      */
  144.     tcdrain(f->fd);
  145.     ioctl(f->fd, TCXONC, TCOOFF);
  146.  
  147.     /*
  148.      * Make sure that we get the CONNECT message from the modem.
  149.      */
  150.     return (get_modem_response(f, 120));
  151. }
  152.  
  153. /*
  154.  * end of page, another page from same document is coming: +FET=0
  155.  * 
  156.  * This transmit page punctuation command is issued after a +FDT has
  157.  * been issued, and indicates that the current page has completed,
  158.  * and another page from the same document is about to be sent.
  159.  *
  160.  * Return codes:
  161.  *     0    all ok
  162.  *    -1    modem response error
  163.  */
  164. static int end_page(f)
  165.      FaxModem *f;
  166. {
  167.     log(L_NOTICE, "end of current page, another page will be sent");
  168.  
  169.     if (fdprintf(f->fd, "AT+FET=0\r") < 0)
  170.       return (-1);
  171.  
  172.     return (get_modem_response(f, TIMEOUT_END_PAGE));
  173. }
  174.  
  175. /*
  176.  * End of page and end of document: +FET=2
  177.  *
  178.  * This transmit page punctuation command is issued after a +FDT has
  179.  * been issued, and incates that the current page has completed,
  180.  * and the document is complete as well.
  181.  *
  182.  * Return codes:
  183.  *     0    all ok
  184.  *    -1    modem response error
  185.  */
  186. static int end_xmit(f)
  187.      FaxModem *f;
  188. { 
  189.     log(L_NOTICE, "end of current page, document is now complete");
  190.  
  191.     if (fdprintf(f->fd, "AT+FET=2\r") < 0)
  192.       return (-1);
  193.  
  194.     return (get_modem_response(f, TIMEOUT_END_XMIT));
  195. }
  196.  
  197. /*
  198.  * When sending data, it is possible to get a CAN message from
  199.  * the remote fax.  This message indicates that the send should
  200.  * be aborted.  The DLE ETX sequence should be sent to the DCE
  201.  * to ack the abort.
  202.  *
  203.  * Return codes:
  204.  *    0    all ok, proceed with sending
  205.  *     -1    send failed, check modem flags for more details
  206.  */
  207. static int process_send_response(f)
  208.      FaxModem *f;
  209. {
  210.     char resp[128];
  211.     int resp_len;
  212.     int i;
  213.  
  214.     /*
  215.      * We poll the fd for any input.  If none is available, all
  216.      * is fine.  If we get any input at all, it should be a CAN
  217.      * command, as that is all that the protocol allows.  However,
  218.      * to be safe we toss out any other junk that may come in.
  219.      */
  220.     switch (resp_len = pread(f->fd, resp, sizeof(resp))) {
  221.       case -1:
  222.     log(L_ERR, "send_page: poll failed: %m");
  223.     f->status = MODEM_STATUS_FAILED;
  224.     return (-1);
  225.       case 0:
  226.     return (0);
  227.       default:
  228.     log(L_INFO, "process_send_response: got \"%.*s\"", resp_len, resp);
  229.     for (i = 0; i < resp_len; i++) {
  230.         if ((resp[i] & 0x7f) == CAN) {
  231.         log(L_NOTICE, "remote fax has canceled transmission");
  232.         fdprintf(f->fd, "%c%c", DLE, ETX);
  233.         f->flags |= FAX_F_CANCELED;
  234.         return (-1);
  235.         }
  236.     }
  237.     return (0);
  238.     }
  239. }
  240.  
  241. /*
  242.  * Actually send a page.  We assume that we have dialed and connected
  243.  * to the remote fax machine, and that all is ready for starting
  244.  * the actually transmission.
  245.  *
  246.  * Return codes:
  247.  *     0    page has been succesfully sent
  248.  *    -1    send of page failed.
  249.  */
  250. static int send_page(f, fd, last_page)
  251.      FaxModem *f;
  252.      int fd;
  253.      int last_page;
  254. {
  255.     log(L_INFO, "sending g3 file");
  256.  
  257.     /*
  258.      * Setup things for transmission.
  259.      */
  260.     if (start_xmit(f, DF_1DHUFFMAN, VR_FINE, WD_1728, LN_UNLIMITED) < 0)
  261.       return (-1);
  262.  
  263.     /*
  264.      * Allow modem to send ^S to us.  Don't use flow control in the
  265.      * other direction, since we need to pass 8 bits.
  266.      */
  267.     tty_fc(f->fd, FC_OUTPUT_ON);
  268.  
  269.     /*
  270.      * Now send the page.
  271.      */
  272.     for (;;) {
  273.     unsigned char buf[SEND_CHUNK];
  274.     unsigned char buf_copy[SEND_CHUNK*2];
  275.     int nchars, ochars;
  276.     int i;
  277.  
  278.     /*
  279.      * Read in a hunk of data.
  280.      */
  281.     if ((nchars = read(fd, buf, sizeof(buf))) < 0) {
  282.         log(L_ERR, "send_page: read failed: %m");
  283.         tty_fc(f->fd, FC_BOTH_ON);
  284.         return (-1);
  285.     }
  286.     if (nchars == 0)
  287.       break;
  288.  
  289.     /*
  290.      * Reverse and stuff buffer characters:
  291.      */
  292.     ochars = 0;
  293.     for (i = 0; i < nchars; i++) {
  294.         buf_copy[ochars] = swap_bits(buf[i]);
  295.         if (buf_copy[ochars++] == DLE)
  296.           buf_copy[ochars++] = DLE;
  297.     }
  298.  
  299.     /*
  300.      * Write out the buffer to the modem.
  301.      */
  302.     if (nwrite(f->fd, (char *)buf_copy, ochars) != ochars) {
  303.         log(L_ERR, "send_page: write to modem failed: %m");
  304.         tty_fc(f->fd, FC_BOTH_ON);
  305.         return (-1);
  306.  
  307.     }
  308.  
  309.     /*
  310.      * Check for any response from the modem.
  311.      */
  312.     if (process_send_response(f) < 0) {
  313.         tty_fc(f->fd, FC_BOTH_ON);
  314.         return (-1);
  315.     }
  316.     }
  317.  
  318.     fdprintf(f->fd, "%c%c", DLE, ETX);
  319.  
  320.     tty_fc(f->fd, FC_BOTH_ON);
  321.  
  322.     if (get_modem_response(f, TIMEOUT_SEND_PAGE) < 0) {
  323.     log(L_NOTICE, "an error sending the file has occured");
  324.     return (-1);
  325.     } else
  326.       log(L_INFO, "send of file has completed");
  327.  
  328.     if (last_page)
  329.       return (end_xmit(f));
  330.     else
  331.       return (end_page(f));
  332. }
  333.  
  334. /*
  335.  * Send off a page.  If a retransmit is requested, try up to tries number
  336.  * of times.  If this is the last page of the transmission, set last_page
  337.  * to be true.  The G3 file to send is opened on the given fd.
  338.  *
  339.  * Return codes:
  340.  *    0    the page was successfully sent
  341.  *     -1    the send failed, see the modem flags for more details
  342.  */
  343. int faxmodem_send_page(f, fd, last_page, tries)
  344.      FaxModem *f;
  345.      int fd;
  346.      int last_page;
  347.      int tries;
  348. {
  349.     int i;
  350.  
  351.     for (i = 0; i < tries; i++) {
  352.     if (send_page(f, fd, last_page) < 0)
  353.       return (-1);
  354.  
  355.     /*
  356.      * If hangup was detected and not last page, then return
  357.      * with an error condition.
  358.      */
  359.     if (last_page) {
  360.         if (FAX_ISSET(f, FAX_F_FHNG) && (f->hangup_code != 0)) {
  361.         log(L_NOTICE, "hangup on last page: %d", f->hangup_code);
  362.         return (-1);
  363.         }
  364.     } else {
  365.         if (FAX_ISSET(f, FAX_F_FHNG)) {
  366.         log(L_NOTICE, "hangup code received while sending pages");
  367.         return (-1);
  368.         }
  369.     }
  370.  
  371.     /*
  372.      * Make sure we got a post page response.
  373.      */
  374.     if (!FAX_ISSET(f, FAX_F_FPTS)) {
  375.         log(L_NOTICE, "didn't receive post page response");
  376.         return (-1);
  377.     }
  378.  
  379.     switch (f->ppr_code) {
  380.       case PPR_MCF:
  381.         /* page good */
  382.         return (0);
  383.  
  384.       case PPR_RTN:
  385.       case PPR_RTP:
  386.         /* retrans requested for both these cases */
  387.         break;
  388.  
  389.       case PPR_PIN:
  390.       case PPR_PIP:
  391.         /* interrupt requested, what do we do here? assume failure */
  392.         return (-1);
  393.  
  394.       default:
  395.         log(L_ERR, "unknown ppr code received");
  396.         return (-1);
  397.     }
  398.     }
  399.     
  400.     f->flags |= FAX_F_RETRIES;
  401.  
  402.     log(L_NOTICE, "failed to successfully send page");
  403.  
  404.     return (-1);
  405. }
  406.  
  407. #ifdef DEBUG
  408. FaxModem fm;
  409.  
  410. int send_test(phone)
  411.      char *phone;
  412. {
  413.     int fd;
  414.  
  415.     log_set_level(LOG_INFO);
  416.     
  417.     if (faxmodem_open(&fm, "/dev/ttyb") < 0) {
  418.     fprintf(stderr, "open failed\n");
  419.     return (-1);
  420.     }
  421.  
  422.     if (faxmodem_initiate_call(&fm, phone) < 0 || !FAX_CONNECTED(&fm)) {
  423.     fprintf(stderr, "connection failed\n");
  424.     return (-1);
  425.     }
  426.  
  427.     if ((fd = open("test.g3.0", O_RDONLY)) < 0) {
  428.     fprintf(stderr, "can't open test file\n");
  429.     faxmodem_close(&fm);
  430.     return (-1);
  431.     }
  432.  
  433.     if (faxmodem_send_page(&fm, fd, TRUE, 3) < 0)
  434.       fprintf(stderr, "send failed\n");
  435.     else
  436.       fprintf(stderr, "send was successful\n");
  437.  
  438.     faxmodem_hangup(&fm);
  439.     faxmodem_close(&fm);
  440.  
  441.     return (0);
  442. }
  443. #endif DEBUG
  444.