1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/src/osdep/wce/tcp_wce.c	Mon Sep 14 15:17:45 2009 +0900
     1.3 @@ -0,0 +1,818 @@
     1.4 +/* ========================================================================
     1.5 + * Copyright 1988-2008 University of Washington
     1.6 + *
     1.7 + * Licensed under the Apache License, Version 2.0 (the "License");
     1.8 + * you may not use this file except in compliance with the License.
     1.9 + * You may obtain a copy of the License at
    1.10 + *
    1.11 + *     http://www.apache.org/licenses/LICENSE-2.0
    1.12 + *
    1.13 + * 
    1.14 + * ========================================================================
    1.15 + */
    1.16 +
    1.17 +/*
    1.18 + * Program:	Winsock TCP/IP routines
    1.19 + *
    1.20 + * Author:	Mark Crispin from Mike Seibel's Winsock code
    1.21 + *		Networks and Distributed Computing
    1.22 + *		Computing & Communications
    1.23 + *		University of Washington
    1.24 + *		Administration Building, AG-44
    1.25 + *		Seattle, WA  98195
    1.26 + *		Internet: MRC@CAC.Washington.EDU
    1.27 + *
    1.28 + * Date:	11 April 1989
    1.29 + * Last Edited:	13 January 2008
    1.30 + */
    1.31 +
    1.32 +
    1.33 +#define TCPMAXSEND 32768
    1.34 +
    1.35 +/* Private functions */
    1.36 +
    1.37 +int tcp_socket_open (struct sockaddr_in *sin,char *tmp,char *hst,
    1.38 +		     unsigned long port);
    1.39 +static char *tcp_getline_work (TCPSTREAM *stream,unsigned long *size,
    1.40 +			       long *contd);
    1.41 +long tcp_abort (TCPSTREAM *stream);
    1.42 +long tcp_close_socket (SOCKET *sock);
    1.43 +char *tcp_name (struct sockaddr_in *sin,long flag);
    1.44 +char *tcp_name_valid (char *s);
    1.45 +
    1.46 +
    1.47 +/* Private data */
    1.48 +
    1.49 +int wsa_initted = 0;		/* init ? */
    1.50 +static int wsa_sock_open = 0;	/* keep track of open sockets */
    1.51 +static tcptimeout_t tmoh = NIL;	/* TCP timeout handler routine */
    1.52 +static long ttmo_read = 0;	/* TCP timeouts, in seconds */
    1.53 +static long ttmo_write = 0;
    1.54 +static long allowreversedns = T;/* allow reverse DNS lookup */
    1.55 +static long tcpdebug = NIL;	/* extra TCP debugging telemetry */
    1.56 +
    1.57 +/* TCP/IP manipulate parameters
    1.58 + * Accepts: function code
    1.59 + *	    function-dependent value
    1.60 + * Returns: function-dependent return value
    1.61 + */
    1.62 +
    1.63 +void *tcp_parameters (long function,void *value)
    1.64 +{
    1.65 +  void *ret = NIL;
    1.66 +  switch ((int) function) {
    1.67 +  case SET_TIMEOUT:
    1.68 +    tmoh = (tcptimeout_t) value;
    1.69 +  case GET_TIMEOUT:
    1.70 +    ret = (void *) tmoh;
    1.71 +    break;
    1.72 +  case SET_READTIMEOUT:
    1.73 +    ttmo_read = (long) value;
    1.74 +  case GET_READTIMEOUT:
    1.75 +    ret = (void *) ttmo_read;
    1.76 +    break;
    1.77 +  case SET_WRITETIMEOUT:
    1.78 +    ttmo_write = (long) value;
    1.79 +  case GET_WRITETIMEOUT:
    1.80 +    ret = (void *) ttmo_write;
    1.81 +    break;
    1.82 +  case SET_ALLOWREVERSEDNS:
    1.83 +    allowreversedns = (long) value;
    1.84 +  case GET_ALLOWREVERSEDNS:
    1.85 +    ret = (void *) allowreversedns;
    1.86 +    break;
    1.87 +  case SET_TCPDEBUG:
    1.88 +    tcpdebug = (long) value;
    1.89 +  case GET_TCPDEBUG:
    1.90 +    ret = (void *) tcpdebug;
    1.91 +    break;
    1.92 +  }
    1.93 +  return ret;
    1.94 +}
    1.95 +
    1.96 +/* TCP/IP open
    1.97 + * Accepts: host name
    1.98 + *	    contact service name
    1.99 + *	    contact port number and optional silent flag
   1.100 + * Returns: TCP/IP stream if success else NIL
   1.101 + */
   1.102 +
   1.103 +TCPSTREAM *tcp_open (char *host,char *service,unsigned long port)
   1.104 +{
   1.105 +  TCPSTREAM *stream = NIL;
   1.106 +  int i;
   1.107 +  SOCKET sock = INVALID_SOCKET;
   1.108 +  int silent = (port & NET_SILENT) ? T : NIL;
   1.109 +  char *s;
   1.110 +  struct sockaddr_in sin;
   1.111 +  struct hostent *he;
   1.112 +  char hostname[MAILTMPLEN];
   1.113 +  char tmp[MAILTMPLEN];
   1.114 +  struct servent *sv = NIL;
   1.115 +  blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
   1.116 +  if (!wsa_initted++) {		/* init Windows Sockets */
   1.117 +    WSADATA wsock;
   1.118 +    if (i = (int) WSAStartup (WSA_VERSION,&wsock)) {
   1.119 +      wsa_initted = 0;		/* in case we try again */
   1.120 +      sprintf (tmp,"Unable to start Windows Sockets (%d)",i);
   1.121 +      mm_log (tmp,ERROR);
   1.122 +      return NIL;
   1.123 +    }
   1.124 +  }
   1.125 +  port &= 0xffff;		/* erase flags */
   1.126 +				/* lookup service */
   1.127 +  if (service && (sv = getservbyname (service,"tcp")))
   1.128 +    port = ntohs (sin.sin_port = sv->s_port);
   1.129 + 				/* copy port number in network format */
   1.130 +  else sin.sin_port = htons ((u_short) port);
   1.131 +  /* The domain literal form is used (rather than simply the dotted decimal
   1.132 +     as with other Windows programs) because it has to be a valid "host name"
   1.133 +     in mailsystem terminology. */
   1.134 +  sin.sin_family = AF_INET;	/* family is always Internet */
   1.135 +				/* look like domain literal? */
   1.136 +  if (host[0] == '[' && host[(strlen (host))-1] == ']') {
   1.137 +    strcpy (tmp,host+1);	/* yes, copy number part */
   1.138 +    tmp[strlen (tmp)-1] = '\0';
   1.139 +    if ((sin.sin_addr.s_addr = inet_addr (tmp)) == INADDR_NONE) {
   1.140 +      sprintf (tmp,"Bad format domain-literal: %.80s",host);
   1.141 +      mm_log (tmp,ERROR);
   1.142 +      return NIL;
   1.143 +    }
   1.144 +    else {
   1.145 +      sin.sin_family = AF_INET;	/* family is always Internet */
   1.146 +      strcpy (hostname,host);
   1.147 +      (*bn) (BLOCK_TCPOPEN,NIL);
   1.148 +      sock = tcp_socket_open (&sin,tmp,hostname,port);
   1.149 +      (*bn) (BLOCK_NONE,NIL);
   1.150 +    }
   1.151 +  }
   1.152 +
   1.153 +  else {			/* lookup host name */
   1.154 +    if (tcpdebug) {
   1.155 +      sprintf (tmp,"DNS resolution %.80s",host);
   1.156 +      mm_log (tmp,TCPDEBUG);
   1.157 +    }
   1.158 +    (*bn) (BLOCK_DNSLOOKUP,NIL);/* look up name */
   1.159 +    if (!(he = gethostbyname (lcase (strcpy (tmp,host)))))
   1.160 +      sprintf (tmp,"Host not found (#%d): %s",WSAGetLastError(),host);
   1.161 +    (*bn) (BLOCK_NONE,NIL);
   1.162 +    if (he) {			/* DNS resolution won? */
   1.163 +      if (tcpdebug) mm_log ("DNS resolution done",TCPDEBUG);
   1.164 +				/* copy address type */
   1.165 +      sin.sin_family = he->h_addrtype;
   1.166 +				/* copy host name */
   1.167 +      strcpy (hostname,he->h_name);
   1.168 +      wsa_sock_open++;		/* prevent tcp_close_socket() from freeing in
   1.169 +				   loop */
   1.170 +      for (i = 0; (sock == INVALID_SOCKET) && (s = he->h_addr_list[i]); i++) {
   1.171 +	if (i && !silent) mm_log (tmp,WARN);
   1.172 +	memcpy (&sin.sin_addr,s,he->h_length);
   1.173 +	(*bn) (BLOCK_TCPOPEN,NIL);
   1.174 +	sock = tcp_socket_open (&sin,tmp,hostname,port);
   1.175 +	(*bn) (BLOCK_NONE,NIL);
   1.176 +      }
   1.177 +      wsa_sock_open--;		/* undo protection */
   1.178 +    }
   1.179 +  }
   1.180 +  if (sock == INVALID_SOCKET) {	/* error? */
   1.181 +    if (!silent) mm_log (tmp,ERROR);
   1.182 +    tcp_close_socket (&sock);	/* do possible cleanup action */
   1.183 +  }
   1.184 +  else {			/* got a socket, create TCP/IP stream */
   1.185 +    stream = (TCPSTREAM *) memset (fs_get (sizeof (TCPSTREAM)),0,
   1.186 +				   sizeof (TCPSTREAM));
   1.187 +    stream->port = port;	/* port number */
   1.188 +				/* init socket */
   1.189 +    stream->tcpsi = stream->tcpso = sock;
   1.190 +    stream->ictr = 0;		/* init input counter */
   1.191 +				/* copy official host name */
   1.192 +    stream->host = cpystr (hostname);
   1.193 +    if (tcpdebug) mm_log ("Stream open and ready for read",TCPDEBUG);
   1.194 +  }
   1.195 +  return stream;		/* return success */
   1.196 +}
   1.197 +
   1.198 +/* Open a TCP socket
   1.199 + * Accepts: Internet socket address block
   1.200 + *	    scratch buffer
   1.201 + *	    host name for error message
   1.202 + *	    port number for error message
   1.203 + * Returns: socket if success, else -1 with error string in scratch buffer
   1.204 + */
   1.205 +
   1.206 +int tcp_socket_open (struct sockaddr_in *sin,char *tmp,char *hst,
   1.207 +		     unsigned long port)
   1.208 +{
   1.209 +  int sock;
   1.210 +  char *s;
   1.211 +  sprintf (tmp,"Trying IP address [%s]",inet_ntoa (sin->sin_addr));
   1.212 +  mm_log (tmp,NIL);
   1.213 +				/* get a TCP stream */
   1.214 +  if ((sock = socket (sin->sin_family,SOCK_STREAM,0)) == INVALID_SOCKET) {
   1.215 +    sprintf (tmp,"Unable to create TCP socket (%d)",WSAGetLastError());
   1.216 +    return -1;
   1.217 +  }
   1.218 +  wsa_sock_open++;		/* count this socket as open */
   1.219 +				/* open connection */
   1.220 +  if (connect (sock,(struct sockaddr *) sin,sizeof (struct sockaddr_in)) ==
   1.221 +      SOCKET_ERROR) {
   1.222 +    switch (WSAGetLastError ()){/* analyze error */
   1.223 +    case WSAECONNREFUSED:
   1.224 +      s = "Refused";
   1.225 +      break;
   1.226 +    case WSAENOBUFS:
   1.227 +      s = "Insufficient system resources";
   1.228 +      break;
   1.229 +    case WSAETIMEDOUT:
   1.230 +      s = "Timed out";
   1.231 +      break;
   1.232 +    case WSAEHOSTUNREACH:
   1.233 +      s = "Host unreachable";
   1.234 +      break;
   1.235 +    default:
   1.236 +      s = "Unknown error";
   1.237 +      break;
   1.238 +    }
   1.239 +    sprintf (tmp,"Can't connect to %.80s,%ld: %s (%d)",hst,port,s,
   1.240 +	     WSAGetLastError ());
   1.241 +    tcp_close_socket (&sock);	/* flush socket */
   1.242 +    sock = INVALID_SOCKET;
   1.243 +  }
   1.244 +  return sock;			/* return the socket */
   1.245 +}
   1.246 +  
   1.247 +/* TCP/IP authenticated open
   1.248 + * Accepts: NETMBX specifier
   1.249 + *	    service name
   1.250 + *	    returned user name buffer
   1.251 + * Returns: TCP/IP stream if success else NIL
   1.252 + */
   1.253 +
   1.254 +TCPSTREAM *tcp_aopen (NETMBX *mb,char *service,char *usrbuf)
   1.255 +{
   1.256 +  return NIL;			/* always NIL on Windows */
   1.257 +}
   1.258 +
   1.259 +/* TCP receive line
   1.260 + * Accepts: TCP stream
   1.261 + * Returns: text line string or NIL if failure
   1.262 + */
   1.263 +
   1.264 +char *tcp_getline (TCPSTREAM *stream)
   1.265 +{
   1.266 +  unsigned long n,contd;
   1.267 +  char *ret = tcp_getline_work (stream,&n,&contd);
   1.268 +  if (ret && contd) {		/* got a line needing continuation? */
   1.269 +    STRINGLIST *stl = mail_newstringlist ();
   1.270 +    STRINGLIST *stc = stl;
   1.271 +    do {			/* collect additional lines */
   1.272 +      stc->text.data = (unsigned char *) ret;
   1.273 +      stc->text.size = n;
   1.274 +      stc = stc->next = mail_newstringlist ();
   1.275 +      ret = tcp_getline_work (stream,&n,&contd);
   1.276 +    } while (ret && contd);
   1.277 +    if (ret) {			/* stash final part of line on list */
   1.278 +      stc->text.data = (unsigned char *) ret;
   1.279 +      stc->text.size = n;
   1.280 +				/* determine how large a buffer we need */
   1.281 +      for (n = 0, stc = stl; stc; stc = stc->next) n += stc->text.size;
   1.282 +      ret = fs_get (n + 1);	/* copy parts into buffer */
   1.283 +      for (n = 0, stc = stl; stc; n += stc->text.size, stc = stc->next)
   1.284 +	memcpy (ret + n,stc->text.data,stc->text.size);
   1.285 +      ret[n] = '\0';
   1.286 +    }
   1.287 +    mail_free_stringlist (&stl);/* either way, done with list */
   1.288 +  }
   1.289 +  return ret;
   1.290 +}
   1.291 +
   1.292 +/* TCP receive line or partial line
   1.293 + * Accepts: TCP stream
   1.294 + *	    pointer to return size
   1.295 + *	    pointer to return continuation flag
   1.296 + * Returns: text line string, size and continuation flag, or NIL if failure
   1.297 + */
   1.298 +
   1.299 +static char *tcp_getline_work (TCPSTREAM *stream,unsigned long *size,
   1.300 +			       long *contd)
   1.301 +{
   1.302 +  unsigned long n;
   1.303 +  char *s,*ret,c,d;
   1.304 +  *contd = NIL;			/* assume no continuation */
   1.305 +				/* make sure have data */
   1.306 +  if (!tcp_getdata (stream)) return NIL;
   1.307 +  for (s = stream->iptr, n = 0, c = '\0'; stream->ictr--; n++, c = d) {
   1.308 +    d = *stream->iptr++;	/* slurp another character */
   1.309 +    if ((c == '\015') && (d == '\012')) {
   1.310 +      ret = (char *) fs_get (n--);
   1.311 +      memcpy (ret,s,*size = n);	/* copy into a free storage string */
   1.312 +      ret[n] = '\0';		/* tie off string with null */
   1.313 +      return ret;
   1.314 +    }
   1.315 +  }
   1.316 +				/* copy partial string from buffer */
   1.317 +  memcpy ((ret = (char *) fs_get (n)),s,*size = n);
   1.318 +				/* get more data from the net */
   1.319 +  if (!tcp_getdata (stream)) fs_give ((void **) &ret);
   1.320 +				/* special case of newline broken by buffer */
   1.321 +  else if ((c == '\015') && (*stream->iptr == '\012')) {
   1.322 +    stream->iptr++;		/* eat the line feed */
   1.323 +    stream->ictr--;
   1.324 +    ret[*size = --n] = '\0';	/* tie off string with null */
   1.325 +  }
   1.326 +  else *contd = LONGT;		/* continuation needed */
   1.327 +  return ret;
   1.328 +}
   1.329 +
   1.330 +/* TCP/IP receive buffer
   1.331 + * Accepts: TCP/IP stream
   1.332 + *	    size in bytes
   1.333 + *	    buffer to read into
   1.334 + * Returns: T if success, NIL otherwise
   1.335 + */
   1.336 +
   1.337 +long tcp_getbuffer (TCPSTREAM *stream,unsigned long size,char *s)
   1.338 +{
   1.339 +  unsigned long n;
   1.340 +				/* make sure socket still alive */
   1.341 +  if (stream->tcpsi == INVALID_SOCKET) return NIL;
   1.342 +				/* can transfer bytes from buffer? */
   1.343 +  if (n = min (size,stream->ictr)) {
   1.344 +    memcpy (s,stream->iptr,n);	/* yes, slurp as much as we can from it */
   1.345 +    s += n;			/* update pointer */
   1.346 +    stream->iptr +=n;
   1.347 +    size -= n;			/* update # of bytes to do */
   1.348 +    stream->ictr -=n;
   1.349 +  }
   1.350 +  if (size) {
   1.351 +    int i;
   1.352 +    fd_set fds;
   1.353 +    struct timeval tmo;
   1.354 +    time_t tc,t = time (0);
   1.355 +    blocknotify_t bn=(blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
   1.356 +    (*bn) (BLOCK_TCPREAD,NIL);
   1.357 +    while (size > 0) {		/* until request satisfied */
   1.358 +      time_t tl = time (0);
   1.359 +      if (tcpdebug) mm_log ("Reading TCP buffer",TCPDEBUG);
   1.360 +      FD_ZERO (&fds);		/* initialize selection vector */
   1.361 +      FD_SET (stream->tcpsi,&fds);/* set bit in selection vector */
   1.362 +      tmo.tv_sec = ttmo_read;
   1.363 +      tmo.tv_usec = 0;
   1.364 +				/* block and read */
   1.365 +      switch ((stream->tcpsi == stream->tcpso) ?
   1.366 +	      select (stream->tcpsi+1,&fds,0,0,
   1.367 +		      ttmo_read ? &tmo : (struct timeval *) 0) : 1) {
   1.368 +      case SOCKET_ERROR:		/* error */
   1.369 +	if (WSAGetLastError () != WSAEINTR) return tcp_abort (stream);
   1.370 +	break;
   1.371 +      case 0:			/* timeout */
   1.372 +	tc = time (0);
   1.373 +	if (tmoh && ((*tmoh) (tc - t,tc - tl))) break;
   1.374 +	return tcp_abort (stream);
   1.375 +      default:
   1.376 +	if (stream->tcpsi == stream->tcpso)
   1.377 +	  while (((i = recv (stream->tcpsi,s,(int) min (maxposint,size),0)) ==
   1.378 +		  SOCKET_ERROR) && (WSAGetLastError () == WSAEINTR));
   1.379 +	else while (((i = read (stream->tcpsi,s,(int) min (maxposint,size))) <
   1.380 +		     0) && (errno == EINTR));
   1.381 +	switch (i) {
   1.382 +	case SOCKET_ERROR:	/* error */
   1.383 +	case 0:			/* no data read */
   1.384 +	  return tcp_abort (stream);
   1.385 +	default:
   1.386 +	  s += i;		/* point at new place to write */
   1.387 +	  size -= i;		/* reduce byte count */
   1.388 +	  if (tcpdebug) mm_log ("Successfully read TCP buffer",TCPDEBUG);
   1.389 +	}
   1.390 +      }
   1.391 +    }
   1.392 +    (*bn) (BLOCK_NONE,NIL);
   1.393 +  }
   1.394 +  *s = '\0';			/* tie off string */
   1.395 +  return T;
   1.396 +}
   1.397 +
   1.398 +/* TCP/IP receive data
   1.399 + * Accepts: TCP/IP stream
   1.400 + * Returns: T if success, NIL otherwise
   1.401 + */
   1.402 +
   1.403 +long tcp_getdata (TCPSTREAM *stream)
   1.404 +{
   1.405 +  struct timeval tmo;
   1.406 +  int i;
   1.407 +  fd_set fds;
   1.408 +  time_t tc,t = time (0);
   1.409 +  blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
   1.410 +  FD_ZERO (&fds);		/* initialize selection vector */
   1.411 +  if (stream->tcpsi == INVALID_SOCKET) return NIL;
   1.412 +  (*bn) (BLOCK_TCPREAD,NIL);
   1.413 +  tmo.tv_sec = ttmo_read;
   1.414 +  tmo.tv_usec = 0;
   1.415 +  while (stream->ictr < 1) {	/* if nothing in the buffer */
   1.416 +    time_t tl = time (0);
   1.417 +    if (tcpdebug) mm_log ("Reading TCP data",TCPDEBUG);
   1.418 +    FD_SET (stream->tcpsi,&fds);/* set bit in selection vector */
   1.419 +				/* block and read */
   1.420 +    switch ((stream->tcpsi == stream->tcpso) ?
   1.421 +	    select (stream->tcpsi+1,&fds,0,0,
   1.422 +		    ttmo_read ? &tmo : (struct timeval *) 0) : 1) {
   1.423 +    case SOCKET_ERROR:		/* error */
   1.424 +      if (WSAGetLastError () != WSAEINTR) return tcp_abort (stream);
   1.425 +      break;
   1.426 +    case 0:			/* timeout */
   1.427 +      tc = time (0);
   1.428 +      if (tmoh && ((*tmoh) (tc - t,tc - tl))) break;
   1.429 +      return tcp_abort (stream);
   1.430 +    default:
   1.431 +      if (stream->tcpsi == stream->tcpso)
   1.432 +	while (((i = recv (stream->tcpsi,stream->ibuf,BUFLEN,0)) ==
   1.433 +		SOCKET_ERROR) && (WSAGetLastError () == WSAEINTR));
   1.434 +      else while (((i = read (stream->tcpsi,stream->ibuf,BUFLEN)) < 0) &&
   1.435 +		  (errno == EINTR));
   1.436 +      switch (i) {
   1.437 +      case SOCKET_ERROR:	/* error */
   1.438 +      case 0:			/* no data read */
   1.439 +	return tcp_abort (stream);
   1.440 +      default:
   1.441 +	stream->ictr = i;	/* set new byte count */
   1.442 +				/* point at TCP buffer */
   1.443 +	stream->iptr = stream->ibuf;
   1.444 +	if (tcpdebug) mm_log ("Successfully read TCP data",TCPDEBUG);
   1.445 +      }
   1.446 +    }
   1.447 +  }
   1.448 +  (*bn) (BLOCK_NONE,NIL);
   1.449 +  return T;
   1.450 +}
   1.451 +
   1.452 +/* TCP/IP send string as record
   1.453 + * Accepts: TCP/IP stream
   1.454 + *	    string pointer
   1.455 + * Returns: T if success else NIL
   1.456 + */
   1.457 +
   1.458 +long tcp_soutr (TCPSTREAM *stream,char *string)
   1.459 +{
   1.460 +  return tcp_sout (stream,string,(unsigned long) strlen (string));
   1.461 +}
   1.462 +
   1.463 +
   1.464 +/* TCP/IP send string
   1.465 + * Accepts: TCP/IP stream
   1.466 + *	    string pointer
   1.467 + *	    byte count
   1.468 + * Returns: T if success else NIL
   1.469 + */
   1.470 +
   1.471 +long tcp_sout (TCPSTREAM *stream,char *string,unsigned long size)
   1.472 +{
   1.473 +  int i;
   1.474 +  struct timeval tmo;
   1.475 +  fd_set fds;
   1.476 +  time_t tc,t = time (0);
   1.477 +  blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
   1.478 +  tmo.tv_sec = ttmo_write;
   1.479 +  tmo.tv_usec = 0;
   1.480 +  FD_ZERO (&fds);		/* initialize selection vector */
   1.481 +  if (stream->tcpso == INVALID_SOCKET) return NIL;
   1.482 +  (*bn) (BLOCK_TCPWRITE,NIL);
   1.483 +  while (size > 0) {		/* until request satisfied */
   1.484 +    time_t tl = time (0);
   1.485 +    if (tcpdebug) mm_log ("Writing to TCP",TCPDEBUG);
   1.486 +    FD_SET (stream->tcpso,&fds);/* set bit in selection vector */
   1.487 +				/* block and write */
   1.488 +    switch ((stream->tcpsi == stream->tcpso) ?
   1.489 +	    select (stream->tcpso+1,NULL,&fds,NULL,
   1.490 +		    tmo.tv_sec ? &tmo : (struct timeval *) 0) : 1) {
   1.491 +    case SOCKET_ERROR:		/* error */
   1.492 +      if (WSAGetLastError () != WSAEINTR) return tcp_abort (stream);
   1.493 +      break;
   1.494 +    case 0:			/* timeout */
   1.495 +      tc = time (0);
   1.496 +      if (tmoh && ((*tmoh) (tc - t,tc - tl))) break;
   1.497 +      return tcp_abort (stream);
   1.498 +    default:
   1.499 +      if (stream->tcpsi == stream->tcpso)
   1.500 +	while (((i = send (stream->tcpso,string,
   1.501 +			   (int) min (size,TCPMAXSEND),0)) == SOCKET_ERROR) &&
   1.502 +	       (WSAGetLastError () == WSAEINTR));
   1.503 +      else while (((i = write (stream->tcpso,string,
   1.504 +			       min (size,TCPMAXSEND))) < 0) &&
   1.505 +		  (errno == EINTR));
   1.506 +      if (i == SOCKET_ERROR) return tcp_abort (stream);
   1.507 +      size -= i;		/* count this size */
   1.508 +      if (tcpdebug) mm_log ("successfully wrote to TCP",TCPDEBUG);
   1.509 +      string += i;
   1.510 +    }
   1.511 +  }
   1.512 +  (*bn) (BLOCK_NONE,NIL);
   1.513 +  return T;			/* all done */
   1.514 +}
   1.515 +
   1.516 +
   1.517 +/* TCP/IP close
   1.518 + * Accepts: TCP/IP stream
   1.519 + */
   1.520 +
   1.521 +void tcp_close (TCPSTREAM *stream)
   1.522 +{
   1.523 +  tcp_abort (stream);		/* nuke the sockets */
   1.524 +				/* flush host names */
   1.525 +  if (stream->host) fs_give ((void **) &stream->host);
   1.526 +  if (stream->remotehost) fs_give ((void **) &stream->remotehost);
   1.527 +  if (stream->localhost) fs_give ((void **) &stream->localhost);
   1.528 +  fs_give ((void **) &stream);	/* flush the stream */
   1.529 +}
   1.530 +
   1.531 +
   1.532 +/* TCP/IP abort sockets
   1.533 + * Accepts: TCP/IP stream
   1.534 + * Returns: NIL, always
   1.535 + */
   1.536 +
   1.537 +long tcp_abort (TCPSTREAM *stream)
   1.538 +{
   1.539 +  if (stream->tcpsi != stream->tcpso) tcp_close_socket (&stream->tcpso);
   1.540 +  else stream->tcpso = INVALID_SOCKET;
   1.541 +  return tcp_close_socket (&stream->tcpsi);
   1.542 +}
   1.543 +
   1.544 +
   1.545 +/* TCP/IP abort stream
   1.546 + * Accepts: WinSock socket
   1.547 + * Returns: NIL, always
   1.548 + */
   1.549 +
   1.550 +long tcp_close_socket (SOCKET *sock)
   1.551 +{
   1.552 +  blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
   1.553 +				/* something to close? */
   1.554 +  if (sock && (*sock != INVALID_SOCKET)) {
   1.555 +    (*bn) (BLOCK_TCPCLOSE,NIL);
   1.556 +    closesocket (*sock);	/* WinSock socket close */
   1.557 +    *sock = INVALID_SOCKET;
   1.558 +    (*bn) (BLOCK_NONE,NIL);
   1.559 +    wsa_sock_open--;		/* drop this socket */
   1.560 +  }
   1.561 +				/* no more open streams? */
   1.562 +  if (wsa_initted && !wsa_sock_open) {
   1.563 +    mm_log ("Winsock cleanup",NIL);
   1.564 +    wsa_initted = 0;		/* no more sockets, so... */
   1.565 +    WSACleanup ();		/* free up resources until needed */
   1.566 +  }
   1.567 +  return NIL;
   1.568 +}
   1.569 +
   1.570 +/* TCP/IP get host name
   1.571 + * Accepts: TCP/IP stream
   1.572 + * Returns: host name for this stream
   1.573 + */
   1.574 +
   1.575 +char *tcp_host (TCPSTREAM *stream)
   1.576 +{
   1.577 +  return stream->host;		/* use tcp_remotehost() if want guarantees */
   1.578 +}
   1.579 +
   1.580 +
   1.581 +/* TCP/IP get remote host name
   1.582 + * Accepts: TCP/IP stream
   1.583 + * Returns: host name for this stream
   1.584 + */
   1.585 +
   1.586 +char *tcp_remotehost (TCPSTREAM *stream)
   1.587 +{
   1.588 +  if (!stream->remotehost) {
   1.589 +    struct sockaddr_in sin;
   1.590 +    int sinlen = sizeof (struct sockaddr_in);
   1.591 +    stream->remotehost =	/* get socket's peer name */
   1.592 +      ((getpeername (stream->tcpsi,(struct sockaddr *) &sin,&sinlen) ==
   1.593 +	SOCKET_ERROR) || (sinlen <= 0)) ?
   1.594 +	  cpystr (stream->host) : tcp_name (&sin,NIL);
   1.595 +  }
   1.596 +  return stream->remotehost;
   1.597 +}
   1.598 +
   1.599 +
   1.600 +/* TCP/IP return port for this stream
   1.601 + * Accepts: TCP/IP stream
   1.602 + * Returns: port number for this stream
   1.603 + */
   1.604 +
   1.605 +unsigned long tcp_port (TCPSTREAM *stream)
   1.606 +{
   1.607 +  return stream->port;		/* return port number */
   1.608 +}
   1.609 +
   1.610 +
   1.611 +/* TCP/IP get local host name
   1.612 + * Accepts: TCP/IP stream
   1.613 + * Returns: local host name
   1.614 + */
   1.615 +
   1.616 +char *tcp_localhost (TCPSTREAM *stream)
   1.617 +{
   1.618 +  if (!stream->localhost) {
   1.619 +    struct sockaddr_in sin;
   1.620 +    int sinlen = sizeof (struct sockaddr_in);
   1.621 +    stream->localhost =		/* get socket's name */
   1.622 +      ((stream->port & 0xffff000) ||
   1.623 +       ((getsockname (stream->tcpsi,(struct sockaddr *) &sin,&sinlen) ==
   1.624 +	 SOCKET_ERROR) || (sinlen <= 0))) ?
   1.625 +	   cpystr (mylocalhost ()) : tcp_name (&sin,NIL);
   1.626 +  }
   1.627 +  return stream->localhost;	/* return local host name */
   1.628 +}
   1.629 +
   1.630 +/* TCP/IP get client host address (server calls only)
   1.631 + * Returns: client host address
   1.632 + */
   1.633 +
   1.634 +char *tcp_clientaddr ()
   1.635 +{
   1.636 +  if (!myClientAddr) {
   1.637 +    struct sockaddr_in sin;
   1.638 +    int sinlen = sizeof (struct sockaddr_in);
   1.639 +    myClientAddr =		/* get stdin's peer name */
   1.640 +      ((getpeername (0,(struct sockaddr *) &sin,&sinlen) == SOCKET_ERROR) ||
   1.641 +       (sinlen <= 0)) ? cpystr ("UNKNOWN") : cpystr (inet_ntoa (sin.sin_addr));
   1.642 +  }
   1.643 +  return myClientAddr;
   1.644 +}
   1.645 +
   1.646 +
   1.647 +/* TCP/IP get client host name (server calls only)
   1.648 + * Returns: client host name
   1.649 + */
   1.650 +
   1.651 +char *tcp_clienthost ()
   1.652 +{
   1.653 +  if (!myClientHost) {
   1.654 +    struct sockaddr_in sin;
   1.655 +    int sinlen = sizeof (struct sockaddr_in);
   1.656 +    myClientHost =		/* get stdin's peer name */
   1.657 +      ((getpeername (0,(struct sockaddr *) &sin,&sinlen) == SOCKET_ERROR) ||
   1.658 +       (sinlen <= 0)) ? cpystr ("UNKNOWN") : tcp_name (&sin,T);
   1.659 +  }
   1.660 +  return myClientHost;
   1.661 +}
   1.662 +
   1.663 +/* TCP/IP get server host address (server calls only)
   1.664 + * Returns: server host address
   1.665 + */
   1.666 +
   1.667 +char *tcp_serveraddr ()
   1.668 +{
   1.669 +  if (!myServerAddr) {
   1.670 +    struct sockaddr_in sin;
   1.671 +    int sinlen = sizeof (struct sockaddr_in);
   1.672 +    myServerAddr =		/* get stdin's peer name */
   1.673 +      ((getsockname (0,(struct sockaddr *) &sin,&sinlen) == SOCKET_ERROR) ||
   1.674 +       (sinlen <= 0)) ? cpystr ("UNKNOWN") : cpystr (inet_ntoa (sin.sin_addr));
   1.675 +  }
   1.676 +  return myServerAddr;
   1.677 +}
   1.678 +
   1.679 +
   1.680 +/* TCP/IP get server host name (server calls only)
   1.681 + * Returns: server host name
   1.682 + */
   1.683 +
   1.684 +static long myServerPort = -1;
   1.685 +
   1.686 +char *tcp_serverhost ()
   1.687 +{
   1.688 +  if (!myServerHost) {
   1.689 +    struct sockaddr_in sin;
   1.690 +    int sinlen = sizeof (struct sockaddr_in);
   1.691 +    if (!wsa_initted++) {	/* init Windows Sockets */
   1.692 +      WSADATA wsock;
   1.693 +      if (WSAStartup (WSA_VERSION,&wsock)) {
   1.694 +	wsa_initted = 0;
   1.695 +	return "random-pc";	/* try again later? */
   1.696 +      }
   1.697 +    }
   1.698 +				/* get stdin's name */
   1.699 +    if ((getsockname (0,(struct sockaddr *) &sin,&sinlen) == SOCKET_ERROR) ||
   1.700 +	(sinlen <= 0)) myServerHost = cpystr (mylocalhost ());
   1.701 +    else {
   1.702 +      myServerHost = tcp_name (&sin,NIL);
   1.703 +      myServerPort = ntohs (sin.sin_port);
   1.704 +    }
   1.705 +  }
   1.706 +  return myServerHost;
   1.707 +}
   1.708 +
   1.709 +
   1.710 +/* TCP/IP get server port number (server calls only)
   1.711 + * Returns: server port number
   1.712 + */
   1.713 +
   1.714 +long tcp_serverport ()
   1.715 +{
   1.716 +  if (!myServerHost) tcp_serverhost ();
   1.717 +  return myServerPort;
   1.718 +}
   1.719 +
   1.720 +/* TCP/IP return canonical form of host name
   1.721 + * Accepts: host name
   1.722 + * Returns: canonical form of host name
   1.723 + */
   1.724 +
   1.725 +char *tcp_canonical (char *name)
   1.726 +{
   1.727 +  char *ret,host[MAILTMPLEN];
   1.728 +  struct hostent *he;
   1.729 +  blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
   1.730 +				/* look like domain literal? */
   1.731 +  if (name[0] == '[' && name[strlen (name) - 1] == ']') return name;
   1.732 +  (*bn) (BLOCK_DNSLOOKUP,NIL);
   1.733 +  if (tcpdebug) {
   1.734 +    sprintf (host,"DNS canonicalization %.80s",name);
   1.735 +    mm_log (host,TCPDEBUG);
   1.736 +  }
   1.737 +				/* note that NT requires lowercase! */
   1.738 +  ret = (he = gethostbyname (lcase (strcpy (host,name)))) ? he->h_name : name;
   1.739 +  (*bn) (BLOCK_NONE,NIL);
   1.740 +  if (tcpdebug) mm_log ("DNS canonicalization done",TCPDEBUG);
   1.741 +  return ret;
   1.742 +}
   1.743 +
   1.744 +
   1.745 +/* TCP/IP return name from socket
   1.746 + * Accepts: socket
   1.747 + *	    verbose flag
   1.748 + * Returns: cpystr name
   1.749 + */
   1.750 +
   1.751 +char *tcp_name (struct sockaddr_in *sin,long flag)
   1.752 +{
   1.753 +  char *ret,*t,adr[MAILTMPLEN],tmp[MAILTMPLEN];
   1.754 +  sprintf (ret = adr,"[%.80s]",inet_ntoa (sin->sin_addr));
   1.755 +  if (allowreversedns) {
   1.756 +    struct hostent *he;
   1.757 +    blocknotify_t bn = (blocknotify_t)mail_parameters(NIL,GET_BLOCKNOTIFY,NIL);
   1.758 +    void *data;
   1.759 +    if (tcpdebug) {
   1.760 +      sprintf (tmp,"Reverse DNS resolution %s",adr);
   1.761 +      mm_log (tmp,TCPDEBUG);
   1.762 +    }
   1.763 +    (*bn) (BLOCK_DNSLOOKUP,NIL);/* quell alarms */
   1.764 +    data = (*bn) (BLOCK_SENSITIVE,NIL);
   1.765 +				/* translate address to name */
   1.766 +    if (t = tcp_name_valid ((he = gethostbyaddr ((char *) &sin->sin_addr,
   1.767 +						 sizeof (struct in_addr),
   1.768 +						 sin->sin_family)) ?
   1.769 +			    (char *) he->h_name : NIL)) {
   1.770 +				/* produce verbose form if needed */
   1.771 +      if (flag)	sprintf (ret = tmp,"%s %s",t,adr);
   1.772 +      else ret = t;
   1.773 +    }
   1.774 +    (*bn) (BLOCK_NONSENSITIVE,data);
   1.775 +    (*bn) (BLOCK_NONE,NIL);	/* alarms OK now */
   1.776 +    if (tcpdebug) mm_log ("Reverse DNS resolution done",TCPDEBUG);
   1.777 +  }
   1.778 +  return cpystr (ret);
   1.779 +}
   1.780 +
   1.781 +/* Return my local host name
   1.782 + * Returns: my local host name
   1.783 + */
   1.784 +
   1.785 +char *mylocalhost (void)
   1.786 +{
   1.787 +  if (!myLocalHost) {
   1.788 +    char tmp[MAILTMPLEN];
   1.789 +    if (!wsa_initted++) {	/* init Windows Sockets */
   1.790 +      WSADATA wsock;
   1.791 +      if (WSAStartup (WSA_VERSION,&wsock)) {
   1.792 +	wsa_initted = 0;
   1.793 +	return "random-pc";	/* try again later? */
   1.794 +      }
   1.795 +    }
   1.796 +    myLocalHost = cpystr ((gethostname (tmp,MAILTMPLEN-1) == SOCKET_ERROR) ?
   1.797 +			  "random-pc" : tcp_canonical (tmp));
   1.798 +  }
   1.799 +  return myLocalHost;
   1.800 +}
   1.801 +
   1.802 +
   1.803 +/* Validate name
   1.804 + * Accepts: domain name
   1.805 + * Returns: T if valid, NIL otherwise
   1.806 + */
   1.807 +
   1.808 +char *tcp_name_valid (char *s)
   1.809 +{
   1.810 +  int c;
   1.811 +  char *ret,*tail;
   1.812 +				/* must be non-empty and not too long */
   1.813 +  if ((ret = (s && *s) ? s : NIL) && (tail = ret + NETMAXHOST)) {
   1.814 +				/* must be alnum, dot, or hyphen */
   1.815 +    while ((c = *s++) && (s <= tail) &&
   1.816 +	   (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) ||
   1.817 +	    ((c >= '0') && (c <= '9')) || (c == '-') || (c == '.')));
   1.818 +    if (c) ret = NIL;
   1.819 +  }
   1.820 +  return ret;
   1.821 +}