src/mesh.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 #include <stdlib.h>
  17
  18 #include "mesh.h"
  19 #include "mesh_log.h"
  20 #include "mesh_private.h"
  21 #include "mesh_dbus.h"
  22
  23 /**
  24  * Mesh network CAPI
  25  */
  26
  27 EXPORT_API int mesh_network_new(mesh_network_h* network)
  28 {
  29         struct mesh_network_s *net;
  30
  31         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
  32
  33         if (network == NULL) {
  34                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
  35                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
  36         }
  37
  38         net = calloc(1, sizeof(struct mesh_network_s));
  39         if (NULL == net) {
  40                 LOGE("Out of memory"); //LCOV_EXCL_LINE
  41                 return MESH_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
  42         }
  43         *network = (mesh_network_h)net;
  44
  45         return MESH_ERROR_NONE;
  46 }
  47
  48 EXPORT_API int mesh_network_clone(mesh_network_h* dst, mesh_network_h src)
  49 {
  50         struct mesh_network_s *net = NULL;
  51         struct mesh_network_s *_src = src;
  52
  53         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
  54
  55         if (dst == NULL || src == NULL) {
  56                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
  57                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
  58         }
  59
  60         net = calloc(1, sizeof(struct mesh_network_s));
  61         if (NULL == net) {
  62                 LOGE("Out of memory"); //LCOV_EXCL_LINE
  63                 return MESH_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
  64         }
  65         memcpy(net->meshid, _src->meshid, MAX_MESHID_LEN);
  66         memcpy(net->bssid, _src->bssid, MAX_BSSID_LEN);
  67         net->channel = _src->channel;
  68         net->rssi = _src->rssi;
  69         net->data_rate = _src->data_rate;
  70         net->security = _src->security;
  71
  72         *dst = (mesh_network_h)net;
  73
  74         return MESH_ERROR_NONE;
  75 }
  76
  77 EXPORT_API int mesh_network_new_with(mesh_network_h* network, const char *meshid,
  78         const char *bssid, int channel, int rssi, int data_rate)
  79 {
  80         struct mesh_network_s *net;
  81
  82         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
  83
  84         if (network == NULL) {
  85                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
  86                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
  87         }
  88
  89         net = calloc(1, sizeof(struct mesh_network_s));
  90         if (meshid) memcpy(net->meshid, meshid, MAX_MESHID_LEN);
  91         if (bssid) memcpy(net->bssid, bssid, MAX_BSSID_LEN);
  92         net->channel = channel;
  93         net->rssi = rssi;
  94         net->data_rate = data_rate;
  95         *network = (mesh_network_h)net;
  96
  97         return MESH_ERROR_NONE;
  98 }
  99
 100 EXPORT_API void mesh_network_destroy(mesh_network_h network)
 101 {
 102         struct mesh_network_s *net = network;
 103         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 104
 105         if (net == NULL) {
 106                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 107                 return; //LCOV_EXCL_LINE
 108         }
 109         if (net) free(net);
 110 }
 111
 112 EXPORT_API int mesh_network_get_meshid(mesh_network_h network, char **meshid)
 113 {
 114         struct mesh_network_s *net = network;
 115
 116         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 117
 118         if (network == NULL || meshid == NULL) {
 119                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 120                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 121         }
 122
 123         *meshid = strdup(net->meshid);
 124
 125         return MESH_ERROR_NONE;
 126 }
 127
 128 EXPORT_API int mesh_network_set_meshid(mesh_network_h network, const char *meshid)
 129 {
 130         struct mesh_network_s *net = (struct mesh_network_s *)network;
 131
 132         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 133
 134         if (network == NULL || meshid == NULL ) {
 135                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 136                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 137         }
 138
 139         memcpy(net->meshid, meshid, MAX_MESHID_LEN);
 140
 141         return MESH_ERROR_NONE;
 142 }
 143
 144 EXPORT_API int mesh_network_get_bssid(mesh_network_h network, char **bssid)
 145 {
 146         struct mesh_network_s *net = (struct mesh_network_s *)network;
 147
 148         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 149
 150         if (network == NULL || bssid == NULL) {
 151                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 152                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 153         }
 154
 155         *bssid = strdup(net->bssid);
 156
 157         return MESH_ERROR_NONE;
 158 }
 159
 160 EXPORT_API int mesh_network_set_bssid(mesh_network_h network, const char *bssid)
 161 {
 162         struct mesh_network_s *net = (struct mesh_network_s *)network;
 163
 164         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 165
 166         if (network == NULL || bssid == NULL ) {
 167                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 168                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 169         }
 170
 171         memcpy(net->bssid, bssid, MAX_BSSID_LEN);
 172
 173         return MESH_ERROR_NONE;
 174 }
 175
 176 EXPORT_API int mesh_network_get_channel(mesh_network_h network, int *channel)
 177 {
 178         struct mesh_network_s *net = (struct mesh_network_s *)network;
 179
 180         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 181
 182         if (network == NULL || channel == NULL ) {
 183                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 184                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 185         }
 186
 187         *channel = net->channel;
 188
 189         return MESH_ERROR_NONE;
 190 }
 191
 192 EXPORT_API int mesh_network_set_channel(mesh_network_h network, int channel)
 193 {
 194         struct mesh_network_s *net = (struct mesh_network_s *)network;
 195
 196         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 197
 198         if (network == NULL) {
 199                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 200                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 201         }
 202
 203         net->channel = channel;
 204
 205         return MESH_ERROR_NONE;
 206 }
 207
 208 EXPORT_API int mesh_network_get_rssi(mesh_network_h network, int *rssi)
 209 {
 210         struct mesh_network_s *net = (struct mesh_network_s *)network;
 211
 212         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 213
 214         if (network == NULL || rssi == NULL ) {
 215                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 216                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 217         }
 218
 219         *rssi = net->channel;
 220
 221         return MESH_ERROR_NONE;
 222 }
 223
 224 EXPORT_API int mesh_network_set_rssi(mesh_network_h network, int rssi)
 225 {
 226         struct mesh_network_s *net = (struct mesh_network_s *)network;
 227
 228         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 229
 230         if (network == NULL) {
 231                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 232                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 233         }
 234
 235         net->rssi = rssi;
 236
 237         return MESH_ERROR_NONE;
 238 }
 239
 240 EXPORT_API int mesh_network_get_data_rate(mesh_network_h network, int *data_rate)
 241 {
 242         struct mesh_network_s *net = (struct mesh_network_s *)network;
 243
 244         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 245
 246         if (network == NULL || data_rate == NULL ) {
 247                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 248                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 249         }
 250
 251         *data_rate = net->channel;
 252
 253         return MESH_ERROR_NONE;
 254 }
 255
 256 EXPORT_API int mesh_network_set_data_rate(mesh_network_h network, int data_rate)
 257 {
 258         struct mesh_network_s *net = (struct mesh_network_s *)network;
 259
 260         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 261
 262         if (network == NULL) {
 263                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 264                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 265         }
 266
 267         net->data_rate = data_rate;
 268
 269         return MESH_ERROR_NONE;
 270 }
 271
 272 EXPORT_API int mesh_peer_get_address(mesh_peer_h peer, char **address)
 273 {
 274         struct mesh_peer_s *peer_info = (struct mesh_peer_s *)peer;
 275
 276         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 277
 278         if (peer == NULL) {
 279                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 280                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 281         }
 282
 283         *address = strdup(peer_info->address);
 284
 285         return MESH_ERROR_NONE;
 286 }
 287
 288 EXPORT_API int mesh_initialize(mesh_h *mesh)
 289 {
 290         int rv;
 291         struct mesh_handle* handle;
 292
 293         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 294
 295         if (mesh == NULL) {
 296                 LOGE("Invalid parameter"); //LCOV_EXCL_LINE
 297                 return MESH_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 298         }
 299
 300 #if 0
 301         rv = _mesh_init();
 302         if (rv != MESH_ERROR_NONE) {
 303                 LOGE("Failed to initialize mesh network");//LCOV_EXCL_LINE
 304                 return rv; //LCOV_EXCL_LINE
 305         }
 306 #endif
 307
 308 #if !GLIB_CHECK_VERSION(2, 35, 0)
 309         g_type_init();
 310 #endif
 311
 312         handle = g_new0(struct mesh_handle, 1);
 313         if (NULL == handle) {
 314                 LOGE("Failed to create handle");
 315                 return MESH_ERROR_OUT_OF_MEMORY;
 316         }
 317         *mesh = handle;
 318
 319         rv = _mesh_dbus_start(*mesh);
 320         if (rv != MESH_ERROR_NONE) {
 321                 LOGD("D-Bus init: (0x%X)", rv);
 322         }
 323
 324         return MESH_ERROR_NONE;
 325 }
 326
 327 EXPORT_API int mesh_deinitialize(mesh_h handle)
 328 {
 329         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 330
 331         _mesh_dbus_stop(handle);
 332
 333         LOGI("Destroy handle: %p", handle);
 334
 335         return MESH_ERROR_NONE;
 336 }
 337
 338 EXPORT_API int mesh_set_event_cb(mesh_h handle, mesh_event_cb event_handler)
 339 {
 340         int rv = 0;
 341         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 342
 343         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 344
 345         rv = _mesh_set_event_cb(handle, event_handler);
 346         return rv;
 347 }
 348
 349 EXPORT_API int mesh_enable(mesh_h handle)
 350 {
 351         int rv = 0;
 352         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 353
 354         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 355
 356         rv = _mesh_enable(handle);
 357         return rv;
 358 }
 359
 360 EXPORT_API int mesh_disable(mesh_h handle)
 361 {
 362         int rv = 0;
 363         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 364
 365         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 366
 367         rv = _mesh_disable(handle);
 368         return rv;
 369 }
 370
 371 EXPORT_API int mesh_scan(mesh_h handle)
 372 {
 373         int rv = 0;
 374         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 375
 376         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 377
 378         rv = _mesh_scan(handle);
 379         return rv;
 380 }
 381
 382 EXPORT_API int mesh_cancel_scan(mesh_h handle)
 383 {
 384         int rv = 0;
 385         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 386
 387         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 388
 389         rv = _mesh_cancel_scan(handle);
 390         return rv;
 391 }
 392
 393 EXPORT_API int mesh_specific_scan(mesh_h handle, const char* ssid, int channel)
 394 {
 395         int rv = 0;
 396         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 397
 398         RETV_IF(NULL == ssid, MESH_ERROR_INVALID_PARAMETER);
 399         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 400
 401         rv = _mesh_specific_scan(handle, ssid, channel);
 402         return rv;
 403 }
 404
 405 EXPORT_API int mesh_foreach_found_mesh_network(mesh_h handle,
 406         mesh_found_mesh_network_cb cb, void *user_data)
 407 {
 408         int rv = 0;
 409         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 410
 411         RETV_IF(NULL == cb, MESH_ERROR_INVALID_PARAMETER);
 412         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 413
 414         rv = _mesh_get_scan_result(handle);
 415         if (MESH_ERROR_NONE != rv) {
 416                 return rv;
 417         }
 418
 419         rv = _mesh_foreach_found_mesh_network(handle, cb, user_data);
 420         return rv;
 421 }
 422
 423 EXPORT_API int mesh_foreach_connected_peers(mesh_h handle,
 424         mesh_connected_peer_cb cb, void *user_data)
 425 {
 426         int rv = 0;
 427         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 428
 429         RETV_IF(NULL == cb, MESH_ERROR_INVALID_PARAMETER);
 430         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 431
 432         rv = _mesh_find_peers(handle);
 433         if (MESH_ERROR_NONE != rv) {
 434                 return rv;
 435         }
 436
 437         rv = _mesh_foreach_connected_peers(handle, cb, user_data);
 438         return rv;
 439 }
 440
 441 EXPORT_API int mesh_enable_mesh(mesh_h handle)
 442 {
 443         int rv = 0;
 444         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 445
 446         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 447
 448         rv = _mesh_enable_mesh(handle);
 449         return rv;
 450 }
 451
 452 EXPORT_API int mesh_disable_mesh(mesh_h handle)
 453 {
 454         int rv = 0;
 455         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 456
 457         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 458
 459         rv = _mesh_disable_mesh(handle);
 460         return rv;
 461 }
 462
 463 EXPORT_API int mesh_is_joined(mesh_h handle, int* is_joined)
 464 {
 465         int rv = 0;
 466         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 467
 468         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 469
 470         rv = _mesh_is_joined(handle, is_joined);
 471         return rv;
 472 }
 473
 474 EXPORT_API int mesh_get_joined_network(mesh_h handle, mesh_network_h *network)
 475 {
 476         int rv = 0;
 477         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 478
 479         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 480
 481         rv = _mesh_get_joined_mesh_network(handle, network);
 482         return rv;
 483 }
 484
 485 EXPORT_API int mesh_set_gate(mesh_h handle, bool stp, bool gate_announce)
 486 {
 487         int rv = 0;
 488         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 489
 490         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 491
 492         rv = _mesh_set_gate(handle, stp, gate_announce);
 493         return rv;
 494 }
 495
 496 EXPORT_API int mesh_unset_gate(mesh_h handle)
 497 {
 498         int rv = 0;
 499         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 500
 501         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 502
 503         rv = _mesh_unset_gate(handle);
 504         return rv;
 505 }
 506
 507 EXPORT_API int mesh_set_softap(mesh_h handle, const char* ssid,
 508                 const char* key, int channel, bool visibility,
 509                 int max_stations, int security)
 510 {
 511         int rv = 0;
 512         char buf[32] = {0,};
 513         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 514
 515         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 516         RETV_IF(NULL == ssid, MESH_ERROR_INVALID_PARAMETER);
 517         RETV_IF(NULL == key, MESH_ERROR_INVALID_PARAMETER);
 518
 519         if (channel <= 13)
 520                 memcpy(buf, "n", strlen("n"));
 521         else
 522                 memcpy(buf, "a", strlen("a"));
 523
 524         rv = _mesh_set_softap(handle, ssid, key, buf, channel,
 525                         visibility, max_stations, security);
 526         return rv;
 527 }
 528
 529 EXPORT_API int mesh_enable_softap(mesh_h handle)
 530 {
 531         int rv = 0;
 532         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 533
 534         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 535
 536         rv = _mesh_enable_softap(handle);
 537         return rv;
 538 }
 539
 540 EXPORT_API int mesh_disable_softap(mesh_h handle)
 541 {
 542         int rv = 0;
 543         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 544
 545         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 546
 547         rv = _mesh_disable_softap(handle);
 548         return rv;
 549 }
 550
 551 EXPORT_API int mesh_create_mesh_network(mesh_h handle, mesh_network_h network)
 552 {
 553         int rv = 0;
 554         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 555
 556         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 557         RETV_IF(NULL == network, MESH_ERROR_INVALID_PARAMETER);
 558
 559         rv = _mesh_create_network(handle, network);
 560         return rv;
 561 }
 562
 563 EXPORT_API int mesh_connect_mesh_network(mesh_h handle, mesh_network_h network)
 564 {
 565         int rv = 0;
 566         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 567
 568         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 569         RETV_IF(NULL == network, MESH_ERROR_INVALID_PARAMETER);
 570
 571         rv = _mesh_connect_network(handle, network);
 572         return rv;
 573 }
 574
 575 EXPORT_API int mesh_disconnect_mesh_network(mesh_h handle, mesh_network_h network)
 576 {
 577         int rv = 0;
 578         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 579
 580         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 581         RETV_IF(NULL == network, MESH_ERROR_INVALID_PARAMETER);
 582
 583         rv = _mesh_disconnect_network(handle, network);
 584         return rv;
 585 }
 586
 587 EXPORT_API int mesh_forget_mesh_network(mesh_h handle, mesh_network_h network)
 588 {
 589         int rv = 0;
 590         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 591
 592         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 593         RETV_IF(NULL == network, MESH_ERROR_INVALID_PARAMETER);
 594
 595         rv = _mesh_forget_network(handle, network);
 596         return rv;
 597 }
 598
 599 EXPORT_API int mesh_get_stations_info(mesh_h handle, mesh_found_station_cb cb, void *user_data)
 600 {
 601         int rv = 0;
 602         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 603
 604         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 605
 606         rv = _mesh_get_stations_info(handle, cb, user_data);
 607         return rv;
 608 }
 609
 610 EXPORT_API int mesh_get_mpath_info(mesh_h handle, mesh_found_mpath_cb cb, void *user_data)
 611 {
 612         int rv = 0;
 613         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 614
 615         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 616
 617         rv = _mesh_get_mpath_info(handle, cb, user_data);
 618         return rv;
 619 }
 620
 621 EXPORT_API int mesh_set_interfaces(mesh_h handle,
 622         const char *mesh, const char* gate, const char *softap)
 623 {
 624         int rv = 0;
 625         CHECK_FEATURE_SUPPORTED(MESH_FEATURE);
 626
 627         RETV_IF(NULL == mesh, MESH_ERROR_INVALID_PARAMETER);
 628         RETV_IF(NULL == handle, MESH_ERROR_INVALID_PARAMETER);
 629
 630         rv = _mesh_set_interfaces(handle, mesh, gate, softap);
 631         return rv;
 632 }