imapext-2007
view src/osdep/unix/tcp_unix.c @ 1:28a55bc1110c
[mq]: imapext
| author | yuuji@gentei.org |
|---|---|
| date | Mon, 14 Sep 2009 19:23:11 +0900 |
| parents | ada5e610ab86 |
| children | 2366b362676d 20c025a380ab |
line source
1 /* ========================================================================
2 * Copyright 1988-2008 University of Washington
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 *
11 * ========================================================================
12 */
14 /*
15 * Program: UNIX TCP/IP routines
16 *
17 * Author: Mark Crispin
18 * Networks and Distributed Computing
19 * Computing & Communications
20 * University of Washington
21 * Administration Building, AG-44
22 * Seattle, WA 98195
23 * Internet: MRC@CAC.Washington.EDU
24 *
25 * Date: 1 August 1988
26 * Last Edited: 13 January 2008
27 */
29 #include "ip_unix.c"
31 #undef write /* don't use redefined write() */
33 static tcptimeout_t tmoh = NIL; /* TCP timeout handler routine */
34 static long ttmo_open = 0; /* TCP timeouts, in seconds */
35 static long ttmo_read = 0;
36 static long ttmo_write = 0;
37 static long rshtimeout = 15; /* rsh timeout */
38 static char *rshcommand = NIL; /* rsh command */
39 static char *rshpath = NIL; /* rsh path */
40 static long sshtimeout = 15; /* ssh timeout */
41 static char *sshcommand = NIL; /* ssh command */
42 static char *sshpath = NIL; /* ssh path */
43 static long allowreversedns = T;/* allow reverse DNS lookup */
44 static long tcpdebug = NIL; /* extra TCP debugging telemetry */
45 static char *myClientAddr = NIL;/* client IP address */
46 static char *myClientHost = NIL;/* client DNS name */
47 static long myClientPort = -1; /* client port number */
48 static char *myServerAddr = NIL;/* server IP address */
49 static char *myServerHost = NIL;/* server DNS name */
50 static long myServerPort = -1; /* server port number */
52 extern long maxposint; /* get this from write.c */
54 /* Local function prototypes */
56 int tcp_socket_open (int family,void *adr,size_t adrlen,unsigned short port,
57 char *tmp,int *ctr,char *hst);
58 static char *tcp_getline_work (TCPSTREAM *stream,unsigned long *size,
59 long *contd);
60 long tcp_abort (TCPSTREAM *stream);
61 char *tcp_name (struct sockaddr *sadr,long flag);
62 char *tcp_name_valid (char *s);
64 /* TCP/IP manipulate parameters
65 * Accepts: function code
66 * function-dependent value
67 * Returns: function-dependent return value
68 */
70 void *tcp_parameters (long function,void *value)
71 {
72 void *ret = NIL;
73 switch ((int) function) {
74 case SET_TIMEOUT:
75 tmoh = (tcptimeout_t) value;
76 case GET_TIMEOUT:
77 ret = (void *) tmoh;
78 break;
79 case SET_OPENTIMEOUT:
80 ttmo_open = (long) value;
81 case GET_OPENTIMEOUT:
82 ret = (void *) ttmo_open;
83 break;
84 case SET_READTIMEOUT:
85 ttmo_read = (long) value;
86 case GET_READTIMEOUT:
87 ret = (void *) ttmo_read;
88 break;
89 case SET_WRITETIMEOUT:
90 ttmo_write = (long) value;
91 case GET_WRITETIMEOUT:
92 ret = (void *) ttmo_write;
93 break;
94 case SET_ALLOWREVERSEDNS:
95 allowreversedns = (long) value;
96 case GET_ALLOWREVERSEDNS:
97 ret = (void *) allowreversedns;
98 break;
99 case SET_TCPDEBUG:
100 tcpdebug = (long) value;
101 case GET_TCPDEBUG:
102 ret = (void *) tcpdebug;
103 break;
105 case SET_RSHTIMEOUT:
106 rshtimeout = (long) value;
107 case GET_RSHTIMEOUT:
108 ret = (void *) rshtimeout;
109 break;
110 case SET_RSHCOMMAND:
111 if (rshcommand) fs_give ((void **) &rshcommand);
112 rshcommand = cpystr ((char *) value);
113 case GET_RSHCOMMAND:
114 ret = (void *) rshcommand;
115 break;
116 case SET_RSHPATH:
117 if (rshpath) fs_give ((void **) &rshpath);
118 rshpath = cpystr ((char *) value);
119 case GET_RSHPATH:
120 ret = (void *) rshpath;
121 break;
122 case SET_SSHTIMEOUT:
123 sshtimeout = (long) value;
124 case GET_SSHTIMEOUT:
125 ret = (void *) sshtimeout;
126 break;
127 case SET_SSHCOMMAND:
128 if (sshcommand) fs_give ((void **) &sshcommand);
129 sshcommand = cpystr ((char *) value);
130 case GET_SSHCOMMAND:
131 ret = (void *) sshcommand;
132 break;
133 case SET_SSHPATH:
134 if (sshpath) fs_give ((void **) &sshpath);
135 sshpath = cpystr ((char *) value);
136 case GET_SSHPATH:
137 ret = (void *) sshpath;
138 break;
139 }
140 return ret;
141 }
143 /* TCP/IP open
144 * Accepts: host name
145 * contact service name
146 * contact port number and optional silent flag
147 * Returns: TCP/IP stream if success else NIL
148 */
150 TCPSTREAM *tcp_open (char *host,char *service,unsigned long port)
151 {
152 TCPSTREAM *stream = NIL;
153 int family;
154 int sock = -1;
155 int ctr = 0;
156 int silent = (port & NET_SILENT) ? T : NIL;
157 int *ctrp = (port & NET_NOOPENTIMEOUT) ? NIL : &ctr;
158 char *s,*hostname,tmp[MAILTMPLEN];
159 void *adr;
160 size_t adrlen;
161 struct servent *sv = NIL;
162 blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
163 void *data,*next;
164 port &= 0xffff; /* erase flags */
165 /* lookup service */
166 if (service && (sv = getservbyname (service,"tcp")))
167 port = ntohs (sv->s_port);
168 /* The domain literal form is used (rather than simply the dotted decimal
169 as with other Unix programs) because it has to be a valid "host name"
170 in mailsystem terminology. */
171 /* look like domain literal? */
172 if (host[0] == '[' && host[(strlen (host))-1] == ']') {
173 strcpy (tmp,host+1); /* yes, copy number part */
174 tmp[(strlen (tmp))-1] = '\0';
175 if (adr = ip_stringtoaddr (tmp,&adrlen,&family)) {
176 (*bn) (BLOCK_TCPOPEN,NIL);
177 /* get an open socket for this system */
178 sock = tcp_socket_open (family,adr,adrlen,port,tmp,ctrp,hostname = host);
179 (*bn) (BLOCK_NONE,NIL);
180 fs_give ((void **) &adr);
181 }
182 else sprintf (tmp,"Bad format domain-literal: %.80s",host);
183 }
185 else { /* lookup host name */
186 if (tcpdebug) {
187 sprintf (tmp,"DNS resolution %.80s",host);
188 mm_log (tmp,TCPDEBUG);
189 }
190 (*bn) (BLOCK_DNSLOOKUP,NIL);/* quell alarms */
191 data = (*bn) (BLOCK_SENSITIVE,NIL);
192 if (!(s = ip_nametoaddr (host,&adrlen,&family,&hostname,&next)))
193 sprintf (tmp,"No such host as %.80s",host);
194 (*bn) (BLOCK_NONSENSITIVE,data);
195 (*bn) (BLOCK_NONE,NIL);
196 if (s) { /* DNS resolution won? */
197 if (tcpdebug) mm_log ("DNS resolution done",TCPDEBUG);
198 do {
199 (*bn) (BLOCK_TCPOPEN,NIL);
200 if (((sock = tcp_socket_open (family,s,adrlen,port,tmp,ctrp,
201 hostname)) < 0) &&
202 (s = ip_nametoaddr (NIL,&adrlen,&family,&hostname,&next)) &&
203 !silent) mm_log (tmp,WARN);
204 (*bn) (BLOCK_NONE,NIL);
205 } while ((sock < 0) && s);/* repeat until success or no more addreses */
206 }
207 }
208 if (sock >= 0) { /* won */
209 stream = (TCPSTREAM *) memset (fs_get (sizeof (TCPSTREAM)),0,
210 sizeof (TCPSTREAM));
211 stream->port = port; /* port number */
212 /* init sockets */
213 stream->tcpsi = stream->tcpso = sock;
214 /* stash in the snuck-in byte */
215 if (stream->ictr = ctr) *(stream->iptr = stream->ibuf) = tmp[0];
216 /* copy official host name */
217 stream->host = cpystr (hostname);
218 if (tcpdebug) mm_log ("Stream open and ready for read",TCPDEBUG);
219 }
220 else if (!silent) mm_log (tmp,ERROR);
221 return stream; /* return success */
222 }
224 /* Open a TCP socket
225 * Accepts: protocol family
226 * address to connect to
227 * address length
228 * port
229 * scratch buffer
230 * pointer to "first byte read in" storage or NIL
231 * host name for error message
232 * Returns: socket if success, else -1 with error string in scratch buffer
233 */
235 int tcp_socket_open (int family,void *adr,size_t adrlen,unsigned short port,
236 char *tmp,int *ctr,char *hst)
237 {
238 int i,ti,sock,flgs;
239 size_t len;
240 time_t now;
241 struct protoent *pt = getprotobyname ("tcp");
242 fd_set fds,efds;
243 struct timeval tmo;
244 struct sockaddr *sadr = ip_sockaddr (family,adr,adrlen,port,&len);
245 blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
246 /* fetid Solaris */
247 void *data = (*bn) (BLOCK_SENSITIVE,NIL);
248 sprintf (tmp,"Trying IP address [%s]",ip_sockaddrtostring (sadr));
249 mm_log (tmp,NIL);
250 /* make a socket */
251 if ((sock = socket (sadr->sa_family,SOCK_STREAM,pt ? pt->p_proto : 0)) < 0) {
252 sprintf (tmp,"Unable to create TCP socket: %s",strerror (errno));
253 (*bn) (BLOCK_NONSENSITIVE,data);
254 }
255 else if (sock >= FD_SETSIZE) {/* unselectable sockets are useless */
256 sprintf (tmp,"Unable to create selectable TCP socket (%d >= %d)",
257 sock,FD_SETSIZE);
258 (*bn) (BLOCK_NONSENSITIVE,data);
259 close (sock);
260 sock = -1;
261 errno = EMFILE;
262 }
264 else { /* get current socket flags */
265 flgs = fcntl (sock,F_GETFL,0);
266 /* set non-blocking if want open timeout */
267 if (ctr) fcntl (sock,F_SETFL,flgs | FNDELAY);
268 /* open connection */
269 while ((i = connect (sock,sadr,len)) < 0 && (errno == EINTR));
270 (*bn) (BLOCK_NONSENSITIVE,data);
271 if (i < 0) switch (errno) { /* failed? */
272 case EAGAIN: /* DG brain damage */
273 case EINPROGRESS: /* what we expect to happen */
274 case EALREADY: /* or another form of it */
275 case EISCONN: /* restart after interrupt? */
276 case EADDRINUSE: /* restart after interrupt? */
277 break; /* well, not really, it was interrupted */
278 default:
279 sprintf (tmp,"Can't connect to %.80s,%u: %s",hst,(unsigned int) port,
280 strerror (errno));
281 close (sock); /* flush socket */
282 sock = -1;
283 }
284 if ((sock >= 0) && ctr) { /* want open timeout? */
285 now = time (0); /* open timeout */
286 ti = ttmo_open ? now + ttmo_open : 0;
287 tmo.tv_usec = 0;
288 FD_ZERO (&fds); /* initialize selection vector */
289 FD_ZERO (&efds); /* handle errors too */
290 FD_SET (sock,&fds); /* block for error or readable */
291 FD_SET (sock,&efds);
292 do { /* block under timeout */
293 tmo.tv_sec = ti ? ti - now : 0;
294 i = select (sock+1,&fds,NIL,&efds,ti ? &tmo : NIL);
295 now = time (0); /* fake timeout if interrupt & time expired */
296 if ((i < 0) && (errno == EINTR) && ti && (ti <= now)) i = 0;
297 } while ((i < 0) && (errno == EINTR));
298 if (i > 0) { /* success, make sure really connected */
299 /* restore blocking status */
300 fcntl (sock,F_SETFL,flgs);
301 /* This used to be a zero-byte read(), but that crashes Solaris */
302 /* get socket status */
303 while (((i = *ctr = read (sock,tmp,1)) < 0) && (errno == EINTR));
304 }
305 if (i <= 0) { /* timeout or error? */
306 i = i ? errno : ETIMEDOUT;/* determine error code */
307 close (sock); /* flush socket */
308 sock = -1;
309 errno = i; /* return error code */
310 sprintf (tmp,"Connection failed to %.80s,%lu: %s",hst,
311 (unsigned long) port,strerror (errno));
312 }
313 }
314 }
315 fs_give ((void **) &sadr);
316 return sock; /* return the socket */
317 }
319 /* TCP/IP authenticated open
320 * Accepts: host name
321 * service name
322 * returned user name buffer
323 * Returns: TCP/IP stream if success else NIL
324 */
326 #define MAXARGV 20
328 TCPSTREAM *tcp_aopen (NETMBX *mb,char *service,char *usrbuf)
329 {
330 TCPSTREAM *stream = NIL;
331 void *adr;
332 char host[MAILTMPLEN],tmp[MAILTMPLEN],*path,*argv[MAXARGV+1],*r;
333 int i,ti,pipei[2],pipeo[2];
334 size_t len;
335 time_t now;
336 struct timeval tmo;
337 fd_set fds,efds;
338 blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
339 #ifdef SSHPATH /* ssh path defined yet? */
340 if (!sshpath) sshpath = cpystr (SSHPATH);
341 #endif
342 #ifdef RSHPATH /* rsh path defined yet? */
343 if (!rshpath) rshpath = cpystr (RSHPATH);
344 #endif
345 if (*service == '*') { /* want ssh? */
346 /* return immediately if ssh disabled */
347 if (!(sshpath && (ti = sshtimeout))) return NIL;
348 /* ssh command prototype defined yet? */
349 if (!sshcommand) sshcommand = cpystr ("%s %s -l %s exec /etc/r%sd");
350 }
351 /* want rsh? */
352 else if (rshpath && (ti = rshtimeout)) {
353 /* rsh command prototype defined yet? */
354 if (!rshcommand) rshcommand = cpystr ("%s %s -l %s exec /etc/r%sd");
355 }
356 else return NIL; /* rsh disabled */
357 /* look like domain literal? */
358 if (mb->host[0] == '[' && mb->host[i = (strlen (mb->host))-1] == ']') {
359 strcpy (host,mb->host+1); /* yes, copy without brackets */
360 host[i-1] = '\0';
361 /* validate domain literal */
362 if (adr = ip_stringtoaddr (host,&len,&i)) fs_give ((void **) &adr);
363 else {
364 sprintf (tmp,"Bad format domain-literal: %.80s",host);
365 mm_log (tmp,ERROR);
366 return NIL;
367 }
368 }
369 else strcpy (host,tcp_canonical (mb->host));
371 if (*service == '*') /* build ssh command */
372 sprintf (tmp,sshcommand,sshpath,host,
373 mb->user[0] ? mb->user : myusername (),service + 1);
374 else sprintf (tmp,rshcommand,rshpath,host,
375 mb->user[0] ? mb->user : myusername (),service);
376 if (tcpdebug) {
377 char msg[MAILTMPLEN];
378 sprintf (msg,"Trying %.100s",tmp);
379 mm_log (msg,TCPDEBUG);
380 }
381 /* parse command into argv */
382 for (i = 1,path = argv[0] = strtok_r (tmp," ",&r);
383 (i < MAXARGV) && (argv[i] = strtok_r (NIL," ",&r)); i++);
384 argv[i] = NIL; /* make sure argv tied off */
385 /* make command pipes */
386 if (pipe (pipei) < 0) return NIL;
387 if ((pipei[0] >= FD_SETSIZE) || (pipei[1] >= FD_SETSIZE) ||
388 (pipe (pipeo) < 0)) {
389 close (pipei[0]); close (pipei[1]);
390 return NIL;
391 }
392 (*bn) (BLOCK_TCPOPEN,NIL); /* quell alarm up here for NeXT */
393 if ((pipeo[0] >= FD_SETSIZE) || (pipeo[1] >= FD_SETSIZE) ||
394 ((i = fork ()) < 0)) { /* make inferior process */
395 close (pipei[0]); close (pipei[1]);
396 close (pipeo[0]); close (pipeo[1]);
397 (*bn) (BLOCK_NONE,NIL);
398 return NIL;
399 }
400 if (!i) { /* if child */
401 alarm (0); /* never have alarms in children */
402 if (!fork ()) { /* make grandchild so it's inherited by init */
403 int cf; /* don't alter parent vars in case vfork() */
404 int maxfd = max (20,max (max(pipei[0],pipei[1]),max(pipeo[0],pipeo[1])));
405 dup2 (pipei[1],1); /* parent's input is my output */
406 dup2 (pipei[1],2); /* parent's input is my error output too */
407 dup2 (pipeo[0],0); /* parent's output is my input */
408 /* close all unnecessary descriptors */
409 for (cf = 3; cf <= maxfd; cf++) close (cf);
410 setpgrp (0,getpid ()); /* be our own process group */
411 _exit (execv (path,argv));/* now run it */
412 }
413 _exit (1); /* child is done */
414 }
415 grim_pid_reap (i,NIL); /* reap child; grandchild now owned by init */
416 close (pipei[1]); /* close child's side of the pipes */
417 close (pipeo[0]);
419 /* create TCP/IP stream */
420 stream = (TCPSTREAM *) memset (fs_get (sizeof (TCPSTREAM)),0,
421 sizeof (TCPSTREAM));
422 /* copy remote host name from argument */
423 stream->remotehost = cpystr (stream->host = cpystr (host));
424 stream->tcpsi = pipei[0]; /* init sockets */
425 stream->tcpso = pipeo[1];
426 stream->ictr = 0; /* init input counter */
427 stream->port = 0xffffffff; /* no port number */
428 ti += now = time (0); /* open timeout */
429 tmo.tv_usec = 0; /* initialize usec timeout */
430 FD_ZERO (&fds); /* initialize selection vector */
431 FD_ZERO (&efds); /* handle errors too */
432 FD_SET (stream->tcpsi,&fds); /* set bit in selection vector */
433 FD_SET (stream->tcpsi,&efds); /* set bit in error selection vector */
434 FD_SET (stream->tcpso,&efds); /* set bit in error selection vector */
435 do { /* block under timeout */
436 tmo.tv_sec = ti - now;
437 i = select (max (stream->tcpsi,stream->tcpso)+1,&fds,NIL,&efds,&tmo);
438 now = time (0); /* fake timeout if interrupt & time expired */
439 if ((i < 0) && (errno == EINTR) && ti && (ti <= now)) i = 0;
440 } while ((i < 0) && (errno == EINTR));
441 if (i <= 0) { /* timeout or error? */
442 sprintf (tmp,i ? "error in %s to IMAP server" :
443 "%s to IMAP server timed out",(*service == '*') ? "ssh" : "rsh");
444 mm_log (tmp,WARN);
445 tcp_close (stream); /* punt stream */
446 stream = NIL;
447 }
448 (*bn) (BLOCK_NONE,NIL);
449 /* return user name */
450 strcpy (usrbuf,mb->user[0] ? mb->user : myusername ());
451 return stream; /* return success */
452 }
454 /* TCP receive line
455 * Accepts: TCP stream
456 * Returns: text line string or NIL if failure
457 */
459 char *tcp_getline (TCPSTREAM *stream)
460 {
461 unsigned long n,contd;
462 char *ret = tcp_getline_work (stream,&n,&contd);
463 if (ret && contd) { /* got a line needing continuation? */
464 STRINGLIST *stl = mail_newstringlist ();
465 STRINGLIST *stc = stl;
466 do { /* collect additional lines */
467 stc->text.data = (unsigned char *) ret;
468 stc->text.size = n;
469 stc = stc->next = mail_newstringlist ();
470 ret = tcp_getline_work (stream,&n,&contd);
471 } while (ret && contd);
472 if (ret) { /* stash final part of line on list */
473 stc->text.data = (unsigned char *) ret;
474 stc->text.size = n;
475 /* determine how large a buffer we need */
476 for (n = 0, stc = stl; stc; stc = stc->next) n += stc->text.size;
477 ret = fs_get (n + 1); /* copy parts into buffer */
478 for (n = 0, stc = stl; stc; n += stc->text.size, stc = stc->next)
479 memcpy (ret + n,stc->text.data,stc->text.size);
480 ret[n] = '\0';
481 }
482 mail_free_stringlist (&stl);/* either way, done with list */
483 }
484 return ret;
485 }
487 /* TCP receive line or partial line
488 * Accepts: TCP stream
489 * pointer to return size
490 * pointer to return continuation flag
491 * Returns: text line string, size and continuation flag, or NIL if failure
492 */
494 static char *tcp_getline_work (TCPSTREAM *stream,unsigned long *size,
495 long *contd)
496 {
497 unsigned long n;
498 char *s,*ret,c,d;
499 *contd = NIL; /* assume no continuation */
500 /* make sure have data */
501 if (!tcp_getdata (stream)) return NIL;
502 for (s = stream->iptr, n = 0, c = '\0'; stream->ictr--; n++, c = d) {
503 d = *stream->iptr++; /* slurp another character */
504 if ((c == '\015') && (d == '\012')) {
505 ret = (char *) fs_get (n--);
506 memcpy (ret,s,*size = n); /* copy into a free storage string */
507 ret[n] = '\0'; /* tie off string with null */
508 return ret;
509 }
510 }
511 /* copy partial string from buffer */
512 memcpy ((ret = (char *) fs_get (n)),s,*size = n);
513 /* get more data from the net */
514 if (!tcp_getdata (stream)) fs_give ((void **) &ret);
515 /* special case of newline broken by buffer */
516 else if ((c == '\015') && (*stream->iptr == '\012')) {
517 stream->iptr++; /* eat the line feed */
518 stream->ictr--;
519 ret[*size = --n] = '\0'; /* tie off string with null */
520 }
521 else *contd = LONGT; /* continuation needed */
522 return ret;
523 }
525 /* TCP/IP receive buffer
526 * Accepts: TCP/IP stream
527 * size in bytes
528 * buffer to read into
529 * Returns: T if success, NIL otherwise
530 */
532 long tcp_getbuffer (TCPSTREAM *stream,unsigned long size,char *s)
533 {
534 unsigned long n;
535 /* make sure socket still alive */
536 if (stream->tcpsi < 0) return NIL;
537 /* can transfer bytes from buffer? */
538 if (n = min (size,stream->ictr)) {
539 memcpy (s,stream->iptr,n); /* yes, slurp as much as we can from it */
540 s += n; /* update pointer */
541 stream->iptr +=n;
542 size -= n; /* update # of bytes to do */
543 stream->ictr -=n;
544 }
545 if (size) {
546 int i;
547 fd_set fds,efds;
548 struct timeval tmo;
549 time_t t = time (0);
550 blocknotify_t bn=(blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
551 (*bn) (BLOCK_TCPREAD,NIL);
552 while (size > 0) { /* until request satisfied */
553 time_t tl = time (0);
554 time_t now = tl;
555 time_t ti = ttmo_read ? now + ttmo_read : 0;
556 if (tcpdebug) mm_log ("Reading TCP buffer",TCPDEBUG);
557 tmo.tv_usec = 0;
558 FD_ZERO (&fds); /* initialize selection vector */
559 FD_ZERO (&efds); /* handle errors too */
560 /* set bit in selection vectors */
561 FD_SET (stream->tcpsi,&fds);
562 FD_SET (stream->tcpsi,&efds);
563 errno = NIL; /* initially no error */
564 do { /* block under timeout */
565 tmo.tv_sec = ti ? ti - now : 0;
566 i = select (stream->tcpsi+1,&fds,NIL,&efds,ti ? &tmo : NIL);
567 now = time (0); /* fake timeout if interrupt & time expired */
568 if ((i < 0) && (errno == EINTR) && ti && (ti <= now)) i = 0;
569 } while ((i < 0) && (errno == EINTR));
570 if (i) { /* non-timeout result from select? */
571 if (i > 0) /* read what we can */
572 while (((i = read (stream->tcpsi,s,(int) min (maxposint,size))) < 0)
573 && (errno == EINTR));
574 if (i <= 0) { /* error seen? */
575 if (tcpdebug) {
576 char tmp[MAILTMPLEN];
577 if (i) sprintf (s = tmp,"TCP buffer read I/O error %d",errno);
578 else s = "TCP buffer read end of file";
579 mm_log (s,TCPDEBUG);
580 }
581 return tcp_abort (stream);
582 }
583 s += i; /* success, point at new place to write */
584 size -= i; /* reduce byte count */
585 if (tcpdebug) mm_log ("Successfully read TCP buffer",TCPDEBUG);
586 }
587 /* timeout, punt unless told not to */
588 else if (!tmoh || !(*tmoh) (now - t,now - tl)) {
589 if (tcpdebug) mm_log ("TCP buffer read timeout",TCPDEBUG);
590 return tcp_abort (stream);
591 }
592 }
593 (*bn) (BLOCK_NONE,NIL);
594 }
595 *s = '\0'; /* tie off string */
596 return LONGT;
597 }
599 /* TCP/IP receive data
600 * Accepts: TCP/IP stream
601 * Returns: T if success, NIL otherwise
602 */
604 long tcp_getdata (TCPSTREAM *stream)
605 {
606 int i;
607 fd_set fds,efds;
608 struct timeval tmo;
609 time_t t = time (0);
610 blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
611 if (stream->tcpsi < 0) return NIL;
612 (*bn) (BLOCK_TCPREAD,NIL);
613 while (stream->ictr < 1) { /* if nothing in the buffer */
614 time_t tl = time (0); /* start of request */
615 time_t now = tl;
616 time_t ti = ttmo_read ? now + ttmo_read : 0;
617 if (tcpdebug) mm_log ("Reading TCP data",TCPDEBUG);
618 tmo.tv_usec = 0;
619 FD_ZERO (&fds); /* initialize selection vector */
620 FD_ZERO (&efds); /* handle errors too */
621 FD_SET (stream->tcpsi,&fds);/* set bit in selection vectors */
622 FD_SET (stream->tcpsi,&efds);
623 errno = NIL; /* initially no error */
624 do { /* block under timeout */
625 tmo.tv_sec = ti ? ti - now : 0;
626 i = select (stream->tcpsi+1,&fds,NIL,&efds,ti ? &tmo : NIL);
627 now = time (0); /* fake timeout if interrupt & time expired */
628 if ((i < 0) && (errno == EINTR) && ti && (ti <= now)) i = 0;
629 } while ((i < 0) && (errno == EINTR));
630 if (i) { /* non-timeout result from select? */
631 /* read what we can */
632 if (i > 0) while (((i = read (stream->tcpsi,stream->ibuf,BUFLEN)) < 0) &&
633 (errno == EINTR));
634 if (i <= 0) { /* error seen? */
635 if (tcpdebug) {
636 char *s,tmp[MAILTMPLEN];
637 if (i) sprintf (s = tmp,"TCP data read I/O error %d",errno);
638 else s = "TCP data read end of file";
639 mm_log (s,TCPDEBUG);
640 }
641 return tcp_abort (stream);
642 }
643 stream->ictr = i; /* success, set new count and pointer */
644 stream->iptr = stream->ibuf;
645 if (tcpdebug) mm_log ("Successfully read TCP data",TCPDEBUG);
646 }
647 /* timeout, punt unless told not to */
648 else if (!tmoh || !(*tmoh) (now - t,now - tl)) {
649 if (tcpdebug) mm_log ("TCP data read timeout",TCPDEBUG);
650 return tcp_abort (stream);/* error or timeout no-continue */
651 }
652 }
653 (*bn) (BLOCK_NONE,NIL);
654 return T;
655 }
657 /* TCP/IP send string as record
658 * Accepts: TCP/IP stream
659 * string pointer
660 * Returns: T if success else NIL
661 */
663 long tcp_soutr (TCPSTREAM *stream,char *string)
664 {
665 return tcp_sout (stream,string,(unsigned long) strlen (string));
666 }
669 /* TCP/IP send string
670 * Accepts: TCP/IP stream
671 * string pointer
672 * byte count
673 * Returns: T if success else NIL
674 */
676 long tcp_sout (TCPSTREAM *stream,char *string,unsigned long size)
677 {
678 int i;
679 fd_set fds,efds;
680 struct timeval tmo;
681 time_t t = time (0);
682 blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
683 if (stream->tcpso < 0) return NIL;
684 (*bn) (BLOCK_TCPWRITE,NIL);
685 while (size > 0) { /* until request satisfied */
686 time_t tl = time (0); /* start of request */
687 time_t now = tl;
688 time_t ti = ttmo_write ? now + ttmo_write : 0;
689 if (tcpdebug) mm_log ("Writing to TCP",TCPDEBUG);
690 tmo.tv_usec = 0;
691 FD_ZERO (&fds); /* initialize selection vector */
692 FD_ZERO (&efds); /* handle errors too */
693 FD_SET (stream->tcpso,&fds);/* set bit in selection vector */
694 FD_SET(stream->tcpso,&efds);/* set bit in error selection vector */
695 errno = NIL; /* block and write */
696 do { /* block under timeout */
697 tmo.tv_sec = ti ? ti - now : 0;
698 i = select (stream->tcpso+1,NIL,&fds,&efds,ti ? &tmo : NIL);
699 now = time (0); /* fake timeout if interrupt & time expired */
700 if ((i < 0) && (errno == EINTR) && ti && (ti <= now)) i = 0;
701 } while ((i < 0) && (errno == EINTR));
702 if (i) { /* non-timeout result from select? */
703 /* write what we can */
704 if (i > 0) while (((i = write (stream->tcpso,string,size)) < 0) &&
705 (errno == EINTR));
706 if (i <= 0) { /* error seen? */
707 if (tcpdebug) {
708 char tmp[MAILTMPLEN];
709 sprintf (tmp,"TCP write I/O error %d",errno);
710 mm_log (tmp,TCPDEBUG);
711 }
712 return tcp_abort (stream);
713 }
714 string += i; /* how much we sent */
715 size -= i; /* count this size */
716 if (tcpdebug) mm_log ("successfully wrote to TCP",TCPDEBUG);
717 }
718 /* timeout, punt unless told not to */
719 else if (!tmoh || !(*tmoh) (now - t,now - tl)) {
720 if (tcpdebug) mm_log ("TCP write timeout",TCPDEBUG);
721 return tcp_abort (stream);
722 }
723 }
724 (*bn) (BLOCK_NONE,NIL);
725 return T; /* all done */
726 }
728 /* TCP/IP close
729 * Accepts: TCP/IP stream
730 */
732 void tcp_close (TCPSTREAM *stream)
733 {
734 tcp_abort (stream); /* nuke the stream */
735 /* flush host names */
736 if (stream->host) fs_give ((void **) &stream->host);
737 if (stream->remotehost) fs_give ((void **) &stream->remotehost);
738 if (stream->localhost) fs_give ((void **) &stream->localhost);
739 fs_give ((void **) &stream); /* flush the stream */
740 }
743 /* TCP/IP abort stream
744 * Accepts: TCP/IP stream
745 * Returns: NIL always
746 */
748 long tcp_abort (TCPSTREAM *stream)
749 {
750 blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
751 if (stream->tcpsi >= 0) { /* no-op if no socket */
752 (*bn) (BLOCK_TCPCLOSE,NIL);
753 close (stream->tcpsi); /* nuke the socket */
754 if (stream->tcpsi != stream->tcpso) close (stream->tcpso);
755 stream->tcpsi = stream->tcpso = -1;
756 }
757 (*bn) (BLOCK_NONE,NIL);
758 return NIL;
759 }
761 /* TCP/IP get host name
762 * Accepts: TCP/IP stream
763 * Returns: host name for this stream
764 */
766 char *tcp_host (TCPSTREAM *stream)
767 {
768 return stream->host; /* use tcp_remotehost() if want guarantees */
769 }
772 /* TCP/IP get remote host name
773 * Accepts: TCP/IP stream
774 * Returns: host name for this stream
775 */
777 char *tcp_remotehost (TCPSTREAM *stream)
778 {
779 if (!stream->remotehost) {
780 size_t sadrlen;
781 struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
782 stream->remotehost = /* get socket's peer name */
783 getpeername (stream->tcpsi,sadr,(void *) &sadrlen) ?
784 cpystr (stream->host) : tcp_name (sadr,NIL);
785 fs_give ((void **) &sadr);
786 }
787 return stream->remotehost;
788 }
791 /* TCP/IP return port for this stream
792 * Accepts: TCP/IP stream
793 * Returns: port number for this stream
794 */
796 unsigned long tcp_port (TCPSTREAM *stream)
797 {
798 return stream->port; /* return port number */
799 }
802 /* TCP/IP get local host name
803 * Accepts: TCP/IP stream
804 * Returns: local host name
805 */
807 char *tcp_localhost (TCPSTREAM *stream)
808 {
809 if (!stream->localhost) {
810 size_t sadrlen;
811 struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
812 stream->localhost = /* get socket's name */
813 ((stream->port & 0xffff000) ||
814 getsockname (stream->tcpsi,sadr,(void *) &sadrlen)) ?
815 cpystr (mylocalhost ()) : tcp_name (sadr,NIL);
816 fs_give ((void **) &sadr);
817 }
818 return stream->localhost; /* return local host name */
819 }
821 /* Get $TCPREMOTEHOST || $TCPREMOTEHOST
822 * If invoked via tcpserver or couriertcpd, consult $TCPREMOTEHOST
823 * or $TCPREMOTEIP
824 */
825 char* gettcpremoteip()
826 {
827 if (getenv("TCPREMOTEHOST") && strcmp("0", getenv("TCPREMOTEHOST"))) {
828 return getenv("TCPREMOTEHOST");
829 } else if (getenv("TCPREMOTEIP")) {
830 return getenv("TCPREMOTEIP");
831 }
832 return "NON-IPv4";
833 }
835 /* TCP/IP get client host address (server calls only)
836 * Returns: client host address
837 */
839 char *tcp_clientaddr ()
840 {
841 if (!myClientAddr) {
842 size_t sadrlen;
843 struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
844 if (getpeername (0,sadr,(void *) &sadrlen))
845 myClientAddr = cpystr ("UNKNOWN");
846 else { /* get stdin's peer name */
847 myClientAddr = cpystr (ip_sockaddrtostring (sadr));
848 if (myClientPort < 0) myClientPort = ip_sockaddrtoport (sadr);
849 }
850 fs_give ((void **) &sadr);
851 }
852 return myClientAddr;
853 }
856 /* TCP/IP get client host name (server calls only)
857 * Returns: client host name
858 */
860 char *tcp_clienthost ()
861 {
862 if (!myClientHost) {
863 size_t sadrlen;
864 struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
865 #ifdef INET6
866 if (getenv("TCPREMOTEIP")) {
867 myClientHost =
868 cpystr((getenv("TCPREMOTEHOST")
869 && strcasecmp("UNKNOWN", getenv("TCPREMOTEHOST")))
870 ? getenv("TCPREMOTEHOST")
871 : getenv("TCPREMOTEIP"));
872 } else
873 #endif
874 if (getpeername (0,sadr,(void *) &sadrlen)) {
875 char *s,*t,*v,tmp[MAILTMPLEN];
876 if ((s = getenv (t = "SSH_CLIENT")) ||
877 (s = getenv (t = "KRB5REMOTEADDR")) ||
878 (s = getenv (t = "SSH2_CLIENT"))) {
879 if (v = strchr (s,' ')) *v = '\0';
880 sprintf (v = tmp,"%.80s=%.80s",t,s);
881 }
882 else v = "UNKNOWN";
883 myClientHost = cpystr (v);
884 }
885 else { /* get stdin's peer name */
886 myClientHost = tcp_name (sadr,T);
887 if (!myClientAddr) myClientAddr = cpystr (ip_sockaddrtostring (sadr));
888 if (myClientPort < 0) myClientPort = ip_sockaddrtoport (sadr);
889 }
890 fs_give ((void **) &sadr);
891 }
892 return myClientHost;
893 }
896 /* TCP/IP get client port number (server calls only)
897 * Returns: client port number
898 */
900 long tcp_clientport ()
901 {
902 if (!myClientHost && !myClientAddr) tcp_clientaddr ();
903 return myClientPort;
904 }
906 /* TCP/IP get server host address (server calls only)
907 * Returns: server host address
908 */
910 char *tcp_serveraddr ()
911 {
912 if (!myServerAddr) {
913 size_t sadrlen;
914 struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
915 if (getsockname (0,sadr,(void *) &sadrlen))
916 myServerAddr = cpystr ("UNKNOWN");
917 else { /* get stdin's name */
918 myServerAddr = cpystr (ip_sockaddrtostring (sadr));
919 if (myServerPort < 0) myServerPort = ip_sockaddrtoport (sadr);
920 }
921 fs_give ((void **) &sadr);
922 }
923 return myServerAddr;
924 }
927 /* TCP/IP get server host name (server calls only)
928 * Returns: server host name
929 */
931 char *tcp_serverhost ()
932 {
933 if (!myServerHost) { /* once-only */
934 size_t sadrlen;
935 struct sockaddr *sadr = ip_newsockaddr (&sadrlen);
936 /* get stdin's name */
937 if (getsockname (0,sadr,(void *) &sadrlen) ||
938 (myServerPort = ip_sockaddrtoport (sadr)) < 0)
939 myServerHost = cpystr (mylocalhost ());
940 else { /* get stdin's name */
941 myServerHost = tcp_name (sadr,NIL);
942 if (!myServerAddr) myServerAddr = cpystr (ip_sockaddrtostring (sadr));
943 if (myServerPort < 0) myServerPort = ip_sockaddrtoport (sadr);
944 }
945 fs_give ((void **) &sadr);
946 }
947 return myServerHost;
948 }
951 /* TCP/IP get server port number (server calls only)
952 * Returns: server port number
953 */
955 long tcp_serverport ()
956 {
957 if (!myServerHost && !myServerAddr) tcp_serveraddr ();
958 return myServerPort;
959 }
961 /* TCP/IP return canonical form of host name
962 * Accepts: host name
963 * Returns: canonical form of host name
964 */
966 char *tcp_canonical (char *name)
967 {
968 char *ret,host[MAILTMPLEN];
969 blocknotify_t bn = (blocknotify_t) mail_parameters (NIL,GET_BLOCKNOTIFY,NIL);
970 void *data;
971 /* look like domain literal? */
972 if (name[0] == '[' && name[strlen (name) - 1] == ']') return name;
973 (*bn) (BLOCK_DNSLOOKUP,NIL); /* quell alarms */
974 data = (*bn) (BLOCK_SENSITIVE,NIL);
975 if (tcpdebug) {
976 sprintf (host,"DNS canonicalization %.80s",name);
977 mm_log (host,TCPDEBUG);
978 }
979 /* get canonical name */
980 if (!ip_nametoaddr (name,NIL,NIL,&ret,NIL)) ret = name;
981 (*bn) (BLOCK_NONSENSITIVE,data);
982 (*bn) (BLOCK_NONE,NIL); /* alarms OK now */
983 if (tcpdebug) mm_log ("DNS canonicalization done",TCPDEBUG);
984 return ret;
985 }
987 /* TCP/IP return name from socket
988 * Accepts: socket
989 * verbose flag
990 * Returns: cpystr name
991 */
993 char *tcp_name (struct sockaddr *sadr,long flag)
994 {
995 char *ret,*t,adr[MAILTMPLEN],tmp[MAILTMPLEN];
996 sprintf (ret = adr,"[%.80s]",ip_sockaddrtostring (sadr));
997 if (allowreversedns) {
998 blocknotify_t bn = (blocknotify_t)mail_parameters(NIL,GET_BLOCKNOTIFY,NIL);
999 void *data;
1000 if (tcpdebug) {
1001 sprintf (tmp,"Reverse DNS resolution %s",adr);
1002 mm_log (tmp,TCPDEBUG);
1003 }
1004 (*bn) (BLOCK_DNSLOOKUP,NIL);/* quell alarms */
1005 data = (*bn) (BLOCK_SENSITIVE,NIL);
1006 /* translate address to name */
1007 if (t = tcp_name_valid (ip_sockaddrtoname (sadr))) {
1008 /* produce verbose form if needed */
1009 if (flag) sprintf (ret = tmp,"%s %s",t,adr);
1010 else ret = t;
1011 }
1012 (*bn) (BLOCK_NONSENSITIVE,data);
1013 (*bn) (BLOCK_NONE,NIL); /* alarms OK now */
1014 if (tcpdebug) mm_log ("Reverse DNS resolution done",TCPDEBUG);
1015 }
1016 return cpystr (ret);
1017 }
1020 /* TCP/IP validate name
1021 * Accepts: domain name
1022 * Returns: name if valid, NIL otherwise
1023 */
1025 char *tcp_name_valid (char *s)
1026 {
1027 int c;
1028 char *ret,*tail;
1029 /* must be non-empty and not too long */
1030 if ((ret = (s && *s) ? s : NIL) && (tail = ret + NETMAXHOST)) {
1031 /* must be alnum, dot, or hyphen */
1032 while ((c = *s++) && (s <= tail) &&
1033 (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) ||
1034 ((c >= '0') && (c <= '9')) || (c == '-') || (c == '.')));
1035 if (c) ret = NIL;
1036 }
1037 return ret;
1038 }
1040 /* TCP/IP check if client is given host name
1041 * Accepts: candidate host name
1042 * Returns: T if match, NIL otherwise
1043 */
1045 long tcp_isclienthost (char *host)
1046 {
1047 int family;
1048 size_t adrlen,sadrlen,len;
1049 void *adr,*next;
1050 struct sockaddr *sadr;
1051 long ret = NIL;
1052 /* make sure that myClientAddr is set */
1053 if (tcp_clienthost () && myClientAddr)
1054 /* get sockaddr of client */
1055 for (adr = ip_nametoaddr (host,&adrlen,&family,NIL,&next); adr && !ret;
1056 adr = ip_nametoaddr (NIL,&adrlen,&family,NIL,&next)) {
1057 /* build sockaddr of given address */
1058 sadr = ip_sockaddr (family,adr,adrlen,1,&len);
1059 if (!strcmp (myClientAddr,ip_sockaddrtostring (sadr))) ret = LONGT;
1060 fs_give ((void **) &sadr); /* done with client sockaddr */
1061 }
1062 return ret;
1063 }
1065 /* Following statement must be at end of this module */
1067 #undef fork /* undo any use of vfork() */