1 /* $Cambridge: exim/src/src/os.c,v 1.3 2005/06/27 14:29:43 ph10 Exp $ */
3 /*************************************************
4 * Exim - an Internet mail transport agent *
5 *************************************************/
7 /* Copyright (c) University of Cambridge 1995 - 2005 */
8 /* See the file NOTICE for conditions of use and distribution. */
16 /* This source file contains "default" system-dependent functions which
17 provide functionality (or lack of it) in cases where the OS-specific os.c
18 file has not. Some of them are tailored by macros defined in os.h files. */
21 #ifndef OS_RESTARTING_SIGNAL
22 /*************************************************
23 * Set up restarting signal *
24 *************************************************/
26 /* This function has the same functionality as the ANSI C signal() function,
27 except that it arranges that, if the signal happens during a system call, the
28 system call gets restarted. (Also, it doesn't return a result.) Different
29 versions of Unix have different defaults, and different ways of setting up a
30 restarting signal handler. If the functionality is not available, the signal
31 should be set to be ignored. This function is used only for catching SIGUSR1.
35 os_restarting_signal(int sig, void (*handler)(int))
37 /* Many systems have the SA_RESTART sigaction for specifying that a signal
38 should restart system calls. These include SunOS5, AIX, BSDI, IRIX, FreeBSD,
39 OSF1, Linux and HP-UX 10 (but *not* HP-UX 9). */
43 act.sa_handler = handler;
44 sigemptyset(&(act.sa_mask));
45 act.sa_flags = SA_RESTART;
46 sigaction(sig, &act, NULL);
49 printf("Used SA_RESTART\n");
52 /* SunOS4 and Ultrix default to non-interruptable signals, with SV_INTERRUPT
53 for making them interruptable. This seems to be a dying fashion. */
55 #elif defined SV_INTERRUPT
59 printf("Used default signal()\n");
63 /* If neither SA_RESTART nor SV_INTERRUPT is available we don't know how to
64 set up a restarting signal, so simply suppress the facility. */
70 printf("Used SIG_IGN\n");
76 #endif /* OS_RESTARTING_SIGNAL */
79 #ifndef OS_NON_RESTARTING_SIGNAL
80 /*************************************************
81 * Set up non-restarting signal *
82 *************************************************/
84 /* This function has the same functionality as the ANSI C signal() function,
85 except that it arranges that, if the signal happens during a system call, the
86 system call gets interrupted. (Also, it doesn't return a result.) Different
87 versions of Unix have different defaults, and different ways of setting up a
88 non-restarting signal handler. For systems for which we don't know what to do,
89 just use the normal signal() function and hope for the best. */
92 os_non_restarting_signal(int sig, void (*handler)(int))
94 /* Many systems have the SA_RESTART sigaction for specifying that a signal
95 should restart system calls. These include SunOS5, AIX, BSDI, IRIX, FreeBSD,
96 OSF1, Linux and HP-UX 10 (but *not* HP-UX 9). */
100 act.sa_handler = handler;
101 sigemptyset(&(act.sa_mask));
103 sigaction(sig, &act, NULL);
106 printf("Used sigaction() with flags = 0\n");
109 /* SunOS4 and Ultrix default to non-interruptable signals, with SV_INTERRUPT
110 for making them interruptable. This seems to be a dying fashion. */
112 #elif defined SV_INTERRUPT
114 sv.sv_handler = handler;
115 sv.sv_flags = SV_INTERRUPT;
117 sigvec(sig, &sv, NULL);
120 printf("Used sigvec() with flags = SV_INTERRUPT\n");
123 /* If neither SA_RESTART nor SV_INTERRUPT is available we don't know how to
124 set up a restarting signal, so just use the standard signal() function. */
127 signal(sig, handler);
130 printf("Used default signal()\n");
136 #endif /* OS_NON_RESTARTING_SIGNAL */
140 #ifdef STRERROR_FROM_ERRLIST
141 /*************************************************
142 * Provide strerror() for non-ANSI libraries *
143 *************************************************/
145 /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
146 in their libraries, but can provide the same facility by this simple
147 alternative function. */
152 if (n < 0 || n >= sys_nerr) return "unknown error number";
153 return sys_errlist[n];
155 #endif /* STRERROR_FROM_ERRLIST */
160 /*************************************************
161 * Provide strsignal() for systems without *
162 *************************************************/
164 /* Some systems have strsignal() to turn signal numbers into names; others
165 may have other means of doing this. This function is used for those systems
166 that have nothing. It provides a basic translation for the common standard
167 signal numbers. I've been extra cautious with the ifdef's here. Probably more
168 than is necessary... */
176 case SIGHUP: return "hangup";
180 case SIGINT: return "interrupt";
184 case SIGQUIT: return "quit";
188 case SIGILL: return "illegal instruction";
192 case SIGTRAP: return "trace trap";
196 case SIGABRT: return "abort";
200 case SIGEMT: return "EMT instruction";
204 case SIGFPE: return "arithmetic exception";
208 case SIGKILL: return "killed";
212 case SIGBUS: return "bus error";
216 case SIGSEGV: return "segmentation fault";
220 case SIGSYS: return "bad system call";
224 case SIGPIPE: return "broken pipe";
228 case SIGALRM: return "alarm";
232 case SIGTERM: return "terminated";
236 case SIGUSR1: return "user signal 1";
240 case SIGUSR2: return "user signal 2";
244 case SIGCHLD: return "child stop or exit";
248 case SIGPWR: return "power fail/restart";
252 case SIGURG: return "urgent condition on I/O channel";
256 case SIGSTOP: return "stop";
260 case SIGTSTP: return "stop from tty";
264 case SIGXCPU: return "exceeded CPU limit";
268 case SIGXFSZ: return "exceeded file size limit";
271 default: return "unrecognized signal number";
274 #endif /* OS_STRSIGNAL */
279 /*************************************************
280 * Provide strexit() for systems without *
281 *************************************************/
283 /* Actually, I don't know of any system that has a strexit() function to turn
284 exit codes into text, but this function is implemented this way so that if any
285 OS does have such a thing, it could be used instead of this build-in one. */
292 /* On systems without sysexits.h we can assume only those exit codes
293 that are given a default value in exim.h. */
296 case EX_USAGE: return "(could mean usage or syntax error)";
297 case EX_DATAERR: return "(could mean error in input data)";
298 case EX_NOINPUT: return "(could mean input data missing)";
299 case EX_NOUSER: return "(could mean user nonexistent)";
300 case EX_NOHOST: return "(could mean host nonexistent)";
301 case EX_SOFTWARE: return "(could mean internal software error)";
302 case EX_OSERR: return "(could mean internal operating system error)";
303 case EX_OSFILE: return "(could mean system file missing)";
304 case EX_IOERR: return "(could mean input/output error)";
305 case EX_PROTOCOL: return "(could mean protocol error)";
306 case EX_NOPERM: return "(could mean permission denied)";
309 case EX_EXECFAILED: return "(could mean unable to exec or command does not exist)";
310 case EX_UNAVAILABLE: return "(could mean service or program unavailable)";
311 case EX_CANTCREAT: return "(could mean can't create output file)";
312 case EX_TEMPFAIL: return "(could mean temporary error)";
313 case EX_CONFIG: return "(could mean configuration error)";
317 #endif /* OS_STREXIT */
322 /***********************************************************
323 * Load average function *
324 ***********************************************************/
326 /* Although every Unix seems to have a different way of getting the load
327 average, a number of them have things in common. Some common variants are
328 provided below, but if an OS has unique requirements it can be handled in
329 a specific os.c file. What is required is a function called os_getloadavg
330 which takes no arguments and passes back the load average * 1000 as an int,
331 or -1 if no data is available. */
334 /* ----------------------------------------------------------------------- */
335 /* If the OS has got a BSD getloadavg() function, life is very easy. */
337 #if !defined(OS_LOAD_AVERAGE) && defined(HAVE_BSD_GETLOADAVG)
338 #define OS_LOAD_AVERAGE
344 int loads = getloadavg (&avg, 1);
345 if (loads != 1) return -1;
346 return (int)(avg * 1000.0);
349 /* ----------------------------------------------------------------------- */
353 /* ----------------------------------------------------------------------- */
354 /* Only SunOS5 has the kstat functions as far as I know, but put the code
355 here as there is the -hal variant, and other systems might follow this road one
358 #if !defined(OS_LOAD_AVERAGE) && defined(HAVE_KSTAT)
359 #define OS_LOAD_AVERAGE
371 if ((kc = kstat_open()) == NULL ||
372 (ksp = kstat_lookup(kc, LOAD_AVG_KSTAT_MODULE, 0, LOAD_AVG_KSTAT))
374 kstat_read(kc, ksp, NULL) < 0 ||
375 (kn = kstat_data_lookup(ksp, LOAD_AVG_SYMBOL)) == NULL)
378 avg = (int)(((double)(kn->LOAD_AVG_FIELD)/FSCALE) * 1000.0);
385 /* ----------------------------------------------------------------------- */
389 /* ----------------------------------------------------------------------- */
390 /* Handle OS where a kernel symbol has to be read from /dev/kmem */
392 #if !defined(OS_LOAD_AVERAGE) && defined(HAVE_DEV_KMEM)
393 #define OS_LOAD_AVERAGE
397 static int avg_kd = -1;
398 static long avg_offset;
408 nl[0].n_name = LOAD_AVG_SYMBOL;
410 nlist (KERNEL_PATH, nl);
411 avg_offset = (long)nl[0].n_value;
412 avg_kd = open ("/dev/kmem", 0);
413 if (avg_kd < 0) return -1;
414 (void) fcntl(avg_kd, F_SETFD, FD_CLOEXEC);
417 if (lseek (avg_kd, avg_offset, 0) == -1L
418 || read (avg_kd, (char *)(&avg), sizeof (avg)) != sizeof(avg))
421 return (int)(((double)avg/FSCALE)*1000.0);
425 /* ----------------------------------------------------------------------- */
429 /* ----------------------------------------------------------------------- */
430 /* If nothing is known about this OS, then the load average facility is
433 #ifndef OS_LOAD_AVERAGE
443 /* ----------------------------------------------------------------------- */
447 #if !defined FIND_RUNNING_INTERFACES
448 /*************************************************
449 * Find all the running network interfaces *
450 *************************************************/
452 /* Finding all the running interfaces is something that has os-dependent
453 tweaks, even in the IPv4 case, and it gets worse for IPv6, which is why this
454 code is now in the os-dependent source file. There is a common function which
455 works on most OS (except IRIX) for IPv4 interfaces, and, with some variations
456 controlled by macros, on at least one OS for IPv6 and IPv4 interfaces. On Linux
457 with IPv6, the common function is used for the IPv4 interfaces and additional
458 code used for IPv6. Consequently, the real function is called
459 os_common_find_running_interfaces() so that it can be called from the Linux
460 function. On non-Linux systems, the macro for os_find_running_interfaces just
461 calls the common function; on Linux it calls the Linux function.
463 This function finds the addresses of all the running interfaces on the machine.
464 A chain of blocks containing the textual form of the addresses is returned.
468 (1) Solaris 2 has the SIOGIFNUM call to get the number of interfaces, but
469 other OS (including Solaris 1) appear not to. So just screw in a largeish
470 fixed number, defined by MAX_INTERFACES. This is in the config.h file and
471 can be changed in Local/Makefile. Unfortunately, the www addressing scheme
472 means that some hosts have a very large number of virtual interfaces. Such
473 hosts are recommended to set local_interfaces to avoid problems with this.
475 (2) If the standard code is run on IRIX, it does not return any alias
476 interfaces. There is special purpose code for that operating system, which
477 uses the sysctl() function. The code is in OS/os.c-IRIX, and this code isn't
480 (3) Some experimental/developing OS (e.g. GNU/Hurd) do not have any means
481 of finding the interfaces. If NO_FIND_INTERFACES is set, a fudge-up is used
484 (4) Some operating systems set the IP address in what SIOCGIFCONF returns;
485 others do not, and require SIOCGIFADDR to be called to get it. For most of
486 the former, calling the latter does no harm, but it causes grief on Linux and
487 BSD systems in the case of IP aliasing, so a means of cutting it out is
491 Returns: a chain of ip_address_items, each pointing to a textual
492 version of an IP address, with the port field set to zero
496 #ifndef NO_FIND_INTERFACES
498 /* If there is IPv6 support, and SIOCGLIFCONF is defined, define macros to
499 use these new, longer versions of the old IPv4 interfaces. Otherwise, define
500 the macros to use the historical versions. */
502 #if HAVE_IPV6 && defined SIOCGLIFCONF
503 #define V_ifconf lifconf
504 #define V_ifreq lifreq
505 #define V_GIFADDR SIOCGLIFADDR
506 #define V_GIFCONF SIOCGLIFCONF
507 #define V_GIFFLAGS SIOCGLIFFLAGS
508 #define V_ifc_buf lifc_buf
509 #define V_ifc_family lifc_family
510 #define V_ifc_flags lifc_flags
511 #define V_ifc_len lifc_len
512 #define V_ifr_addr lifr_addr
513 #define V_ifr_flags lifr_flags
514 #define V_ifr_name lifr_name
515 #define V_FAMILY_QUERY AF_UNSPEC
516 #define V_family ss_family
518 #define V_ifconf ifconf
519 #define V_ifreq ifreq
520 #define V_GIFADDR SIOCGIFADDR
521 #define V_GIFCONF SIOCGIFCONF
522 #define V_GIFFLAGS SIOCGIFFLAGS
523 #define V_ifc_buf ifc_buf
524 #define V_ifc_family ifc_family
525 #define V_ifc_flags ifc_flags
526 #define V_ifc_len ifc_len
527 #define V_ifr_addr ifr_addr
528 #define V_ifr_flags ifr_flags
529 #define V_ifr_name ifr_name
530 #define V_family sa_family
533 /* In all cases of IPv6 support, use an IPv6 socket. Otherwise (at least on
534 Solaris 8) the call to read the flags doesn't work for IPv6 interfaces. If
535 we find we can't actually make an IPv6 socket, the code will revert to trying
539 #define FAMILY AF_INET6
541 #define FAMILY AF_INET
544 /* OK, after all that preliminary stuff, here's the code. */
547 os_common_find_running_interfaces(void)
550 struct V_ifreq ifreq;
552 ip_address_item *yield = NULL;
553 ip_address_item *last = NULL;
554 ip_address_item *next;
556 char buf[MAX_INTERFACES*sizeof(struct V_ifreq)];
557 struct sockaddr *addrp;
561 /* We have to create a socket in order to do ioctls on it to find out
562 what we want to know. */
564 if ((vs = socket(FAMILY, SOCK_DGRAM, 0)) < 0)
568 debug_printf("Unable to create IPv6 socket to find interface addresses:\n "
569 "error %d %s\nTrying for an IPv4 socket\n", errno, strerror(errno));
570 vs = socket(AF_INET, SOCK_DGRAM, 0);
573 log_write(0, LOG_PANIC_DIE, "Unable to create IPv4 socket to find interface "
574 "addresses: %d %s", errno, strerror(errno));
577 /* Get the interface configuration. Some additional data is required when the
578 new structures are in use. */
580 ifc.V_ifc_len = sizeof(buf);
583 #ifdef V_FAMILY_QUERY
584 ifc.V_ifc_family = V_FAMILY_QUERY;
588 if (ioctl(vs, V_GIFCONF, (char *)&ifc) < 0)
589 log_write(0, LOG_PANIC_DIE, "Unable to get interface configuration: %d %s",
590 errno, strerror(errno));
592 /* If the buffer is big enough, the ioctl sets the value of ifc.V_ifc_len to
593 the amount actually used. If the buffer isn't big enough, at least on some
594 operating systems, ifc.V_ifc_len still gets set to correspond to the total
595 number of interfaces, even though they don't all fit in the buffer. */
597 if (ifc.V_ifc_len > sizeof(buf))
599 ifc.V_ifc_len = sizeof(buf);
601 debug_printf("more than %d interfaces found: remainder not used\n"
602 "(set MAX_INTERFACES in Local/Makefile and rebuild if you want more)\n",
606 /* For each interface, check it is an IP interface, get its flags, and see if
607 it is up; if not, skip.
609 BSD systems differ from others in what SIOCGIFCONF returns. Other systems
610 return a vector of ifreq structures whose size is as defined by the structure.
611 BSD systems allow sockaddrs to be longer than their sizeof, which in turn makes
612 the ifreq structures longer than their sizeof. The code below has its origins
613 in amd and ifconfig; it uses the sa_len field of each sockaddr to determine
616 This is complicated by the fact that, at least on BSD systems, the data in the
617 buffer is not guaranteed to be aligned. Thus, we must first copy the basic
618 struct to some aligned memory before looking at the field in the fixed part to
619 find its length, and then recopy the correct length. */
621 for (cp = buf; cp < buf + ifc.V_ifc_len; cp += len)
623 memcpy((char *)&ifreq, cp, sizeof(ifreq));
626 len = sizeof(struct V_ifreq);
629 len = ((ifreq.ifr_addr.sa_len > sizeof(ifreq.ifr_addr))?
630 ifreq.ifr_addr.sa_len : sizeof(ifreq.ifr_addr)) +
631 sizeof(ifreq.V_ifr_name);
632 if (len > sizeof(addrbuf))
633 log_write(0, LOG_PANIC_DIE, "Address for %s interface is absurdly long",
638 /* If not an IP interface, skip */
640 if (ifreq.V_ifr_addr.V_family != AF_INET
642 && ifreq.V_ifr_addr.V_family != AF_INET6
646 /* Get the interface flags, and if the interface is down, continue. Formerly,
647 we treated the inability to get the flags as a panic-die error. However, it
648 seems that on some OS (Solaris 9 being the case noted), it is possible to
649 have an interface in this list for which this call fails because the
650 interface hasn't been "plumbed" to any protocol (IPv4 or IPv6). Therefore,
651 we now just treat this case as "down" as well. */
653 if (ioctl(vs, V_GIFFLAGS, (char *)&ifreq) < 0)
657 log_write(0, LOG_PANIC_DIE, "Unable to get flags for %s interface: %d %s",
658 ifreq.V_ifr_name, errno, strerror(errno));
661 if ((ifreq.V_ifr_flags & IFF_UP) == 0) continue;
663 /* On some operating systems we have to get the IP address of the interface
664 by another call. On others, it's already there, but we must reinstate the
665 data in ifreq, because SIOCGIFFLAGS may wreck it. */
667 #ifndef SIOCGIFCONF_GIVES_ADDR
668 if (ioctl(vs, V_GIFADDR, (char *)&ifreq) < 0)
669 log_write(0, LOG_PANIC_DIE, "Unable to get IP address for %s interface: "
670 "%d %s", ifreq.V_ifr_name, errno, strerror(errno));
671 addrp = &ifreq.V_ifr_addr;
674 memcpy((char *)&ifreq, cp, sizeof(ifreq));
675 memcpy(addrbuf, (char *)&(ifreq.V_ifr_addr), len - sizeof(ifreq.V_ifr_name));
676 addrp = (struct sockaddr *)addrbuf;
679 /* Create a data block for the address, fill in the data, and put it on the
682 next = store_get(sizeof(ip_address_item));
685 (void)host_ntoa(-1, addrp, next->address, NULL);
687 if (yield == NULL) yield = last = next; else
693 DEBUG(D_interface) debug_printf("Actual local interface address is %s (%s)\n",
694 last->address, ifreq.V_ifr_name);
697 /* Close the socket, and return the chain of data blocks. */
703 #else /* NO_FIND_INTERFACES */
705 /* Some experimental or developing OS (e.g. GNU/Hurd) do not have the ioctls,
706 and there is no other way to get a list of the (IP addresses of) local
707 interfaces. We just return the loopback address(es). */
710 os_common_find_running_interfaces(void)
712 ip_address_item *yield = store_get(sizeof(address_item));
713 yield->address = US"127.0.0.1";
718 yield->next = store_get(sizeof(address_item));
719 yield->next->address = US"::1";
720 yield->next->port = 0;
721 yield->next->next = NULL;
724 DEBUG(D_interface) debug_printf("Unable to find local interface addresses "
725 "on this OS: returning loopback address(es)\n");
729 #endif /* NO_FIND_INTERFACES */
730 #endif /* FIND_RUNNING_INTERFACES */
736 /*************************************************
737 **************************************************
738 * Stand-alone test program *
739 **************************************************
740 *************************************************/
745 #ifdef CLOCKS_PER_SEC
746 #define REAL_CLOCK_TICK CLOCKS_PER_SEC
749 #define REAL_CLOCK_TICK CLK_TCK
751 #define REAL_CLOCK_TICK 1000000 /* SunOS4 */
756 int main(int argc, char **argv)
759 int fd = fileno(stdin);
762 printf("Testing restarting signal; wait for handler message, then type a line\n");
763 strcpy(buffer, "*** default ***\n");
764 os_restarting_signal(SIGALRM, sigalrm_handler);
766 if ((rc = read(fd, buffer, sizeof(buffer))) < 0)
767 printf("No data read\n");
771 printf("Read: %s", buffer);
775 printf("Testing non-restarting signal; should read no data after handler message\n");
776 strcpy(buffer, "*** default ***\n");
777 os_non_restarting_signal(SIGALRM, sigalrm_handler);
779 if ((rc = read(fd, buffer, sizeof(buffer))) < 0)
780 printf("No data read\n");
784 printf("Read: %s", buffer);
788 printf("Testing load averages (last test - ^C to kill)\n");
793 clock_t before = clock();
794 avg = os_getloadavg();
795 used = clock() - before;
796 printf("cpu time = %.2f ", (double)used/REAL_CLOCK_TICK);
799 printf("load average not available\n");
802 printf("load average = %.2f\n", (double)avg/1000.0);