home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / NCSATELN / TEL23SRC.ZIP / LPR / LP.C next >
Encoding:
C/C++ Source or Header  |  1991-06-27  |  8.9 KB  |  251 lines
  1. /*  -------------------------------------------------------------
  2.     lp.c
  3.  
  4.     Routines common to lpr, lpq, and lprm.
  5.  
  6.     Paul Hilchey    May 1989
  7.  
  8.     Copyright (C) 1989  The University of British Columbia
  9.     All rights reserved.
  10.  
  11.      history
  12.      -------
  13.      1/6/89   Microsoft C port by Heeren Pathak (NCSA)
  14.     -------------------------------------------------------------
  15. */
  16.  
  17. #define LPR
  18.  
  19. #include <stdio.h>
  20. #include <conio.h>
  21. #include <stdlib.h>
  22. #include <stdarg.h>
  23. #ifdef MEMORY_DEBUG
  24. #include "memdebug.h"
  25. #endif
  26. #include "netevent.h"
  27. #include "hostform.h"
  28. #include "lp.h"
  29. #include "externs.h"
  30.  
  31. #ifdef MSC
  32. #define EXIT_FAILURE 1
  33. #endif
  34.  
  35. /****************************************************************
  36.  * lookup                                                       *
  37.  * Try to find the remote host in the local cache or from a     *
  38.  * domain name server.                                          *
  39.  * parameters: null terminated string containing the name or    *
  40.  *                ip address of the host                        *
  41.  * return value: pointer to machine info record, or 0 if the    *
  42.  *               lookup failed                                  *
  43.  ****************************************************************/
  44. struct machinfo *lookup(char *host)
  45. {
  46.     int what,dat;
  47.     int machine_number;     /* used to identify domain lookup events */
  48.     struct machinfo *machine_info;
  49.  
  50.     machine_info = Sgethost(host);  /* look up in hosts cache */
  51.  
  52.     if (!machine_info) {
  53.         if ((machine_number = Sdomain(host)) < 0) return(0);  /* initiate domain name lookup */
  54.  
  55.         while (machine_info==NULL) {                /* wait for DOMOK or DOMFAIL event */
  56.             switch(lgetevent(USERCLASS,&what,&dat)) {
  57.                 case DOMFAIL: return(0);                             /* lookup failed, return 0 */
  58.                 case DOMOK:   machine_info=Slooknum(machine_number); /* get pointer to machine record */
  59.                 default: break;
  60.             }
  61.         }
  62.     if (debug) puts("Domain lookup worked");
  63.     }
  64.     return(machine_info);
  65. }
  66.  
  67. /*****************************************************************
  68.  *  open_connection                                              *
  69.  *  Open the TCP connection.                                     *
  70.  *  parameters: pointer to machine info record                   *
  71.  *              source port number                               *
  72.  *              destination port number                          *
  73.  *  return value: connection identifier (port number), or -1 if  *
  74.  *                connection could not be opened                 *
  75.  *****************************************************************/
  76. int open_connection(struct machinfo *machine_record, int source_port,
  77.                     int dest_port)
  78. {
  79.     int ev,what,dat;  /* parameters for lgetevent */
  80.     int conid;    /* connection identifier */
  81.  
  82.     /* set the source port */
  83.     netfromport(source_port);
  84.  
  85.     /* initiate connection open */
  86.     if (0 > (conid = Snetopen(machine_record,dest_port)))
  87.         return(-1);
  88.  
  89.     if (debug) puts("snetopen ok");
  90.  
  91.     /* wait for connection to open or for attempt to fail */
  92.     while(1) {
  93.         if (0 != (ev = lgetevent(CONCLASS,&what,&dat))) {
  94.             if (dat != conid) {     /* not for us */
  95. /*              netputevent(what,ev,dat); */
  96.                 continue;
  97.             }
  98.             if (ev == CONOPEN)
  99.                 break;
  100.             else
  101.                 return(-1);
  102.         }
  103.     }
  104.     if (debug) puts("Conopen");
  105.     return(conid);
  106. }
  107.  
  108.  
  109. /*******************************************************************
  110.  * crash                                                           *
  111.  * Shut down all network stuff, print an error message to stderr,  *
  112.  * and abort.                                                      *
  113.  * parameters: variable length argument list for the error         *
  114.  *                message (a la printf)                            *
  115.  *******************************************************************/
  116. void crash(char *msg,...)
  117. {
  118.     va_list argptr;
  119.  
  120.     fprintf(stderr,"\nError: ");
  121.     va_start(argptr,msg);
  122.     vfprintf(stderr,msg,argptr);
  123.     va_end(argptr);
  124.     fprintf(stderr,"\n");
  125.  
  126.     /* shut everything down */
  127.     netshut();
  128.     exit(EXIT_FAILURE);
  129. }
  130.  
  131. /*********************************************************************
  132.  * Check for any error events that may have occured.  Either print   *
  133.  * the message on stderr or just ignore it if it is probably not     *
  134.  * serious.  Set debug on to see all error messages.                 *
  135.  *********************************************************************/
  136. void checkerr(void )
  137. {
  138.     char *errmsg;
  139.     int i,j;
  140.  
  141.     while (ERR1 == Sgetevent(ERRCLASS,&i,&j)) {
  142.         if ((!debug) &&
  143.            ((300 <= j && j <= 399) ||  /* IP messages */
  144.             (400 <= j && j <= 499) ||  /* TCP messages */
  145.             (600 <= j && j <= 699) ||  /* ICMP messages */
  146.             j == 801  || j == 805  ||  /* misc. domain stuff */
  147.             j == 806))
  148.             continue;                  /* just ignore them */
  149.         errmsg = neterrstring(j);
  150.         fprintf(stderr,"%s\n",errmsg);
  151.     }
  152. }
  153.  
  154. /*********************************************************************
  155.  * lgetevent                                                         *
  156.  * Check for network events. The next pending non-error event is     *
  157.  * returned (if any).                                                *
  158.  * Takes the same parameters as sgetevent.                           *
  159.  *********************************************************************/
  160. int lgetevent(int class, int *what, int *datp)
  161. {
  162.     checkerr();
  163.     return(Sgetevent(class, what, datp));
  164. }
  165.  
  166. /******************************************************************
  167.  * nprintf                                                        *
  168.  * Formatted write to an open TCP conection.  Like fprintf, but   *
  169.  * use a connection id returned from snteopen instead of a file   *
  170.  * handle.  The formatted string must not exceed 1023 bytes.      *
  171.  * Returns EOF if an error occurs                                 *
  172.  ******************************************************************/
  173. int nprintf(int connection_id, char *format,...)
  174. #define BUFF_SIZE 1024
  175. {
  176.     va_list argptr;
  177.     char    buff[BUFF_SIZE], *buff_ptr;
  178.     int     len1, len2;
  179.  
  180.     va_start(argptr,format);
  181.     len1 = vsprintf(buff,format,argptr);
  182.     va_end(argptr);
  183.     if ((len1 == EOF) || len1+1 >= BUFF_SIZE) return(EOF);
  184.     buff_ptr = buff;
  185.     while (buff_ptr < (buff + len1)) {
  186.         len2 = netwrite(connection_id, buff_ptr, len1-(buff_ptr - buff));
  187.         checkerr();
  188.         Stask();
  189.         if (len2 < 0) return(EOF);
  190.         buff_ptr += len2;
  191.     }
  192.     if (debug) puts(buff);
  193.     return (len1);
  194. }
  195.  
  196. /******************************************************************
  197.  * nread                                                          *
  198.  * Read from an open TCP connection.  Waits for incoming data if  *
  199.  * there is none in the queue.  Returns EOF if the connection     *
  200.  * closes and there is no more data.                              *
  201.  *                                                                *
  202.  * parameters: connection id returned by Snetopen                 *
  203.  *             buffer for returned data                           *
  204.  *             size of buffer                                     *
  205.  * returned value: number of characters read into the buffer      *
  206.  ******************************************************************/
  207.  
  208. int nread(int connection_id, char *buff, int buff_size)
  209. {
  210.     int class,data,ev;
  211.     int len;
  212.  
  213.     netpush(connection_id);  /* flush buffer */
  214.  
  215.     while (0 == netest(connection_id)) {
  216.         ev = lgetevent(CONCLASS, &class, &data);
  217.         if (!ev) continue;
  218.         if (data != connection_id) {   /* not for us; throw away */
  219. /*         netputevent(class, ev, data); */
  220.            continue;
  221.         }
  222.         if (debug) printf("nread %d %d\n",class,ev);
  223.         if (ev == CONDATA) {
  224.             len = netread(connection_id,buff,buff_size);
  225.             if (len == 0) continue;
  226.             if (debug) printf("received %.*s\n",len,buff);
  227.             return (len);
  228.         }
  229.     }
  230.     /* throw away other events.  getevent should be changed so we
  231.        can retrieve events for a selected port only  */
  232.     while (lgetevent(USERCLASS | CONCLASS, &class, &data));
  233.     return (EOF);    /* connection is closed and no data in queue */
  234. }
  235.  
  236. #ifdef MSC
  237. #else
  238. #pragma warn .par
  239. #endif
  240.  
  241. /******************************************************************
  242.  * breakstop                                                      *
  243.  * Handle break interrupts by shutting down the network stuff and *
  244.  * aborting.                                                      *
  245.  ******************************************************************/
  246. int breakstop(void )
  247. {
  248.     netshut();
  249.     return(0);
  250. }
  251.