lib/syslib/ds.c

   1
   2 #include <minix/ds.h>
   3 #include <string.h>
   4
   5 #include "syslib.h"
   6
   7 int
   8 ds_subscribe(ds_name_regexp, type, flags)
   9 char *ds_name_regexp;
  10 int type;
  11 int flags;
  12 {
  13         int r;
  14         message m;
  15         cp_grant_id_t g;
  16         size_t len;
  17
  18         len = strlen(ds_name_regexp)+1;
  19         g = cpf_grant_direct(DS_PROC_NR,
  20                 (vir_bytes) ds_name_regexp, len, CPF_READ);
  21
  22         if(!GRANT_VALID(g))
  23                 return -1;
  24
  25         flags &= DS_INITIAL;
  26
  27         m.DS_KEY_GRANT = (char *) g;
  28         m.DS_KEY_LEN = len;
  29         m.DS_FLAGS = flags | (type & DS_TYPE_MASK);
  30
  31         r = _taskcall(DS_PROC_NR, DS_SUBSCRIBE, &m);
  32
  33         cpf_revoke(g);
  34
  35         return r;
  36 }
  37
  38 int ds_publish_u32(ds_name, value)
  39 char *ds_name;
  40 u32_t value;
  41 {
  42         int r;
  43         message m;
  44         cp_grant_id_t g;
  45         size_t len;
  46
  47         len = strlen(ds_name)+1;
  48         g = cpf_grant_direct(DS_PROC_NR,
  49                 (vir_bytes) ds_name, len, CPF_READ);
  50
  51         if(!GRANT_VALID(g))
  52                 return -1;
  53
  54         m.DS_KEY_GRANT = (char *) g;
  55         m.DS_KEY_LEN = len;
  56         m.DS_FLAGS = DS_TYPE_U32;
  57         m.DS_VAL = value;
  58         m.DS_VAL_LEN = sizeof(value);
  59
  60         r = _taskcall(DS_PROC_NR, DS_PUBLISH, &m);
  61
  62         cpf_revoke(g);
  63
  64         return r;
  65 }
  66
  67 int ds_publish_str(ds_name, value)
  68 char *ds_name;
  69 char *value;
  70 {
  71         int r;
  72         message m;
  73         cp_grant_id_t g_key, g_str;
  74         size_t len_key, len_str;
  75
  76         /* Grant for key. */
  77         len_key = strlen(ds_name)+1;
  78         g_key = cpf_grant_direct(DS_PROC_NR,
  79                 (vir_bytes) ds_name, len_key, CPF_READ);
  80         if(!GRANT_VALID(g_key))
  81                 return -1;
  82
  83         /* Grant for value. */
  84         len_str = strlen(value)+1;
  85         g_str = cpf_grant_direct(DS_PROC_NR,
  86                 (vir_bytes) value, len_str, CPF_READ);
  87
  88         if(!GRANT_VALID(g_str))  {
  89                 cpf_revoke(g_key);
  90                 return -1;
  91         }
  92
  93         m.DS_KEY_GRANT = (char *) g_key;
  94         m.DS_KEY_LEN = len_key;
  95         m.DS_FLAGS = DS_TYPE_STR;
  96         m.DS_VAL = g_str;
  97         m.DS_VAL_LEN = len_str;
  98
  99         r = _taskcall(DS_PROC_NR, DS_PUBLISH, &m);
 100
 101         cpf_revoke(g_key);
 102         cpf_revoke(g_str);
 103
 104         return r;
 105 }
 106
 107 int ds_retrieve_u32(ds_name, value)
 108 char *ds_name;
 109 u32_t *value;
 110 {
 111         int r;
 112         message m;
 113         cp_grant_id_t g_key;
 114         size_t len_key;
 115
 116         /* Grant for key. */
 117         len_key = strlen(ds_name)+1;
 118         g_key = cpf_grant_direct(DS_PROC_NR,
 119                 (vir_bytes) ds_name, len_key, CPF_READ);
 120         if(!GRANT_VALID(g_key))
 121                 return -1;
 122
 123         /* Do request. */
 124         m.DS_KEY_GRANT = (char *) g_key;
 125         m.DS_KEY_LEN = len_key;
 126         m.DS_FLAGS = DS_TYPE_U32;
 127
 128         r = _taskcall(DS_PROC_NR, DS_RETRIEVE, &m);
 129
 130         cpf_revoke(g_key);
 131
 132         /* Assign u32 value. */
 133         *value = m.DS_VAL;
 134
 135         return r;
 136 }
 137
 138 int ds_retrieve_str(ds_name, value, len_str)
 139 char *ds_name;
 140 char *value;
 141 size_t len_str;
 142 {
 143         int r;
 144         message m;
 145         cp_grant_id_t g_key, g_str;
 146         size_t len_key;
 147
 148         /* Grant for key. */
 149         len_key = strlen(ds_name)+1;
 150         g_key = cpf_grant_direct(DS_PROC_NR,
 151                 (vir_bytes) ds_name, len_key, CPF_READ);
 152         if(!GRANT_VALID(g_key))
 153                 return -1;
 154
 155         /* Grant for value. */
 156         g_str = cpf_grant_direct(DS_PROC_NR,
 157                 (vir_bytes) value, len_str, CPF_WRITE);
 158
 159         if(!GRANT_VALID(g_str))  {
 160                 cpf_revoke(g_key);
 161                 return -1;
 162         }
 163
 164         /* Do request. */
 165
 166         m.DS_KEY_GRANT = (char *) g_key;
 167         m.DS_KEY_LEN = len_key;
 168         m.DS_FLAGS = DS_TYPE_STR;
 169         m.DS_VAL = g_str;
 170         m.DS_VAL_LEN = len_str;
 171
 172         r = _taskcall(DS_PROC_NR, DS_RETRIEVE, &m);
 173
 174         cpf_revoke(g_key);
 175         cpf_revoke(g_str);
 176
 177         return r;
 178 }
 179
 180 int ds_check_str(ds_key, len_key, value, len_str)
 181 char *ds_key;
 182 size_t len_key;
 183 char *value;
 184 size_t len_str;
 185 {
 186         int r;
 187         message m;
 188         cp_grant_id_t g_key, g_str;
 189
 190         if(len_key < 1 || len_str < 1) return -1;
 191
 192         /* Grant for key. */
 193         g_key = cpf_grant_direct(DS_PROC_NR,
 194                 (vir_bytes) ds_key, len_key, CPF_WRITE);
 195         if(!GRANT_VALID(g_key))
 196                 return -1;
 197
 198         /* Grant for value. */
 199         g_str = cpf_grant_direct(DS_PROC_NR,
 200                 (vir_bytes) value, len_str, CPF_WRITE);
 201
 202         if(!GRANT_VALID(g_str))  {
 203                 cpf_revoke(g_key);
 204                 return -1;
 205         }
 206
 207         /* Do request. */
 208
 209         m.DS_KEY_GRANT = (char *) g_key;
 210         m.DS_KEY_LEN = len_key;
 211         m.DS_FLAGS = DS_TYPE_STR;
 212         m.DS_VAL = g_str;
 213         m.DS_VAL_LEN = len_str;
 214
 215         r = _taskcall(DS_PROC_NR, DS_CHECK, &m);
 216
 217         cpf_revoke(g_key);
 218         cpf_revoke(g_str);
 219
 220         ds_key[len_key-1] = '\0';
 221         value[len_str-1] = '\0';
 222
 223         return r;
 224 }
 225
 226 int ds_check_u32(ds_key, len_key, value)
 227 char *ds_key;
 228 size_t len_key;
 229 u32_t *value;
 230 {
 231         int r;
 232         message m;
 233         cp_grant_id_t g_key;
 234
 235         if(len_key < 1) return -1;
 236
 237         /* Grant for key. */
 238         g_key = cpf_grant_direct(DS_PROC_NR,
 239                 (vir_bytes) ds_key, len_key, CPF_WRITE);
 240         if(!GRANT_VALID(g_key))
 241                 return -1;
 242
 243         /* Do request. */
 244         m.DS_KEY_GRANT = (char *) g_key;
 245         m.DS_KEY_LEN = len_key;
 246         m.DS_FLAGS = DS_TYPE_U32;
 247
 248         r = _taskcall(DS_PROC_NR, DS_CHECK, &m);
 249
 250         cpf_revoke(g_key);
 251
 252         ds_key[len_key-1] = '\0';
 253
 254         /* Assign u32 value. */
 255         *value = m.DS_VAL;
 256
 257         return r;
 258 }
 259