libeap/src/fst/fst_ctrl_iface.c

   1 /*
   2  * FST module - Control Interface implementation
   3  * Copyright (c) 2014, Qualcomm Atheros, Inc.
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10 #include "utils/common.h"
  11 #include "common/defs.h"
  12 #include "list.h"
  13 #include "fst/fst.h"
  14 #include "fst/fst_internal.h"
  15 #include "fst_ctrl_defs.h"
  16 #include "fst_ctrl_iface.h"
  17
  18
  19 static struct fst_group * get_fst_group_by_id(const char *id)
  20 {
  21         struct fst_group *g;
  22
  23         foreach_fst_group(g) {
  24                 const char *group_id = fst_group_get_id(g);
  25
  26                 if (os_strncmp(group_id, id, os_strlen(group_id)) == 0)
  27                         return g;
  28         }
  29
  30         return NULL;
  31 }
  32
  33
  34 /* notifications */
  35 static Boolean format_session_state_extra(const union fst_event_extra *extra,
  36                                           char *buffer, size_t size)
  37 {
  38         int len;
  39         char reject_str[32] = FST_CTRL_PVAL_NONE;
  40         const char *initiator = FST_CTRL_PVAL_NONE;
  41         const struct fst_event_extra_session_state *ss;
  42
  43         ss = &extra->session_state;
  44         if (ss->new_state != FST_SESSION_STATE_INITIAL)
  45                 return TRUE;
  46
  47         switch (ss->extra.to_initial.reason) {
  48         case REASON_REJECT:
  49                 if (ss->extra.to_initial.reject_code != WLAN_STATUS_SUCCESS)
  50                         os_snprintf(reject_str, sizeof(reject_str), "%u",
  51                                     ss->extra.to_initial.reject_code);
  52                 /* no break */
  53         case REASON_TEARDOWN:
  54         case REASON_SWITCH:
  55                 switch (ss->extra.to_initial.initiator) {
  56                 case FST_INITIATOR_LOCAL:
  57                         initiator = FST_CS_PVAL_INITIATOR_LOCAL;
  58                         break;
  59                 case FST_INITIATOR_REMOTE:
  60                         initiator = FST_CS_PVAL_INITIATOR_REMOTE;
  61                         break;
  62                 default:
  63                         break;
  64                 }
  65                 break;
  66         default:
  67                 break;
  68         }
  69
  70         len = os_snprintf(buffer, size,
  71                           FST_CES_PNAME_REASON "=%s "
  72                           FST_CES_PNAME_REJECT_CODE "=%s "
  73                           FST_CES_PNAME_INITIATOR "=%s",
  74                           fst_reason_name(ss->extra.to_initial.reason),
  75                           reject_str, initiator);
  76
  77         return !os_snprintf_error(size, len);
  78 }
  79
  80
  81 static void fst_ctrl_iface_notify(struct fst_iface *f, u32 session_id,
  82                                   enum fst_event_type event_type,
  83                                   const union fst_event_extra *extra)
  84 {
  85         struct fst_group *g;
  86         char extra_str[128] = "";
  87         const struct fst_event_extra_session_state *ss;
  88         const struct fst_event_extra_iface_state *is;
  89         const struct fst_event_extra_peer_state *ps;
  90
  91         /*
  92          * FST can use any of interface objects as it only sends messages
  93          * on global Control Interface, so we just pick the 1st one.
  94          */
  95
  96         if (!f) {
  97                 foreach_fst_group(g) {
  98                         f = fst_group_first_iface(g);
  99                         if (f)
 100                                 break;
 101                 }
 102                 if (!f)
 103                         return;
 104         }
 105
 106         WPA_ASSERT(f->iface_obj.ctx);
 107
 108         switch (event_type) {
 109         case EVENT_FST_IFACE_STATE_CHANGED:
 110                 if (!extra)
 111                         return;
 112                 is = &extra->iface_state;
 113                 wpa_msg_global_only(f->iface_obj.ctx, MSG_INFO,
 114                                     FST_CTRL_EVENT_IFACE " %s "
 115                                     FST_CEI_PNAME_IFNAME "=%s "
 116                                     FST_CEI_PNAME_GROUP "=%s",
 117                                     is->attached ? FST_CEI_PNAME_ATTACHED :
 118                                     FST_CEI_PNAME_DETACHED,
 119                                     is->ifname, is->group_id);
 120                 break;
 121         case EVENT_PEER_STATE_CHANGED:
 122                 if (!extra)
 123                         return;
 124                 ps = &extra->peer_state;
 125                 wpa_msg_global_only(fst_iface_get_wpa_obj_ctx(f), MSG_INFO,
 126                                     FST_CTRL_EVENT_PEER " %s "
 127                                     FST_CEP_PNAME_IFNAME "=%s "
 128                                     FST_CEP_PNAME_ADDR "=" MACSTR,
 129                                     ps->connected ? FST_CEP_PNAME_CONNECTED :
 130                                     FST_CEP_PNAME_DISCONNECTED,
 131                                     ps->ifname, MAC2STR(ps->addr));
 132                 break;
 133         case EVENT_FST_SESSION_STATE_CHANGED:
 134                 if (!extra)
 135                         return;
 136                 if (!format_session_state_extra(extra, extra_str,
 137                                                 sizeof(extra_str))) {
 138                         fst_printf(MSG_ERROR,
 139                                    "CTRL: Cannot format STATE_CHANGE extra");
 140                         extra_str[0] = 0;
 141                 }
 142                 ss = &extra->session_state;
 143                 wpa_msg_global_only(fst_iface_get_wpa_obj_ctx(f), MSG_INFO,
 144                                     FST_CTRL_EVENT_SESSION " "
 145                                     FST_CES_PNAME_SESSION_ID "=%u "
 146                                     FST_CES_PNAME_EVT_TYPE "=%s "
 147                                     FST_CES_PNAME_OLD_STATE "=%s "
 148                                     FST_CES_PNAME_NEW_STATE "=%s %s",
 149                                     session_id,
 150                                     fst_session_event_type_name(event_type),
 151                                     fst_session_state_name(ss->old_state),
 152                                     fst_session_state_name(ss->new_state),
 153                                     extra_str);
 154                 break;
 155         case EVENT_FST_ESTABLISHED:
 156         case EVENT_FST_SETUP:
 157                 wpa_msg_global_only(fst_iface_get_wpa_obj_ctx(f), MSG_INFO,
 158                                     FST_CTRL_EVENT_SESSION " "
 159                                     FST_CES_PNAME_SESSION_ID "=%u "
 160                                     FST_CES_PNAME_EVT_TYPE "=%s",
 161                                     session_id,
 162                                     fst_session_event_type_name(event_type));
 163                 break;
 164         }
 165 }
 166
 167
 168 /* command processors */
 169
 170 /* fst session_get */
 171 static int session_get(const char *session_id, char *buf, size_t buflen)
 172 {
 173         struct fst_session *s;
 174         struct fst_iface *new_iface, *old_iface;
 175         const u8 *old_peer_addr, *new_peer_addr;
 176         u32 id;
 177
 178         id = strtoul(session_id, NULL, 0);
 179
 180         s = fst_session_get_by_id(id);
 181         if (!s) {
 182                 fst_printf(MSG_WARNING, "CTRL: Cannot find session %u", id);
 183                 return os_snprintf(buf, buflen, "FAIL\n");
 184         }
 185
 186         old_peer_addr = fst_session_get_peer_addr(s, TRUE);
 187         new_peer_addr = fst_session_get_peer_addr(s, FALSE);
 188         new_iface = fst_session_get_iface(s, FALSE);
 189         old_iface = fst_session_get_iface(s, TRUE);
 190
 191         return os_snprintf(buf, buflen,
 192                            FST_CSG_PNAME_OLD_PEER_ADDR "=" MACSTR "\n"
 193                            FST_CSG_PNAME_NEW_PEER_ADDR "=" MACSTR "\n"
 194                            FST_CSG_PNAME_NEW_IFNAME "=%s\n"
 195                            FST_CSG_PNAME_OLD_IFNAME "=%s\n"
 196                            FST_CSG_PNAME_LLT "=%u\n"
 197                            FST_CSG_PNAME_STATE "=%s\n",
 198                            MAC2STR(old_peer_addr),
 199                            MAC2STR(new_peer_addr),
 200                            new_iface ? fst_iface_get_name(new_iface) :
 201                            FST_CTRL_PVAL_NONE,
 202                            old_iface ? fst_iface_get_name(old_iface) :
 203                            FST_CTRL_PVAL_NONE,
 204                            fst_session_get_llt(s),
 205                            fst_session_state_name(fst_session_get_state(s)));
 206 }
 207
 208
 209 /* fst session_set */
 210 static int session_set(const char *session_id, char *buf, size_t buflen)
 211 {
 212         struct fst_session *s;
 213         char *p, *q;
 214         u32 id;
 215         int ret;
 216
 217         id = strtoul(session_id, &p, 0);
 218
 219         s = fst_session_get_by_id(id);
 220         if (!s) {
 221                 fst_printf(MSG_WARNING, "CTRL: Cannot find session %u", id);
 222                 return os_snprintf(buf, buflen, "FAIL\n");
 223         }
 224
 225         if (*p != ' ' || !(q = os_strchr(p + 1, '=')))
 226                 return os_snprintf(buf, buflen, "FAIL\n");
 227         p++;
 228
 229         if (os_strncasecmp(p, FST_CSS_PNAME_OLD_IFNAME, q - p) == 0) {
 230                 ret = fst_session_set_str_ifname(s, q + 1, TRUE);
 231         } else if (os_strncasecmp(p, FST_CSS_PNAME_NEW_IFNAME, q - p) == 0) {
 232                 ret = fst_session_set_str_ifname(s, q + 1, FALSE);
 233         } else if (os_strncasecmp(p, FST_CSS_PNAME_OLD_PEER_ADDR, q - p) == 0) {
 234                 ret = fst_session_set_str_peer_addr(s, q + 1, TRUE);
 235         } else if (os_strncasecmp(p, FST_CSS_PNAME_NEW_PEER_ADDR, q - p) == 0) {
 236                 ret = fst_session_set_str_peer_addr(s, q + 1, FALSE);
 237         } else if (os_strncasecmp(p, FST_CSS_PNAME_LLT, q - p) == 0) {
 238                 ret = fst_session_set_str_llt(s, q + 1);
 239         } else {
 240                 fst_printf(MSG_ERROR, "CTRL: Unknown parameter: %s", p);
 241                 return os_snprintf(buf, buflen, "FAIL\n");
 242         }
 243
 244         return os_snprintf(buf, buflen, "%s\n", ret ? "FAIL" : "OK");
 245 }
 246
 247
 248 /* fst session_add/remove */
 249 static int session_add(const char *group_id, char *buf, size_t buflen)
 250 {
 251         struct fst_group *g;
 252         struct fst_session *s;
 253
 254         g = get_fst_group_by_id(group_id);
 255         if (!g) {
 256                 fst_printf(MSG_WARNING, "CTRL: Cannot find group '%s'",
 257                            group_id);
 258                 return os_snprintf(buf, buflen, "FAIL\n");
 259         }
 260
 261         s = fst_session_create(g);
 262         if (!s) {
 263                 fst_printf(MSG_ERROR,
 264                            "CTRL: Cannot create session for group '%s'",
 265                            group_id);
 266                 return os_snprintf(buf, buflen, "FAIL\n");
 267         }
 268
 269         return os_snprintf(buf, buflen, "%u\n", fst_session_get_id(s));
 270 }
 271
 272
 273 static int session_remove(const char *session_id, char *buf, size_t buflen)
 274 {
 275         struct fst_session *s;
 276         struct fst_group *g;
 277         u32 id;
 278
 279         id = strtoul(session_id, NULL, 0);
 280
 281         s = fst_session_get_by_id(id);
 282         if (!s) {
 283                 fst_printf(MSG_WARNING, "CTRL: Cannot find session %u", id);
 284                 return os_snprintf(buf, buflen, "FAIL\n");
 285         }
 286
 287         g = fst_session_get_group(s);
 288         fst_session_reset(s);
 289         fst_session_delete(s);
 290         fst_group_delete_if_empty(g);
 291
 292         return os_snprintf(buf, buflen, "OK\n");
 293 }
 294
 295
 296 /* fst session_initiate */
 297 static int session_initiate(const char *session_id, char *buf, size_t buflen)
 298 {
 299         struct fst_session *s;
 300         u32 id;
 301
 302         id = strtoul(session_id, NULL, 0);
 303
 304         s = fst_session_get_by_id(id);
 305         if (!s) {
 306                 fst_printf(MSG_WARNING, "CTRL: Cannot find session %u", id);
 307                 return os_snprintf(buf, buflen, "FAIL\n");
 308         }
 309
 310         if (fst_session_initiate_setup(s)) {
 311                 fst_printf(MSG_WARNING, "CTRL: Cannot initiate session %u", id);
 312                 return os_snprintf(buf, buflen, "FAIL\n");
 313         }
 314
 315         return os_snprintf(buf, buflen, "OK\n");
 316 }
 317
 318
 319 /* fst session_respond */
 320 static int session_respond(const char *session_id, char *buf, size_t buflen)
 321 {
 322         struct fst_session *s;
 323         char *p;
 324         u32 id;
 325         u8 status_code;
 326
 327         id = strtoul(session_id, &p, 0);
 328
 329         s = fst_session_get_by_id(id);
 330         if (!s) {
 331                 fst_printf(MSG_WARNING, "CTRL: Cannot find session %u", id);
 332                 return os_snprintf(buf, buflen, "FAIL\n");
 333         }
 334
 335         if (*p != ' ')
 336                 return os_snprintf(buf, buflen, "FAIL\n");
 337         p++;
 338
 339         if (!os_strcasecmp(p, FST_CS_PVAL_RESPONSE_ACCEPT)) {
 340                 status_code = WLAN_STATUS_SUCCESS;
 341         } else if (!os_strcasecmp(p, FST_CS_PVAL_RESPONSE_REJECT)) {
 342                 status_code = WLAN_STATUS_PENDING_ADMITTING_FST_SESSION;
 343         } else {
 344                 fst_printf(MSG_WARNING,
 345                            "CTRL: session %u: unknown response status: %s",
 346                            id, p);
 347                 return os_snprintf(buf, buflen, "FAIL\n");
 348         }
 349
 350         if (fst_session_respond(s, status_code)) {
 351                 fst_printf(MSG_WARNING, "CTRL: Cannot respond to session %u",
 352                            id);
 353                 return os_snprintf(buf, buflen, "FAIL\n");
 354         }
 355
 356         fst_printf(MSG_INFO, "CTRL: session %u responded", id);
 357
 358         return os_snprintf(buf, buflen, "OK\n");
 359 }
 360
 361
 362 /* fst session_transfer */
 363 static int session_transfer(const char *session_id, char *buf, size_t buflen)
 364 {
 365         struct fst_session *s;
 366         u32 id;
 367
 368         id = strtoul(session_id, NULL, 0);
 369
 370         s = fst_session_get_by_id(id);
 371         if (!s) {
 372                 fst_printf(MSG_WARNING, "CTRL: Cannot find session %u", id);
 373                 return os_snprintf(buf, buflen, "FAIL\n");
 374         }
 375
 376         if (fst_session_initiate_switch(s)) {
 377                 fst_printf(MSG_WARNING,
 378                            "CTRL: Cannot initiate ST for session %u", id);
 379                 return os_snprintf(buf, buflen, "FAIL\n");
 380         }
 381
 382         return os_snprintf(buf, buflen, "OK\n");
 383 }
 384
 385
 386 /* fst session_teardown */
 387 static int session_teardown(const char *session_id, char *buf, size_t buflen)
 388 {
 389         struct fst_session *s;
 390         u32 id;
 391
 392         id = strtoul(session_id, NULL, 0);
 393
 394         s = fst_session_get_by_id(id);
 395         if (!s) {
 396                 fst_printf(MSG_WARNING, "CTRL: Cannot find session %u", id);
 397                 return os_snprintf(buf, buflen, "FAIL\n");
 398         }
 399
 400         if (fst_session_tear_down_setup(s)) {
 401                 fst_printf(MSG_WARNING, "CTRL: Cannot tear down session %u",
 402                            id);
 403                 return os_snprintf(buf, buflen, "FAIL\n");
 404         }
 405
 406         return os_snprintf(buf, buflen, "OK\n");
 407 }
 408
 409
 410 #ifdef CONFIG_FST_TEST
 411 /* fst test_request */
 412 static int test_request(const char *request, char *buf, size_t buflen)
 413 {
 414         const char *p = request;
 415         int ret;
 416
 417         if (!os_strncasecmp(p, FST_CTR_SEND_SETUP_REQUEST,
 418                             os_strlen(FST_CTR_SEND_SETUP_REQUEST))) {
 419                 ret = fst_test_req_send_fst_request(
 420                         p + os_strlen(FST_CTR_SEND_SETUP_REQUEST));
 421         } else if (!os_strncasecmp(p, FST_CTR_SEND_SETUP_RESPONSE,
 422                                    os_strlen(FST_CTR_SEND_SETUP_RESPONSE))) {
 423                 ret = fst_test_req_send_fst_response(
 424                         p + os_strlen(FST_CTR_SEND_SETUP_RESPONSE));
 425         } else if (!os_strncasecmp(p, FST_CTR_SEND_ACK_REQUEST,
 426                                    os_strlen(FST_CTR_SEND_ACK_REQUEST))) {
 427                 ret = fst_test_req_send_ack_request(
 428                         p + os_strlen(FST_CTR_SEND_ACK_REQUEST));
 429         } else if (!os_strncasecmp(p, FST_CTR_SEND_ACK_RESPONSE,
 430                                    os_strlen(FST_CTR_SEND_ACK_RESPONSE))) {
 431                 ret = fst_test_req_send_ack_response(
 432                         p + os_strlen(FST_CTR_SEND_ACK_RESPONSE));
 433         } else if (!os_strncasecmp(p, FST_CTR_SEND_TEAR_DOWN,
 434                                    os_strlen(FST_CTR_SEND_TEAR_DOWN))) {
 435                 ret = fst_test_req_send_tear_down(
 436                         p + os_strlen(FST_CTR_SEND_TEAR_DOWN));
 437         } else if (!os_strncasecmp(p, FST_CTR_GET_FSTS_ID,
 438                                    os_strlen(FST_CTR_GET_FSTS_ID))) {
 439                 u32 fsts_id = fst_test_req_get_fsts_id(
 440                         p + os_strlen(FST_CTR_GET_FSTS_ID));
 441                 if (fsts_id != FST_FSTS_ID_NOT_FOUND)
 442                         return os_snprintf(buf, buflen, "%u\n", fsts_id);
 443                 return os_snprintf(buf, buflen, "FAIL\n");
 444         } else if (!os_strncasecmp(p, FST_CTR_GET_LOCAL_MBIES,
 445                                    os_strlen(FST_CTR_GET_LOCAL_MBIES))) {
 446                 return fst_test_req_get_local_mbies(
 447                         p + os_strlen(FST_CTR_GET_LOCAL_MBIES), buf, buflen);
 448         } else if (!os_strncasecmp(p, FST_CTR_IS_SUPPORTED,
 449                                    os_strlen(FST_CTR_IS_SUPPORTED))) {
 450                 ret = 0;
 451         } else {
 452                 fst_printf(MSG_ERROR, "CTRL: Unknown parameter: %s", p);
 453                 return os_snprintf(buf, buflen, "FAIL\n");
 454         }
 455
 456         return os_snprintf(buf, buflen, "%s\n", ret ? "FAIL" : "OK");
 457 }
 458 #endif /* CONFIG_FST_TEST */
 459
 460
 461 /* fst list_sessions */
 462 struct list_sessions_cb_ctx {
 463         char *buf;
 464         size_t buflen;
 465         size_t reply_len;
 466 };
 467
 468
 469 static void list_session_enum_cb(struct fst_group *g, struct fst_session *s,
 470                                  void *ctx)
 471 {
 472         struct list_sessions_cb_ctx *c = ctx;
 473         int ret;
 474
 475         ret = os_snprintf(c->buf, c->buflen, " %u", fst_session_get_id(s));
 476
 477         c->buf += ret;
 478         c->buflen -= ret;
 479         c->reply_len += ret;
 480 }
 481
 482
 483 static int list_sessions(const char *group_id, char *buf, size_t buflen)
 484 {
 485         struct list_sessions_cb_ctx ctx;
 486         struct fst_group *g;
 487
 488         g = get_fst_group_by_id(group_id);
 489         if (!g) {
 490                 fst_printf(MSG_WARNING, "CTRL: Cannot find group '%s'",
 491                            group_id);
 492                 return os_snprintf(buf, buflen, "FAIL\n");
 493         }
 494
 495         ctx.buf = buf;
 496         ctx.buflen = buflen;
 497         ctx.reply_len = 0;
 498
 499         fst_session_enum(g, list_session_enum_cb, &ctx);
 500
 501         ctx.reply_len += os_snprintf(buf + ctx.reply_len, ctx.buflen, "\n");
 502
 503         return ctx.reply_len;
 504 }
 505
 506
 507 /* fst iface_peers */
 508 static int iface_peers(const char *group_id, char *buf, size_t buflen)
 509 {
 510         const char *ifname;
 511         struct fst_group *g;
 512         struct fst_iface *f;
 513         struct fst_get_peer_ctx *ctx;
 514         const u8 *addr;
 515         unsigned found = 0;
 516         int ret = 0;
 517
 518         g = get_fst_group_by_id(group_id);
 519         if (!g) {
 520                 fst_printf(MSG_WARNING, "CTRL: Cannot find group '%s'",
 521                            group_id);
 522                 return os_snprintf(buf, buflen, "FAIL\n");
 523         }
 524
 525         ifname = os_strchr(group_id, ' ');
 526         if (!ifname)
 527                 return os_snprintf(buf, buflen, "FAIL\n");
 528         ifname++;
 529
 530         foreach_fst_group_iface(g, f) {
 531                 const char *in = fst_iface_get_name(f);
 532
 533                 if (os_strncmp(ifname, in, os_strlen(in)) == 0) {
 534                         found = 1;
 535                         break;
 536                 }
 537         }
 538
 539         if (!found)
 540                 return os_snprintf(buf, buflen, "FAIL\n");
 541
 542         addr = fst_iface_get_peer_first(f, &ctx, FALSE);
 543         for (; addr != NULL; addr = fst_iface_get_peer_next(f, &ctx, FALSE)) {
 544                 int res;
 545
 546                 res = os_snprintf(buf + ret, buflen - ret, MACSTR "\n",
 547                                   MAC2STR(addr));
 548                 if (os_snprintf_error(buflen - ret, res))
 549                         break;
 550                 ret += res;
 551         }
 552
 553         return ret;
 554 }
 555
 556
 557 static int get_peer_mbies(const char *params, char *buf, size_t buflen)
 558 {
 559         char *endp;
 560         char ifname[FST_MAX_INTERFACE_SIZE];
 561         u8 peer_addr[ETH_ALEN];
 562         struct fst_group *g;
 563         struct fst_iface *iface = NULL;
 564         const struct wpabuf *mbies;
 565
 566         if (fst_read_next_text_param(params, ifname, sizeof(ifname), &endp) ||
 567             !*ifname)
 568                 goto problem;
 569
 570         while (isspace(*endp))
 571                 endp++;
 572         if (fst_read_peer_addr(endp, peer_addr))
 573                 goto problem;
 574
 575         foreach_fst_group(g) {
 576                 iface = fst_group_get_iface_by_name(g, ifname);
 577                 if (iface)
 578                         break;
 579         }
 580         if (!iface)
 581                 goto problem;
 582
 583         mbies = fst_iface_get_peer_mb_ie(iface, peer_addr);
 584         if (!mbies)
 585                 goto problem;
 586
 587         return wpa_snprintf_hex(buf, buflen, wpabuf_head(mbies),
 588                                 wpabuf_len(mbies));
 589
 590 problem:
 591         return os_snprintf(buf, buflen, "FAIL\n");
 592 }
 593
 594
 595 /* fst list_ifaces */
 596 static int list_ifaces(const char *group_id, char *buf, size_t buflen)
 597 {
 598         struct fst_group *g;
 599         struct fst_iface *f;
 600         int ret = 0;
 601
 602         g = get_fst_group_by_id(group_id);
 603         if (!g) {
 604                 fst_printf(MSG_WARNING, "CTRL: Cannot find group '%s'",
 605                            group_id);
 606                 return os_snprintf(buf, buflen, "FAIL\n");
 607         }
 608
 609         foreach_fst_group_iface(g, f) {
 610                 int res;
 611                 const u8 *iface_addr = fst_iface_get_addr(f);
 612
 613                 res = os_snprintf(buf + ret, buflen - ret,
 614                                   "%s|" MACSTR "|%u|%u\n",
 615                                   fst_iface_get_name(f),
 616                                   MAC2STR(iface_addr),
 617                                   fst_iface_get_priority(f),
 618                                   fst_iface_get_llt(f));
 619                 if (os_snprintf_error(buflen - ret, res))
 620                         break;
 621                 ret += res;
 622         }
 623
 624         return ret;
 625 }
 626
 627
 628 /* fst list_groups */
 629 static int list_groups(const char *cmd, char *buf, size_t buflen)
 630 {
 631         struct fst_group *g;
 632         int ret = 0;
 633
 634         foreach_fst_group(g) {
 635                 int res;
 636
 637                 res = os_snprintf(buf + ret, buflen - ret, "%s\n",
 638                                   fst_group_get_id(g));
 639                 if (os_snprintf_error(buflen - ret, res))
 640                         break;
 641                 ret += res;
 642         }
 643
 644         return ret;
 645 }
 646
 647
 648 static const char * band_freq(enum mb_band_id band)
 649 {
 650         static const char *band_names[] = {
 651                 [MB_BAND_ID_WIFI_2_4GHZ] "2.4GHZ",
 652                 [MB_BAND_ID_WIFI_5GHZ] "5GHZ",
 653                 [MB_BAND_ID_WIFI_60GHZ] "60GHZ",
 654         };
 655
 656         return fst_get_str_name(band, band_names, ARRAY_SIZE(band_names));
 657 }
 658
 659
 660 static int print_band(unsigned num, struct fst_iface *iface, const u8 *addr,
 661                       char *buf, size_t buflen)
 662 {
 663         const struct wpabuf *wpabuf;
 664         enum hostapd_hw_mode hw_mode;
 665         u8 channel;
 666         int ret = 0;
 667
 668         fst_iface_get_channel_info(iface, &hw_mode, &channel);
 669
 670         ret += os_snprintf(buf + ret, buflen - ret, "band%u_frequency=%s\n",
 671                            num, band_freq(fst_hw_mode_to_band(hw_mode)));
 672         ret += os_snprintf(buf + ret, buflen - ret, "band%u_iface=%s\n",
 673                            num, fst_iface_get_name(iface));
 674         wpabuf = fst_iface_get_peer_mb_ie(iface, addr);
 675         if (wpabuf) {
 676                 ret += os_snprintf(buf + ret, buflen - ret, "band%u_mb_ies=",
 677                                    num);
 678                 ret += wpa_snprintf_hex(buf + ret, buflen - ret,
 679                                         wpabuf_head(wpabuf),
 680                                         wpabuf_len(wpabuf));
 681                 ret += os_snprintf(buf + ret, buflen - ret, "\n");
 682         }
 683         ret += os_snprintf(buf + ret, buflen - ret, "band%u_fst_group_id=%s\n",
 684                            num, fst_iface_get_group_id(iface));
 685         ret += os_snprintf(buf + ret, buflen - ret, "band%u_fst_priority=%u\n",
 686                            num, fst_iface_get_priority(iface));
 687         ret += os_snprintf(buf + ret, buflen - ret, "band%u_fst_llt=%u\n",
 688                            num, fst_iface_get_llt(iface));
 689
 690         return ret;
 691 }
 692
 693
 694 static void fst_ctrl_iface_on_iface_state_changed(struct fst_iface *i,
 695                                                   Boolean attached)
 696 {
 697         union fst_event_extra extra;
 698
 699         os_memset(&extra, 0, sizeof(extra));
 700         extra.iface_state.attached = attached;
 701         os_strlcpy(extra.iface_state.ifname, fst_iface_get_name(i),
 702                    sizeof(extra.iface_state.ifname));
 703         os_strlcpy(extra.iface_state.group_id, fst_iface_get_group_id(i),
 704                    sizeof(extra.iface_state.group_id));
 705
 706         fst_ctrl_iface_notify(i, FST_INVALID_SESSION_ID,
 707                               EVENT_FST_IFACE_STATE_CHANGED, &extra);
 708 }
 709
 710
 711 static int fst_ctrl_iface_on_iface_added(struct fst_iface *i)
 712 {
 713         fst_ctrl_iface_on_iface_state_changed(i, TRUE);
 714         return 0;
 715 }
 716
 717
 718 static void fst_ctrl_iface_on_iface_removed(struct fst_iface *i)
 719 {
 720         fst_ctrl_iface_on_iface_state_changed(i, FALSE);
 721 }
 722
 723
 724 static void fst_ctrl_iface_on_event(enum fst_event_type event_type,
 725                                     struct fst_iface *i, struct fst_session *s,
 726                                     const union fst_event_extra *extra)
 727 {
 728         u32 session_id = s ? fst_session_get_id(s) : FST_INVALID_SESSION_ID;
 729
 730         fst_ctrl_iface_notify(i, session_id, event_type, extra);
 731 }
 732
 733
 734 static const struct fst_ctrl ctrl_cli = {
 735         .on_iface_added = fst_ctrl_iface_on_iface_added,
 736         .on_iface_removed =  fst_ctrl_iface_on_iface_removed,
 737         .on_event = fst_ctrl_iface_on_event,
 738 };
 739
 740 const struct fst_ctrl *fst_ctrl_cli = &ctrl_cli;
 741
 742
 743 int fst_ctrl_iface_mb_info(const u8 *addr, char *buf, size_t buflen)
 744 {
 745         struct fst_group *g;
 746         struct fst_iface *f;
 747         unsigned num = 0;
 748         int ret = 0;
 749
 750         foreach_fst_group(g) {
 751                 foreach_fst_group_iface(g, f) {
 752                         if (fst_iface_is_connected(f, addr)) {
 753                                 ret += print_band(num++, f, addr,
 754                                                   buf + ret, buflen - ret);
 755                         }
 756                 }
 757         }
 758
 759         return ret;
 760 }
 761
 762
 763 /* fst ctrl processor */
 764 int fst_ctrl_iface_receive(const char *cmd, char *reply, size_t reply_size)
 765 {
 766         static const struct fst_command {
 767                 const char *name;
 768                 unsigned has_param;
 769                 int (*process)(const char *group_id, char *buf, size_t buflen);
 770         } commands[] = {
 771                 { FST_CMD_LIST_GROUPS, 0, list_groups},
 772                 { FST_CMD_LIST_IFACES, 1, list_ifaces},
 773                 { FST_CMD_IFACE_PEERS, 1, iface_peers},
 774                 { FST_CMD_GET_PEER_MBIES, 1, get_peer_mbies},
 775                 { FST_CMD_LIST_SESSIONS, 1, list_sessions},
 776                 { FST_CMD_SESSION_ADD, 1, session_add},
 777                 { FST_CMD_SESSION_REMOVE, 1, session_remove},
 778                 { FST_CMD_SESSION_GET, 1, session_get},
 779                 { FST_CMD_SESSION_SET, 1, session_set},
 780                 { FST_CMD_SESSION_INITIATE, 1, session_initiate},
 781                 { FST_CMD_SESSION_RESPOND, 1, session_respond},
 782                 { FST_CMD_SESSION_TRANSFER, 1, session_transfer},
 783                 { FST_CMD_SESSION_TEARDOWN, 1, session_teardown},
 784 #ifdef CONFIG_FST_TEST
 785                 { FST_CMD_TEST_REQUEST, 1, test_request },
 786 #endif /* CONFIG_FST_TEST */
 787                 { NULL, 0, NULL }
 788         };
 789         const struct fst_command *c;
 790         const char *p;
 791         const char *temp;
 792         Boolean non_spaces_found;
 793
 794         for (c = commands; c->name; c++) {
 795                 if (os_strncasecmp(cmd, c->name, os_strlen(c->name)) != 0)
 796                         continue;
 797                 p = cmd + os_strlen(c->name);
 798                 if (c->has_param) {
 799                         if (!isspace(p[0]))
 800                                 return os_snprintf(reply, reply_size, "FAIL\n");
 801                         p++;
 802                         temp = p;
 803                         non_spaces_found = FALSE;
 804                         while (*temp) {
 805                                 if (!isspace(*temp)) {
 806                                         non_spaces_found = TRUE;
 807                                         break;
 808                                 }
 809                                 temp++;
 810                         }
 811                         if (!non_spaces_found)
 812                                 return os_snprintf(reply, reply_size, "FAIL\n");
 813                 }
 814                 return c->process(p, reply, reply_size);
 815         }
 816
 817         return os_snprintf(reply, reply_size, "UNKNOWN FST COMMAND\n");
 818 }
 819
 820
 821 int fst_read_next_int_param(const char *params, Boolean *valid, char **endp)
 822 {
 823         int ret = -1;
 824         const char *curp;
 825
 826         *valid = FALSE;
 827         *endp = (char *) params;
 828         curp = params;
 829         if (*curp) {
 830                 ret = (int) strtol(curp, endp, 0);
 831                 if (!**endp || isspace(**endp))
 832                         *valid = TRUE;
 833         }
 834
 835         return ret;
 836 }
 837
 838
 839 int fst_read_next_text_param(const char *params, char *buf, size_t buflen,
 840                              char **endp)
 841 {
 842         size_t max_chars_to_copy;
 843         char *cur_dest;
 844
 845         *endp = (char *) params;
 846         while (isspace(**endp))
 847                 (*endp)++;
 848         if (!**endp || buflen <= 1)
 849                 return -EINVAL;
 850
 851         max_chars_to_copy = buflen - 1;
 852         /* We need 1 byte for the terminating zero */
 853         cur_dest = buf;
 854         while (**endp && !isspace(**endp) && max_chars_to_copy > 0) {
 855                 *cur_dest = **endp;
 856                 (*endp)++;
 857                 cur_dest++;
 858                 max_chars_to_copy--;
 859         }
 860         *cur_dest = 0;
 861
 862         return 0;
 863 }
 864
 865
 866 int fst_read_peer_addr(const char *mac, u8 *peer_addr)
 867 {
 868         if (hwaddr_aton(mac, peer_addr)) {
 869                 fst_printf(MSG_WARNING, "Bad peer_mac %s: invalid addr string",
 870                            mac);
 871                 return -1;
 872         }
 873
 874         if (is_zero_ether_addr(peer_addr) ||
 875             is_multicast_ether_addr(peer_addr)) {
 876                 fst_printf(MSG_WARNING, "Bad peer_mac %s: not a unicast addr",
 877                            mac);
 878                 return -1;
 879         }
 880
 881         return 0;
 882 }
 883
 884
 885 int fst_parse_attach_command(const char *cmd, char *ifname, size_t ifname_size,
 886                              struct fst_iface_cfg *cfg)
 887 {
 888         char *pos;
 889         char *endp;
 890         Boolean is_valid;
 891         int val;
 892
 893         if (fst_read_next_text_param(cmd, ifname, ifname_size, &endp) ||
 894             fst_read_next_text_param(endp, cfg->group_id, sizeof(cfg->group_id),
 895                                      &endp))
 896                 return -EINVAL;
 897
 898         cfg->llt = FST_DEFAULT_LLT_CFG_VALUE;
 899         cfg->priority = 0;
 900         pos = os_strstr(endp, FST_ATTACH_CMD_PNAME_LLT);
 901         if (pos) {
 902                 pos += os_strlen(FST_ATTACH_CMD_PNAME_LLT);
 903                 if (*pos == '=') {
 904                         val = fst_read_next_int_param(pos + 1, &is_valid,
 905                                                       &endp);
 906                         if (is_valid)
 907                                 cfg->llt = val;
 908                 }
 909         }
 910         pos = os_strstr(endp, FST_ATTACH_CMD_PNAME_PRIORITY);
 911         if (pos) {
 912                 pos += os_strlen(FST_ATTACH_CMD_PNAME_PRIORITY);
 913                 if (*pos == '=') {
 914                         val = fst_read_next_int_param(pos + 1, &is_valid,
 915                                                       &endp);
 916                         if (is_valid)
 917                                 cfg->priority = (u8) val;
 918                 }
 919         }
 920
 921         return 0;
 922 }
 923
 924
 925 int fst_parse_detach_command(const char *cmd, char *ifname, size_t ifname_size)
 926 {
 927         char *endp;
 928
 929         return fst_read_next_text_param(cmd, ifname, ifname_size, &endp);
 930 }
 931
 932
 933 int fst_iface_detach(const char *ifname)
 934 {
 935         struct fst_group *g;
 936
 937         foreach_fst_group(g) {
 938                 struct fst_iface *f;
 939
 940                 f = fst_group_get_iface_by_name(g, ifname);
 941                 if (f) {
 942                         fst_detach(f);
 943                         return 0;
 944                 }
 945         }
 946
 947         return -EINVAL;
 948 }