tcp_unix.c

广泛使用的邮件服务器！同时

      tmo.tv_sec = ti ? ti - now : 0;
      i = select (stream->tcpso+1,NIL,&fds,&efds,ti ? &tmo : NIL);
      now = time (0);		/* fake timeout if interrupt & time expired */
      if ((i < 0) && (errno == EINTR) && ti && (ti <= now)) i = 0;
    } while ((i < 0) && (errno == EINTR));
    if (i) {			/* non-timeout result from select? */
				/* write what we can */
      if (i > 0) while (((i = write (stream->tcpso,string,size)) < 0) &&
			(errno == EINTR));
      if (i <= 0) {		/* error seen? */
	if (tcpdebug) {
	  char tmp[MAILTMPLEN];
	  sprintf (tmp,"TCP write I/O error %d",errno);
	  mm_log (tmp,TCPDEBUG);
	}
	return tcp_abort (stream);
      }
      string += i;		/* how much we sent */
      size -= i;		/* count this size */
      if (tcpdebug) mm_log ("successfully wrote to TCP",TCPDEBUG);
    }
				/* timeout, punt unless told not to */
    else if (!tmoh || !(*tmoh) (now - t,now - tl)) {
      if (tcpdebug) mm_log ("TCP write timeout",TCPDEBUG);
      return tcp_abort (stream);
    }
  }
  (*bn) (BLOCK_NONE,NIL);
  return T;			/* all done */
}

/* TCP/IP close
 * Accepts: TCP/IP stream
 */

void tcp_close (TCPSTREAM *stream)
{
  tcp_abort (stream);		/* nuke the stream */
				/* flush host names */
  if (stream->host) fs_give ((void **) &stream->host);
  if (stream->remotehost) fs_give ((void **) &stream->remotehost);
  if (stream->localhost) fs_give ((void **) &stream->localhost);
  fs_give ((void **) &stream);	/* flush the stream */
}


/* TCP/IP abort stream
 * Accepts: TCP/IP stream
 * Returns: NIL always
 */

long tcp_abort (TCPSTREAM *stream)
{
  blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  if (stream->tcpsi >= 0) {	/* no-op if no socket */
    (*bn) (BLOCK_TCPCLOSE,NIL);
    close (stream->tcpsi);	/* nuke the socket */
    if (stream->tcpsi != stream->tcpso) close (stream->tcpso);
    stream->tcpsi = stream->tcpso = -1;
  }
  (*bn) (BLOCK_NONE,NIL);
  return NIL;
}

/* TCP/IP get host name
 * Accepts: TCP/IP stream
 * Returns: host name for this stream
 */

char *tcp_host (TCPSTREAM *stream)
{
  return stream->host;		/* use tcp_remotehost() if want guarantees */
}


/* TCP/IP get remote host name
 * Accepts: TCP/IP stream
 * Returns: host name for this stream
 */

char *tcp_remotehost (TCPSTREAM *stream)
{
  if (!stream->remotehost) {
    size_t sadrlen;
    struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
    stream->remotehost =	/* get socket's peer name */
      getpeername (stream->tcpsi,sadr,(void *) &sadrlen) ?
        cpystr (stream->host) : tcp_name (sadr,NIL);
    fs_give ((void **) &sadr);
  }
  return stream->remotehost;
}


/* TCP/IP return port for this stream
 * Accepts: TCP/IP stream
 * Returns: port number for this stream
 */

unsigned long tcp_port (TCPSTREAM *stream)
{
  return stream->port;		/* return port number */
}


/* TCP/IP get local host name
 * Accepts: TCP/IP stream
 * Returns: local host name
 */

char *tcp_localhost (TCPSTREAM *stream)
{
  if (!stream->localhost) {
    size_t sadrlen;
    struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
    stream->localhost =		/* get socket's name */
      ((stream->port & 0xffff000) ||
       getsockname (stream->tcpsi,sadr,(void *) &sadrlen)) ?
      cpystr (mylocalhost ()) : tcp_name (sadr,NIL);
    fs_give ((void **) &sadr);
  }
  return stream->localhost;	/* return local host name */
}

/* TCP/IP get client host address (server calls only)
 * Returns: client host address
 */

char *tcp_clientaddr ()
{
  if (!myClientAddr) {
    size_t sadrlen;
    struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
    if (getpeername (0,sadr,(void *) &sadrlen))
      myClientAddr = cpystr ("UNKNOWN");
    else {			/* get stdin's peer name */
      myClientAddr = cpystr (ip_sockaddrtostring (sadr));
      if (myClientPort < 0) myClientPort = ip_sockaddrtoport (sadr);
    }
    fs_give ((void **) &sadr);
  }
  return myClientAddr;
}


/* TCP/IP get client host name (server calls only)
 * Returns: client host name
 */

char *tcp_clienthost ()
{
  if (!myClientHost) {
    size_t sadrlen;
    struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
    if (getpeername (0,sadr,(void *) &sadrlen)) {
      char *s,*t,*v,tmp[MAILTMPLEN];
      if ((s = getenv (t = "SSH_CLIENT")) ||
	  (s = getenv (t = "KRB5REMOTEADDR")) ||
	  (s = getenv (t = "SSH2_CLIENT"))) {
	if (v = strchr (s,' ')) *v = '\0';
	sprintf (v = tmp,"%.80s=%.80s",t,s);
      }
      else v = "UNKNOWN";
      myClientHost = cpystr (v);
    }
    else {			/* get stdin's peer name */
      myClientHost = tcp_name (sadr,T);
      if (!myClientAddr) myClientAddr = cpystr (ip_sockaddrtostring (sadr));
      if (myClientPort < 0) myClientPort = ip_sockaddrtoport (sadr);
    }
    fs_give ((void **) &sadr);
  }
  return myClientHost;
}


/* TCP/IP get client port number (server calls only)
 * Returns: client port number
 */

long tcp_clientport ()
{
  if (!myClientHost && !myClientAddr) tcp_clientaddr ();
  return myClientPort;
}

/* TCP/IP get server host address (server calls only)
 * Returns: server host address
 */

char *tcp_serveraddr ()
{
  if (!myServerAddr) {
    size_t sadrlen;
    struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
    if (getsockname (0,sadr,(void *) &sadrlen))
      myServerAddr = cpystr ("UNKNOWN");
    else {			/* get stdin's name */
      myServerAddr = cpystr (ip_sockaddrtostring (sadr));
      if (myServerPort < 0) myServerPort = ip_sockaddrtoport (sadr);
    }
    fs_give ((void **) &sadr);
  }
  return myServerAddr;
}


/* TCP/IP get server host name (server calls only)
 * Returns: server host name
 */

char *tcp_serverhost ()
{
  if (!myServerHost) {		/* once-only */
    size_t sadrlen;
    struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
				/* get stdin's name */
    if (getsockname (0,sadr,(void *) &sadrlen))
      myServerHost = cpystr (mylocalhost ());
    else {			/* get stdin's name */
      myServerHost = tcp_name (sadr,NIL);
      if (!myServerAddr) myServerAddr = cpystr (ip_sockaddrtostring (sadr));
      if (myServerPort < 0) myServerPort = ip_sockaddrtoport (sadr);
    }
    fs_give ((void **) &sadr);
  }
  return myServerHost;
}


/* TCP/IP get server port number (server calls only)
 * Returns: server port number
 */

long tcp_serverport ()
{
  if (!myServerHost && !myServerAddr) tcp_serveraddr ();
  return myServerPort;
}

/* TCP/IP return canonical form of host name
 * Accepts: host name
 * Returns: canonical form of host name
 */

char *tcp_canonical (char *name)
{
  char *ret,host[MAILTMPLEN];
  blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
  void *data;
				/* look like domain literal? */
  if (name[0] == '[' && name[strlen (name) - 1] == ']') return name;
  (*bn) (BLOCK_DNSLOOKUP,NIL);	/* quell alarms */
  data = (*bn) (BLOCK_SENSITIVE,NIL);
  if (tcpdebug) {
    sprintf (host,"DNS canonicalization %.80s",name);
    mm_log (host,TCPDEBUG);
  }
				/* get canonical name */
  if (!ip_nametoaddr (name,NIL,NIL,&ret,NIL)) ret = name;
  (*bn) (BLOCK_NONSENSITIVE,data);
  (*bn) (BLOCK_NONE,NIL);	/* alarms OK now */
  if (tcpdebug) mm_log ("DNS canonicalization done",TCPDEBUG);
  return ret;
}

/* TCP/IP return name from socket
 * Accepts: socket
 *	    verbose flag
 * Returns: cpystr name
 */

char *tcp_name (struct sockaddr *sadr,long flag)
{
  char *ret,*t,adr[MAILTMPLEN],tmp[MAILTMPLEN];
  sprintf (ret = adr,"[%.80s]",ip_sockaddrtostring (sadr));
  if (allowreversedns) {
    blocknotify_t bn = (blocknotify_t)mail_parameters(NIL,GET_BLOCKNOTIFY,NIL);
    void *data;
    if (tcpdebug) {
      sprintf (tmp,"Reverse DNS resolution %s",adr);
      mm_log (tmp,TCPDEBUG);
    }
    (*bn) (BLOCK_DNSLOOKUP,NIL);/* quell alarms */
    data = (*bn) (BLOCK_SENSITIVE,NIL);
				/* translate address to name */
    if (t = tcp_name_valid (ip_sockaddrtoname (sadr))) {
				/* produce verbose form if needed */
      if (flag)	sprintf (ret = tmp,"%s %s",t,adr);
      else ret = t;
    }
    (*bn) (BLOCK_NONSENSITIVE,data);
    (*bn) (BLOCK_NONE,NIL);	/* alarms OK now */
    if (tcpdebug) mm_log ("Reverse DNS resolution done",TCPDEBUG);
  }
  return cpystr (ret);
}


/* TCP/IP validate name
 * Accepts: domain name
 * Returns: name if valid, NIL otherwise
 */

char *tcp_name_valid (char *s)
{
  int c;
  char *ret,*tail;
				/* must be non-empty and not too long */
  if ((ret = (s && *s) ? s : NIL) && (tail = ret + NETMAXHOST)) {
				/* must be alnum, dot, or hyphen */
    while ((c = *s++) && (s <= tail) &&
	   (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) ||
	    ((c >= '0') && (c <= '9')) || (c == '-') || (c == '.')));
    if (c) ret = NIL;
  }
  return ret;
}

/* TCP/IP check if client is given host name
 * Accepts: candidate host name
 * Returns: T if match, NIL otherwise
 */

long tcp_isclienthost (char *host)
{
  int family;
  size_t adrlen,sadrlen,len;
  void *adr,*next;
  struct sockaddr *sadr;
  long ret = NIL;
				/* make sure that myClientAddr is set */
  if (tcp_clienthost () && myClientAddr)
				/* get sockaddr of client */
    for (adr = ip_nametoaddr (host,&adrlen,&family,NIL,&next); adr && !ret;
	 adr = ip_nametoaddr (NIL,&adrlen,&family,NIL,&next)) {
				/* build sockaddr of given address */
      sadr = ip_sockaddr (family,adr,adrlen,1,&len);
      if (!strcmp (myClientAddr,ip_sockaddrtostring (sadr))) ret = LONGT;
      fs_give ((void **) &sadr);	/* done with client sockaddr */
    }
  return ret;
}

/* Following statement must be at end of this module */

#undef fork			/* undo any use of vfork() */