开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
sysutil.c
资源名称：vsftpd-2.2.2.tar.gz　[点击查看]
上传用户：ig0539
上传日期：2022-05-21
资源大小：181k
文件大小：60k
源码类别：

Ftp客户端

开发平台：

C/C++

sysutil.c：源码内容
  1. /*
  2.  * Part of Very Secure FTPd
  3.  * Licence: GPL v2
  4.  * Author: Chris Evans
  5.  * 
  6.  * sysutil.c
  7.  *
  8.  * Routines to make the libc/syscall API more pleasant to use. Long term,
  9.  * more libc/syscalls will go in here to reduce the number of .c files with
  10.  * dependencies on libc or syscalls.
  11.  */
  13. #define PRIVATE_HANDS_OFF_syscall_retval syscall_retval
  14. #define PRIVATE_HANDS_OFF_exit_status exit_status
  15. #include "sysutil.h"
  16. #include "utility.h"
  17. #include "tunables.h"
  18. #include "sysdeputil.h"
  20. /* Activate 64-bit file support on Linux/32bit plus others */
  21. #define _FILE_OFFSET_BITS 64
  22. #define _LARGEFILE_SOURCE 1
  23. #define _LARGEFILE64_SOURCE 1
  24. #define _LARGE_FILES 1
  26. /* For Linux, this adds nothing :-) */
  27. #include "port/porting_junk.h"
  29. #include <signal.h>
  30. #include <string.h>
  31. #include <stdlib.h>
  32. #include <unistd.h>
  33. #include <sys/types.h>
  34. #include <sys/socket.h>
  35. #include <sys/mman.h>
  36. #include <sys/stat.h>
  37. #include <fcntl.h>
  38. #include <netinet/in.h>
  39. #include <stdio.h>
  40. #include <dirent.h>
  41. #include <time.h>
  42. #include <arpa/inet.h>
  43. #include <errno.h>
  44. #include <pwd.h>
  45. #include <grp.h>
  46. #include <ctype.h>
  47. #include <sys/wait.h>
  48. #include <sys/time.h>
  49. /* Must be before netinet/ip.h. Found on FreeBSD, Solaris */
  50. #include <netinet/in_systm.h>
  51. #include <netinet/ip.h>
  52. #include <netinet/tcp.h>
  53. #include <limits.h>
  54. #include <syslog.h>
  55. #include <utime.h>
  56. #include <netdb.h>
  57. #include <sys/resource.h>
  59. /* Private variables to this file */
  60. /* Current umask() */
  61. static unsigned int s_current_umask;
  62. /* Cached time */
  63. static struct timeval s_current_time;
  64. /* Current pid */
  65. static int s_current_pid = -1;
  66. /* Exit function */
  67. static exitfunc_t s_exit_func;
  68. /* Difference in timezone from GMT in seconds */
  69. static long s_timezone;
  71. /* Our internal signal handling implementation details */
  72. static struct vsf_sysutil_sig_details
  73. {
  74.   vsf_sighandle_t sync_sig_handler;
  75.   void* p_private;
  76.   volatile sig_atomic_t pending;
  77.   int running;
  78.   int use_alarm;
  79. } s_sig_details[NSIG];
  81. static vsf_context_io_t s_io_handler;
  82. static void* s_p_io_handler_private;
  83. static int s_io_handler_running;
  85. struct vsf_sysutil_sockaddr
  86. {
  87.   union
  88.   {
  89.     struct sockaddr u_sockaddr;
  90.     struct sockaddr_in u_sockaddr_in;
  91.     struct sockaddr_in6 u_sockaddr_in6;
  92.   } u;
  93. };
  95. /* File locals */
  96. static void vsf_sysutil_common_sighandler(int signum);
  97. static void vsf_sysutil_alrm_sighandler(int signum);
  98. static int vsf_sysutil_translate_sig(const enum EVSFSysUtilSignal sig);
  99. static void vsf_sysutil_set_sighandler(int sig, void (*p_handlefunc)(int));
  100. static int vsf_sysutil_translate_memprot(
  101.   const enum EVSFSysUtilMapPermission perm);
  102. static int vsf_sysutil_translate_openmode(
  103.   const enum EVSFSysUtilOpenMode mode);
  104. static void vsf_sysutil_alloc_statbuf(struct vsf_sysutil_statbuf** p_ptr);
  105. void vsf_sysutil_sockaddr_alloc(struct vsf_sysutil_sockaddr** p_sockptr);
  106. static int lock_internal(int fd, int lock_type);
  108. static void
  109. vsf_sysutil_alrm_sighandler(int signum)
  110. {
  111.   (void) signum;
  112.   alarm(1);
  113. }
  115. static void
  116. vsf_sysutil_common_sighandler(int signum)
  117. {
  118.   if (signum < 0 || signum >= NSIG)
  119.   {
  120.     /* "cannot happen" */
  121.     return;
  122.   }
  123.   if (s_sig_details[signum].sync_sig_handler)
  124.   {
  125.     s_sig_details[signum].pending = 1;
  126.     /* Since this synchronous signal framework has a small race (signal coming
  127.      * in just before we start a blocking call), there's the option to fire an
  128.      * alarm repeatedly until the signal is handled.
  129.      */
  130.     if (s_sig_details[signum].use_alarm)
  131.     {
  132.       alarm(1);
  133.     }
  134.   }
  135. }
  137. /* Notes. This signal check is evaluated after potentially blocking system
  138.  * calls, i.e. at highly defined points in the code. Since we only interrupt
  139.  * at these definite locations, the signal handlers can be non-trivial
  140.  * without us having to worry about re-entrancy.
  141.  *
  142.  * We guarantee that a handler for a given signal is not re-entrant. This
  143.  * is taken care of by the "running" flag.
  144.  *
  145.  * This call itself can only be re-entered once we dereference the actual
  146.  * hander function pointer, so we are safe with respect to races modifying
  147.  * the "running" flag.
  148.  */
  149. void
  150. vsf_sysutil_check_pending_actions(
  151.   const enum EVSFSysUtilInterruptContext context, int retval, int fd)
  152. {
  153.   unsigned int i;
  154.   /* Check the i/o handler before the signal handlers */
  155.   if (s_io_handler && !s_io_handler_running && context == kVSFSysUtilIO)
  156.   {
  157.     s_io_handler_running = 1;
  158.     (*s_io_handler)(retval, fd, s_p_io_handler_private);
  159.     s_io_handler_running = 0;
  160.   }
  161.   for (i=0; i < NSIG; ++i)
  162.   {
  163.     if (s_sig_details[i].pending && !s_sig_details[i].running)
  164.     {
  165.       s_sig_details[i].running = 1;
  166.       if (s_sig_details[i].use_alarm)
  167.       {
  168.         alarm(0);
  169.       }
  170.       if (s_sig_details[i].sync_sig_handler)
  171.       {
  172.         s_sig_details[i].pending = 0;
  173.         (*(s_sig_details[i].sync_sig_handler))(s_sig_details[i].p_private);
  174.       }
  175.       s_sig_details[i].running = 0;
  176.     }
  177.   }
  178. }
  180. static int
  181. vsf_sysutil_translate_sig(const enum EVSFSysUtilSignal sig)
  182. {
  183.   int realsig = 0;
  184.   switch (sig)
  185.   {
  186.     case kVSFSysUtilSigALRM:
  187.       realsig = SIGALRM;
  188.       break;
  189.     case kVSFSysUtilSigTERM:
  190.       realsig = SIGTERM;
  191.       break;
  192.     case kVSFSysUtilSigCHLD:
  193.       realsig = SIGCHLD;
  194.       break;
  195.     case kVSFSysUtilSigPIPE:
  196.       realsig = SIGPIPE;
  197.       break;
  198.     case kVSFSysUtilSigURG:
  199.       realsig = SIGURG;
  200.       break;
  201.     case kVSFSysUtilSigHUP:
  202.       realsig = SIGHUP;
  203.       break;
  204.     default:
  205.       bug("unknown signal in vsf_sysutil_translate_sig");
  206.       break;
  207.   }
  208.   if (realsig < 0 || realsig >= NSIG)
  209.   {
  210.     bug("signal out of range in vsf_sysutil_translate_sig");
  211.   }
  212.   return realsig;
  213. }
  215. void
  216. vsf_sysutil_install_sighandler(const enum EVSFSysUtilSignal sig,
  217.                                vsf_sighandle_t handler,
  218.                                void* p_private,
  219.                                int use_alarm)
  220. {
  221.   int realsig = vsf_sysutil_translate_sig(sig);
  222.   s_sig_details[realsig].p_private = p_private;
  223.   s_sig_details[realsig].sync_sig_handler = handler;
  224.   s_sig_details[realsig].use_alarm = use_alarm;
  225.   vsf_sysutil_set_sighandler(realsig, vsf_sysutil_common_sighandler);
  226.   if (use_alarm && realsig != SIGALRM)
  227.   {
  228.     vsf_sysutil_set_sighandler(SIGALRM, vsf_sysutil_alrm_sighandler);
  229.   }
  230. }
  232. void
  233. vsf_sysutil_default_sig(const enum EVSFSysUtilSignal sig)
  234. {
  235.   int realsig = vsf_sysutil_translate_sig(sig);
  236.   vsf_sysutil_set_sighandler(realsig, SIG_DFL);
  237.   s_sig_details[realsig].p_private = NULL;
  238.   s_sig_details[realsig].sync_sig_handler = NULL;
  239. }
  241. void
  242. vsf_sysutil_install_null_sighandler(const enum EVSFSysUtilSignal sig)
  243. {
  244.   int realsig = vsf_sysutil_translate_sig(sig);
  245.   s_sig_details[realsig].p_private = NULL;
  246.   s_sig_details[realsig].sync_sig_handler = NULL;
  247.   vsf_sysutil_set_sighandler(realsig, vsf_sysutil_common_sighandler);
  248. }
  250. void
  251. vsf_sysutil_install_async_sighandler(const enum EVSFSysUtilSignal sig,
  252.                                      vsf_async_sighandle_t handler)
  253. {
  254.   int realsig = vsf_sysutil_translate_sig(sig);
  255.   s_sig_details[realsig].p_private = NULL;
  256.   s_sig_details[realsig].sync_sig_handler = NULL;
  257.   vsf_sysutil_block_sig(sig);
  258.   vsf_sysutil_set_sighandler(realsig, handler);
  259. }
  261. static void
  262. vsf_sysutil_set_sighandler(int sig, void (*p_handlefunc)(int))
  263. {
  264.   int retval;
  265.   struct sigaction sigact;
  266.   vsf_sysutil_memclr(&sigact, sizeof(sigact));
  267.   sigact.sa_handler = p_handlefunc;
  268.   retval = sigfillset(&sigact.sa_mask);
  269.   if (retval != 0)
  270.   {
  271.     die("sigfillset");
  272.   }
  273.   retval = sigaction(sig, &sigact, NULL);
  274.   if (retval != 0)
  275.   {
  276.     die("sigaction");
  277.   }
  278. }
  280. void
  281. vsf_sysutil_block_sig(const enum EVSFSysUtilSignal sig)
  282. {
  283.   sigset_t sset;
  284.   int retval;
  285.   int realsig = vsf_sysutil_translate_sig(sig);
  286.   retval = sigemptyset(&sset);
  287.   if (retval != 0)
  288.   {
  289.     die("sigemptyset");
  290.   }
  291.   retval = sigaddset(&sset, realsig);
  292.   if (retval != 0)
  293.   {
  294.     die("sigaddset");
  295.   }
  296.   retval = sigprocmask(SIG_BLOCK, &sset, NULL);
  297.   if (retval != 0)
  298.   {
  299.     die("sigprocmask");
  300.   }
  301. }
  303. void
  304. vsf_sysutil_unblock_sig(const enum EVSFSysUtilSignal sig)
  305. {
  306.   sigset_t sset;
  307.   int retval;
  308.   int realsig = vsf_sysutil_translate_sig(sig);
  309.   retval = sigemptyset(&sset);
  310.   if (retval != 0)
  311.   {
  312.     die("sigemptyset");
  313.   }
  314.   retval = sigaddset(&sset, realsig);
  315.   if (retval != 0)
  316.   {
  317.     die("sigaddset");
  318.   }
  319.   retval = sigprocmask(SIG_UNBLOCK, &sset, NULL);
  320.   if (retval != 0)
  321.   {
  322.     die("sigprocmask");
  323.   }
  324. }
  325. void
  326. vsf_sysutil_install_io_handler(vsf_context_io_t handler, void* p_private)
  327. {
  328.   if (s_io_handler != NULL)
  329.   {
  330.     bug("double register of i/o handler");
  331.   }
  332.   s_io_handler = handler;
  333.   s_p_io_handler_private = p_private;
  334. }
  336. void
  337. vsf_sysutil_uninstall_io_handler(void)
  338. {
  339.   if (s_io_handler == NULL)
  340.   {
  341.     bug("no i/o handler to unregister!");
  342.   }
  343.   s_io_handler = NULL;
  344.   s_p_io_handler_private = NULL;
  345. }
  347. void
  348. vsf_sysutil_set_alarm(const unsigned int trigger_seconds)
  349. {
  350.   (void) alarm(trigger_seconds);
  351. }
  353. void
  354. vsf_sysutil_clear_alarm(void)
  355. {
  356.   vsf_sysutil_set_alarm(0);
  357. }
  359. int
  360. vsf_sysutil_read(const int fd, void* p_buf, const unsigned int size)
  361. {
  362.   while (1)
  363.   {
  364.     int retval = read(fd, p_buf, size);
  365.     int saved_errno = errno;
  366.     vsf_sysutil_check_pending_actions(kVSFSysUtilIO, retval, fd);
  367.     if (retval < 0 && saved_errno == EINTR)
  368.     {
  369.       continue;
  370.     }
  371.     return retval;
  372.   }
  373. }
  375. int
  376. vsf_sysutil_write(const int fd, const void* p_buf, const unsigned int size)
  377. {
  378.   while (1)
  379.   {
  380.     int retval = write(fd, p_buf, size);
  381.     int saved_errno = errno;
  382.     vsf_sysutil_check_pending_actions(kVSFSysUtilIO, retval, fd);
  383.     if (retval < 0 && saved_errno == EINTR)
  384.     {
  385.       continue;
  386.     }
  387.     return retval;
  388.   }
  389. }
  391. int
  392. vsf_sysutil_read_loop(const int fd, void* p_buf, unsigned int size)
  393. {
  394.   int retval;
  395.   int num_read = 0;
  396.   if (size > INT_MAX)
  397.   {
  398.     die("size too big in vsf_sysutil_read_loop");
  399.   }
  400.   while (1)
  401.   {
  402.     retval = vsf_sysutil_read(fd, (char*)p_buf + num_read, size);
  403.     if (retval < 0)
  404.     {
  405.       return retval;
  406.     }
  407.     else if (retval == 0)
  408.     {
  409.       /* Read all we're going to read.. */
  410.       return num_read; 
  411.     }
  412.     if ((unsigned int) retval > size)
  413.     {
  414.       die("retval too big in vsf_sysutil_read_loop");
  415.     }
  416.     num_read += retval;
  417.     size -= (unsigned int) retval;
  418.     if (size == 0)
  419.     {
  420.       /* Hit the read target, cool. */
  421.       return num_read;
  422.     }
  423.   }
  424. }
  426. int
  427. vsf_sysutil_write_loop(const int fd, const void* p_buf, unsigned int size)
  428. {
  429.   int retval;
  430.   int num_written = 0;
  431.   if (size > INT_MAX)
  432.   {
  433.     die("size too big in vsf_sysutil_write_loop");
  434.   }
  435.   while (1)
  436.   {
  437.     retval = vsf_sysutil_write(fd, (const char*)p_buf + num_written, size);
  438.     if (retval < 0)
  439.     {
  440.       /* Error */
  441.       return retval;
  442.     }
  443.     else if (retval == 0)
  444.     {
  445.       /* Written all we're going to write.. */
  446.       return num_written;
  447.     }
  448.     if ((unsigned int) retval > size)
  449.     {
  450.       die("retval too big in vsf_sysutil_write_loop");
  451.     }
  452.     num_written += retval;
  453.     size -= (unsigned int) retval;
  454.     if (size == 0)
  455.     {
  456.       /* Hit the write target, cool. */
  457.       return num_written;
  458.     }
  459.   }
  460. }
  462. filesize_t
  463. vsf_sysutil_get_file_offset(const int file_fd)
  464. {
  465.   filesize_t retval = lseek(file_fd, 0, SEEK_CUR);
  466.   if (retval < 0)
  467.   {
  468.     die("lseek");
  469.   }
  470.   return retval;
  471. }
  473. void
  474. vsf_sysutil_lseek_to(const int fd, filesize_t seek_pos)
  475. {
  476.   filesize_t retval;
  477.   if (seek_pos < 0)
  478.   {
  479.     die("negative seek_pos in vsf_sysutil_lseek_to");
  480.   }
  481.   retval = lseek(fd, seek_pos, SEEK_SET);
  482.   if (retval < 0)
  483.   {
  484.     die("lseek");
  485.   }
  486. }
  488. void*
  489. vsf_sysutil_malloc(unsigned int size)
  490. {
  491.   void* p_ret;
  492.   /* Paranoia - what if we got an integer overflow/underflow? */
  493.   if (size == 0 || size > INT_MAX)
  494.   {
  495.     bug("zero or big size in vsf_sysutil_malloc");
  496.   }  
  497.   p_ret = malloc(size);
  498.   if (p_ret == NULL)
  499.   {
  500.     die("malloc");
  501.   }
  502.   return p_ret;
  503. }
  505. void*
  506. vsf_sysutil_realloc(void* p_ptr, unsigned int size)
  507. {
  508.   void* p_ret;
  509.   if (size == 0 || size > INT_MAX)
  510.   {
  511.     bug("zero or big size in vsf_sysutil_realloc");
  512.   }
  513.   p_ret = realloc(p_ptr, size);
  514.   if (p_ret == NULL)
  515.   {
  516.     die("realloc");
  517.   }
  518.   return p_ret;
  519. }
  521. void
  522. vsf_sysutil_free(void* p_ptr)
  523. {
  524.   if (p_ptr == NULL)
  525.   {
  526.     bug("vsf_sysutil_free got a null pointer");
  527.   }
  528.   free(p_ptr);
  529. }
  531. unsigned int
  532. vsf_sysutil_getpid(void)
  533. {
  534.   if (s_current_pid == -1)
  535.   {
  536.     s_current_pid = vsf_sysutil_getpid_nocache();
  537.   }
  538.   return (unsigned int) s_current_pid;
  539. }
  541. int
  542. vsf_sysutil_fork(void)
  543. {
  544.   int retval = vsf_sysutil_fork_failok();
  545.   if (retval < 0)
  546.   {
  547.     die("fork");
  548.   }
  549.   return retval;
  550. }
  552. int
  553. vsf_sysutil_fork_failok(void)
  554. {
  555.   int retval;
  556.   retval = fork();
  557.   if (retval == 0)
  558.   {
  559.     vsf_sysutil_post_fork();
  560.   }
  561.   return retval;
  562. }
  564. void
  565. vsf_sysutil_set_exit_func(exitfunc_t exitfunc)
  566. {
  567.   s_exit_func = exitfunc;
  568. }
  570. void
  571. vsf_sysutil_exit(int exit_code)
  572. {
  573.   if (s_exit_func)
  574.   {
  575.     exitfunc_t curr_func = s_exit_func;
  576.     /* Prevent recursion */
  577.     s_exit_func = 0;
  578.     (*curr_func)();
  579.   }
  580.   _exit(exit_code);
  581. }
  583. struct vsf_sysutil_wait_retval
  584. vsf_sysutil_wait(void)
  585. {
  586.   struct vsf_sysutil_wait_retval retval;
  587.   vsf_sysutil_memclr(&retval, sizeof(retval));
  588.   while (1)
  589.   {
  590.     int sys_ret = wait(&retval.exit_status);
  591.     if (sys_ret < 0 && errno == EINTR)
  592.     {
  593.       vsf_sysutil_check_pending_actions(kVSFSysUtilUnknown, 0, 0);
  594.       continue;
  595.     }
  596.     retval.syscall_retval = sys_ret;
  597.     return retval;
  598.   }
  599. }
  601. int
  602. vsf_sysutil_wait_reap_one(void)
  603. {
  604.   int retval = waitpid(-1, NULL, WNOHANG);
  605.   if (retval == 0 || (retval < 0 && errno == ECHILD))
  606.   {
  607.     /* No more children */
  608.     return 0;
  609.   }
  610.   if (retval < 0)
  611.   {
  612.     die("waitpid");
  613.   }
  614.   /* Got one */
  615.   return retval;
  616. }
  618. int
  619. vsf_sysutil_wait_get_retval(const struct vsf_sysutil_wait_retval* p_waitret)
  620. {
  621.   return p_waitret->syscall_retval;
  622. }
  624. int
  625. vsf_sysutil_wait_exited_normally(
  626.   const struct vsf_sysutil_wait_retval* p_waitret)
  627. {
  628.   int status = ((struct vsf_sysutil_wait_retval*) p_waitret)->exit_status;
  629.   return WIFEXITED(status);
  630. }
  632. int
  633. vsf_sysutil_wait_get_exitcode(const struct vsf_sysutil_wait_retval* p_waitret)
  634. {
  635.   int status;
  636.   if (!vsf_sysutil_wait_exited_normally(p_waitret))
  637.   {
  638.     bug("not a normal exit in vsf_sysutil_wait_get_exitcode");
  639.   }
  640.   status = ((struct vsf_sysutil_wait_retval*) p_waitret)->exit_status;
  641.   return WEXITSTATUS(status);
  642. }
  644. void
  645. vsf_sysutil_activate_keepalive(int fd)
  646. {
  647.   int keepalive = 1;
  648.   int retval = setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &keepalive,
  649.                           sizeof(keepalive));
  650.   if (retval != 0)
  651.   {
  652.     die("setsockopt: keepalive");
  653.   }
  654. }
  656. void
  657. vsf_sysutil_activate_reuseaddr(int fd)
  658. {
  659.   int reuseaddr = 1;
  660.   int retval = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
  661.                           sizeof(reuseaddr));
  662.   if (retval != 0)
  663.   {
  664.     die("setsockopt: reuseaddr");
  665.   }
  666. }
  668. void
  669. vsf_sysutil_set_nodelay(int fd)
  670. {
  671.   int nodelay = 1;
  672.   int retval = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &nodelay,
  673.                           sizeof(nodelay));
  674.   if (retval != 0)
  675.   {
  676.     die("setsockopt: nodelay");
  677.   }
  678. }
  680. void
  681. vsf_sysutil_activate_sigurg(int fd)
  682. {
  683.   int retval = fcntl(fd, F_SETOWN, vsf_sysutil_getpid());
  684.   if (retval != 0)
  685.   {
  686.     die("fcntl");
  687.   }
  688. }
  690. void
  691. vsf_sysutil_activate_oobinline(int fd)
  692. {
  693.   int oob_inline = 1;
  694.   int retval = setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &oob_inline,
  695.                           sizeof(oob_inline));
  696.   if (retval != 0)
  697.   {
  698.     die("setsockopt: oobinline");
  699.   }
  700. }
  702. void
  703. vsf_sysutil_set_iptos_throughput(int fd)
  704. {
  705.   int tos = IPTOS_THROUGHPUT;
  706.   /* Ignore failure to set (maybe this IP stack demands privilege for this) */
  707.   (void) setsockopt(fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
  708. }
  710. void
  711. vsf_sysutil_activate_linger(int fd)
  712. {
  713.   int retval;
  714.   struct linger the_linger;
  715.   vsf_sysutil_memclr(&the_linger, sizeof(the_linger));
  716.   the_linger.l_onoff = 1;
  717.   the_linger.l_linger = 32767;
  718.   retval = setsockopt(fd, SOL_SOCKET, SO_LINGER, &the_linger,
  719.                       sizeof(the_linger));
  720.   if (retval != 0)
  721.   {
  722.     die("setsockopt: linger");
  723.   }
  724. }
  726. void
  727. vsf_sysutil_deactivate_linger_failok(int fd)
  728. {
  729.   struct linger the_linger;
  730.   the_linger.l_onoff = 0;
  731.   the_linger.l_linger = 0;
  732.   (void) setsockopt(fd, SOL_SOCKET, SO_LINGER, &the_linger, sizeof(the_linger));
  733. }
  735. void
  736. vsf_sysutil_activate_noblock(int fd)
  737. {
  738.   int retval;
  739.   int curr_flags = fcntl(fd, F_GETFL);
  740.   if (vsf_sysutil_retval_is_error(curr_flags))
  741.   {
  742.     die("fcntl");
  743.   }
  744.   curr_flags |= O_NONBLOCK;
  745.   retval = fcntl(fd, F_SETFL, curr_flags);
  746.   if (retval != 0)
  747.   {
  748.     die("fcntl");
  749.   }
  750. }
  752. void
  753. vsf_sysutil_deactivate_noblock(int fd)
  754. {
  755.   int retval;
  756.   int curr_flags = fcntl(fd, F_GETFL);
  757.   if (vsf_sysutil_retval_is_error(curr_flags))
  758.   {
  759.     die("fcntl");
  760.   }
  761.   curr_flags &= ~O_NONBLOCK;
  762.   retval = fcntl(fd, F_SETFL, curr_flags);
  763.   if (retval != 0)
  764.   {
  765.     die("fcntl");
  766.   }
  767. }
  769. int
  770. vsf_sysutil_recv_peek(const int fd, void* p_buf, unsigned int len)
  771. {
  772.   while (1)
  773.   {
  774.     int retval = recv(fd, p_buf, len, MSG_PEEK);
  775.     int saved_errno = errno;
  776.     vsf_sysutil_check_pending_actions(kVSFSysUtilIO, retval, fd);
  777.     if (retval < 0 && saved_errno == EINTR)
  778.     {
  779.       continue;
  780.     }
  781.     return retval;
  782.   }
  783. }
  785. int
  786. vsf_sysutil_atoi(const char* p_str)
  787. {
  788.   return atoi(p_str);
  789. }
  791. filesize_t
  792. vsf_sysutil_a_to_filesize_t(const char* p_str)
  793. {
  794.   /* atoll() is C99 standard - but even modern FreeBSD, OpenBSD don't have
  795.    * it, so we'll supply our own
  796.    */
  797.   filesize_t result = 0;
  798.   filesize_t mult = 1;
  799.   unsigned int len = vsf_sysutil_strlen(p_str);
  800.   unsigned int i;
  801.   /* Bail if the number is excessively big (petabytes!) */
  802.   if (len > 15)
  803.   {
  804.     return 0;
  805.   }
  806.   for (i=0; i<len; ++i)
  807.   {
  808.     char the_char = p_str[len-(i+1)];
  809.     filesize_t val;
  810.     if (the_char < '0' || the_char > '9')
  811.     {
  812.       return 0;
  813.     }
  814.     val = the_char - '0';
  815.     val *= mult;
  816.     result += val;
  817.     mult *= 10;
  818.   }
  819.   return result;
  820. }
  822. const char*
  823. vsf_sysutil_ulong_to_str(unsigned long the_ulong)
  824. {
  825.   static char ulong_buf[32];
  826.   (void) snprintf(ulong_buf, sizeof(ulong_buf), "%lu", the_ulong);
  827.   return ulong_buf;
  828. }
  830. const char*
  831. vsf_sysutil_filesize_t_to_str(filesize_t the_filesize)
  832. {
  833.   static char filesize_buf[32];
  834.   if (sizeof(long) == 8)
  835.   {
  836.     /* Avoid using non-standard %ll if we can */
  837.     (void) snprintf(filesize_buf, sizeof(filesize_buf), "%ld",
  838.                     (long) the_filesize);
  839.   }
  840.   else
  841.   {
  842.     (void) snprintf(filesize_buf, sizeof(filesize_buf), "%lld", the_filesize);
  843.   }
  844.   return filesize_buf;
  845. }
  847. const char*
  848. vsf_sysutil_double_to_str(double the_double)
  849. {
  850.   static char double_buf[32];
  851.   (void) snprintf(double_buf, sizeof(double_buf), "%.2f", the_double);
  852.   return double_buf;
  853. }
  855. const char*
  856. vsf_sysutil_uint_to_octal(unsigned int the_uint)
  857. {
  858.   static char octal_buf[32];
  859.   if (the_uint == 0)
  860.   {
  861.     octal_buf[0] = '0';
  862.     octal_buf[1] = '';
  863.   }
  864.   else
  865.   {
  866.     (void) snprintf(octal_buf, sizeof(octal_buf), "0%o", the_uint);
  867.   }
  868.   return octal_buf;
  869. }
  871. unsigned int
  872. vsf_sysutil_octal_to_uint(const char* p_str)
  873. {
  874.   /* NOTE - avoiding using sscanf() parser */
  875.   unsigned int result = 0;
  876.   int seen_non_zero_digit = 0;
  877.   while (*p_str != '')
  878.   {
  879.     int digit = *p_str;
  880.     if (!isdigit(digit) || digit > '7')
  881.     {
  882.       break;
  883.     }
  884.     if (digit != '0')
  885.     {
  886.       seen_non_zero_digit = 1;
  887.     }
  888.     if (seen_non_zero_digit)
  889.     {
  890.       result <<= 3;
  891.       result += (digit - '0');
  892.     }
  893.     p_str++;
  894.   }
  895.   return result;
  896. }
  898. int
  899. vsf_sysutil_toupper(int the_char)
  900. {
  901.   return toupper(the_char);
  902. }
  904. int
  905. vsf_sysutil_isspace(int the_char)
  906. {
  907.   return isspace(the_char);
  908. }
  910. int
  911. vsf_sysutil_isprint(int the_char)
  912. {
  913.   /* From Solar - we know better than some libc's! Don't let any potential
  914.    * control chars through
  915.    */
  916.   unsigned char uc = (unsigned char) the_char;
  917.   if (uc <= 31)
  918.   {
  919.     return 0;
  920.   }
  921.   if (uc == 177)
  922.   {
  923.     return 0;
  924.   }
  925.   if (uc >= 128 && uc <= 159)
  926.   {
  927.     return 0;
  928.   }
  929.   return isprint(the_char);
  930. }
  932. int
  933. vsf_sysutil_isalnum(int the_char)
  934. {
  935.   return isalnum(the_char);
  936. }
  938. int
  939. vsf_sysutil_isdigit(int the_char)
  940. {
  941.   return isdigit(the_char);
  942. }
  944. char*
  945. vsf_sysutil_getcwd(char* p_dest, const unsigned int buf_size)
  946. {
  947.   char* p_retval;
  948.   if (buf_size == 0) {
  949.     return p_dest;
  950.   }
  951.   p_retval = getcwd(p_dest, buf_size);
  952.   p_dest[buf_size - 1] = '';
  953.   return p_retval;
  954. }
  956. int
  957. vsf_sysutil_mkdir(const char* p_dirname, const unsigned int mode)
  958. {
  959.   return mkdir(p_dirname, mode);
  960. }
  962. int
  963. vsf_sysutil_rmdir(const char* p_dirname)
  964. {
  965.   return rmdir(p_dirname);
  966. }
  968. int
  969. vsf_sysutil_chdir(const char* p_dirname)
  970. {
  971.   return chdir(p_dirname);
  972. }
  974. int
  975. vsf_sysutil_rename(const char* p_from, const char* p_to)
  976. {
  977.   return rename(p_from, p_to);
  978. }
  980. struct vsf_sysutil_dir*
  981. vsf_sysutil_opendir(const char* p_dirname)
  982. {
  983.   return (struct vsf_sysutil_dir*) opendir(p_dirname);
  984. }
  986. void
  987. vsf_sysutil_closedir(struct vsf_sysutil_dir* p_dir)
  988. {
  989.   DIR* p_real_dir = (DIR*) p_dir;
  990.   int retval = closedir(p_real_dir);
  991.   if (retval != 0)
  992.   {
  993.     die("closedir");
  994.   }
  995. }
  997. const char*
  998. vsf_sysutil_next_dirent(struct vsf_sysutil_dir* p_dir)
  999. {
  1000.   DIR* p_real_dir = (DIR*) p_dir;
  1001.   struct dirent* p_dirent = readdir(p_real_dir);
  1002.   if (p_dirent == NULL)
  1003.   {
  1004.     return NULL;
  1005.   }
  1006.   return p_dirent->d_name;
  1007. }
  1009. unsigned int
  1010. vsf_sysutil_strlen(const char* p_text)
  1011. {
  1012.   unsigned int ret = strlen(p_text);
  1013.   /* A defense in depth measure. */
  1014.   if (ret > INT_MAX / 8)
  1015.   {
  1016.     die("string suspiciously long");
  1017.   }
  1018.   return ret;
  1019. }
  1021. char*
  1022. vsf_sysutil_strdup(const char* p_str)
  1023. {
  1024.   return strdup(p_str);
  1025. }
  1027. void
  1028. vsf_sysutil_memclr(void* p_dest, unsigned int size)
  1029. {
  1030.   /* Safety */
  1031.   if (size == 0)
  1032.   {
  1033.     return;
  1034.   }
  1035.   memset(p_dest, '', size);
  1036. }
  1038. void
  1039. vsf_sysutil_memcpy(void* p_dest, const void* p_src, const unsigned int size)
  1040. {
  1041.   /* Safety */
  1042.   if (size == 0)
  1043.   {
  1044.     return;
  1045.   }
  1046.   /* Defense in depth */
  1047.   if (size > INT_MAX)
  1048.   {
  1049.     die("possible negative value to memcpy?");
  1050.   }
  1051.   memcpy(p_dest, p_src, size);
  1052. }
  1054. void
  1055. vsf_sysutil_strcpy(char* p_dest, const char* p_src, unsigned int maxsize)
  1056. {
  1057.   if (maxsize == 0)
  1058.   {
  1059.     return;
  1060.   }
  1061.   strncpy(p_dest, p_src, maxsize);
  1062.   p_dest[maxsize - 1] = '';
  1063. }
  1065. int
  1066. vsf_sysutil_memcmp(const void* p_src1, const void* p_src2, unsigned int size)
  1067. {
  1068.   /* Safety */
  1069.   if (size == 0)
  1070.   {
  1071.     return 0;
  1072.   }
  1073.   return memcmp(p_src1, p_src2, size);
  1074. }
  1076. int
  1077. vsf_sysutil_strcmp(const char* p_src1, const char* p_src2)
  1078. {
  1079.   return strcmp(p_src1, p_src2);
  1080. }
  1082. unsigned int
  1083. vsf_sysutil_getpagesize(void)
  1084. {
  1085.   static unsigned int s_page_size;
  1086.   if (s_page_size == 0)
  1087.   {
  1088.     s_page_size = getpagesize();
  1089.     if (s_page_size == 0)
  1090.     {
  1091.       die("getpagesize");
  1092.     }
  1093.   }
  1094.   return s_page_size;
  1095. }
  1097. static int
  1098. vsf_sysutil_translate_memprot(const enum EVSFSysUtilMapPermission perm)
  1099. {
  1100.   int retval = 0;
  1101.   switch (perm)
  1102.   {
  1103.     case kVSFSysUtilMapProtReadOnly:
  1104.       retval = PROT_READ;
  1105.       break;
  1106.     case kVSFSysUtilMapProtNone:
  1107.       retval = PROT_NONE;
  1108.       break;
  1109.     default:
  1110.       bug("bad value in vsf_sysutil_translate_memprot");
  1111.       break;
  1112.   }
  1113.   return retval;
  1114. }
  1116. void
  1117. vsf_sysutil_memprotect(void* p_addr, unsigned int len,
  1118.                        const enum EVSFSysUtilMapPermission perm)
  1119. {
  1120.   int prot = vsf_sysutil_translate_memprot(perm);
  1121.   int retval = mprotect(p_addr, len, prot);
  1122.   if (retval != 0)
  1123.   {
  1124.     die("mprotect");
  1125.   }
  1126. }
  1128. void
  1129. vsf_sysutil_memunmap(void* p_start, unsigned int length)
  1130. {
  1131.   int retval = munmap(p_start, length);
  1132.   if (retval != 0)
  1133.   {
  1134.     die("munmap");
  1135.   }
  1136. }
  1138. static int
  1139. vsf_sysutil_translate_openmode(const enum EVSFSysUtilOpenMode mode)
  1140. {
  1141.   int retval = 0;
  1142.   switch (mode)
  1143.   {
  1144.     case kVSFSysUtilOpenReadOnly:
  1145.       retval = O_RDONLY;
  1146.       break;
  1147.     case kVSFSysUtilOpenWriteOnly:
  1148.       retval = O_WRONLY;
  1149.       break;
  1150.     case kVSFSysUtilOpenReadWrite:
  1151.       retval = O_RDWR;
  1152.       break;
  1153.     default:
  1154.       bug("bad mode in vsf_sysutil_translate_openmode");
  1155.       break;
  1156.   }
  1157.   return retval;
  1158. }
  1160. int
  1161. vsf_sysutil_open_file(const char* p_filename,
  1162.                       const enum EVSFSysUtilOpenMode mode)
  1163. {
  1164.   return open(p_filename, vsf_sysutil_translate_openmode(mode) | O_NONBLOCK);
  1165. }
  1167. int
  1168. vsf_sysutil_create_file(const char* p_filename)
  1169. {
  1170.   /* umask() also contributes to end mode */
  1171.   return open(p_filename, O_CREAT | O_EXCL | O_WRONLY | O_APPEND,
  1172.               tunable_file_open_mode);
  1173. }
  1175. int
  1176. vsf_sysutil_create_overwrite_file(const char* p_filename)
  1177. {
  1178.   return open(p_filename, O_CREAT | O_TRUNC | O_WRONLY |
  1179.                           O_APPEND | O_NONBLOCK,
  1180.               tunable_file_open_mode);
  1181. }
  1183. int
  1184. vsf_sysutil_create_or_open_file(const char* p_filename, unsigned int mode)
  1185. {
  1186.   return open(p_filename, O_CREAT | O_WRONLY | O_APPEND | O_NONBLOCK, mode);
  1187. }
  1189. void
  1190. vsf_sysutil_dupfd2(int old_fd, int new_fd)
  1191. {
  1192.   int retval;
  1193.   if (old_fd == new_fd)
  1194.   {
  1195.     return;
  1196.   }
  1197.   retval = dup2(old_fd, new_fd);
  1198.   if (retval != new_fd)
  1199.   {
  1200.     die("dup2");
  1201.   }
  1202. }
  1204. void
  1205. vsf_sysutil_close(int fd)
  1206. {
  1207.   while (1)
  1208.   {
  1209.     int retval = close(fd);
  1210.     if (retval != 0)
  1211.     {
  1212.       if (errno == EINTR)
  1213.       {
  1214.         vsf_sysutil_check_pending_actions(kVSFSysUtilUnknown, 0, 0);
  1215.         continue;
  1216.       }
  1217.       die("close");
  1218.     }
  1219.     return;
  1220.   }
  1221. }
  1223. int
  1224. vsf_sysutil_close_failok(int fd)
  1225. {
  1226.   return close(fd);
  1227. }
  1229. int
  1230. vsf_sysutil_unlink(const char* p_dead)
  1231. {
  1232.   return unlink(p_dead);
  1233. }
  1235. int
  1236. vsf_sysutil_write_access(const char* p_filename)
  1237. {
  1238.   int retval = access(p_filename, W_OK);
  1239.   return (retval == 0);
  1240. }
  1242. static void
  1243. vsf_sysutil_alloc_statbuf(struct vsf_sysutil_statbuf** p_ptr)
  1244. {
  1245.   if (*p_ptr == NULL)
  1246.   {
  1247.     *p_ptr = vsf_sysutil_malloc(sizeof(struct stat));
  1248.   }
  1249. }
  1251. void
  1252. vsf_sysutil_fstat(int fd, struct vsf_sysutil_statbuf** p_ptr)
  1253. {
  1254.   int retval;
  1255.   vsf_sysutil_alloc_statbuf(p_ptr);
  1256.   retval = fstat(fd, (struct stat*) (*p_ptr));
  1257.   if (retval != 0)
  1258.   {
  1259.     die("fstat");
  1260.   }
  1261. }
  1263. int
  1264. vsf_sysutil_stat(const char* p_name, struct vsf_sysutil_statbuf** p_ptr)
  1265. {
  1266.   vsf_sysutil_alloc_statbuf(p_ptr);
  1267.   return stat(p_name, (struct stat*) (*p_ptr));
  1268. }
  1270. int
  1271. vsf_sysutil_lstat(const char* p_name, struct vsf_sysutil_statbuf** p_ptr)
  1272. {
  1273.   vsf_sysutil_alloc_statbuf(p_ptr);
  1274.   return lstat(p_name, (struct stat*) (*p_ptr));
  1275. }
  1277. void
  1278. vsf_sysutil_dir_stat(const struct vsf_sysutil_dir* p_dir,
  1279.                      struct vsf_sysutil_statbuf** p_ptr)
  1280. {
  1281.   int fd = dirfd((DIR*) p_dir);
  1282.   vsf_sysutil_fstat(fd, p_ptr);
  1283. }
  1285. int
  1286. vsf_sysutil_statbuf_is_regfile(const struct vsf_sysutil_statbuf* p_stat)
  1287. {
  1288.   const struct stat* p_realstat = (const struct stat*) p_stat;
  1289.   return S_ISREG(p_realstat->st_mode);
  1290. }
  1292. int
  1293. vsf_sysutil_statbuf_is_symlink(const struct vsf_sysutil_statbuf* p_stat)
  1294. {
  1295.   const struct stat* p_realstat = (const struct stat*) p_stat;
  1296.   return S_ISLNK(p_realstat->st_mode);
  1297. }
  1299. int
  1300. vsf_sysutil_statbuf_is_socket(const struct vsf_sysutil_statbuf* p_stat)
  1301. {
  1302.   const struct stat* p_realstat = (const struct stat*) p_stat;
  1303.   return S_ISSOCK(p_realstat->st_mode);
  1304. }
  1306. int
  1307. vsf_sysutil_statbuf_is_dir(const struct vsf_sysutil_statbuf* p_stat)
  1308. {
  1309.   const struct stat* p_realstat = (const struct stat*) p_stat;
  1310.   return S_ISDIR(p_realstat->st_mode);
  1311. }
  1313. const char*
  1314. vsf_sysutil_statbuf_get_perms(const struct vsf_sysutil_statbuf* p_statbuf)
  1315. {
  1316.   static char perms[11];
  1317.   int i;
  1318.   const struct stat* p_stat = (const struct stat*) p_statbuf;
  1319.   for (i=0; i<10; i++)
  1320.   {
  1321.     perms[i] = '-';
  1322.   }
  1323.   perms[0] = '?';
  1324.   switch (p_stat->st_mode & S_IFMT)
  1325.   {
  1326.     case S_IFREG: perms[0] = '-'; break;
  1327.     case S_IFDIR: perms[0] = 'd'; break;
  1328.     case S_IFLNK: perms[0] = 'l'; break;
  1329.     case S_IFIFO: perms[0] = 'p'; break;
  1330.     case S_IFSOCK: perms[0] = 's'; break;
  1331.     case S_IFCHR: perms[0] = 'c'; break;
  1332.     case S_IFBLK: perms[0] = 'b'; break;
  1333.   }
  1334.   if (p_stat->st_mode & S_IRUSR) perms[1] = 'r';
  1335.   if (p_stat->st_mode & S_IWUSR) perms[2] = 'w';
  1336.   if (p_stat->st_mode & S_IXUSR) perms[3] = 'x';
  1337.   if (p_stat->st_mode & S_IRGRP) perms[4] = 'r';
  1338.   if (p_stat->st_mode & S_IWGRP) perms[5] = 'w';
  1339.   if (p_stat->st_mode & S_IXGRP) perms[6] = 'x';
  1340.   if (p_stat->st_mode & S_IROTH) perms[7] = 'r';
  1341.   if (p_stat->st_mode & S_IWOTH) perms[8] = 'w';
  1342.   if (p_stat->st_mode & S_IXOTH) perms[9] = 'x';
  1343.   if (p_stat->st_mode & S_ISUID) perms[3] = (perms[3] == 'x') ? 's' : 'S';
  1344.   if (p_stat->st_mode & S_ISGID) perms[6] = (perms[6] == 'x') ? 's' : 'S';
  1345.   if (p_stat->st_mode & S_ISVTX) perms[9] = (perms[9] == 'x') ? 't' : 'T';
  1346.   perms[10] = '';
  1347.   return perms;
  1348. }
  1350. const char*
  1351. vsf_sysutil_statbuf_get_date(const struct vsf_sysutil_statbuf* p_statbuf,
  1352.                              int use_localtime, long curr_time)
  1353. {
  1354.   static char datebuf[64];
  1355.   int retval;
  1356.   struct tm* p_tm;
  1357.   const struct stat* p_stat = (const struct stat*) p_statbuf;
  1358.   const char* p_date_format = "%b %d %H:%M";
  1359.   if (!use_localtime)
  1360.   {
  1361.     p_tm = gmtime(&p_stat->st_mtime);
  1362.   }
  1363.   else
  1364.   {
  1365.     p_tm = localtime(&p_stat->st_mtime);
  1366.   }
  1367.   /* Is this a future or 6 months old date? If so, we drop to year format */
  1368.   if (p_stat->st_mtime > curr_time ||
  1369.       (curr_time - p_stat->st_mtime) > 60*60*24*182)
  1370.   {
  1371.     p_date_format = "%b %d  %Y";
  1372.   }
  1373.   retval = strftime(datebuf, sizeof(datebuf), p_date_format, p_tm);
  1374.   datebuf[sizeof(datebuf)-1] = '';
  1375.   if (retval == 0)
  1376.   {
  1377.     die("strftime");
  1378.   }
  1379.   return datebuf;
  1380. }
  1382. const char*
  1383. vsf_sysutil_statbuf_get_numeric_date(
  1384.   const struct vsf_sysutil_statbuf* p_statbuf,
  1385.   int use_localtime)
  1386. {
  1387.   static char datebuf[15];
  1388.   const struct stat* p_stat = (const struct stat*) p_statbuf;
  1389.   struct tm* p_tm;
  1390.   int retval;
  1391.   if (!use_localtime)
  1392.   {
  1393.     p_tm = gmtime(&p_stat->st_mtime);
  1394.   }
  1395.   else
  1396.   {
  1397.     p_tm = localtime(&p_stat->st_mtime);
  1398.   }
  1399.   retval = strftime(datebuf, sizeof(datebuf), "%Y%m%d%H%M%S", p_tm);
  1400.   if (retval == 0)
  1401.   {
  1402.     die("strftime");
  1403.   }
  1404.   return datebuf;
  1405. }
  1407. filesize_t
  1408. vsf_sysutil_statbuf_get_size(const struct vsf_sysutil_statbuf* p_statbuf)
  1409. {
  1410.   const struct stat* p_stat = (const struct stat*) p_statbuf;
  1411.   if (p_stat->st_size < 0)
  1412.   {
  1413.     die("invalid inode size in vsf_sysutil_statbuf_get_size");
  1414.   }
  1415.   return p_stat->st_size;
  1416. }
  1418. int
  1419. vsf_sysutil_statbuf_get_uid(const struct vsf_sysutil_statbuf* p_statbuf)
  1420. {
  1421.   const struct stat* p_stat = (const struct stat*) p_statbuf;
  1422.   return p_stat->st_uid;
  1423. }
  1425. int
  1426. vsf_sysutil_statbuf_get_gid(const struct vsf_sysutil_statbuf* p_statbuf)
  1427. {
  1428.   const struct stat* p_stat = (const struct stat*) p_statbuf;
  1429.   return p_stat->st_gid;
  1430. }
  1432. unsigned int
  1433. vsf_sysutil_statbuf_get_links(const struct vsf_sysutil_statbuf* p_statbuf)
  1434. {
  1435.   const struct stat* p_stat = (const struct stat*) p_statbuf;
  1436.   return p_stat->st_nlink;
  1437. }
  1439. int
  1440. vsf_sysutil_statbuf_is_readable_other(
  1441.   const struct vsf_sysutil_statbuf* p_statbuf)
  1442. {
  1443.   const struct stat* p_stat = (const struct stat*) p_statbuf;
  1444.   if (p_stat->st_mode & S_IROTH)
  1445.   {
  1446.     return 1;
  1447.   }
  1448.   return 0;
  1449. }
  1451. const char*
  1452. vsf_sysutil_statbuf_get_sortkey_mtime(
  1453.   const struct vsf_sysutil_statbuf* p_statbuf)
  1454. {
  1455.   static char intbuf[32];
  1456.   const struct stat* p_stat = (const struct stat*) p_statbuf;
  1457.   /* This slight hack function must return a character date format such that
  1458.    * more recent dates appear later in the alphabet! Most notably, we must
  1459.    * make sure we pad to the same length with 0's 
  1460.    */
  1461.   snprintf(intbuf, sizeof(intbuf), "%030ld", (long) p_stat->st_mtime);
  1462.   return intbuf;
  1463. }
  1465. void
  1466. vsf_sysutil_fchown(const int fd, const int uid, const int gid)
  1467. {
  1468.   if (fchown(fd, uid, gid) != 0)
  1469.   {
  1470.     die("fchown");
  1471.   }
  1472. }
  1474. void
  1475. vsf_sysutil_fchmod(const int fd, unsigned int mode)
  1476. {
  1477.   mode = mode & 0777;
  1478.   if (fchmod(fd, mode))
  1479.   {
  1480.     die("fchmod");
  1481.   }
  1482. }
  1484. int
  1485. vsf_sysutil_chmod(const char* p_filename, unsigned int mode)
  1486. {
  1487.   /* Safety: mask "mode" to just access permissions, e.g. no suid setting! */
  1488.   mode = mode & 0777;
  1489.   return chmod(p_filename, mode);
  1490. }
  1492. int
  1493. vsf_sysutil_lock_file_write(int fd)
  1494. {
  1495.   return lock_internal(fd, F_WRLCK);
  1496. }
  1498. int
  1499. vsf_sysutil_lock_file_read(int fd)
  1500. {
  1501.   return lock_internal(fd, F_RDLCK);
  1502. }
  1504. static int
  1505. lock_internal(int fd, int lock_type)
  1506. {
  1507.   struct flock the_lock;
  1508.   int retval;
  1509.   int saved_errno;
  1510.   vsf_sysutil_memclr(&the_lock, sizeof(the_lock));
  1511.   the_lock.l_type = lock_type;
  1512.   the_lock.l_whence = SEEK_SET;
  1513.   the_lock.l_start = 0;
  1514.   the_lock.l_len = 0;
  1515.   do
  1516.   {
  1517.     retval = fcntl(fd, F_SETLKW, &the_lock);
  1518.     saved_errno = errno;
  1519.     vsf_sysutil_check_pending_actions(kVSFSysUtilUnknown, 0, 0);
  1520.   }
  1521.   while (retval < 0 && saved_errno == EINTR);
  1522.   return retval;
  1523. }
  1525. void
  1526. vsf_sysutil_unlock_file(int fd)
  1527. {
  1528.   int retval;
  1529.   struct flock the_lock;
  1530.   vsf_sysutil_memclr(&the_lock, sizeof(the_lock));
  1531.   the_lock.l_type = F_UNLCK;
  1532.   the_lock.l_whence = SEEK_SET;
  1533.   the_lock.l_start = 0;
  1534.   the_lock.l_len = 0;
  1535.   retval = fcntl(fd, F_SETLK, &the_lock);
  1536.   if (retval != 0)
  1537.   {
  1538.     die("fcntl");
  1539.   }
  1540. }
  1542. int
  1543. vsf_sysutil_readlink(const char* p_filename, char* p_dest, unsigned int bufsiz)
  1544. {
  1545.   int retval;
  1546.   if (bufsiz == 0) {
  1547.     return -1;
  1548.   }
  1549.   retval = readlink(p_filename, p_dest, bufsiz - 1);
  1550.   if (retval < 0)
  1551.   {
  1552.     return retval;
  1553.   }
  1554.   /* Ensure buffer is NULL terminated; readlink(2) doesn't do that */
  1555.   p_dest[retval] = '';
  1556.   return retval;
  1557. }
  1559. int
  1560. vsf_sysutil_retval_is_error(int retval)
  1561. {
  1562.   if (retval < 0)
  1563.   {
  1564.     return 1;
  1565.   }
  1566.   return 0;
  1567. }
  1569. enum EVSFSysUtilError
  1570. vsf_sysutil_get_error(void)
  1571. {
  1572.   enum EVSFSysUtilError retval = kVSFSysUtilErrUnknown;
  1573.   switch (errno)
  1574.   {
  1575.     case EADDRINUSE:
  1576.       retval = kVSFSysUtilErrADDRINUSE;
  1577.       break;
  1578.     case ENOSYS:
  1579.       retval = kVSFSysUtilErrNOSYS;
  1580.       break;
  1581.     case EINTR:
  1582.       retval = kVSFSysUtilErrINTR;
  1583.       break;
  1584.     case EINVAL:
  1585.       retval = kVSFSysUtilErrINVAL;
  1586.       break;
  1587.     case EOPNOTSUPP:
  1588.       retval = kVSFSysUtilErrOPNOTSUPP;
  1589.       break;
  1590.     case EACCES:
  1591.       retval = kVSFSysUtilErrACCES;
  1592.       break;
  1593.     case ENOENT:
  1594.       retval = kVSFSysUtilErrNOENT;
  1595.       break;
  1596.   }
  1597.   return retval;
  1598. }
  1600. int
  1601. vsf_sysutil_get_ipv4_sock(void)
  1602. {
  1603.   int retval = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  1604.   if (retval < 0)
  1605.   {
  1606.     die("socket");
  1607.   }
  1608.   return retval;
  1609. }
  1611. int
  1612. vsf_sysutil_get_ipv6_sock(void)
  1613. {
  1614.   int retval = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);
  1615.   if (retval < 0)
  1616.   {
  1617.     die("socket");
  1618.   }
  1619.   return retval;
  1620. }
  1622. struct vsf_sysutil_socketpair_retval
  1623. vsf_sysutil_unix_stream_socketpair(void)
  1624. {
  1625.   struct vsf_sysutil_socketpair_retval retval;
  1626.   int the_sockets[2];
  1627.   int sys_retval = socketpair(PF_UNIX, SOCK_STREAM, 0, the_sockets);
  1628.   if (sys_retval != 0)
  1629.   {
  1630.     die("socketpair");
  1631.   }
  1632.   retval.socket_one = the_sockets[0];
  1633.   retval.socket_two = the_sockets[1];
  1634.   return retval;
  1635. }
  1637. int
  1638. vsf_sysutil_bind(int fd, const struct vsf_sysutil_sockaddr* p_sockptr)
  1639. {
  1640.   const struct sockaddr* p_sockaddr = &p_sockptr->u.u_sockaddr;
  1641.   int len = 0;
  1642.   if (p_sockaddr->sa_family == AF_INET)
  1643.   {
  1644.     len = sizeof(struct sockaddr_in);
  1645.   }
  1646.   else if (p_sockaddr->sa_family == AF_INET6)
  1647.   {
  1648.     len = sizeof(struct sockaddr_in6);
  1649.   }
  1650.   else
  1651.   {
  1652.     die("can only support ipv4 and ipv6 currently");
  1653.   }
  1654.   return bind(fd, p_sockaddr, len);
  1655. }
  1657. int
  1658. vsf_sysutil_listen(int fd, const unsigned int backlog)
  1659. {
  1660.   int retval = listen(fd, backlog);
  1661.   if (vsf_sysutil_retval_is_error(retval) &&
  1662.       vsf_sysutil_get_error() != kVSFSysUtilErrADDRINUSE)
  1663.   {
  1664.     die("listen");
  1665.   }
  1666.   return retval;
  1667. }
  1669. /* Warning: callers of this function assume it does NOT make use of any
  1670.  * non re-entrant calls such as malloc().
  1671.  */
  1672. int
  1673. vsf_sysutil_accept_timeout(int fd, struct vsf_sysutil_sockaddr* p_sockaddr,
  1674.                            unsigned int wait_seconds)
  1675. {
  1676.   struct vsf_sysutil_sockaddr remote_addr;
  1677.   int retval;
  1678.   int saved_errno;
  1679.   fd_set accept_fdset;
  1680.   struct timeval timeout;
  1681.   socklen_t socklen = sizeof(remote_addr);
  1682.   if (p_sockaddr)
  1683.   {
  1684.     vsf_sysutil_memclr(p_sockaddr, sizeof(*p_sockaddr));
  1685.   }
  1686.   if (wait_seconds > 0)
  1687.   {
  1688.     FD_ZERO(&accept_fdset);
  1689.     FD_SET(fd, &accept_fdset);
  1690.     timeout.tv_sec = wait_seconds;
  1691.     timeout.tv_usec = 0;
  1692.     do
  1693.     {
  1694.       retval = select(fd + 1, &accept_fdset, NULL, NULL, &timeout);
  1695.       saved_errno = errno;
  1696.       vsf_sysutil_check_pending_actions(kVSFSysUtilUnknown, 0, 0);
  1697.     } while (retval < 0 && saved_errno == EINTR);
  1698.     if (retval == 0)
  1699.     {
  1700.       errno = EAGAIN;
  1701.       return -1;
  1702.     }
  1703.   }
  1704.   retval = accept(fd, &remote_addr.u.u_sockaddr, &socklen);
  1705.   vsf_sysutil_check_pending_actions(kVSFSysUtilUnknown, 0, 0);
  1706.   if (retval < 0)
  1707.   {
  1708.     return retval;
  1709.   }
  1710.   /* FreeBSD bug / paranoia: ai32@drexel.edu */
  1711.   if (socklen == 0)
  1712.   {
  1713.     return -1;
  1714.   }
  1715.   if (remote_addr.u.u_sockaddr.sa_family != AF_INET &&
  1716.       remote_addr.u.u_sockaddr.sa_family != AF_INET6)
  1717.   {
  1718.     die("can only support ipv4 and ipv6 currently");
  1719.   }
  1720.   if (p_sockaddr)
  1721.   {
  1722.     if (remote_addr.u.u_sockaddr.sa_family == AF_INET)
  1723.     {
  1724.       vsf_sysutil_memclr(&remote_addr.u.u_sockaddr_in.sin_zero,
  1725.                          sizeof(remote_addr.u.u_sockaddr_in.sin_zero));
  1726.       vsf_sysutil_memcpy(p_sockaddr, &remote_addr.u.u_sockaddr_in,
  1727.                          sizeof(remote_addr.u.u_sockaddr_in));
  1728.     }
  1729.     else
  1730.     {
  1731.       vsf_sysutil_memcpy(p_sockaddr, &remote_addr.u.u_sockaddr_in6,
  1732.                          sizeof(remote_addr.u.u_sockaddr_in6));
  1733.     }
  1734.   }
  1735.   return retval;
  1736. }
  1738. int
  1739. vsf_sysutil_connect_timeout(int fd, const struct vsf_sysutil_sockaddr* p_addr,
  1740.                             unsigned int wait_seconds)
  1741. {
  1742.   const struct sockaddr* p_sockaddr = &p_addr->u.u_sockaddr;
  1743.   unsigned int addrlen = 0;
  1744.   int retval;
  1745.   int saved_errno;
  1746.   if (p_sockaddr->sa_family == AF_INET)
  1747.   {
  1748.     addrlen = sizeof(p_addr->u.u_sockaddr_in);
  1749.   }
  1750.   else if (p_sockaddr->sa_family == AF_INET6)
  1751.   {
  1752.     addrlen = sizeof(p_addr->u.u_sockaddr_in6);
  1753.   }
  1754.   else
  1755.   {
  1756.     die("can only support ipv4 and ipv6 currently");
  1757.   }
  1758.   if (wait_seconds > 0)
  1759.   {
  1760.     vsf_sysutil_activate_noblock(fd);
  1761.   }
  1762.   retval = connect(fd, p_sockaddr, addrlen);
  1763.   if (retval < 0 && errno == EINPROGRESS)
  1764.   {
  1765.     fd_set connect_fdset;
  1766.     struct timeval timeout;
  1767.     FD_ZERO(&connect_fdset);
  1768.     FD_SET(fd, &connect_fdset);
  1769.     timeout.tv_sec = wait_seconds;
  1770.     timeout.tv_usec = 0;
  1771.     do
  1772.     {
  1773.       retval = select(fd + 1, NULL, &connect_fdset, NULL, &timeout);
  1774.       saved_errno = errno;
  1775.       vsf_sysutil_check_pending_actions(kVSFSysUtilUnknown, 0, 0);
  1776.     }
  1777.     while (retval < 0 && saved_errno == EINTR);
  1778.     if (retval == 0)
  1779.     {
  1780.       retval = -1;
  1781.       errno = EAGAIN;
  1782.     }
  1783.     else
  1784.     {
  1785.       socklen_t socklen = sizeof(retval);
  1786.       int sockoptret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &retval, &socklen);
  1787.       if (sockoptret != 0)
  1788.       {
  1789.         die("getsockopt");
  1790.       }
  1791.     }
  1792.   }
  1793.   if (wait_seconds > 0)
  1794.   {
  1795.     vsf_sysutil_deactivate_noblock(fd);
  1796.   }
  1797.   return retval;
  1798. }
  1800. void
  1801. vsf_sysutil_getsockname(int fd, struct vsf_sysutil_sockaddr** p_sockptr)
  1802. {
  1803.   struct vsf_sysutil_sockaddr the_addr;
  1804.   int retval;
  1805.   socklen_t socklen = sizeof(the_addr);
  1806.   vsf_sysutil_sockaddr_clear(p_sockptr);
  1807.   retval = getsockname(fd, &the_addr.u.u_sockaddr, &socklen);
  1808.   if (retval != 0)
  1809.   {
  1810.     die("getsockname");
  1811.   }
  1812.   if (the_addr.u.u_sockaddr.sa_family != AF_INET &&
  1813.       the_addr.u.u_sockaddr.sa_family != AF_INET6)
  1814.   {
  1815.     die("can only support ipv4 and ipv6 currently");
  1816.   }
  1817.   vsf_sysutil_sockaddr_alloc(p_sockptr);
  1818.   if (socklen > sizeof(the_addr))
  1819.   {
  1820.     socklen = sizeof(the_addr);
  1821.   }
  1822.   vsf_sysutil_memcpy(*p_sockptr, &the_addr, socklen);
  1823. }
  1825. void
  1826. vsf_sysutil_getpeername(int fd, struct vsf_sysutil_sockaddr** p_sockptr)
  1827. {
  1828.   struct vsf_sysutil_sockaddr the_addr;
  1829.   int retval;
  1830.   socklen_t socklen = sizeof(the_addr);
  1831.   vsf_sysutil_sockaddr_clear(p_sockptr);
  1832.   retval = getpeername(fd, &the_addr.u.u_sockaddr, &socklen);
  1833.   if (retval != 0)
  1834.   {
  1835.     die("getpeername");
  1836.   }
  1837.   if (the_addr.u.u_sockaddr.sa_family != AF_INET &&
  1838.       the_addr.u.u_sockaddr.sa_family != AF_INET6)
  1839.   {
  1840.     die("can only support ipv4 and ipv6 currently");
  1841.   }
  1842.   vsf_sysutil_sockaddr_alloc(p_sockptr);
  1843.   if (socklen > sizeof(the_addr))
  1844.   {
  1845.     socklen = sizeof(the_addr);
  1846.   }
  1847.   vsf_sysutil_memcpy(*p_sockptr, &the_addr, socklen);
  1848. }
  1850. void
  1851. vsf_sysutil_shutdown_failok(int fd)
  1852. {
  1853.   /* SHUT_RDWR is a relatively new addition */
  1854.   #ifndef SHUT_RDWR
  1855.   #define SHUT_RDWR 2
  1856.   #endif
  1857.   (void) shutdown(fd, SHUT_RDWR);
  1858. }
  1860. void
  1861. vsf_sysutil_shutdown_read_failok(int fd)
  1862. {
  1863.   /* SHUT_RD is a relatively new addition */
  1864.   #ifndef SHUT_RD
  1865.   #define SHUT_RD 0
  1866.   #endif
  1867.   (void) shutdown(fd, SHUT_RD);
  1868. }
  1870. void
  1871. vsf_sysutil_sockaddr_clear(struct vsf_sysutil_sockaddr** p_sockptr)
  1872. {
  1873.   if (*p_sockptr != NULL)
  1874.   {
  1875.     vsf_sysutil_free(*p_sockptr);
  1876.     *p_sockptr = NULL;
  1877.   }
  1878. }
  1880. void
  1881. vsf_sysutil_sockaddr_alloc(struct vsf_sysutil_sockaddr** p_sockptr)
  1882. {
  1883.   vsf_sysutil_sockaddr_clear(p_sockptr);
  1884.   *p_sockptr = vsf_sysutil_malloc(sizeof(**p_sockptr));
  1885.   vsf_sysutil_memclr(*p_sockptr, sizeof(**p_sockptr));
  1886. }
  1888. void
  1889. vsf_sysutil_sockaddr_alloc_ipv4(struct vsf_sysutil_sockaddr** p_sockptr)
  1890. {
  1891.   vsf_sysutil_sockaddr_alloc(p_sockptr);
  1892.   (*p_sockptr)->u.u_sockaddr.sa_family = AF_INET;
  1893. }
  1895. void
  1896. vsf_sysutil_sockaddr_alloc_ipv6(struct vsf_sysutil_sockaddr** p_sockptr)
  1897. {
  1898.   vsf_sysutil_sockaddr_alloc(p_sockptr);
  1899.   (*p_sockptr)->u.u_sockaddr.sa_family = AF_INET6;
  1900. }
  1902. void
  1903. vsf_sysutil_sockaddr_clone(struct vsf_sysutil_sockaddr** p_sockptr,
  1904.                            const struct vsf_sysutil_sockaddr* p_src)
  1905. {
  1906.   struct vsf_sysutil_sockaddr* p_sockaddr = 0;
  1907.   vsf_sysutil_sockaddr_alloc(p_sockptr);
  1908.   p_sockaddr = *p_sockptr;
  1909.   if (p_src->u.u_sockaddr.sa_family == AF_INET)
  1910.   {
  1911.     p_sockaddr->u.u_sockaddr.sa_family = AF_INET;
  1912.     vsf_sysutil_memcpy(&p_sockaddr->u.u_sockaddr_in.sin_addr,
  1913.                        &p_src->u.u_sockaddr_in.sin_addr,
  1914.                        sizeof(p_sockaddr->u.u_sockaddr_in.sin_addr));
  1915.   }
  1916.   else if (p_src->u.u_sockaddr.sa_family == AF_INET6)
  1917.   {
  1918.     p_sockaddr->u.u_sockaddr.sa_family = AF_INET6;
  1919.     vsf_sysutil_memcpy(&p_sockaddr->u.u_sockaddr_in6.sin6_addr,
  1920.                        &p_src->u.u_sockaddr_in6.sin6_addr,
  1921.                        sizeof(p_sockaddr->u.u_sockaddr_in6.sin6_addr));
  1922.     p_sockaddr->u.u_sockaddr_in6.sin6_scope_id =
  1923.         p_src->u.u_sockaddr_in6.sin6_scope_id;
  1924.   }
  1925.   else
  1926.   {
  1927.     die("can only support ipv4 and ipv6 currently");
  1928.   }
  1929. }
  1931. int
  1932. vsf_sysutil_sockaddr_addr_equal(const struct vsf_sysutil_sockaddr* p1,
  1933.                                 const struct vsf_sysutil_sockaddr* p2)
  1934. {
  1935.   int family1 = p1->u.u_sockaddr.sa_family;
  1936.   int family2 = p2->u.u_sockaddr.sa_family;
  1937.   if (family1 != family2)
  1938.   {
  1939.     if (family1 == AF_INET && family2 == AF_INET6)
  1940.     {
  1941.       const void* p_ipv4_addr = vsf_sysutil_sockaddr_ipv6_v4(p2);
  1942.       if (p_ipv4_addr &&
  1943.           !vsf_sysutil_memcmp(p_ipv4_addr, &p1->u.u_sockaddr_in.sin_addr,
  1944.                               sizeof(p1->u.u_sockaddr_in.sin_addr)))
  1945.       {
  1946.         return 1;
  1947.       }
  1948.     }
  1949.     else if (family1 == AF_INET6 && family2 == AF_INET)
  1950.     {
  1951.       const void* p_ipv4_addr = vsf_sysutil_sockaddr_ipv6_v4(p1);
  1952.       if (p_ipv4_addr &&
  1953.           !vsf_sysutil_memcmp(p_ipv4_addr, &p2->u.u_sockaddr_in.sin_addr,
  1954.                               sizeof(p2->u.u_sockaddr_in.sin_addr)))
  1955.       {
  1956.         return 1;
  1957.       }
  1958.     }
  1959.     return 0;
  1960.   }
  1961.   if (family1 == AF_INET)
  1962.   {
  1963.     if (vsf_sysutil_memcmp(&p1->u.u_sockaddr_in.sin_addr,
  1964.                            &p2->u.u_sockaddr_in.sin_addr,
  1965.                            sizeof(p1->u.u_sockaddr_in.sin_addr)) == 0)
  1966.     {
  1967.       return 1;
  1968.     }
  1969.   }
  1970.   else if (family1 == AF_INET6)
  1971.   {
  1972.     if (vsf_sysutil_memcmp(&p1->u.u_sockaddr_in6.sin6_addr,
  1973.                            &p2->u.u_sockaddr_in6.sin6_addr,
  1974.                            sizeof(p1->u.u_sockaddr_in6.sin6_addr)) == 0)
  1975.     {
  1976.       return 1;
  1977.     }
  1978.   }
  1979.   return 0;
  1980. }
  1982. int
  1983. vsf_sysutil_sockaddr_is_ipv6(const struct vsf_sysutil_sockaddr* p_sockaddr)
  1984. {
  1985.   if (p_sockaddr->u.u_sockaddr.sa_family == AF_INET6)
  1986.   {
  1987.     return 1;
  1988.   }
  1989.   return 0;
  1990. }
  1992. void
  1993. vsf_sysutil_sockaddr_set_ipv4addr(struct vsf_sysutil_sockaddr* p_sockptr,
  1994.                                   const unsigned char* p_raw)
  1995. {
  1996.   if (p_sockptr->u.u_sockaddr.sa_family == AF_INET)
  1997.   {
  1998.     vsf_sysutil_memcpy(&p_sockptr->u.u_sockaddr_in.sin_addr, p_raw,
  1999.                        sizeof(p_sockptr->u.u_sockaddr_in.sin_addr));
  2000.   }
  2001.   else if (p_sockptr->u.u_sockaddr.sa_family == AF_INET6)
  2002.   {
  2003.     static struct vsf_sysutil_sockaddr* s_p_sockaddr;
  2004.     vsf_sysutil_sockaddr_alloc_ipv4(&s_p_sockaddr);
  2005.     vsf_sysutil_memcpy(&s_p_sockaddr->u.u_sockaddr_in.sin_addr, p_raw,
  2006.                        sizeof(&s_p_sockaddr->u.u_sockaddr_in.sin_addr));
  2007.     vsf_sysutil_memcpy(&p_sockptr->u.u_sockaddr_in6.sin6_addr,
  2008.                        vsf_sysutil_sockaddr_ipv4_v6(s_p_sockaddr),
  2009.                        sizeof(p_sockptr->u.u_sockaddr_in6.sin6_addr));
  2010.   }
  2011.   else
  2012.   {
  2013.     bug("bad family");
  2014.   }
  2015. }
  2017. void
  2018. vsf_sysutil_sockaddr_set_ipv6addr(struct vsf_sysutil_sockaddr* p_sockptr,
  2019.                                   const unsigned char* p_raw)
  2020. {
  2021.   if (p_sockptr->u.u_sockaddr.sa_family == AF_INET6)
  2022.   {
  2023.     vsf_sysutil_memcpy(&p_sockptr->u.u_sockaddr_in6.sin6_addr, p_raw,
  2024.                        sizeof(p_sockptr->u.u_sockaddr_in6.sin6_addr));
  2025.   }
  2026.   else
  2027.   {
  2028.     bug("bad family");
  2029.   }
  2030. }
  2032. const void*
  2033. vsf_sysutil_sockaddr_ipv6_v4(const struct vsf_sysutil_sockaddr* p_addr)
  2034. {
  2035.   static char pattern[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF };
  2036.   const unsigned char* p_addr_start;
  2037.   if (p_addr->u.u_sockaddr.sa_family != AF_INET6)
  2038.   {
  2039.     return 0;
  2040.   }
  2041.   if (vsf_sysutil_memcmp(pattern, &p_addr->u.u_sockaddr_in6.sin6_addr, 12))
  2042.   {
  2043.     return 0;
  2044.   }
  2045.   p_addr_start = (const unsigned char*)&p_addr->u.u_sockaddr_in6.sin6_addr;
  2046.   return &p_addr_start[12];
  2047. }
  2049. const void*
  2050. vsf_sysutil_sockaddr_ipv4_v6(const struct vsf_sysutil_sockaddr* p_addr)
  2051. {
  2052.   static char ret[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF };
  2053.   if (p_addr->u.u_sockaddr.sa_family != AF_INET)
  2054.   {
  2055.     return 0;
  2056.   }
  2057.   vsf_sysutil_memcpy(&ret[12], &p_addr->u.u_sockaddr_in.sin_addr, 4);
  2058.   return ret;
  2059. }
  2061. void*
  2062. vsf_sysutil_sockaddr_get_raw_addr(struct vsf_sysutil_sockaddr* p_sockptr)
  2063. {
  2064.   if (p_sockptr->u.u_sockaddr.sa_family == AF_INET)
  2065.   {
  2066.     return &p_sockptr->u.u_sockaddr_in.sin_addr;
  2067.   }
  2068.   else if (p_sockptr->u.u_sockaddr.sa_family == AF_INET6)
  2069.   {
  2070.     return &p_sockptr->u.u_sockaddr_in6.sin6_addr;
  2071.   }
  2072.   else
  2073.   {
  2074.     bug("bad family");
  2075.   }
  2076.   return 0;
  2077. }
  2079. unsigned int
  2080. vsf_sysutil_get_ipaddr_size(void)
  2081. {
  2082.   struct vsf_sysutil_sockaddr addr;
  2083.   unsigned int size = sizeof(addr.u.u_sockaddr_in.sin_addr);
  2084.   unsigned int size2 = sizeof(addr.u.u_sockaddr_in6.sin6_addr);
  2085.   if (size2 > size)
  2086.   {
  2087.     size = size2;
  2088.   }
  2089.   return size;
  2090. }
  2092. int
  2093. vsf_sysutil_get_ipsock(const struct vsf_sysutil_sockaddr* p_addr)
  2094. {
  2095.   if (p_addr->u.u_sockaddr.sa_family == AF_INET)
  2096.   {
  2097.     return vsf_sysutil_get_ipv4_sock();
  2098.   }
  2099.   else if (p_addr->u.u_sockaddr.sa_family == AF_INET6)
  2100.   {
  2101.     return vsf_sysutil_get_ipv6_sock();
  2102.   }
  2103.   else
  2104.   {
  2105.     bug("bad family");
  2106.   }
  2107.   return -1;
  2108. }
  2110. void
  2111. vsf_sysutil_sockaddr_set_any(struct vsf_sysutil_sockaddr* p_sockaddr)
  2112. {
  2113.   if (p_sockaddr->u.u_sockaddr.sa_family == AF_INET)
  2114.   {
  2115.     vsf_sysutil_memclr(&p_sockaddr->u.u_sockaddr_in.sin_addr,
  2116.                        sizeof(p_sockaddr->u.u_sockaddr_in.sin_addr));
  2117.   }
  2118.   else if (p_sockaddr->u.u_sockaddr.sa_family == AF_INET6)
  2119.   {
  2120.     vsf_sysutil_memclr(&p_sockaddr->u.u_sockaddr_in6.sin6_addr,
  2121.                        sizeof(p_sockaddr->u.u_sockaddr_in6.sin6_addr));
  2122.   }
  2123.   else
  2124.   {
  2125.     bug("bad family");
  2126.   }
  2127. }
  2129. unsigned short
  2130. vsf_sysutil_sockaddr_get_port(const struct vsf_sysutil_sockaddr* p_sockptr)
  2131. {
  2132.   if (p_sockptr->u.u_sockaddr.sa_family == AF_INET)
  2133.   {
  2134.     return ntohs(p_sockptr->u.u_sockaddr_in.sin_port);
  2135.   }
  2136.   else if (p_sockptr->u.u_sockaddr.sa_family == AF_INET6)
  2137.   {
  2138.     return ntohs(p_sockptr->u.u_sockaddr_in6.sin6_port);
  2139.   }
  2140.   else
  2141.   {
  2142.     bug("bad family");
  2143.   }
  2144.   /* NOTREACHED */
  2145.   return 0;
  2146. }
  2148. void
  2149. vsf_sysutil_sockaddr_set_port(struct vsf_sysutil_sockaddr* p_sockptr,
  2150.                               unsigned short the_port)
  2151. {
  2152.   if (p_sockptr->u.u_sockaddr.sa_family == AF_INET)
  2153.   {
  2154.     p_sockptr->u.u_sockaddr_in.sin_port = htons(the_port);
  2155.   }
  2156.   else if (p_sockptr->u.u_sockaddr.sa_family == AF_INET6)
  2157.   {
  2158.     p_sockptr->u.u_sockaddr_in6.sin6_port = htons(the_port);
  2159.   }
  2160.   else
  2161.   {
  2162.     bug("bad family");
  2163.   }
  2164. }
  2166. int
  2167. vsf_sysutil_is_port_reserved(unsigned short the_port)
  2168. {
  2169.   if (the_port < IPPORT_RESERVED)
  2170.   {
  2171.     return 1;
  2172.   }
  2173.   return 0;
  2174. }
  2176. const char*
  2177. vsf_sysutil_inet_ntop(const struct vsf_sysutil_sockaddr* p_sockptr)
  2178. {
  2179.   const struct sockaddr* p_sockaddr = &p_sockptr->u.u_sockaddr;
  2180.   if (p_sockaddr->sa_family == AF_INET)
  2181.   {
  2182.     return inet_ntoa(p_sockptr->u.u_sockaddr_in.sin_addr);
  2183.   }
  2184.   else if (p_sockaddr->sa_family == AF_INET6)
  2185.   {
  2186.     static char inaddr_buf[64];
  2187.     const char* p_ret = inet_ntop(AF_INET6,
  2188.                                   &p_sockptr->u.u_sockaddr_in6.sin6_addr,
  2189.                                   inaddr_buf, sizeof(inaddr_buf));
  2190.     inaddr_buf[sizeof(inaddr_buf) - 1] = '';
  2191.     if (p_ret == NULL)
  2192.     {
  2193.       inaddr_buf[0] = '';
  2194.     }
  2195.     return inaddr_buf;
  2196.   }
  2197.   else
  2198.   {
  2199.     die("can only support ipv4 and ipv6 currently");
  2200.     return 0;
  2201.   }
  2202. }
  2204. const char*
  2205. vsf_sysutil_inet_ntoa(const void* p_raw_addr)
  2206. {
  2207.   return inet_ntoa(*((struct in_addr*)p_raw_addr));
  2208. }
  2210. int
  2211. vsf_sysutil_inet_aton(const char* p_text, struct vsf_sysutil_sockaddr* p_addr)
  2212. {
  2213.   struct in_addr sin_addr;
  2214.   if (p_addr->u.u_sockaddr.sa_family != AF_INET)
  2215.   {
  2216.     bug("bad family");
  2217.   }
  2218.   if (inet_aton(p_text, &sin_addr))
  2219.   {
  2220.     vsf_sysutil_memcpy(&p_addr->u.u_sockaddr_in.sin_addr,
  2221.                        &sin_addr, sizeof(p_addr->u.u_sockaddr_in.sin_addr));
  2222.     return 1;
  2223.   }
  2224.   else
  2225.   {
  2226.     return 0;
  2227.   }
  2228. }
  2230. void
  2231. vsf_sysutil_dns_resolve(struct vsf_sysutil_sockaddr** p_sockptr,
  2232.                         const char* p_name)
  2233. {
  2234.   struct hostent* hent = gethostbyname(p_name);
  2235.   if (hent == NULL)
  2236.   {
  2237.     die2("cannot resolve host:", p_name);
  2238.   }
  2239.   vsf_sysutil_sockaddr_clear(p_sockptr);
  2240.   if (hent->h_addrtype == AF_INET)
  2241.   {
  2242.     unsigned int len = hent->h_length;
  2243.     if (len > sizeof((*p_sockptr)->u.u_sockaddr_in.sin_addr))
  2244.     {
  2245.       len = sizeof((*p_sockptr)->u.u_sockaddr_in.sin_addr);
  2246.     }
  2247.     vsf_sysutil_sockaddr_alloc_ipv4(p_sockptr);
  2248.     vsf_sysutil_memcpy(&(*p_sockptr)->u.u_sockaddr_in.sin_addr,
  2249.                        hent->h_addr_list[0], len);
  2250.   }
  2251.   else if (hent->h_addrtype == AF_INET6)
  2252.   {
  2253.     unsigned int len = hent->h_length;
  2254.     if (len > sizeof((*p_sockptr)->u.u_sockaddr_in6.sin6_addr))
  2255.     {
  2256.       len = sizeof((*p_sockptr)->u.u_sockaddr_in6.sin6_addr);
  2257.     }
  2258.     vsf_sysutil_sockaddr_alloc_ipv6(p_sockptr);
  2259.     vsf_sysutil_memcpy(&(*p_sockptr)->u.u_sockaddr_in6.sin6_addr,
  2260.                        hent->h_addr_list[0], len);
  2261.   }
  2262.   else
  2263.   {
  2264.     die("gethostbyname(): neither IPv4 nor IPv6");
  2265.   }
  2266. }
  2268. struct vsf_sysutil_user*
  2269. vsf_sysutil_getpwuid(const int uid)
  2270. {
  2271.   if (uid < 0)
  2272.   {
  2273.     bug("negative uid in vsf_sysutil_getpwuid");
  2274.   }
  2275.   return (struct vsf_sysutil_user*) getpwuid((unsigned int) uid);
  2276. }
  2278. struct vsf_sysutil_user*
  2279. vsf_sysutil_getpwnam(const char* p_user)
  2280. {
  2281.   return (struct vsf_sysutil_user*) getpwnam(p_user);
  2282. }
  2284. const char*
  2285. vsf_sysutil_user_getname(const struct vsf_sysutil_user* p_user)
  2286. {
  2287.   const struct passwd* p_passwd = (const struct passwd*) p_user;
  2288.   return p_passwd->pw_name;
  2289. }
  2291. const char*
  2292. vsf_sysutil_user_get_homedir(const struct vsf_sysutil_user* p_user)
  2293. {
  2294.   const struct passwd* p_passwd = (const struct passwd*) p_user;
  2295.   return p_passwd->pw_dir;
  2296. }
  2298. int
  2299. vsf_sysutil_user_getuid(const struct vsf_sysutil_user* p_user)
  2300. {
  2301.   const struct passwd* p_passwd = (const struct passwd*) p_user;
  2302.   return p_passwd->pw_uid;
  2303. }
  2305. int
  2306. vsf_sysutil_user_getgid(const struct vsf_sysutil_user* p_user)
  2307. { 
  2308.   const struct passwd* p_passwd = (const struct passwd*) p_user;
  2309.   return p_passwd->pw_gid;
  2310. }
  2312. struct vsf_sysutil_group*
  2313. vsf_sysutil_getgrgid(const int gid)
  2314. {
  2315.   if (gid < 0)
  2316.   {
  2317.     die("negative gid in vsf_sysutil_getgrgid");
  2318.   }
  2319.   return (struct vsf_sysutil_group*) getgrgid((unsigned int) gid);
  2320. }
  2322. const char*
  2323. vsf_sysutil_group_getname(const struct vsf_sysutil_group* p_group)
  2324. {
  2325.   const struct group* p_grp = (const struct group*) p_group;
  2326.   return p_grp->gr_name;
  2327. }
  2329. unsigned char
  2330. vsf_sysutil_get_random_byte(void)
  2331. {
  2332.   static int seeded;
  2333.   unsigned int uint_res;
  2334.   unsigned char c1, c2, c3, c4;
  2335.   if (!seeded)
  2336.   {
  2337.     struct timeval tv;
  2338.     int retval = gettimeofday(&tv, NULL);
  2339.     if (retval != 0)
  2340.     {
  2341.       die("gettimeofday");
  2342.     }
  2343.     srand((unsigned)tv.tv_usec);
  2344.     seeded = 1;
  2345.   }
  2346.   uint_res = rand();
  2347.   c1 = uint_res & 0x000000ff;
  2348.   c2 = (uint_res >> 8) & 0x000000ff;
  2349.   c3 = (uint_res >> 16) & 0x000000ff;
  2350.   c4 = (uint_res >> 24) & 0x000000ff;
  2351.   return c1 ^ c2 ^ c3 ^ c4;    
  2352. }
  2354. int
  2355. vsf_sysutil_running_as_root(void)
  2356. {
  2357.   return (getuid() == 0);
  2358. }
  2360. void
  2361. vsf_sysutil_setuid(const struct vsf_sysutil_user* p_user)
  2362. {
  2363.   const struct passwd* p_passwd = (const struct passwd*) p_user;
  2364.   vsf_sysutil_setuid_numeric(p_passwd->pw_uid);
  2365. }
  2367. void
  2368. vsf_sysutil_setuid_numeric(int uid)
  2369. {
  2370.   int retval = setuid(uid);
  2371.   if (retval != 0)
  2372.   {
  2373.     die("setuid");
  2374.   }
  2375. }
  2377. void
  2378. vsf_sysutil_setgid(const struct vsf_sysutil_user* p_user)
  2379. {
  2380.   const struct passwd* p_passwd = (const struct passwd*) p_user;
  2381.   vsf_sysutil_setgid_numeric(p_passwd->pw_gid);
  2382. }
  2384. void
  2385. vsf_sysutil_setgid_numeric(int gid)
  2386. {
  2387.   int retval = setgid(gid);
  2388.   if (retval != 0)
  2389.   {
  2390.     die("setgid");
  2391.   }
  2392. }
  2394. int
  2395. vsf_sysutil_geteuid(void)
  2396. {
  2397.   int retval = geteuid();
  2398.   if (retval < 0)
  2399.   {
  2400.     die("geteuid");
  2401.   }
  2402.   return retval;
  2403. }
  2405. int
  2406. vsf_sysutil_getegid(void)
  2407. {
  2408.   int retval = getegid();
  2409.   if (retval < 0)
  2410.   {
  2411.     die("getegid");
  2412.   }
  2413.   return retval;
  2414. }
  2416. void
  2417. vsf_sysutil_seteuid(const struct vsf_sysutil_user* p_user)
  2418. {
  2419.   const struct passwd* p_passwd = (const struct passwd*) p_user;
  2420.   vsf_sysutil_seteuid_numeric(p_passwd->pw_uid);
  2421. }
  2423. void
  2424. vsf_sysutil_setegid(const struct vsf_sysutil_user* p_user)
  2425. {
  2426.   const struct passwd* p_passwd = (const struct passwd*) p_user;
  2427.   vsf_sysutil_setegid_numeric(p_passwd->pw_gid);
  2428. }
  2430. void
  2431. vsf_sysutil_seteuid_numeric(int uid)
  2432. {
  2433.   /* setreuid() would seem to be more portable than seteuid() */
  2434.   int retval = setreuid(-1, uid);
  2435.   if (retval != 0)
  2436.   {
  2437.     die("seteuid");
  2438.   }
  2439. }
  2441. void
  2442. vsf_sysutil_setegid_numeric(int gid)
  2443. {
  2444.   /* setregid() would seem to be more portable than setegid() */
  2445.   int retval = setregid(-1, gid);
  2446.   if (retval != 0)
  2447.   {
  2448.     die("setegid");
  2449.   }
  2450. }
  2452. void
  2453. vsf_sysutil_clear_supp_groups(void)
  2454. {
  2455.   int retval = setgroups(0, NULL);
  2456.   if (retval != 0)
  2457.   {
  2458.     die("setgroups");
  2459.   }
  2460. }
  2462. void
  2463. vsf_sysutil_initgroups(const struct vsf_sysutil_user* p_user)
  2464. {
  2465.   const struct passwd* p_passwd = (const struct passwd*) p_user;
  2466.   int retval = initgroups(p_passwd->pw_name, p_passwd->pw_gid);
  2467.   if (retval != 0)
  2468.   {
  2469.     die("initgroups");
  2470.   }
  2471. }
  2473. void
  2474. vsf_sysutil_chroot(const char* p_root_path)
  2475. {
  2476.   int retval = chroot(p_root_path);
  2477.   if (retval != 0)
  2478.   {
  2479.     die("chroot");
  2480.   }
  2481. }
  2483. unsigned int
  2484. vsf_sysutil_get_umask(void)
  2485. {
  2486.   return s_current_umask;
  2487. }
  2489. void
  2490. vsf_sysutil_set_umask(unsigned int new_umask)
  2491. {
  2492.   s_current_umask = (new_umask & 0777);
  2493.   (void) umask(s_current_umask);
  2494. }
  2496. void
  2497. vsf_sysutil_make_session_leader(void)
  2498. {
  2499.   /* This makes us the leader if we are not already */
  2500.   (void) setsid();
  2501.   /* Check we're the leader */
  2502.   if ((int) vsf_sysutil_getpid() != getpgrp())
  2503.   {
  2504.     die("not session leader");
  2505.   }
  2506. }
  2508. void
  2509. vsf_sysutil_reopen_standard_fds(void)
  2510. {
  2511.   /* This reopens STDIN, STDOUT and STDERR to /dev/null */
  2512.   int fd;
  2513.   if ((fd = open("/dev/null", O_RDWR, 0)) < 0)
  2514.   {
  2515.     goto error;
  2516.   }
  2517.   vsf_sysutil_dupfd2(fd, STDIN_FILENO);
  2518.   vsf_sysutil_dupfd2(fd, STDOUT_FILENO);
  2519.   vsf_sysutil_dupfd2(fd, STDERR_FILENO);
  2520.   if ( fd > 2 )
  2521.   {
  2522.     vsf_sysutil_close(fd);
  2523.   }
  2524.   return;
  2526. error:
  2527.   die("reopening standard file descriptors to /dev/null failed");
  2528. }
  2530. void
  2531. vsf_sysutil_tzset(void)
  2532. {
  2533.   int retval;
  2534.   char tzbuf[sizeof("+HHMM!")];
  2535.   time_t the_time = time(NULL);
  2536.   struct tm* p_tm;
  2537.   tzset();
  2538.   p_tm = localtime(&the_time);
  2539.   if (p_tm == NULL)
  2540.   {
  2541.     die("localtime");
  2542.   }
  2543.   /* Set our timezone in the TZ environment variable to cater for the fact
  2544.    * that modern glibc does not cache /etc/localtime (which becomes inaccessible
  2545.    * when we chroot().
  2546.    */
  2547.   retval = strftime(tzbuf, sizeof(tzbuf), "%z", p_tm);
  2548.   tzbuf[sizeof(tzbuf) - 1] = '';
  2549.   if (retval == 5)
  2550.   {
  2551.     /* Static because putenv() does not copy the string. */
  2552.     static char envtz[sizeof("TZ=UTC-hh:mm")];
  2553.     /* Insert a colon so we have e.g. -05:00 instead of -0500 */
  2554.     tzbuf[5] = tzbuf[4];
  2555.     tzbuf[4] = tzbuf[3];
  2556.     tzbuf[3] = ':';
  2557.     /* Invert the sign - we just got the offset _from_ UTC but for TZ, we need
  2558.      * the offset _to_ UTC.
  2559.      */
  2560.     if (tzbuf[0] == '+')
  2561.     {
  2562.       tzbuf[0] = '-';
  2563.     }
  2564.     else
  2565.     {
  2566.       tzbuf[0] = '+';
  2567.     }
  2568.     snprintf(envtz, sizeof(envtz), "TZ=UTC%s", tzbuf);
  2569.     putenv(envtz);
  2570.     s_timezone = ((tzbuf[1] - '0') * 10 + (tzbuf[2] - '0')) * 60 * 60;
  2571.     s_timezone += ((tzbuf[4] - '0') * 10 + (tzbuf[5] - '0')) * 60;
  2572.     if (tzbuf[0] == '-')
  2573.     {
  2574.       s_timezone *= -1;
  2575.     }
  2576.   }
  2577. }
  2579. const char*
  2580. vsf_sysutil_get_current_date(void)
  2581. {
  2582.   static char datebuf[64];
  2583.   time_t curr_time;
  2584.   const struct tm* p_tm;
  2585.   int i = 0;
  2586.   curr_time = vsf_sysutil_get_time_sec();
  2587.   p_tm = localtime(&curr_time);
  2588.   if (strftime(datebuf, sizeof(datebuf), "%a %b!%d %H:%M:%S %Y", p_tm) == 0)
  2589.   {
  2590.     die("strftime");
  2591.   }
  2592.   datebuf[sizeof(datebuf) - 1] = '';
  2593.   /* This hack is because %e in strftime() isn't so portable */
  2594.   while (datebuf[i] != '!' && datebuf[i] != '')
  2595.   {
  2596.     ++i;
  2597.   }
  2598.   if (datebuf[i] == '!')
  2599.   {
  2600.     datebuf[i] = ' ';
  2601.     if (datebuf[i+1] == '0')
  2602.     {
  2603.       datebuf[i+1] = ' ';
  2604.     }
  2605.   }
  2606.   return datebuf;
  2607. }
  2609. long
  2610. vsf_sysutil_get_time_sec(void)
  2611. {
  2612.   if (gettimeofday(&s_current_time, NULL) != 0)
  2613.   {
  2614.     die("gettimeofday");
  2615.   }
  2616.   return s_current_time.tv_sec;
  2617. }
  2619. long
  2620. vsf_sysutil_get_time_usec(void)
  2621. {
  2622.   return s_current_time.tv_usec;
  2623. }
  2625. void
  2626. vsf_sysutil_qsort(void* p_base, unsigned int num_elem, unsigned int elem_size,
  2627.                   int (*p_compar)(const void *, const void *))
  2628. {
  2629.   qsort(p_base, num_elem, elem_size, p_compar);
  2630. }
  2632. void
  2633. vsf_sysutil_sleep(double seconds)
  2634. {
  2635.   int retval;
  2636.   int saved_errno;
  2637.   double fractional;
  2638.   time_t secs;
  2639.   struct timespec ts;
  2640.   secs = (time_t) seconds;
  2641.   fractional = seconds - (double) secs;
  2642.   ts.tv_sec = secs;
  2643.   ts.tv_nsec = (long) (fractional * (double) 1000000000);
  2644.   do
  2645.   {
  2646.     retval = nanosleep(&ts, &ts);
  2647.     saved_errno = errno;
  2648.     vsf_sysutil_check_pending_actions(kVSFSysUtilUnknown, 0, 0);
  2649.   } while (retval == -1 && saved_errno == EINTR);
  2650. }
  2652. char*
  2653. vsf_sysutil_getenv(const char* p_var)
  2654. {
  2655.   return getenv(p_var);
  2656. }
  2658. void
  2659. vsf_sysutil_openlog(int force)
  2660. {
  2661.   int facility = LOG_DAEMON;
  2662.   int option = LOG_PID;
  2663.   if (!force)
  2664.   {
  2665.     option |= LOG_NDELAY;
  2666.   }
  2667. #ifdef LOG_FTP
  2668.   facility = LOG_FTP;
  2669. #endif
  2670.   openlog("vsftpd", option, facility);
  2671. }
  2673. void
  2674. vsf_sysutil_closelog(void)
  2675. {
  2676.   closelog();
  2677. }
  2679. void
  2680. vsf_sysutil_syslog(const char* p_text, int severe)
  2681. {
  2682.   int prio = LOG_INFO;
  2683.   if (severe)
  2684.   {
  2685.     prio = LOG_WARNING;
  2686.   }
  2687.   syslog(prio, "%s", p_text);
  2688. }
  2690. long
  2691. vsf_sysutil_parse_time(const char* p_text)
  2692. {
  2693.   struct tm the_time;
  2694.   unsigned int len = vsf_sysutil_strlen(p_text);
  2695.   vsf_sysutil_memclr(&the_time, sizeof(the_time));
  2696.   if (len >= 8)
  2697.   {
  2698.     char yr[5];
  2699.     char mon[3];
  2700.     char day[3];
  2701.     vsf_sysutil_strcpy(yr, p_text, 5);
  2702.     vsf_sysutil_strcpy(mon, p_text + 4, 3);
  2703.     vsf_sysutil_strcpy(day, p_text + 6, 3);
  2704.     the_time.tm_year = vsf_sysutil_atoi(yr) - 1900;
  2705.     the_time.tm_mon = vsf_sysutil_atoi(mon) - 1;
  2706.     the_time.tm_mday = vsf_sysutil_atoi(day);
  2707.   }
  2708.   if (len >= 14)
  2709.   {
  2710.     char hr[3];
  2711.     char mins[3];
  2712.     char sec[3];
  2713.     vsf_sysutil_strcpy(hr, p_text + 8, 3);
  2714.     vsf_sysutil_strcpy(mins, p_text + 10, 3);
  2715.     vsf_sysutil_strcpy(sec, p_text + 12, 3);
  2716.     the_time.tm_hour = vsf_sysutil_atoi(hr);
  2717.     the_time.tm_min = vsf_sysutil_atoi(mins);
  2718.     the_time.tm_sec = vsf_sysutil_atoi(sec);
  2719.   }
  2720.   return mktime(&the_time);
  2721. }
  2723. int
  2724. vsf_sysutil_setmodtime(const char* p_file, long the_time, int is_localtime)
  2725. {
  2726.   struct utimbuf new_times;
  2727.   if (!is_localtime)
  2728.   {
  2729.     the_time -= s_timezone;
  2730.   }
  2731.   vsf_sysutil_memclr(&new_times, sizeof(new_times));
  2732.   new_times.actime = the_time;
  2733.   new_times.modtime = the_time;
  2734.   return utime(p_file, &new_times);
  2735. }
  2737. void
  2738. vsf_sysutil_ftruncate(int fd)
  2739. {
  2740.   int ret = ftruncate(fd, 0);
  2741.   if (ret != 0)
  2742.   {
  2743.     die("ftruncate");
  2744.   }
  2745. }
  2747. int
  2748. vsf_sysutil_getuid(void)
  2749. {
  2750.   return getuid();
  2751. }
  2753. void
  2754. vsf_sysutil_set_address_space_limit(long bytes)
  2755. {
  2756.   /* Unfortunately, OpenBSD is missing RLIMIT_AS. */
  2757. #ifdef RLIMIT_AS
  2758.   int ret;
  2759.   struct rlimit rlim;
  2760.   rlim.rlim_cur = bytes;
  2761.   rlim.rlim_max = bytes;
  2762.   ret = setrlimit(RLIMIT_AS, &rlim);
  2763.   /* Permit EPERM as this could indicate that the shell launching vsftpd already
  2764.    * has a lower limit.
  2765.    */
  2766.   if (ret != 0 && errno != EPERM)
  2767.   {
  2768.     die("setrlimit");
  2769.   }
  2770. #endif /* RLIMIT_AS */
  2771.   (void) bytes;
  2772. }
  2774. void
  2775. vsf_sysutil_set_no_fds()
  2776. {
  2777.   int ret;
  2778.   struct rlimit rlim;
  2779.   rlim.rlim_cur = 0;
  2780.   rlim.rlim_max = 0;
  2781.   ret = setrlimit(RLIMIT_NOFILE, &rlim);
  2782.   if (ret != 0)
  2783.   {
  2784.     die("setrlimit NOFILE");
  2785.   }
  2786. }
  2788. void
  2789. vsf_sysutil_set_no_procs()
  2790. {
  2791. #ifdef RLIMIT_NPROC
  2792.   int ret;
  2793.   struct rlimit rlim;
  2794.   rlim.rlim_cur = 0;
  2795.   rlim.rlim_max = 0;
  2796.   ret = setrlimit(RLIMIT_NPROC, &rlim);
  2797.   if (ret != 0)
  2798.   {
  2799.     die("setrlimit NPROC");
  2800.   }
  2801. #endif
  2802. }
  2804. void
  2805. vsf_sysutil_post_fork()
  2806. {
  2807.   int i;
  2808.   /* Don't inherit any exit function. */
  2809.   s_exit_func = NULL;
  2810.   /* Uncached the current PID. */ 
  2811.   s_current_pid = -1;
  2812.   /* Don't inherit anything relating to the synchronous signal system */
  2813.   s_io_handler = NULL;
  2814.   for (i=0; i < NSIG; ++i)
  2815.   {
  2816.     s_sig_details[i].sync_sig_handler = NULL;
  2817.   }
  2818.   for (i=0; i < NSIG; ++i)
  2819.   {
  2820.     s_sig_details[i].pending = 0;
  2821.   }
  2822. }