tidying
[exim.git] / src / src / os.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2016 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 #ifdef STAND_ALONE
9 #include <signal.h>
10 #include <stdio.h>
11 #include <time.h>
12 #endif
13
14 /* This source file contains "default" system-dependent functions which
15 provide functionality (or lack of it) in cases where the OS-specific os.c
16 file has not. Some of them are tailored by macros defined in os.h files. */
17
18
19 #ifndef OS_RESTARTING_SIGNAL
20 /*************************************************
21 *          Set up restarting signal              *
22 *************************************************/
23
24 /* This function has the same functionality as the ANSI C signal() function,
25 except that it arranges that, if the signal happens during a system call, the
26 system call gets restarted. (Also, it doesn't return a result.) Different
27 versions of Unix have different defaults, and different ways of setting up a
28 restarting signal handler. If the functionality is not available, the signal
29 should be set to be ignored. This function is used only for catching SIGUSR1.
30 */
31
32 void
33 os_restarting_signal(int sig, void (*handler)(int))
34 {
35 /* Many systems have the SA_RESTART sigaction for specifying that a signal
36 should restart system calls. These include SunOS5, AIX, BSDI, IRIX, FreeBSD,
37 OSF1, Linux and HP-UX 10 (but *not* HP-UX 9). */
38
39 #ifdef SA_RESTART
40 struct sigaction act;
41 act.sa_handler = handler;
42 sigemptyset(&(act.sa_mask));
43 act.sa_flags = SA_RESTART;
44 sigaction(sig, &act, NULL);
45
46 #ifdef STAND_ALONE
47 printf("Used SA_RESTART\n");
48 #endif
49
50 /* SunOS4 and Ultrix default to non-interruptable signals, with SV_INTERRUPT
51 for making them interruptable. This seems to be a dying fashion. */
52
53 #elif defined SV_INTERRUPT
54 signal(sig, handler);
55
56 #ifdef STAND_ALONE
57 printf("Used default signal()\n");
58 #endif
59
60
61 /* If neither SA_RESTART nor SV_INTERRUPT is available we don't know how to
62 set up a restarting signal, so simply suppress the facility. */
63
64 #else
65 signal(sig, SIG_IGN);
66
67 #ifdef STAND_ALONE
68 printf("Used SIG_IGN\n");
69 #endif
70
71 #endif
72 }
73
74 #endif  /* OS_RESTARTING_SIGNAL */
75
76
77 #ifndef OS_NON_RESTARTING_SIGNAL
78 /*************************************************
79 *          Set up non-restarting signal          *
80 *************************************************/
81
82 /* This function has the same functionality as the ANSI C signal() function,
83 except that it arranges that, if the signal happens during a system call, the
84 system call gets interrupted. (Also, it doesn't return a result.) Different
85 versions of Unix have different defaults, and different ways of setting up a
86 non-restarting signal handler. For systems for which we don't know what to do,
87 just use the normal signal() function and hope for the best. */
88
89 void
90 os_non_restarting_signal(int sig, void (*handler)(int))
91 {
92 /* Many systems have the SA_RESTART sigaction for specifying that a signal
93 should restart system calls. These include SunOS5, AIX, BSDI, IRIX, FreeBSD,
94 OSF1, Linux and HP-UX 10 (but *not* HP-UX 9). */
95
96 #ifdef SA_RESTART
97 struct sigaction act;
98 act.sa_handler = handler;
99 sigemptyset(&(act.sa_mask));
100 act.sa_flags = 0;
101 sigaction(sig, &act, NULL);
102
103 #ifdef STAND_ALONE
104 printf("Used sigaction() with flags = 0\n");
105 #endif
106
107 /* SunOS4 and Ultrix default to non-interruptable signals, with SV_INTERRUPT
108 for making them interruptable. This seems to be a dying fashion. */
109
110 #elif defined SV_INTERRUPT
111 struct sigvec sv;
112 sv.sv_handler = handler;
113 sv.sv_flags = SV_INTERRUPT;
114 sv.sv_mask = -1;
115 sigvec(sig, &sv, NULL);
116
117 #ifdef STAND_ALONE
118 printf("Used sigvec() with flags = SV_INTERRUPT\n");
119 #endif
120
121 /* If neither SA_RESTART nor SV_INTERRUPT is available we don't know how to
122 set up a restarting signal, so just use the standard signal() function. */
123
124 #else
125 signal(sig, handler);
126
127 #ifdef STAND_ALONE
128 printf("Used default signal()\n");
129 #endif
130
131 #endif
132 }
133
134 #endif  /* OS_NON_RESTARTING_SIGNAL */
135
136
137
138 #ifdef STRERROR_FROM_ERRLIST
139 /*************************************************
140 *     Provide strerror() for non-ANSI libraries  *
141 *************************************************/
142
143 /* Some old-fashioned systems still around (e.g. SunOS4) don't have strerror()
144 in their libraries, but can provide the same facility by this simple
145 alternative function. */
146
147 char *
148 strerror(int n)
149 {
150 if (n < 0 || n >= sys_nerr) return "unknown error number";
151 return sys_errlist[n];
152 }
153 #endif /* STRERROR_FROM_ERRLIST */
154
155
156
157 #ifndef OS_STRSIGNAL
158 /*************************************************
159 *      Provide strsignal() for systems without   *
160 *************************************************/
161
162 /* Some systems have strsignal() to turn signal numbers into names; others
163 may have other means of doing this. This function is used for those systems
164 that have nothing. It provides a basic translation for the common standard
165 signal numbers. I've been extra cautious with the ifdef's here. Probably more
166 than is necessary... */
167
168 const char *
169 os_strsignal(const int n)
170 {
171 switch (n)
172   {
173   #ifdef SIGHUP
174   case SIGHUP:  return "hangup";
175   #endif
176
177   #ifdef SIGINT
178   case SIGINT:  return "interrupt";
179   #endif
180
181   #ifdef SIGQUIT
182   case SIGQUIT: return "quit";
183   #endif
184
185   #ifdef SIGILL
186   case SIGILL:  return "illegal instruction";
187   #endif
188
189   #ifdef SIGTRAP
190   case SIGTRAP: return "trace trap";
191   #endif
192
193   #ifdef SIGABRT
194   case SIGABRT: return "abort";
195   #endif
196
197   #ifdef SIGEMT
198   case SIGEMT:  return "EMT instruction";
199   #endif
200
201   #ifdef SIGFPE
202   case SIGFPE:  return "arithmetic exception";
203   #endif
204
205   #ifdef SIGKILL
206   case SIGKILL: return "killed";
207   #endif
208
209   #ifdef SIGBUS
210   case SIGBUS:  return "bus error";
211   #endif
212
213   #ifdef SIGSEGV
214   case SIGSEGV: return "segmentation fault";
215   #endif
216
217   #ifdef SIGSYS
218   case SIGSYS:  return "bad system call";
219   #endif
220
221   #ifdef SIGPIPE
222   case SIGPIPE: return "broken pipe";
223   #endif
224
225   #ifdef SIGALRM
226   case SIGALRM: return "alarm";
227   #endif
228
229   #ifdef SIGTERM
230   case SIGTERM: return "terminated";
231   #endif
232
233   #ifdef SIGUSR1
234   case SIGUSR1: return "user signal 1";
235   #endif
236
237   #ifdef SIGUSR2
238   case SIGUSR2: return "user signal 2";
239   #endif
240
241   #ifdef SIGCHLD
242   case SIGCHLD: return "child stop or exit";
243   #endif
244
245   #ifdef SIGPWR
246   case SIGPWR:  return "power fail/restart";
247   #endif
248
249   #ifdef SIGURG
250   case SIGURG:  return "urgent condition on I/O channel";
251   #endif
252
253   #ifdef SIGSTOP
254   case SIGSTOP: return "stop";
255   #endif
256
257   #ifdef SIGTSTP
258   case SIGTSTP: return "stop from tty";
259   #endif
260
261   #ifdef SIGXCPU
262   case SIGXCPU: return "exceeded CPU limit";
263   #endif
264
265   #ifdef SIGXFSZ
266   case SIGXFSZ: return "exceeded file size limit";
267   #endif
268
269   default:      return "unrecognized signal number";
270   }
271 }
272 #endif /* OS_STRSIGNAL */
273
274
275
276 #ifndef OS_STREXIT
277 /*************************************************
278 *      Provide strexit() for systems without     *
279 *************************************************/
280
281 /* Actually, I don't know of any system that has a strexit() function to turn
282 exit codes into text, but this function is implemented this way so that if any
283 OS does have such a thing, it could be used instead of this build-in one. */
284
285 const char *
286 os_strexit(const int n)
287 {
288 switch (n)
289   {
290   /* On systems without sysexits.h we can assume only those exit codes
291   that are given a default value in exim.h. */
292
293   #ifndef NO_SYSEXITS
294   case EX_USAGE:       return "(could mean usage or syntax error)";
295   case EX_DATAERR:     return "(could mean error in input data)";
296   case EX_NOINPUT:     return "(could mean input data missing)";
297   case EX_NOUSER:      return "(could mean user nonexistent)";
298   case EX_NOHOST:      return "(could mean host nonexistent)";
299   case EX_SOFTWARE:    return "(could mean internal software error)";
300   case EX_OSERR:       return "(could mean internal operating system error)";
301   case EX_OSFILE:      return "(could mean system file missing)";
302   case EX_IOERR:       return "(could mean input/output error)";
303   case EX_PROTOCOL:    return "(could mean protocol error)";
304   case EX_NOPERM:      return "(could mean permission denied)";
305   #endif
306
307   case EX_EXECFAILED:  return "(could mean unable to exec or command does not exist)";
308   case EX_UNAVAILABLE: return "(could mean service or program unavailable)";
309   case EX_CANTCREAT:   return "(could mean can't create output file)";
310   case EX_TEMPFAIL:    return "(could mean temporary error)";
311   case EX_CONFIG:      return "(could mean configuration error)";
312   default:             return "";
313   }
314 }
315 #endif /* OS_STREXIT */
316
317
318
319
320 /***********************************************************
321 *                   Load average function                  *
322 ***********************************************************/
323
324 /* Although every Unix seems to have a different way of getting the load
325 average, a number of them have things in common. Some common variants are
326 provided below, but if an OS has unique requirements it can be handled in
327 a specific os.c file. What is required is a function called os_getloadavg
328 which takes no arguments and passes back the load average * 1000 as an int,
329 or -1 if no data is available. */
330
331
332 /* ----------------------------------------------------------------------- */
333 /* If the OS has got a BSD getloadavg() function, life is very easy. */
334
335 #if !defined(OS_LOAD_AVERAGE) && defined(HAVE_BSD_GETLOADAVG)
336 #define OS_LOAD_AVERAGE
337
338 int
339 os_getloadavg(void)
340 {
341 double avg;
342 int loads = getloadavg (&avg, 1);
343 if (loads != 1) return -1;
344 return (int)(avg * 1000.0);
345 }
346 #endif
347 /* ----------------------------------------------------------------------- */
348
349
350
351 /* ----------------------------------------------------------------------- */
352 /* Only SunOS5 has the kstat functions as far as I know, but put the code
353 here as there is the -hal variant, and other systems might follow this road one
354 day. */
355
356 #if !defined(OS_LOAD_AVERAGE) && defined(HAVE_KSTAT)
357 #define OS_LOAD_AVERAGE
358
359 #include <kstat.h>
360
361 int
362 os_getloadavg(void)
363 {
364 int avg;
365 kstat_ctl_t *kc;
366 kstat_t *ksp;
367 kstat_named_t *kn;
368
369 if ((kc = kstat_open()) == NULL ||
370     (ksp = kstat_lookup(kc, LOAD_AVG_KSTAT_MODULE, 0, LOAD_AVG_KSTAT))
371         == NULL ||
372      kstat_read(kc, ksp, NULL) < 0 ||
373     (kn = kstat_data_lookup(ksp, LOAD_AVG_SYMBOL)) == NULL)
374   return -1;
375
376 avg = (int)(((double)(kn->LOAD_AVG_FIELD)/FSCALE) * 1000.0);
377
378 kstat_close(kc);
379 return avg;
380 }
381
382 #endif
383 /* ----------------------------------------------------------------------- */
384
385
386
387 /* ----------------------------------------------------------------------- */
388 /* Handle OS where a kernel symbol has to be read from /dev/kmem */
389
390 #if !defined(OS_LOAD_AVERAGE) && defined(HAVE_DEV_KMEM)
391 #define OS_LOAD_AVERAGE
392
393 #include <nlist.h>
394
395 static int  avg_kd = -1;
396 static long avg_offset;
397
398 int
399 os_getloadavg(void)
400 {
401 LOAD_AVG_TYPE avg;
402
403 if (avg_kd < 0)
404   {
405   struct nlist nl[2];
406   nl[0].n_name = LOAD_AVG_SYMBOL;
407   nl[1].n_name = "";
408   nlist (KERNEL_PATH, nl);
409   avg_offset = (long)nl[0].n_value;
410   avg_kd = open ("/dev/kmem", 0);
411   if (avg_kd < 0) return -1;
412   (void) fcntl(avg_kd, F_SETFD, FD_CLOEXEC);
413   }
414
415 if (lseek (avg_kd, avg_offset, 0) == -1L
416     || read (avg_kd, (char *)(&avg), sizeof (avg)) != sizeof(avg))
417   return -1;
418
419 return (int)(((double)avg/FSCALE)*1000.0);
420 }
421
422 #endif
423 /* ----------------------------------------------------------------------- */
424
425
426
427 /* ----------------------------------------------------------------------- */
428 /* If nothing is known about this OS, then the load average facility is
429 not available. */
430
431 #ifndef OS_LOAD_AVERAGE
432
433 int
434 os_getloadavg(void)
435 {
436 return -1;
437 }
438
439 #endif
440
441 /* ----------------------------------------------------------------------- */
442
443
444
445 #if !defined FIND_RUNNING_INTERFACES
446 /*************************************************
447 *     Find all the running network interfaces    *
448 *************************************************/
449
450 /* Finding all the running interfaces is something that has os-dependent
451 tweaks, even in the IPv4 case, and it gets worse for IPv6, which is why this
452 code is now in the os-dependent source file. There is a common function which
453 works on most OS (except IRIX) for IPv4 interfaces, and, with some variations
454 controlled by macros, on at least one OS for IPv6 and IPv4 interfaces. On Linux
455 with IPv6, the common function is used for the IPv4 interfaces and additional
456 code used for IPv6. Consequently, the real function is called
457 os_common_find_running_interfaces() so that it can be called from the Linux
458 function. On non-Linux systems, the macro for os_find_running_interfaces just
459 calls the common function; on Linux it calls the Linux function.
460
461 This function finds the addresses of all the running interfaces on the machine.
462 A chain of blocks containing the textual form of the addresses is returned.
463
464 getifaddrs() provides a sane consistent way to query this on modern OSs,
465 otherwise fall back to a maze of twisty ioctl() calls
466
467 Arguments:    none
468 Returns:      a chain of ip_address_items, each pointing to a textual
469               version of an IP address, with the port field set to zero
470 */
471
472
473 #ifndef NO_FIND_INTERFACES
474
475 #ifdef HAVE_GETIFADDRS
476
477 #include <ifaddrs.h>
478
479 ip_address_item *
480 os_common_find_running_interfaces(void)
481 {
482 struct ifaddrs *ifalist = NULL;
483 ip_address_item *yield = NULL;
484 ip_address_item *last = NULL;
485 ip_address_item  *next;
486
487 if (getifaddrs(&ifalist) != 0)
488   log_write(0, LOG_PANIC_DIE, "Unable to call getifaddrs: %d %s",
489     errno, strerror(errno));
490
491 struct ifaddrs *ifa;
492 for (ifa = ifalist; ifa != NULL; ifa = ifa->ifa_next)
493   {
494   if (ifa->ifa_addr->sa_family != AF_INET
495 #if HAVE_IPV6
496     && ifa->ifa_addr->sa_family != AF_INET6
497 #endif /* HAVE_IPV6 */
498     )
499     continue;
500
501   if ( !(ifa->ifa_flags & IFF_UP) ) /* Only want 'UP' interfaces */
502     continue;
503
504   /* Create a data block for the address, fill in the data, and put it on the
505   chain. */
506
507   next = store_get(sizeof(ip_address_item));
508   next->next = NULL;
509   next->port = 0;
510   (void)host_ntoa(-1, ifa->ifa_addr, next->address, NULL);
511
512   if (yield == NULL)
513     yield = last = next;
514   else
515     {
516     last->next = next;
517     last = next;
518     }
519
520   DEBUG(D_interface) debug_printf("Actual local interface address is %s (%s)\n",
521     last->address, ifa->ifa_name);
522   }
523
524 /* free the list of addresses, and return the chain of data blocks. */
525
526 freeifaddrs (ifalist);
527 return yield;
528 }
529
530 #else /* HAVE_GETIFADDRS */
531
532 /*
533 Problems:
534
535   (1) Solaris 2 has the SIOGIFNUM call to get the number of interfaces, but
536   other OS (including Solaris 1) appear not to. So just screw in a largeish
537   fixed number, defined by MAX_INTERFACES. This is in the config.h file and
538   can be changed in Local/Makefile. Unfortunately, the www addressing scheme
539   means that some hosts have a very large number of virtual interfaces. Such
540   hosts are recommended to set local_interfaces to avoid problems with this.
541
542   (2) If the standard code is run on IRIX, it does not return any alias
543   interfaces. There is special purpose code for that operating system, which
544   uses the sysctl() function. The code is in OS/os.c-IRIX, and this code isn't
545   used on that OS.
546
547   (3) Some experimental/developing OS (e.g. GNU/Hurd) do not have any means
548   of finding the interfaces. If NO_FIND_INTERFACES is set, a fudge-up is used
549   instead.
550
551   (4) Some operating systems set the IP address in what SIOCGIFCONF returns;
552   others do not, and require SIOCGIFADDR to be called to get it. For most of
553   the former, calling the latter does no harm, but it causes grief on Linux and
554   BSD systems in the case of IP aliasing, so a means of cutting it out is
555   provided.
556 */
557
558 /* If there is IPv6 support, and SIOCGLIFCONF is defined, define macros to
559 use these new, longer versions of the old IPv4 interfaces. Otherwise, define
560 the macros to use the historical versions. */
561
562 #if HAVE_IPV6 && defined SIOCGLIFCONF
563 #define V_ifconf        lifconf
564 #define V_ifreq         lifreq
565 #define V_GIFADDR       SIOCGLIFADDR
566 #define V_GIFCONF       SIOCGLIFCONF
567 #define V_GIFFLAGS      SIOCGLIFFLAGS
568 #define V_ifc_buf       lifc_buf
569 #define V_ifc_family    lifc_family
570 #define V_ifc_flags     lifc_flags
571 #define V_ifc_len       lifc_len
572 #define V_ifr_addr      lifr_addr
573 #define V_ifr_flags     lifr_flags
574 #define V_ifr_name      lifr_name
575 #define V_FAMILY_QUERY  AF_UNSPEC
576 #define V_family        ss_family
577 #else
578 #define V_ifconf        ifconf
579 #define V_ifreq         ifreq
580 #define V_GIFADDR       SIOCGIFADDR
581 #define V_GIFCONF       SIOCGIFCONF
582 #define V_GIFFLAGS      SIOCGIFFLAGS
583 #define V_ifc_buf       ifc_buf
584 #define V_ifc_family    ifc_family
585 #define V_ifc_flags     ifc_flags
586 #define V_ifc_len       ifc_len
587 #define V_ifr_addr      ifr_addr
588 #define V_ifr_flags     ifr_flags
589 #define V_ifr_name      ifr_name
590 #define V_family        sa_family
591 #endif
592
593 /* In all cases of IPv6 support, use an IPv6 socket. Otherwise (at least on
594 Solaris 8) the call to read the flags doesn't work for IPv6 interfaces. If
595 we find we can't actually make an IPv6 socket, the code will revert to trying
596 an IPv4 socket. */
597
598 #if HAVE_IPV6
599 #define FAMILY          AF_INET6
600 #else
601 #define FAMILY          AF_INET
602 #endif
603
604 /* OK, after all that preliminary stuff, here's the code. */
605
606 ip_address_item *
607 os_common_find_running_interfaces(void)
608 {
609 struct V_ifconf ifc;
610 struct V_ifreq ifreq;
611 int vs;
612 ip_address_item *yield = NULL;
613 ip_address_item *last = NULL;
614 ip_address_item  *next;
615 char *cp;
616 char buf[MAX_INTERFACES*sizeof(struct V_ifreq)];
617 struct sockaddr *addrp;
618 size_t len = 0;
619 char addrbuf[512];
620
621 /* We have to create a socket in order to do ioctls on it to find out
622 what we want to know. */
623
624 if ((vs = socket(FAMILY, SOCK_DGRAM, 0)) < 0)
625   {
626   #if HAVE_IPV6
627   DEBUG(D_interface)
628     debug_printf("Unable to create IPv6 socket to find interface addresses:\n  "
629       "error %d %s\nTrying for an IPv4 socket\n", errno, strerror(errno));
630   vs = socket(AF_INET, SOCK_DGRAM, 0);
631   if (vs < 0)
632   #endif
633   log_write(0, LOG_PANIC_DIE, "Unable to create IPv4 socket to find interface "
634     "addresses: %d %s", errno, strerror(errno));
635   }
636
637 /* Get the interface configuration. Some additional data is required when the
638 new structures are in use. */
639
640 ifc.V_ifc_len = sizeof(buf);
641 ifc.V_ifc_buf = buf;
642
643 #ifdef V_FAMILY_QUERY
644 ifc.V_ifc_family = V_FAMILY_QUERY;
645 ifc.V_ifc_flags = 0;
646 #endif
647
648 if (ioctl(vs, V_GIFCONF, (char *)&ifc) < 0)
649   log_write(0, LOG_PANIC_DIE, "Unable to get interface configuration: %d %s",
650     errno, strerror(errno));
651
652 /* If the buffer is big enough, the ioctl sets the value of ifc.V_ifc_len to
653 the amount actually used. If the buffer isn't big enough, at least on some
654 operating systems, ifc.V_ifc_len still gets set to correspond to the total
655 number of interfaces, even though they don't all fit in the buffer. */
656
657 if (ifc.V_ifc_len > sizeof(buf))
658   {
659   ifc.V_ifc_len = sizeof(buf);
660   DEBUG(D_interface)
661     debug_printf("more than %d interfaces found: remainder not used\n"
662       "(set MAX_INTERFACES in Local/Makefile and rebuild if you want more)\n",
663       MAX_INTERFACES);
664   }
665
666 /* For each interface, check it is an IP interface, get its flags, and see if
667 it is up; if not, skip.
668
669 BSD systems differ from others in what SIOCGIFCONF returns. Other systems
670 return a vector of ifreq structures whose size is as defined by the structure.
671 BSD systems allow sockaddrs to be longer than their sizeof, which in turn makes
672 the ifreq structures longer than their sizeof. The code below has its origins
673 in amd and ifconfig; it uses the sa_len field of each sockaddr to determine
674 each item's length.
675
676 This is complicated by the fact that, at least on BSD systems, the data in the
677 buffer is not guaranteed to be aligned. Thus, we must first copy the basic
678 struct to some aligned memory before looking at the field in the fixed part to
679 find its length, and then recopy the correct length. */
680
681 for (cp = buf; cp < buf + ifc.V_ifc_len; cp += len)
682   {
683   memcpy((char *)&ifreq, cp, sizeof(ifreq));
684
685   #ifndef HAVE_SA_LEN
686   len = sizeof(struct V_ifreq);
687
688   #else
689   len = ((ifreq.ifr_addr.sa_len > sizeof(ifreq.ifr_addr))?
690           ifreq.ifr_addr.sa_len : sizeof(ifreq.ifr_addr)) +
691          sizeof(ifreq.V_ifr_name);
692   if (len > sizeof(addrbuf))
693     log_write(0, LOG_PANIC_DIE, "Address for %s interface is absurdly long",
694         ifreq.V_ifr_name);
695
696   #endif
697
698   /* If not an IP interface, skip */
699
700   if (ifreq.V_ifr_addr.V_family != AF_INET
701   #if HAVE_IPV6
702     && ifreq.V_ifr_addr.V_family != AF_INET6
703   #endif
704     ) continue;
705
706   /* Get the interface flags, and if the interface is down, continue. Formerly,
707   we treated the inability to get the flags as a panic-die error. However, it
708   seems that on some OS (Solaris 9 being the case noted), it is possible to
709   have an interface in this list for which this call fails because the
710   interface hasn't been "plumbed" to any protocol (IPv4 or IPv6). Therefore,
711   we now just treat this case as "down" as well. */
712
713   if (ioctl(vs, V_GIFFLAGS, (char *)&ifreq) < 0)
714     {
715     continue;
716     /*************
717     log_write(0, LOG_PANIC_DIE, "Unable to get flags for %s interface: %d %s",
718       ifreq.V_ifr_name, errno, strerror(errno));
719     *************/
720     }
721   if ((ifreq.V_ifr_flags & IFF_UP) == 0) continue;
722
723   /* On some operating systems we have to get the IP address of the interface
724   by another call. On others, it's already there, but we must copy the full
725   length because we only copied the basic length above, and anyway,
726   GIFFLAGS may have wrecked the data. */
727
728   #ifndef SIOCGIFCONF_GIVES_ADDR
729   if (ioctl(vs, V_GIFADDR, (char *)&ifreq) < 0)
730     log_write(0, LOG_PANIC_DIE, "Unable to get IP address for %s interface: "
731       "%d %s", ifreq.V_ifr_name, errno, strerror(errno));
732   addrp = &ifreq.V_ifr_addr;
733
734   #else
735   memcpy(addrbuf, cp + offsetof(struct V_ifreq, V_ifr_addr),
736     len - sizeof(ifreq.V_ifr_name));
737   addrp = (struct sockaddr *)addrbuf;
738   #endif
739
740   /* Create a data block for the address, fill in the data, and put it on the
741   chain. */
742
743   next = store_get(sizeof(ip_address_item));
744   next->next = NULL;
745   next->port = 0;
746   (void)host_ntoa(-1, addrp, next->address, NULL);
747
748   if (yield == NULL) yield = last = next; else
749     {
750     last->next = next;
751     last = next;
752     }
753
754   DEBUG(D_interface) debug_printf("Actual local interface address is %s (%s)\n",
755     last->address, ifreq.V_ifr_name);
756   }
757
758 /* Close the socket, and return the chain of data blocks. */
759
760 (void)close(vs);
761 return yield;
762 }
763
764 #endif /* HAVE_GETIFADDRS */
765
766 #else  /* NO_FIND_INTERFACES */
767
768 /* Some experimental or developing OS (e.g. GNU/Hurd) do not have the ioctls,
769 and there is no other way to get a list of the (IP addresses of) local
770 interfaces. We just return the loopback address(es). */
771
772 ip_address_item *
773 os_common_find_running_interfaces(void)
774 {
775 ip_address_item *yield = store_get(sizeof(address_item));
776 yield->address = US"127.0.0.1";
777 yield->port = 0;
778 yield->next = NULL;
779
780 #if HAVE_IPV6
781 yield->next = store_get(sizeof(address_item));
782 yield->next->address = US"::1";
783 yield->next->port = 0;
784 yield->next->next = NULL;
785 #endif
786
787 DEBUG(D_interface) debug_printf("Unable to find local interface addresses "
788   "on this OS: returning loopback address(es)\n");
789 return yield;
790 }
791
792 #endif /* NO_FIND_INTERFACES */
793 #endif /* FIND_RUNNING_INTERFACES */
794
795
796
797
798 /* ----------------------------------------------------------------------- */
799
800 /***********************************************************
801 *                 DNS Resolver Base Finder                 *
802 ***********************************************************/
803
804 /* We need to be able to set options for the system resolver(5), historically
805 made available as _res.  At least one OS (NetBSD) now no longer provides this
806 directly, instead making you call a function per thread to get a handle.
807 Other OSs handle thread-safe resolver differently, in ways which fail if the
808 programmer creates their own structs. */
809
810 #if !defined(OS_GET_DNS_RESOLVER_RES) && !defined(COMPILE_UTILITY)
811
812 #include <resolv.h>
813
814 /* confirmed that res_state is typedef'd as a struct* on BSD and Linux, will
815 find out how unportable it is on other OSes, but most resolver implementations
816 should be descended from ISC's bind.
817
818 Linux and BSD do:
819   define _res (*__res_state())
820 identically.  We just can't rely on __foo functions.  It's surprising that use
821 of _res has been as portable as it has, for so long.
822
823 So, since _res works everywhere, and everything can decode the struct, I'm
824 going to gamble that res_state is a typedef everywhere and use that as the
825 return type.
826 */
827
828 res_state
829 os_get_dns_resolver_res(void)
830 {
831   return &_res;
832 }
833
834 #endif /* OS_GET_DNS_RESOLVER_RES */
835
836 /* ----------------------------------------------------------------------- */
837
838 /***********************************************************
839 *                 unsetenv()                               *
840 ***********************************************************/
841
842 /* Most modern systems define int unsetenv(const char*),
843 * some don't. */
844
845 #if !defined(OS_UNSETENV)
846 int
847 os_unsetenv(const unsigned char * name)
848 {
849 return unsetenv((char *)name);
850 }
851 #endif
852
853 /* ----------------------------------------------------------------------- */
854
855 /***********************************************************
856 *               getcwd()                                   *
857 ***********************************************************/
858
859 /* Glibc allows getcwd(NULL, 0) to do auto-allocation. Some systems
860 do auto-allocation, but need the size of the buffer, and others
861 may not even do this. If the OS supports getcwd(NULL, 0) we'll use
862 this, for all other systems we provide our own getcwd() */
863
864 #if !defined(OS_GETCWD)
865 unsigned char *
866 os_getcwd(unsigned char * buffer, size_t size)
867 {
868 return (unsigned char *) getcwd((char *)buffer, size);
869 }
870 #else
871 #ifndef PATH_MAX
872 # define PATH_MAX 4096
873 #endif
874 unsigned char *
875 os_getcwd(unsigned char * buffer, size_t size)
876 {
877 char * b = (char *)buffer;
878
879 if (!size) size = PATH_MAX;
880 if (!b && !(b = malloc(size))) return NULL;
881 if (!(b = getcwd(b, size))) return NULL;
882 return buffer ? buffer : realloc(b, strlen(b) + 1);
883 }
884 #endif
885
886 /* ----------------------------------------------------------------------- */
887
888
889
890
891 /*************************************************
892 **************************************************
893 *             Stand-alone test program           *
894 **************************************************
895 *************************************************/
896
897
898 #ifdef STAND_ALONE
899
900 #ifdef CLOCKS_PER_SEC
901 #define REAL_CLOCK_TICK CLOCKS_PER_SEC
902 #else
903   #ifdef CLK_TCK
904   #define REAL_CLOCK_TICK CLK_TCK
905   #else
906   #define REAL_CLOCK_TICK 1000000   /* SunOS4 */
907   #endif
908 #endif
909
910
911 int main(int argc, char **argv)
912 {
913 char buffer[128];
914 int fd = fileno(stdin);
915 int rc;
916
917 printf("Testing restarting signal; wait for handler message, then type a line\n");
918 strcpy(buffer, "*** default ***\n");
919 os_restarting_signal(SIGALRM, sigalrm_handler);
920 alarm(2);
921 if ((rc = read(fd, buffer, sizeof(buffer))) < 0)
922   printf("No data read\n");
923 else
924   {
925   buffer[rc] = 0;
926   printf("Read: %s", buffer);
927   }
928 alarm(0);
929
930 printf("Testing non-restarting signal; should read no data after handler message\n");
931 strcpy(buffer, "*** default ***\n");
932 os_non_restarting_signal(SIGALRM, sigalrm_handler);
933 alarm(2);
934 if ((rc = read(fd, buffer, sizeof(buffer))) < 0)
935   printf("No data read\n");
936 else
937   {
938   buffer[rc] = 0;
939   printf("Read: %s", buffer);
940   }
941 alarm(0);
942
943 printf("Testing load averages (last test - ^C to kill)\n");
944 for (;;)
945   {
946   int avg;
947   clock_t used;
948   clock_t before = clock();
949   avg = os_getloadavg();
950   used = clock() - before;
951   printf("cpu time = %.2f ", (double)used/REAL_CLOCK_TICK);
952   if (avg < 0)
953     {
954     printf("load average not available\n");
955     break;
956     }
957   printf("load average = %.2f\n", (double)avg/1000.0);
958   sleep(2);
959   }
960 return 0;
961 }
962
963 #endif
964
965 /* End of os.c */