fwp/lib/fwp/fwp_utils.c

   1 #include "fwp_utils.h"
   2
   3 #include <sched.h>
   4 /*#include <stdlib.h>*/
   5
   6 /*const int prio_to_ac[8] = {2,3,3,2,1,1,0,0};
   7 const unsigned int ac_to_tos[4] = {224,160,96,64};
   8 const char *ac_to_text[4] = {[AC_VO] = "AC_VO", [AC_VI] = "AC_VI",
   9                              [AC_BE] = "AC_BE", [AC_BK] = "AC_BK", };
  10 */
  11
  12 inline void fwp_timespec_add (struct timespec *sum, const struct timespec *left,
  13               const struct timespec *right)
  14 {
  15         sum->tv_sec = left->tv_sec + right->tv_sec;
  16         sum->tv_nsec = left->tv_nsec + right->tv_nsec;
  17
  18         if (sum->tv_nsec >= 1000000000){
  19                 ++sum->tv_sec;
  20                 sum->tv_nsec -= 1000000000;
  21         }
  22 }
  23
  24 inline void fwp_timespec_sub (struct timespec *diff, const struct timespec *left,
  25               const struct timespec *right)
  26 {
  27         diff->tv_sec = left->tv_sec - right->tv_sec;
  28         diff->tv_nsec = left->tv_nsec - right->tv_nsec;
  29
  30         if (diff->tv_nsec < 0){
  31                   --diff->tv_sec;
  32                   diff->tv_nsec += 1000000000;
  33         }
  34 }
  35
  36 int fwp_set_rt_prio(int priority)
  37 {
  38         int maxpri, minpri;
  39         static struct sched_param param;
  40
  41         if ((maxpri = sched_get_priority_max(SCHED_FIFO)) == -1) {
  42                 FWP_ERROR("sched_get_priority_max call failed: %s\n",
  43                                 strerror(errno));
  44                 return -1;
  45         }
  46
  47         if ((minpri = sched_get_priority_min(SCHED_FIFO)) == -1) {
  48                 FWP_ERROR("sched_get_priority_min call failed: %s\n",
  49                                 strerror(errno));
  50                 return -1;
  51         }
  52
  53         if (priority > maxpri)  {
  54                 FWP_ERROR("parameter %d is greater than the maximal allowed"
  55                                 " priority %d.\n", priority, maxpri);
  56                 errno = EINVAL;
  57                 return -1;
  58         }
  59
  60         if (priority < minpri)  {
  61                 FWP_ERROR("priority parameter %d is lower than the minimal "
  62                                 "allowed priority %d.\n", priority, minpri);
  63                 errno = EINVAL;
  64                 return -1;
  65         }
  66
  67         param.sched_priority = priority;
  68
  69         if (sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
  70                 FWP_ERROR("sched_setscheduler call failed: %s\n",
  71                                 strerror(errno));
  72                 return -1;
  73         }
  74
  75         return 0;
  76 }
  77
  78 int fwp_create_unix_socket(char *path, struct sockaddr_un *addr)
  79 {
  80         int sockfd;
  81
  82         if ((sockfd = socket(AF_UNIX, SOCK_DGRAM, 0)) == -1){
  83                 FWP_ERROR("socket error: %s", strerror(errno));
  84                 return (-1);
  85         }
  86
  87         bzero(addr, sizeof(addr));
  88         addr->sun_family = AF_UNIX;
  89         strcpy(addr->sun_path, path);
  90
  91         unlink(path);
  92
  93         if (bind(sockfd, (struct sockaddr*)addr,
  94                  sizeof(*addr)) == -1) {
  95                         FWP_ERROR("fwp_open_unix_socket - bind error: %s", strerror(errno));
  96                         return (-1);
  97         }
  98
  99         return sockfd;
 100 }
 101
 102 int fwp_create_inet_socket(unsigned int port, struct sockaddr_in *addr)
 103 {
 104         int sockfd;
 105
 106         if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1){
 107                 FWP_ERROR("socket error: %s", strerror(errno));
 108                 return (-1);
 109         }
 110
 111         addr->sin_family = AF_INET;
 112         addr->sin_addr.s_addr = INADDR_ANY;
 113         addr->sin_port = htons(port);
 114
 115         if (bind(sockfd, (struct sockaddr*)addr,
 116                  sizeof(*addr)) == -1) {
 117
 118                 FWP_ERROR("bind error: %s", strerror(errno));
 119                 return (-1);
 120         }
 121
 122         return sockfd;
 123 }
 124
 125 /*void block_signals(void)
 126 {
 127         sigset_t sigset;
 128         int ret;
 129         sigemptyset(&sigset);
 130         sigaddset(&sigset, SIGINT);
 131         sigaddset(&sigset, SIGTERM);
 132         ret = pthread_sigmask(SIG_BLOCK, &sigset, NULL);
 133         if (ret != 0) {
 134                 FWP_ERROR("pthread_sigmask failed: %s", strerror(errno));
 135                 exit(1);
 136         }
 137 }
 138 */