fwp/lib/core/fwp_util.c

   1 #include "fwp_util.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", strerror(errno));
  43                 return -1;
  44         }
  45
  46         if ((minpri = sched_get_priority_min(SCHED_FIFO)) == -1)        {
  47                 FWP_ERROR("sched_get_priority_min call failed: %s", strerror(errno));
  48                 return -1;
  49         }
  50
  51         if (priority > maxpri)  {
  52                 FWP_ERROR("parameter %d is greater than the maximal allowed priority %d.\n",
  53                           priority, maxpri);
  54                 errno = EINVAL;
  55                 return -1;
  56         }
  57
  58         if (priority < minpri)  {
  59                 FWP_ERROR(stderr,"priority parameter %d is lower than the minimal allowed priority %d.\n",
  60                           priority, minpri);
  61                 errno = EINVAL;
  62                 return -1;
  63         }
  64
  65         param.sched_priority = priority;
  66
  67         if (sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
  68                 FWP_ERROR("sched_setscheduler call failed: %s", strerror(errno));
  69                 return -1;
  70         }
  71
  72         return 0;
  73 }
  74
  75 int fwp_create_unix_socket(char *path, struct sockaddr_un *addr)
  76 {
  77         int sockfd;
  78
  79         if ((sockfd = socket(AF_UNIX, SOCK_DGRAM, 0)) == -1){
  80                 FWP_ERROR("socket error: %s", strerror(errno));
  81                 return (-1);
  82         }
  83
  84         bzero(addr, sizeof(addr));
  85         addr->sun_family = AF_UNIX;
  86         strcpy(addr->sun_path, path);
  87
  88         unlink(path);
  89
  90         if (bind(sockfd, (struct sockaddr*)addr,
  91                  sizeof(*addr)) == -1) {
  92                         FWP_ERROR("fwp_open_unix_socket - bind error: %s", strerror(errno));
  93                         return (-1);
  94         }
  95
  96         return sockfd;
  97 }
  98
  99 int fwp_create_inet_socket(unsigned int port, struct sockaddr_in *addr)
 100 {
 101         int sockfd;
 102
 103         if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1){
 104                 FWP_ERROR("socket error: %s", strerror(errno));
 105                 return (-1);
 106         }
 107
 108         addr->sin_family = AF_INET;
 109         addr->sin_addr.s_addr = INADDR_ANY;
 110         addr->sin_port = htons(port);
 111
 112         if (bind(sockfd, (struct sockaddr*)addr,
 113                  sizeof(*addr)) == -1) {
 114
 115                 FWP_ERROR("bind error: %s", strerror(errno));
 116                 return (-1);
 117         }
 118
 119         return sockfd;
 120 }
 121
 122 /*void block_signals(void)
 123 {
 124         sigset_t sigset;
 125         int ret;
 126         sigemptyset(&sigset);
 127         sigaddset(&sigset, SIGINT);
 128         sigaddset(&sigset, SIGTERM);
 129         ret = pthread_sigmask(SIG_BLOCK, &sigset, NULL);
 130         if (ret != 0) {
 131                 FWP_ERROR("pthread_sigmask failed: %s", strerror(errno));
 132                 exit(1);
 133         }
 134 }
 135 */