contrib/wpa/wpa_supplicant/dbus/dbus_new_handlers_wps.c

   1 /*
   2  * WPA Supplicant / dbus-based control interface (WPS)
   3  * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
   4  * Copyright (c) 2009, Witold Sowa <witold.sowa@gmail.com>
   5  *
   6  * This software may be distributed under the terms of the BSD license.
   7  * See README for more details.
   8  */
   9
  10 #include "includes.h"
  11
  12 #include "common.h"
  13 #include "../config.h"
  14 #include "../wpa_supplicant_i.h"
  15 #include "../wps_supplicant.h"
  16 #include "../driver_i.h"
  17 #include "../ap.h"
  18 #include "dbus_new_helpers.h"
  19 #include "dbus_new.h"
  20 #include "dbus_new_handlers.h"
  21 #include "dbus_dict_helpers.h"
  22
  23
  24 struct wps_start_params {
  25         int role; /* 0 - not set, 1 - enrollee, 2 - registrar */
  26         int type; /* 0 - not set, 1 - pin,      2 - pbc       */
  27         u8 *bssid;
  28         char *pin;
  29         u8 *p2p_dev_addr;
  30 };
  31
  32
  33 static int wpas_dbus_handler_wps_role(DBusMessage *message,
  34                                       DBusMessageIter *entry_iter,
  35                                       struct wps_start_params *params,
  36                                       DBusMessage **reply)
  37 {
  38         DBusMessageIter variant_iter;
  39         char *val;
  40
  41         dbus_message_iter_recurse(entry_iter, &variant_iter);
  42         if (dbus_message_iter_get_arg_type(&variant_iter) !=
  43             DBUS_TYPE_STRING) {
  44                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong Role type, "
  45                            "string required");
  46                 *reply = wpas_dbus_error_invalid_args(message,
  47                                                       "Role must be a string");
  48                 return -1;
  49         }
  50         dbus_message_iter_get_basic(&variant_iter, &val);
  51         if (os_strcmp(val, "enrollee") == 0)
  52                 params->role = 1;
  53         else if (os_strcmp(val, "registrar") == 0)
  54                 params->role = 2;
  55         else {
  56                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Uknown role %s", val);
  57                 *reply = wpas_dbus_error_invalid_args(message, val);
  58                 return -1;
  59         }
  60         return 0;
  61 }
  62
  63
  64 static int wpas_dbus_handler_wps_type(DBusMessage *message,
  65                                       DBusMessageIter *entry_iter,
  66                                       struct wps_start_params *params,
  67                                       DBusMessage **reply)
  68 {
  69         DBusMessageIter variant_iter;
  70         char *val;
  71
  72         dbus_message_iter_recurse(entry_iter, &variant_iter);
  73         if (dbus_message_iter_get_arg_type(&variant_iter) !=
  74             DBUS_TYPE_STRING) {
  75                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong Type type, "
  76                            "string required");
  77                 *reply = wpas_dbus_error_invalid_args(message,
  78                                                       "Type must be a string");
  79                 return -1;
  80         }
  81         dbus_message_iter_get_basic(&variant_iter, &val);
  82         if (os_strcmp(val, "pin") == 0)
  83                 params->type = 1;
  84         else if (os_strcmp(val, "pbc") == 0)
  85                 params->type = 2;
  86         else {
  87                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Unknown type %s",
  88                            val);
  89                 *reply = wpas_dbus_error_invalid_args(message, val);
  90                 return -1;
  91         }
  92         return 0;
  93 }
  94
  95
  96 static int wpas_dbus_handler_wps_bssid(DBusMessage *message,
  97                                        DBusMessageIter *entry_iter,
  98                                        struct wps_start_params *params,
  99                                        DBusMessage **reply)
 100 {
 101         DBusMessageIter variant_iter, array_iter;
 102         int len;
 103
 104         dbus_message_iter_recurse(entry_iter, &variant_iter);
 105         if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY ||
 106             dbus_message_iter_get_element_type(&variant_iter) !=
 107             DBUS_TYPE_BYTE) {
 108                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong Bssid type, "
 109                            "byte array required");
 110                 *reply = wpas_dbus_error_invalid_args(
 111                         message, "Bssid must be a byte array");
 112                 return -1;
 113         }
 114         dbus_message_iter_recurse(&variant_iter, &array_iter);
 115         dbus_message_iter_get_fixed_array(&array_iter, &params->bssid, &len);
 116         if (len != ETH_ALEN) {
 117                 wpa_printf(MSG_DEBUG, "dbus: WPS.Stsrt - Wrong Bssid length "
 118                            "%d", len);
 119                 *reply = wpas_dbus_error_invalid_args(message,
 120                                                       "Bssid is wrong length");
 121                 return -1;
 122         }
 123         return 0;
 124 }
 125
 126
 127 static int wpas_dbus_handler_wps_pin(DBusMessage *message,
 128                                      DBusMessageIter *entry_iter,
 129                                      struct wps_start_params *params,
 130                                      DBusMessage **reply)
 131 {
 132         DBusMessageIter variant_iter;
 133
 134         dbus_message_iter_recurse(entry_iter, &variant_iter);
 135         if (dbus_message_iter_get_arg_type(&variant_iter) !=
 136             DBUS_TYPE_STRING) {
 137                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong Pin type, "
 138                            "string required");
 139                 *reply = wpas_dbus_error_invalid_args(message,
 140                                                       "Pin must be a string");
 141                 return -1;
 142         }
 143         dbus_message_iter_get_basic(&variant_iter, &params->pin);
 144         return 0;
 145 }
 146
 147
 148 #ifdef CONFIG_P2P
 149 static int wpas_dbus_handler_wps_p2p_dev_addr(DBusMessage *message,
 150                                               DBusMessageIter *entry_iter,
 151                                               struct wps_start_params *params,
 152                                               DBusMessage **reply)
 153 {
 154         DBusMessageIter variant_iter, array_iter;
 155         int len;
 156
 157         dbus_message_iter_recurse(entry_iter, &variant_iter);
 158         if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY ||
 159             dbus_message_iter_get_element_type(&variant_iter) !=
 160             DBUS_TYPE_BYTE) {
 161                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong "
 162                            "P2PDeviceAddress type, byte array required");
 163                 *reply = wpas_dbus_error_invalid_args(
 164                         message, "P2PDeviceAddress must be a byte array");
 165                 return -1;
 166         }
 167         dbus_message_iter_recurse(&variant_iter, &array_iter);
 168         dbus_message_iter_get_fixed_array(&array_iter, &params->p2p_dev_addr,
 169                                           &len);
 170         if (len != ETH_ALEN) {
 171                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong "
 172                            "P2PDeviceAddress length %d", len);
 173                 *reply = wpas_dbus_error_invalid_args(message,
 174                                                       "P2PDeviceAddress "
 175                                                       "has wrong length");
 176                 return -1;
 177         }
 178         return 0;
 179 }
 180 #endif /* CONFIG_P2P */
 181
 182
 183 static int wpas_dbus_handler_wps_start_entry(DBusMessage *message, char *key,
 184                                              DBusMessageIter *entry_iter,
 185                                              struct wps_start_params *params,
 186                                              DBusMessage **reply)
 187 {
 188         if (os_strcmp(key, "Role") == 0)
 189                 return wpas_dbus_handler_wps_role(message, entry_iter,
 190                                                   params, reply);
 191         else if (os_strcmp(key, "Type") == 0)
 192                 return wpas_dbus_handler_wps_type(message, entry_iter,
 193                                                   params, reply);
 194         else if (os_strcmp(key, "Bssid") == 0)
 195                 return wpas_dbus_handler_wps_bssid(message, entry_iter,
 196                                                    params, reply);
 197         else if (os_strcmp(key, "Pin") == 0)
 198                 return wpas_dbus_handler_wps_pin(message, entry_iter,
 199                                                  params, reply);
 200 #ifdef CONFIG_P2P
 201         else if (os_strcmp(key, "P2PDeviceAddress") == 0)
 202                 return wpas_dbus_handler_wps_p2p_dev_addr(message, entry_iter,
 203                                                           params, reply);
 204 #endif /* CONFIG_P2P */
 205
 206         wpa_printf(MSG_DEBUG, "dbus: WPS.Start - unknown key %s", key);
 207         *reply = wpas_dbus_error_invalid_args(message, key);
 208         return -1;
 209 }
 210
 211
 212 /**
 213  * wpas_dbus_handler_wps_start - Start WPS configuration
 214  * @message: Pointer to incoming dbus message
 215  * @wpa_s: %wpa_supplicant data structure
 216  * Returns: DBus message dictionary on success or DBus error on failure
 217  *
 218  * Handler for "Start" method call. DBus dictionary argument contains
 219  * information about role (enrollee or registrar), authorization method
 220  * (pin or push button) and optionally pin and bssid. Returned message
 221  * has a dictionary argument which may contain newly generated pin (optional).
 222  */
 223 DBusMessage * wpas_dbus_handler_wps_start(DBusMessage *message,
 224                                           struct wpa_supplicant *wpa_s)
 225 {
 226         DBusMessage *reply = NULL;
 227         DBusMessageIter iter, dict_iter, entry_iter;
 228         struct wps_start_params params;
 229         char *key;
 230         char npin[9] = { '\0' };
 231         int ret;
 232
 233         os_memset(&params, 0, sizeof(params));
 234         dbus_message_iter_init(message, &iter);
 235
 236         dbus_message_iter_recurse(&iter, &dict_iter);
 237         while (dbus_message_iter_get_arg_type(&dict_iter) ==
 238                DBUS_TYPE_DICT_ENTRY) {
 239                 dbus_message_iter_recurse(&dict_iter, &entry_iter);
 240
 241                 dbus_message_iter_get_basic(&entry_iter, &key);
 242                 dbus_message_iter_next(&entry_iter);
 243
 244                 if (wpas_dbus_handler_wps_start_entry(message, key,
 245                                                       &entry_iter,
 246                                                       &params, &reply))
 247                         return reply;
 248
 249                 dbus_message_iter_next(&dict_iter);
 250         }
 251
 252         if (params.role == 0) {
 253                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Role not specified");
 254                 return wpas_dbus_error_invalid_args(message,
 255                                                     "Role not specified");
 256         } else if (params.role == 1 && params.type == 0) {
 257                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Type not specified");
 258                 return wpas_dbus_error_invalid_args(message,
 259                                                     "Type not specified");
 260         } else if (params.role == 2 && params.pin == NULL) {
 261                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Pin required for "
 262                            "registrar role");
 263                 return wpas_dbus_error_invalid_args(
 264                         message, "Pin required for registrar role.");
 265         }
 266
 267         if (params.role == 2)
 268                 ret = wpas_wps_start_reg(wpa_s, params.bssid, params.pin,
 269                                          NULL);
 270         else if (params.type == 1) {
 271 #ifdef CONFIG_AP
 272                 if (wpa_s->ap_iface)
 273                         ret = wpa_supplicant_ap_wps_pin(wpa_s,
 274                                                         params.bssid,
 275                                                         params.pin,
 276                                                         npin, sizeof(npin), 0);
 277                 else
 278 #endif /* CONFIG_AP */
 279                 {
 280                         ret = wpas_wps_start_pin(wpa_s, params.bssid,
 281                                                  params.pin, 0,
 282                                                  DEV_PW_DEFAULT);
 283                         if (ret > 0)
 284                                 os_snprintf(npin, sizeof(npin), "%08d", ret);
 285                 }
 286         } else {
 287 #ifdef CONFIG_AP
 288                 if (wpa_s->ap_iface)
 289                         ret = wpa_supplicant_ap_wps_pbc(wpa_s,
 290                                                         params.bssid,
 291                                                         params.p2p_dev_addr);
 292                 else
 293 #endif /* CONFIG_AP */
 294                 ret = wpas_wps_start_pbc(wpa_s, params.bssid, 0);
 295         }
 296
 297         if (ret < 0) {
 298                 wpa_printf(MSG_DEBUG, "dbus: WPS.Start wpas_wps_failed in "
 299                            "role %s and key %s",
 300                            (params.role == 1 ? "enrollee" : "registrar"),
 301                            (params.type == 0 ? "" :
 302                             (params.type == 1 ? "pin" : "pbc")));
 303                 return wpas_dbus_error_unknown_error(message,
 304                                                      "WPS start failed");
 305         }
 306
 307         reply = dbus_message_new_method_return(message);
 308         if (!reply) {
 309                 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
 310                                               NULL);
 311         }
 312
 313         dbus_message_iter_init_append(reply, &iter);
 314         if (!wpa_dbus_dict_open_write(&iter, &dict_iter)) {
 315                 dbus_message_unref(reply);
 316                 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
 317                                               NULL);
 318         }
 319
 320         if (os_strlen(npin) > 0) {
 321                 if (!wpa_dbus_dict_append_string(&dict_iter, "Pin", npin)) {
 322                         dbus_message_unref(reply);
 323                         return dbus_message_new_error(message,
 324                                                       DBUS_ERROR_NO_MEMORY,
 325                                                       NULL);
 326                 }
 327         }
 328
 329         if (!wpa_dbus_dict_close_write(&iter, &dict_iter)) {
 330                 dbus_message_unref(reply);
 331                 return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
 332                                               NULL);
 333         }
 334
 335         return reply;
 336 }
 337
 338
 339 /**
 340  * wpas_dbus_getter_process_credentials - Check if credentials are processed
 341  * @message: Pointer to incoming dbus message
 342  * @wpa_s: %wpa_supplicant data structure
 343  * Returns: TRUE on success, FALSE on failure
 344  *
 345  * Getter for "ProcessCredentials" property. Returns returned boolean will be
 346  * true if wps_cred_processing configuration field is not equal to 1 or false
 347  * if otherwise.
 348  */
 349 dbus_bool_t wpas_dbus_getter_process_credentials(DBusMessageIter *iter,
 350                                                  DBusError *error,
 351                                                  void *user_data)
 352 {
 353         struct wpa_supplicant *wpa_s = user_data;
 354         dbus_bool_t process = (wpa_s->conf->wps_cred_processing != 1);
 355         return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
 356                                                 &process, error);
 357 }
 358
 359
 360 /**
 361  * wpas_dbus_setter_process_credentials - Set credentials_processed conf param
 362  * @iter: Pointer to incoming dbus message iter
 363  * @error: Location to store error on failure
 364  * @user_data: Function specific data
 365  * Returns: TRUE on success, FALSE on failure
 366  *
 367  * Setter for "ProcessCredentials" property. Sets credentials_processed on 2
 368  * if boolean argument is true or on 1 if otherwise.
 369  */
 370 dbus_bool_t wpas_dbus_setter_process_credentials(DBusMessageIter *iter,
 371                                                  DBusError *error,
 372                                                  void *user_data)
 373 {
 374         struct wpa_supplicant *wpa_s = user_data;
 375         dbus_bool_t process_credentials, old_pc;
 376
 377         if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
 378                                               &process_credentials))
 379                 return FALSE;
 380
 381         old_pc = (wpa_s->conf->wps_cred_processing != 1);
 382         wpa_s->conf->wps_cred_processing = (process_credentials ? 2 : 1);
 383
 384         if ((wpa_s->conf->wps_cred_processing != 1) != old_pc)
 385                 wpa_dbus_mark_property_changed(wpa_s->global->dbus,
 386                                                wpa_s->dbus_new_path,
 387                                                WPAS_DBUS_NEW_IFACE_WPS,
 388                                                "ProcessCredentials");
 389
 390         return TRUE;
 391 }