src/mptcp-internal.c

   1 #include <glib.h>
   2 #include <string.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <fcntl.h>
   6 #include <unistd.h>
   7
   8 #include "mptcp-internal.h"
   9 #include "log.h"
  10
  11 #define NET_PROC_SYS_NET_MPTCP  "/proc/sys/net/mptcp/"
  12 #define NET_PROC_SYS_NET_MPTCP_VALUE_MAX_SIZE   15
  13
  14 static gboolean __write_mptcp_parameter(const char* key, const char* value)
  15 {
  16         char path[50];
  17         int fd = -1;
  18
  19         snprintf(path, sizeof(path), NET_PROC_SYS_NET_MPTCP"%s", key);
  20
  21         fd = open(path, O_RDWR);
  22         if (fd < 0) {
  23                 ERR("Fail to open %s", path);
  24                 return FALSE;
  25         }
  26
  27         DBG("write mptcp parameter. len: %zd, value: %s", strlen(value), value);
  28         if (write(fd, value, strlen(value)) < 0) {
  29                 ERR("Fail to write %s to %s", value, path);
  30                 close(fd);
  31                 return FALSE;
  32         }
  33
  34         close(fd);
  35         return TRUE;
  36 }
  37
  38 static char* __read_mptcp_parameter(const char* key)
  39 {
  40         char path[50];
  41         int fd = -1;
  42         int len = -1;
  43         char buf[NET_PROC_SYS_NET_MPTCP_VALUE_MAX_SIZE];
  44
  45         snprintf(path, sizeof(path), NET_PROC_SYS_NET_MPTCP"%s", key);
  46
  47         fd = open(path, O_RDWR);
  48         if (fd < 0) {
  49                 ERR("Fail to open %s", path);
  50                 return NULL;
  51         }
  52
  53         if ((len = read(fd, buf, NET_PROC_SYS_NET_MPTCP_VALUE_MAX_SIZE)) < 0) {
  54                 ERR("Fail to read %s", path);
  55                 close(fd);
  56                 return NULL;
  57         }
  58
  59         if (len < 1) {
  60                 ERR("Fail to read");
  61                 close(fd);
  62                 return NULL;
  63         }
  64
  65         buf[len - 1] = '\0';
  66
  67         DBG("read mptcp parameter. len: %d, value: %s", len, buf);
  68         close(fd);
  69         return g_strndup(buf, strlen(buf));
  70 }
  71
  72 gboolean mptcp_supported()
  73 {
  74         return g_file_test(NET_PROC_SYS_NET_MPTCP, G_FILE_TEST_EXISTS);
  75 }
  76
  77 gboolean mptcp_set_enabled(gint enable)
  78 {
  79         const char* sysctlname = "mptcp_enabled";
  80         char buf[2];
  81         if (enable != 0 && enable != 1 && enable != 2) {
  82                 ERR("Invalid parameter enable %d", enable);
  83                 return FALSE;
  84         }
  85
  86         snprintf(buf, 2, "%d", enable);
  87         return __write_mptcp_parameter(sysctlname, buf);
  88 }
  89
  90 gint mptcp_get_enabled()
  91 {
  92         const char* sysctlname = "mptcp_enabled";
  93         char* buf;
  94         int enabled = -1;
  95
  96         if ((buf = __read_mptcp_parameter(sysctlname)) == NULL)  {
  97                 ERR("Fail to read %s", sysctlname);
  98                 return -1;
  99         }
 100
 101         enabled = atoi(buf);
 102         g_free(buf);
 103
 104         return enabled;
 105 }
 106
 107 gboolean mptcp_set_path_manager(const gchar* pm)
 108 {
 109         const char* sysctlname = "mptcp_path_manager";
 110         return __write_mptcp_parameter(sysctlname, pm);
 111 }
 112
 113 gchar* mptcp_get_path_manager()
 114 {
 115         const char* sysctlname = "mptcp_path_manager";
 116         return __read_mptcp_parameter(sysctlname);
 117 }
 118
 119 gboolean mptcp_mptcp_set_scheduler(const gchar* scheduler)
 120 {
 121         const char* sysctlname = "mptcp_scheduler";
 122         return __write_mptcp_parameter(sysctlname, scheduler);
 123 }
 124
 125 gchar* mptcp_get_scheduler()
 126 {
 127         const char* sysctlname = "mptcp_scheduler";
 128         return __read_mptcp_parameter(sysctlname);
 129 }
 130