client/ins.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2020  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <stdint.h>
  30 #include <stdbool.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33 #include <errno.h>
  34
  35 #include <glib.h>
  36
  37 #include "ins.h"
  38
  39 #define BOOLSTR(s) (((s) == true) ? "TRUE" : "FALSE")
  40
  41 struct ins_info_s {
  42         struct {
  43                 bool last_user_selection;
  44                 bool last_connected;
  45                 bool security_priority;
  46                 bool internet_connection;
  47                 bool frequency;
  48                 bool strength;
  49         } ssid;
  50         struct {
  51                 bool last_connected;
  52                 bool assoc_reject;
  53                 bool frequency;
  54                 bool strength;
  55         } bssid;
  56 };
  57
  58 struct bssid_info_s {
  59         char *bssid;
  60         unsigned int strength;
  61         unsigned int frequency;
  62         int score_ins;
  63         int score_last_connected;
  64         int score_assoc_reject;
  65         int score_frequency;
  66         int score_strength;
  67 };
  68
  69 static void print_bssid_info(gpointer value, gpointer user_data)
  70 {
  71         struct bssid_info_s *bssid_info = value;
  72         int *bssid_rank = user_data;
  73
  74         fprintf(stdout, "     %2d) %-20s total[%2d] last_conn[%2d] "
  75                         "assoc_reject[%2d] freq[%2d(%4d)] strength[%2d(%2d)]\n",
  76                         *bssid_rank, bssid_info->bssid, bssid_info->score_ins,
  77                         bssid_info->score_last_connected, bssid_info->score_assoc_reject,
  78                         bssid_info->score_frequency, bssid_info->frequency,
  79                         bssid_info->score_strength, bssid_info->strength);
  80
  81         (*bssid_rank)++;
  82 }
  83
  84 static GSList *get_bssid_list(DBusMessageIter *iter, struct ins_info_s *ins_info)
  85 {
  86         char *property;
  87         DBusMessageIter entry, val;
  88         GSList *bssid_list = NULL;
  89         struct bssid_info_s *bssid_info = NULL;
  90
  91         while (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
  92                 dbus_message_iter_recurse(iter, &entry);
  93                 dbus_message_iter_get_basic(&entry, &property);
  94
  95                 if (strcmp(property, "BSSID") == 0) {
  96                         bssid_info = g_try_new0(struct bssid_info_s, 1);
  97                         if (!bssid_info)
  98                                 continue;
  99
 100                         dbus_message_iter_next(&entry);
 101                         dbus_message_iter_recurse(&entry, &val);
 102                         dbus_message_iter_get_basic(&val, &(bssid_info->bssid));
 103
 104                 } else if (strcmp(property, "ScoreINS") == 0) {
 105                         dbus_message_iter_next(&entry);
 106                         dbus_message_iter_recurse(&entry, &val);
 107                         dbus_message_iter_get_basic(&val, &(bssid_info->score_ins));
 108
 109                 } else if (strcmp(property, "ScoreLastConnected") == 0) {
 110                         dbus_message_iter_next(&entry);
 111                         dbus_message_iter_recurse(&entry, &val);
 112                         dbus_message_iter_get_basic(&val, &(bssid_info->score_last_connected));
 113                         if (bssid_info->score_last_connected)
 114                                 ins_info->bssid.last_connected = true;
 115
 116                 } else if (strcmp(property, "ScoreAssocReject") == 0) {
 117                         dbus_message_iter_next(&entry);
 118                         dbus_message_iter_recurse(&entry, &val);
 119                         dbus_message_iter_get_basic(&val, &(bssid_info->score_assoc_reject));
 120                         if (bssid_info->score_assoc_reject)
 121                                 ins_info->bssid.assoc_reject = true;
 122
 123                 } else if (strcmp(property, "Frequency") == 0) {
 124                         dbus_message_iter_next(&entry);
 125                         dbus_message_iter_recurse(&entry, &val);
 126                         dbus_message_iter_get_basic(&val, &(bssid_info->frequency));
 127
 128                 } else if (strcmp(property, "ScoreFrequency") == 0) {
 129                         dbus_message_iter_next(&entry);
 130                         dbus_message_iter_recurse(&entry, &val);
 131                         dbus_message_iter_get_basic(&val, &(bssid_info->score_frequency));
 132                         if (bssid_info->score_frequency)
 133                                 ins_info->bssid.frequency = true;
 134
 135                 } else if (strcmp(property, "Strength") == 0) {
 136                         dbus_message_iter_next(&entry);
 137                         dbus_message_iter_recurse(&entry, &val);
 138                         dbus_message_iter_get_basic(&val, &(bssid_info->strength));
 139
 140                 } else if (strcmp(property, "ScoreStrength") == 0) {
 141                         dbus_message_iter_next(&entry);
 142                         dbus_message_iter_recurse(&entry, &val);
 143                         dbus_message_iter_get_basic(&val, &(bssid_info->score_strength));
 144                         if (bssid_info->score_strength)
 145                                 ins_info->bssid.strength = true;
 146
 147                         bssid_list = g_slist_append(bssid_list, bssid_info);
 148                 }
 149
 150                 dbus_message_iter_next(iter);
 151         }
 152
 153         return bssid_list;
 154 }
 155
 156 static void print_ins_info(int *rank, struct ins_info_s *ins_info,
 157                 char *path, char *filter, DBusMessageIter *iter)
 158 {
 159         char *name = "";
 160         char *security;
 161         char *str = NULL;
 162         int count = 0;
 163         char *property;
 164         unsigned char strength;
 165         unsigned int frequency;
 166         int score_INS;
 167         int score_last_user_selection;
 168         int score_last_connected;
 169         int score_frequency;
 170         int score_security_priority;
 171         int score_internet_connection;
 172         int score_strength;
 173         GSList *bssid_list = NULL;
 174         DBusMessageIter entry, val, dict;
 175
 176         while (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
 177                 dbus_message_iter_recurse(iter, &entry);
 178                 dbus_message_iter_get_basic(&entry, &property);
 179
 180                 if (strcmp(property, "Name") == 0) {
 181                         dbus_message_iter_next(&entry);
 182                         dbus_message_iter_recurse(&entry, &val);
 183                         dbus_message_iter_get_basic(&val, &name);
 184
 185                 } else if (strcmp(property, "ScoreINS") == 0) {
 186                         dbus_message_iter_next(&entry);
 187                         dbus_message_iter_recurse(&entry, &val);
 188                         dbus_message_iter_get_basic(&val, &score_INS);
 189
 190                 } else if (strcmp(property, "ScoreLastUserSelection") == 0) {
 191                         dbus_message_iter_next(&entry);
 192                         dbus_message_iter_recurse(&entry, &val);
 193                         dbus_message_iter_get_basic(&val, &score_last_user_selection);
 194                         if (score_last_user_selection)
 195                                 ins_info->ssid.last_user_selection = true;
 196
 197                 } else if (strcmp(property, "ScoreLastConnected") == 0) {
 198                         dbus_message_iter_next(&entry);
 199                         dbus_message_iter_recurse(&entry, &val);
 200                         dbus_message_iter_get_basic(&val, &score_last_connected);
 201                         if (score_last_connected)
 202                                 ins_info->ssid.last_connected = true;
 203
 204                 } else if (strcmp(property, "Security") == 0) {
 205                         dbus_message_iter_next(&entry);
 206                         dbus_message_iter_recurse(&entry, &val);
 207                         dbus_message_iter_get_basic(&val, &security);
 208
 209                 } else if (strcmp(property, "ScoreSecurityPriority") == 0) {
 210                         dbus_message_iter_next(&entry);
 211                         dbus_message_iter_recurse(&entry, &val);
 212                         dbus_message_iter_get_basic(&val, &score_security_priority);
 213                         if (score_security_priority)
 214                                 ins_info->ssid.security_priority = true;
 215
 216                 } else if (strcmp(property, "Strength") == 0) {
 217                         dbus_message_iter_next(&entry);
 218                         dbus_message_iter_recurse(&entry, &val);
 219                         dbus_message_iter_get_basic(&val, &strength);
 220
 221                 } else if (strcmp(property, "ScoreStrength") == 0) {
 222                         dbus_message_iter_next(&entry);
 223                         dbus_message_iter_recurse(&entry, &val);
 224                         dbus_message_iter_get_basic(&val, &score_strength);
 225                         if (score_strength)
 226                                 ins_info->ssid.strength = true;
 227
 228                 } else if (strcmp(property, "ScoreInternetConnection") == 0) {
 229                         dbus_message_iter_next(&entry);
 230                         dbus_message_iter_recurse(&entry, &val);
 231                         dbus_message_iter_get_basic(&val, &score_internet_connection);
 232                         if (score_internet_connection)
 233                                 ins_info->ssid.internet_connection = true;
 234
 235                 } else if (strcmp(property, "Frequency") == 0) {
 236                         dbus_message_iter_next(&entry);
 237                         dbus_message_iter_recurse(&entry, &val);
 238                         dbus_message_iter_get_basic(&val, &frequency);
 239
 240                 } else if (strcmp(property, "ScoreFrequency") == 0) {
 241                         dbus_message_iter_next(&entry);
 242                         dbus_message_iter_recurse(&entry, &val);
 243                         dbus_message_iter_get_basic(&val, &score_frequency);
 244                         if (score_frequency)
 245                                 ins_info->ssid.frequency = true;
 246
 247                 } else if (strcmp(property, "BSSID.List") == 0) {
 248                         dbus_message_iter_next(&entry);
 249                         dbus_message_iter_recurse(&entry, &val);
 250                         if (dbus_message_iter_get_arg_type(&val)
 251                                 == DBUS_TYPE_ARRAY) {
 252                                 dbus_message_iter_recurse(&val, &dict);
 253                                 bssid_list = get_bssid_list(&dict, ins_info);
 254                         }
 255
 256                 }
 257
 258                 count++;
 259                 dbus_message_iter_next(iter);
 260         }
 261
 262         str = strrchr(path, '/');
 263         if (str)
 264                 str++;
 265         else
 266                 str = path;
 267
 268         if (count > 0) {
 269                 if (!filter || strcmp(filter, name) == 0 || strcmp(filter, "ssid") == 0) {
 270                         fprintf(stdout, "  [%2d] %-20s total[%2d] last_usr[%2d] last_conn[%2d] "
 271                                 "internet[%2d] sec[%2d(%9s)] freq[%2d(%4d)] strength[%2d(%2d)]\n  %s\n",
 272                                 *rank, name, score_INS, score_last_user_selection, score_last_connected,
 273                                 score_internet_connection, score_security_priority, security,
 274                                 score_frequency, frequency, score_strength, strength, str);
 275
 276                         if (!filter || strcmp(filter, "ssid") != 0) {
 277                                 int bssid_rank = 1;
 278                                 g_slist_foreach(bssid_list, print_bssid_info, &bssid_rank);
 279                         }
 280
 281                         (*rank)++;
 282                 }
 283
 284         } else {
 285                 fprintf(stdout, "%-24s %s", "unchanged\n", str);
 286         }
 287
 288 }
 289
 290 static void list_ins_array(DBusMessageIter *iter, char *filter)
 291 {
 292         DBusMessageIter array, dict;
 293         char *path = NULL;
 294         int rank = 1;
 295         struct ins_info_s ins_info;
 296
 297         memset(&ins_info, 0, sizeof(ins_info));
 298
 299         while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRUCT) {
 300
 301                 dbus_message_iter_recurse(iter, &array);
 302                 if (dbus_message_iter_get_arg_type(&array)
 303                                 != DBUS_TYPE_OBJECT_PATH)
 304                         return;
 305
 306                 dbus_message_iter_get_basic(&array, &path);
 307
 308                 dbus_message_iter_next(&array);
 309                 if (dbus_message_iter_get_arg_type(&array)
 310                                 == DBUS_TYPE_ARRAY) {
 311                         dbus_message_iter_recurse(&array, &dict);
 312                         print_ins_info(&rank, &ins_info, path, filter, &dict);
 313                 }
 314
 315                 dbus_message_iter_next(iter);
 316         }
 317
 318         fprintf(stdout, "\n");
 319         fprintf(stdout, "  [SSID]  last_usr[%s] last_conn[%s] "
 320                 "sec_priority[%s] internet[%s] freq[%s] strength[%s]\n",
 321                 BOOLSTR(ins_info.ssid.last_user_selection), BOOLSTR(ins_info.ssid.last_connected),
 322                 BOOLSTR(ins_info.ssid.security_priority), BOOLSTR(ins_info.ssid.internet_connection),
 323                 BOOLSTR(ins_info.ssid.frequency), BOOLSTR(ins_info.ssid.strength));
 324
 325         fprintf(stdout, "  [BSSID] last_conn[%s] assoc_reject[%s] freq[%s] strength[%s]\n",
 326                 BOOLSTR(ins_info.bssid.last_connected), BOOLSTR(ins_info.bssid.assoc_reject),
 327                 BOOLSTR(ins_info.bssid.frequency), BOOLSTR(ins_info.bssid.strength));
 328 }
 329
 330 void __connmanctl_ins_list(DBusMessageIter *iter, char *filter)
 331 {
 332         DBusMessageIter array;
 333         char *path;
 334
 335         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
 336                 return;
 337
 338         dbus_message_iter_recurse(iter, &array);
 339         list_ins_array(&array, filter);
 340
 341         dbus_message_iter_next(iter);
 342         if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
 343                 return;
 344
 345         fprintf(stdout, "\n}, {");
 346
 347         dbus_message_iter_recurse(iter, &array);
 348         while (dbus_message_iter_get_arg_type(&array)
 349                         == DBUS_TYPE_OBJECT_PATH) {
 350                 dbus_message_iter_get_basic(&array, &path);
 351                 fprintf(stdout, "\n%-24s %s", "removed", path);
 352
 353                 dbus_message_iter_next(&array);
 354         }
 355
 356 }