开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
tcp_ami.c
资源名称：imap-4.7.tar.Z　[点击查看]
上传用户：ycwykj01
上传日期：2007-01-04
资源大小：1819k
文件大小：20k
源码类别：

网络编程

开发平台：

Unix_Linux

tcp_ami.c：源码内容
  1. /*
  2.  * Program: Amiga TCP/IP routines
  3.  *
  4.  * Author: Mark Crispin
  5.  * Networks and Distributed Computing
  6.  * Computing & Communications
  7.  * University of Washington
  8.  * Administration Building, AG-44
  9.  * Seattle, WA  98195
  10.  * Internet: MRC@CAC.Washington.EDU
  11.  *
  12.  * Date: 1 August 1988
  13.  * Last Edited: 14 June 1999
  14.  *
  15.  * Copyright 1999 by the University of Washington
  16.  *
  17.  *  Permission to use, copy, modify, and distribute this software and its
  18.  * documentation for any purpose and without fee is hereby granted, provided
  19.  * that the above copyright notice appears in all copies and that both the
  20.  * above copyright notice and this permission notice appear in supporting
  21.  * documentation, and that the name of the University of Washington not be
  22.  * used in advertising or publicity pertaining to distribution of the software
  23.  * without specific, written prior permission.  This software is made available
  24.  * "as is", and
  25.  * THE UNIVERSITY OF WASHINGTON DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
  26.  * WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT LIMITATION ALL IMPLIED
  27.  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND IN
  28.  * NO EVENT SHALL THE UNIVERSITY OF WASHINGTON BE LIABLE FOR ANY SPECIAL,
  29.  * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  30.  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, TORT
  31.  * (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF OR IN CONNECTION
  32.  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  33.  *
  34.  */
  36. #undef write /* don't use redefined write() */
  37.  
  38. static tcptimeout_t tmoh = NIL; /* TCP timeout handler routine */
  39. static long ttmo_open = 0; /* TCP timeouts, in seconds */
  40. static long ttmo_read = 0;
  41. static long ttmo_write = 0;
  42. static long allowreversedns = /* allow reverse DNS lookup */
  43. #ifdef DISABLE_REVERSE_DNS_LOOKUP
  44.   NIL /* Not recommended, especially if using Kerberos authentication */
  45. #else
  46.   T
  47. #endif
  48.   ;
  50. /* Local function prototypes */
  52. int tcp_socket_open (struct sockaddr_in *sin,char *tmp,int *ctr,char *hst,
  53.      unsigned long port);
  54. long tcp_abort (TCPSTREAM *stream);
  55. char *tcp_name (struct sockaddr_in *sin,long flag);
  57. /* TCP/IP manipulate parameters
  58.  * Accepts: function code
  59.  *     function-dependent value
  60.  * Returns: function-dependent return value
  61.  */
  63. void *tcp_parameters (long function,void *value)
  64. {
  65.   switch ((int) function) {
  66.   case SET_TIMEOUT:
  67.     tmoh = (tcptimeout_t) value;
  68.     break;
  69.   case GET_TIMEOUT:
  70.     value = (void *) tmoh;
  71.     break;
  72.   case SET_OPENTIMEOUT:
  73.     ttmo_open = (long) value;
  74.     break;
  75.   case GET_OPENTIMEOUT:
  76.     value = (void *) ttmo_open;
  77.     break;
  78.   case SET_READTIMEOUT:
  79.     ttmo_read = (long) value;
  80.     break;
  81.   case GET_READTIMEOUT:
  82.     value = (void *) ttmo_read;
  83.     break;
  84.   case SET_WRITETIMEOUT:
  85.     ttmo_write = (long) value;
  86.     break;
  87.   case GET_WRITETIMEOUT:
  88.     value = (void *) ttmo_write;
  89.     break;
  90.   case SET_ALLOWREVERSEDNS:
  91.     allowreversedns = (long) value;
  92.     break;
  93.   case GET_ALLOWREVERSEDNS:
  94.     value = (void *) allowreversedns;
  95.     break;
  96.   default:
  97.     value = NIL; /* error case */
  98.     break;
  99.   }
  100.   return value;
  101. }
  103. /* TCP/IP open
  104.  * Accepts: host name
  105.  *     contact service name
  106.  *     contact port number and optional silent flag
  107.  * Returns: TCP/IP stream if success else NIL
  108.  */
  110. TCPSTREAM *tcp_open (char *host,char *service,unsigned long port)
  111. {
  112.   TCPSTREAM *stream = NIL;
  113.   int i,sock;
  114.   int ctr = 0;
  115.   int silent = (port & 0x80000000) ? T : NIL;
  116.   int *ctrp = &ctr;
  117.   char *s;
  118.   struct sockaddr_in sin;
  119.   struct hostent *he;
  120.   char hostname[MAILTMPLEN];
  121.   char tmp[MAILTMPLEN];
  122.   struct servent *sv = NIL;
  123.   blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  124.   void *data;
  125.   port &= 0x7fffffff; /* erase silent flag */
  126.   if (service) { /* service specified? */
  127.     if (*service == '*') { /* yes, special alt driver kludge? */
  128.       ctrp = NIL; /* yes, don't do open timeout */
  129.       sv = getservbyname (service + 1,"tcp");
  130.     }
  131.     else sv = getservbyname (service,"tcp");
  132.   }
  133. /* user service name port */
  134.   if (sv) port = ntohs (sin.sin_port = sv->s_port);
  135.   /* copy port number in network format */
  136.   else sin.sin_port = htons (port);
  137.   /* The domain literal form is used (rather than simply the dotted decimal
  138.      as with other Amiga programs) because it has to be a valid "host name"
  139.      in mailsystem terminology. */
  140. /* look like domain literal? */
  141.   if (host[0] == '[' && host[(strlen (host))-1] == ']') {
  142.     strcpy (hostname,host+1); /* yes, copy number part */
  143.     hostname[(strlen (hostname))-1] = '';
  144.     if ((sin.sin_addr.s_addr = inet_addr (hostname)) != -1) {
  145.       sin.sin_family = AF_INET; /* family is always Internet */
  146.       strcpy (hostname,host); /* hostname is user's argument */
  147. /* get an open socket for this system */
  148.       sock = tcp_socket_open (&sin,tmp,ctrp,hostname,port);
  149.     }
  150.     else {
  151.       sprintf (tmp,"Bad format domain-literal: %.80s",host);
  152.       mm_log (tmp,ERROR);
  153.       return NIL;
  154.     }
  155.   }
  157.   else { /* lookup host name */
  158.     (*bn) (BLOCK_DNSLOOKUP,NIL);
  159.     data = (*bn) (BLOCK_SENSITIVE,NIL);
  160. /* quell alarms */
  161.     if (he = gethostbyname (lcase (strcpy (hostname,host)))) {
  162.       (*bn) (BLOCK_NONSENSITIVE,data);
  163.       (*bn) (BLOCK_NONE,NIL);
  164. /* copy address type */
  165.       sin.sin_family = he->h_addrtype;
  166. /* copy host name */
  167.       strcpy (hostname,he->h_name);
  168. #ifdef HOST_NOT_FOUND /* muliple addresses only on DNS systems */
  169.       for (sock = -1,i = 0; (sock < 0) && (s = he->h_addr_list[i]); i++) {
  170. if (i && !silent) mm_log (tmp,WARN);
  171. memcpy (&sin.sin_addr,s,he->h_length);
  172. (*bn) (BLOCK_TCPOPEN,NIL);
  173. sock = tcp_socket_open (&sin,tmp,ctrp,hostname,port);
  174. (*bn) (BLOCK_NONE,NIL);
  175.       }
  176. #else /* the one true address then */
  177.       memcpy (&sin.sin_addr,he->h_addr,he->h_length);
  178.       (*bn) (BLOCK_DNSLOOKUP,NIL);
  179.       sock = tcp_socket_open (&sin,tmp,ctrp,hostname,port);
  180.       (*bn) (BLOCK_NONE,NIL);
  181. #endif
  182.     }
  183.     else {
  184.       (*bn) (BLOCK_NONSENSITIVE,data);
  185.       (*bn) (BLOCK_NONE,NIL);
  186.       sprintf (tmp,"No such host as %.80s",host);
  187.       mm_log (tmp,ERROR);
  188.       return NIL;
  189.     }
  190.   }
  191.   if (sock >= 0)  { /* won */
  192.     stream = (TCPSTREAM *) memset (fs_get (sizeof (TCPSTREAM)),0,
  193.    sizeof (TCPSTREAM));
  194.     stream->port = port; /* port number */
  195. /* init sockets */
  196.     stream->tcpsi = stream->tcpso = sock;
  197. /* stash in the snuck-in byte */
  198.     if (stream->ictr = ctr) *(stream->iptr = stream->ibuf) = tmp[0];
  199. /* copy official host name */
  200.     stream->host = cpystr (hostname);
  201.   }
  202.   else if (!silent) mm_log (tmp,ERROR);
  203.   return stream; /* return success */
  204. }
  206. /* Open a TCP socket
  207.  * Accepts: Internet socket address block
  208.  *     scratch buffer
  209.  *     pointer to "first byte read in" storage or NIL
  210.  *     host name for error message
  211.  *     port number for error message
  212.  * Returns: socket if success, else -1 with error string in scratch buffer
  213.  */
  215. int tcp_socket_open (struct sockaddr_in *sin,char *tmp,int *ctr,char *hst,
  216.      unsigned long port)
  217. {
  218.   int i,sock,flgs;
  219.   struct protoent *pt = getprotobyname ("ip");
  220.   fd_set fds,efds;
  221.   struct timeval tmo;
  222.   sprintf (tmp,"Trying IP address [%s]",inet_ntoa (sin->sin_addr));
  223.   mm_log (tmp,NIL);
  224. /* make a socket */
  225.   if ((sock = socket (sin->sin_family,SOCK_STREAM,pt ? pt->p_proto : 0)) < 0) {
  226.     sprintf (tmp,"Unable to create TCP socket: %s",strerror (errno));
  227.     return -1;
  228.   }
  229.   if (!ctr) { /* no open timeout wanted */
  230. /* open connection */
  231.     while ((i = connect (sock,(struct sockaddr *) sin,
  232.  sizeof (struct sockaddr_in))) < 0 && errno == EINTR);
  233.     if (i < 0) { /* failed? */
  234.       sprintf (tmp,"Can't connect to %.80s,%lu: %s",hst,port,strerror (errno));
  235.       close (sock); /* flush socket */
  236.       return -1;
  237.     }
  238.   }
  240.   else { /*  want open timeout */
  241. /* get current socket flags */
  242.     flgs = fcntl (sock,F_GETFL,0);
  243. /* set non-blocking */
  244.     fcntl (sock,F_SETFL,flgs | FNDELAY);
  245. /* open connection */
  246.     while ((i = connect (sock,(struct sockaddr *) sin,
  247.        sizeof (struct sockaddr_in))) < 0 && errno == EINTR);
  248.     if (i < 0) switch (errno) { /* failed? */
  249.     case EAGAIN: /* DG brain damage */
  250.     case EINPROGRESS: /* what we expect to happen */
  251.     case EISCONN: /* restart after interrupt? */
  252.     case EADDRINUSE: /* restart after interrupt? */
  253.       break; /* well, not really, it was interrupted */
  254.     default:
  255.       sprintf (tmp,"Can't connect to %.80s,%lu: %s",hst,port,strerror (errno));
  256.       close (sock); /* flush socket */
  257.       return -1;
  258.     }
  259.     tmo.tv_sec = ttmo_open; /* open timeout */
  260.     tmo.tv_usec = 0;
  261.     FD_ZERO (&fds); /* initialize selection vector */
  262.     FD_ZERO (&efds); /* handle errors too */
  263.     FD_SET (sock,&fds); /* block for error or writeable */
  264.     FD_SET (sock,&efds);
  265. /* block under timeout */
  266.     while (((i = select (sock+1,0,&fds,&efds,ttmo_open ? &tmo : 0)) < 0) &&
  267.    (errno == EINTR));
  268.     if (i > 0) { /* success, make sure really connected */
  269.       fcntl (sock,F_SETFL,flgs);/* restore blocking status */
  270.       /* This used to be a zero-byte read(), but that crashes Solaris */
  271. /* get socket status */
  272.       while (((i = *ctr = read (sock,tmp,1)) < 0) && (errno == EINTR));
  273.     }
  274.     if (i <= 0) { /* timeout or error? */
  275.       i = i ? errno : ETIMEDOUT;/* determine error code */
  276.       close (sock); /* flush socket */
  277.       errno = i; /* return error code */
  278.       sprintf (tmp,"Connection failed to %.80s,%lu: %s",hst,port,
  279.        strerror (errno));
  280.       return -1;
  281.     }
  282.   }
  283.   return sock; /* return the socket */
  284. }
  285.   
  286. /* TCP/IP authenticated open
  287.  * Accepts: host name
  288.  *     service name
  289.  *     returned user name buffer
  290.  * Returns: TCP/IP stream if success else NIL
  291.  */
  293. #define MAXARGV 10
  295. TCPSTREAM *tcp_aopen (NETMBX *mb,char *service,char *usrbuf)
  296. {
  297.   return NIL; /* disabled */
  298. }
  300. /* TCP/IP receive line
  301.  * Accepts: TCP/IP stream
  302.  * Returns: text line string or NIL if failure
  303.  */
  305. char *tcp_getline (TCPSTREAM *stream)
  306. {
  307.   int n,m;
  308.   char *st,*ret,*stp;
  309.   char c = '';
  310.   char d;
  311. /* make sure have data */
  312.   if (!tcp_getdata (stream)) return NIL;
  313.   st = stream->iptr; /* save start of string */
  314.   n = 0; /* init string count */
  315.   while (stream->ictr--) { /* look for end of line */
  316.     d = *stream->iptr++; /* slurp another character */
  317.     if ((c == '15') && (d == '12')) {
  318.       ret = (char *) fs_get (n--);
  319.       memcpy (ret,st,n); /* copy into a free storage string */
  320.       ret[n] = ''; /* tie off string with null */
  321.       return ret;
  322.     }
  323.     n++; /* count another character searched */
  324.     c = d; /* remember previous character */
  325.   }
  326. /* copy partial string from buffer */
  327.   memcpy ((ret = stp = (char *) fs_get (n)),st,n);
  328. /* get more data from the net */
  329.   if (!tcp_getdata (stream)) fs_give ((void **) &ret);
  330. /* special case of newline broken by buffer */
  331.   else if ((c == '15') && (*stream->iptr == '12')) {
  332.     stream->iptr++; /* eat the line feed */
  333.     stream->ictr--;
  334.     ret[n - 1] = ''; /* tie off string with null */
  335.   }
  336. /* else recurse to get remainder */
  337.   else if (st = tcp_getline (stream)) {
  338.     ret = (char *) fs_get (n + 1 + (m = strlen (st)));
  339.     memcpy (ret,stp,n); /* copy first part */
  340.     memcpy (ret + n,st,m); /* and second part */
  341.     fs_give ((void **) &stp); /* flush first part */
  342.     fs_give ((void **) &st); /* flush second part */
  343.     ret[n + m] = ''; /* tie off string with null */
  344.   }
  345.   return ret;
  346. }
  348. /* TCP/IP receive buffer
  349.  * Accepts: TCP/IP stream
  350.  *     size in bytes
  351.  *     buffer to read into
  352.  * Returns: T if success, NIL otherwise
  353.  */
  355. long tcp_getbuffer (TCPSTREAM *stream,unsigned long size,char *buffer)
  356. {
  357.   unsigned long n;
  358.   char *bufptr = buffer;
  359.   while (size > 0) { /* until request satisfied */
  360.     if (!tcp_getdata (stream)) return NIL;
  361.     n = min (size,stream->ictr);/* number of bytes to transfer */
  362. /* do the copy */
  363.     memcpy (bufptr,stream->iptr,n);
  364.     bufptr += n; /* update pointer */
  365.     stream->iptr +=n;
  366.     size -= n; /* update # of bytes to do */
  367.     stream->ictr -=n;
  368.   }
  369.   bufptr[0] = ''; /* tie off string */
  370.   return T;
  371. }
  373. /* TCP/IP receive data
  374.  * Accepts: TCP/IP stream
  375.  * Returns: T if success, NIL otherwise
  376.  */
  378. long tcp_getdata (TCPSTREAM *stream)
  379. {
  380.   int i;
  381.   fd_set fds,efds;
  382.   struct timeval tmo;
  383.   time_t t = time (0);
  384.   blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  385.   if (stream->tcpsi < 0) return NIL;
  386.   (*bn) (BLOCK_TCPREAD,NIL);
  387.   while (stream->ictr < 1) { /* if nothing in the buffer */
  388.     time_t tl = time (0); /* start of request */
  389.     tmo.tv_sec = ttmo_read; /* read timeout */
  390.     tmo.tv_usec = 0;
  391.     FD_ZERO (&fds); /* initialize selection vector */
  392.     FD_ZERO (&efds); /* handle errors too */
  393.     FD_SET (stream->tcpsi,&fds);/* set bit in selection vector */
  394.     FD_SET(stream->tcpsi,&efds);/* set bit in error selection vector */
  395.     errno = NIL; /* block and read */
  396.     while (((i = select (stream->tcpsi+1,&fds,0,&efds,ttmo_read ? &tmo : 0))<0)
  397.    && (errno == EINTR));
  398.     if (!i) { /* timeout? */
  399.       time_t tc = time (0);
  400.       if (tmoh && ((*tmoh) (tc - t,tc - tl))) continue;
  401.       else return tcp_abort (stream);
  402.     }
  403.     else if (i < 0) return tcp_abort (stream);
  404.     while (((i = read (stream->tcpsi,stream->ibuf,BUFLEN)) < 0) &&
  405.    (errno == EINTR));
  406.     if (i < 1) return tcp_abort (stream);
  407.     stream->iptr = stream->ibuf;/* point at TCP buffer */
  408.     stream->ictr = i; /* set new byte count */
  409.   }
  410.   (*bn) (BLOCK_NONE,NIL);
  411.   return T;
  412. }
  414. /* TCP/IP send string as record
  415.  * Accepts: TCP/IP stream
  416.  *     string pointer
  417.  * Returns: T if success else NIL
  418.  */
  420. long tcp_soutr (TCPSTREAM *stream,char *string)
  421. {
  422.   return tcp_sout (stream,string,(unsigned long) strlen (string));
  423. }
  426. /* TCP/IP send string
  427.  * Accepts: TCP/IP stream
  428.  *     string pointer
  429.  *     byte count
  430.  * Returns: T if success else NIL
  431.  */
  433. long tcp_sout (TCPSTREAM *stream,char *string,unsigned long size)
  434. {
  435.   int i;
  436.   fd_set fds;
  437.   struct timeval tmo;
  438.   time_t t = time (0);
  439.   blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  440.   if (stream->tcpso < 0) return NIL;
  441.   (*bn) (BLOCK_TCPWRITE,NIL);
  442.   while (size > 0) { /* until request satisfied */
  443.     time_t tl = time (0); /* start of request */
  444.     tmo.tv_sec = ttmo_write; /* write timeout */
  445.     tmo.tv_usec = 0;
  446.     FD_ZERO (&fds); /* initialize selection vector */
  447.     FD_SET (stream->tcpso,&fds);/* set bit in selection vector */
  448.     errno = NIL; /* block and write */
  449.     while (((i = select (stream->tcpso+1,0,&fds,0,ttmo_write ? &tmo : 0)) < 0)
  450.    && (errno == EINTR));
  451.     if (!i) { /* timeout? */
  452.       time_t tc = time (0);
  453.       if (tmoh && ((*tmoh) (tc - t,tc - tl))) continue;
  454.       else return tcp_abort (stream);
  455.     }
  456.     else if (i < 0) return tcp_abort (stream);
  457.     while (((i = write (stream->tcpso,string,size)) < 0) && (errno == EINTR));
  458.     if (i < 0) return tcp_abort (stream);
  459.     size -= i; /* how much we sent */
  460.     string += i;
  461.   }
  462.   (*bn) (BLOCK_NONE,NIL);
  463.   return T; /* all done */
  464. }
  466. /* TCP/IP close
  467.  * Accepts: TCP/IP stream
  468.  */
  470. void tcp_close (TCPSTREAM *stream)
  471. {
  472.   tcp_abort (stream); /* nuke the stream */
  473. /* flush host names */
  474.   if (stream->host) fs_give ((void **) &stream->host);
  475.   if (stream->remotehost) fs_give ((void **) &stream->remotehost);
  476.   if (stream->localhost) fs_give ((void **) &stream->localhost);
  477.   fs_give ((void **) &stream); /* flush the stream */
  478. }
  481. /* TCP/IP abort stream
  482.  * Accepts: TCP/IP stream
  483.  * Returns: NIL always
  484.  */
  486. long tcp_abort (TCPSTREAM *stream)
  487. {
  488.   blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  489.   if (stream->tcpsi >= 0) { /* no-op if no socket */
  490.     (*bn) (BLOCK_TCPCLOSE,NIL);
  491.     close (stream->tcpsi); /* nuke the socket */
  492.     if (stream->tcpsi != stream->tcpso) close (stream->tcpso);
  493.     stream->tcpsi = stream->tcpso = -1;
  494.   }
  495.   (*bn) (BLOCK_NONE,NIL);
  496.   return NIL;
  497. }
  499. /* TCP/IP get host name
  500.  * Accepts: TCP/IP stream
  501.  * Returns: host name for this stream
  502.  */
  504. char *tcp_host (TCPSTREAM *stream)
  505. {
  506.   return stream->host; /* use tcp_remotehost() if want guarantees */
  507. }
  510. /* TCP/IP get remote host name
  511.  * Accepts: TCP/IP stream
  512.  * Returns: host name for this stream
  513.  */
  515. char *tcp_remotehost (TCPSTREAM *stream)
  516. {
  517.   if (!stream->remotehost) {
  518.     struct sockaddr_in sin;
  519.     int sinlen = sizeof (struct sockaddr_in);
  520.     stream->remotehost = /* get socket's peer name */
  521.       getpeername (stream->tcpsi,(struct sockaddr *) &sin,(void *) &sinlen) ?
  522. cpystr (stream->host) : tcp_name (&sin,NIL);
  523.   }
  524.   return stream->remotehost;
  525. }
  528. /* TCP/IP return port for this stream
  529.  * Accepts: TCP/IP stream
  530.  * Returns: port number for this stream
  531.  */
  533. unsigned long tcp_port (TCPSTREAM *stream)
  534. {
  535.   return stream->port; /* return port number */
  536. }
  539. /* TCP/IP get local host name
  540.  * Accepts: TCP/IP stream
  541.  * Returns: local host name
  542.  */
  544. char *tcp_localhost (TCPSTREAM *stream)
  545. {
  546.   if (!stream->localhost) {
  547.     struct sockaddr_in sin;
  548.     int sinlen = sizeof (struct sockaddr_in);
  549.     stream->localhost = /* get socket's name */
  550.       ((stream->port & 0xffff000) ||
  551.        getsockname (stream->tcpsi,(struct sockaddr *) &sin,(void *) &sinlen)) ?
  552.  cpystr (mylocalhost ()) : tcp_name (&sin,NIL);
  553.   }
  554.   return stream->localhost; /* return local host name */
  555. }
  557. /* TCP/IP get client host name (server calls only)
  558.  * Returns: client host name
  559.  */
  561. static char *myClientHost = NIL;
  563. char *tcp_clienthost ()
  564. {
  565.   if (!myClientHost) {
  566.     struct sockaddr_in sin;
  567.     int sinlen = sizeof (struct sockaddr_in);
  568. /* get stdin's peer name */
  569.     myClientHost = getpeername (0,(struct sockaddr *) &sin,(void *) &sinlen) ?
  570.       cpystr ("UNKNOWN") : tcp_name (&sin,T);
  571.   }
  572.   return myClientHost;
  573. }
  576. /* TCP/IP get server host name (server calls only)
  577.  * Returns: server host name
  578.  */
  580. static char *myServerHost = NIL;
  581. static long myServerPort = -1;
  583. char *tcp_serverhost ()
  584. {
  585.   if (!myServerHost) {
  586.     struct sockaddr_in sin;
  587.     int sinlen = sizeof (struct sockaddr_in);
  588. /* get stdin's name */
  589.     if (getsockname (0,(struct sockaddr *) &sin,(void *) &sinlen))
  590.       myServerHost = cpystr (mylocalhost ());
  591.     else {
  592.       myServerHost = tcp_name (&sin,NIL);
  593.       myServerPort = ntohs (sin.sin_port);
  594.     }
  595.   }
  596.   return myServerHost;
  597. }
  600. /* TCP/IP get server port number (server calls only)
  601.  * Returns: server port number
  602.  */
  604. long tcp_serverport ()
  605. {
  606.   if (!myServerHost) tcp_serverhost ();
  607.   return myServerPort;
  608. }
  610. /* TCP/IP return canonical form of host name
  611.  * Accepts: host name
  612.  * Returns: canonical form of host name
  613.  */
  615. char *tcp_canonical (char *name)
  616. {
  617.   char *ret,host[MAILTMPLEN];
  618.   struct hostent *he;
  619.   blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  620.   void *data;
  621. /* look like domain literal? */
  622.   if (name[0] == '[' && name[strlen (name) - 1] == ']') return name;
  623.   (*bn) (BLOCK_DNSLOOKUP,NIL);
  624.   data = (*bn) (BLOCK_SENSITIVE,NIL);
  625. /* note that Amiga requires lowercase! */
  626.   ret = (he = gethostbyname (lcase (strcpy (host,name)))) ? he->h_name : name;
  627.   (*bn) (BLOCK_NONSENSITIVE,data);
  628.   (*bn) (BLOCK_NONE,NIL);
  629.   return ret;
  630. }
  633. /* TCP/IP return name from socket
  634.  * Accepts: socket
  635.  *     verbose flag
  636.  * Returns: cpystr name
  637.  */
  639. char *tcp_name (struct sockaddr_in *sin,long flag)
  640. {
  641.   char *s,tmp[MAILTMPLEN];
  642.   if (allowreversedns) {
  643.     struct hostent *he;
  644.     blocknotify_t bn = (blocknotify_t)mail_parameters(NIL,GET_BLOCKNOTIFY,NIL);
  645.     void *data;
  646.     (*bn) (BLOCK_DNSLOOKUP,NIL);
  647.     data = (*bn) (BLOCK_SENSITIVE,NIL);
  648. /* translate address to name */
  649.     if (!(he = gethostbyaddr ((char *) &sin->sin_addr,
  650.       sizeof (struct in_addr),sin->sin_family)))
  651.       sprintf (s = tmp,"[%s]",inet_ntoa (sin->sin_addr));
  652.     else if (flag) sprintf (s = tmp,"%s [%s]",he->h_name,
  653.     inet_ntoa (sin->sin_addr));
  654.     else s = he->h_name;
  655.     (*bn) (BLOCK_NONSENSITIVE,data);
  656.     (*bn) (BLOCK_NONE,NIL);
  657.   }
  658.   else sprintf (s = tmp,"[%s]",inet_ntoa (sin->sin_addr));
  659.   return cpystr (s);
  660. }