Lines Matching refs:dev
22 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev);
81 struct p2p_device *dev, *n;
86 dl_list_for_each_safe(dev, n, &p2p->devices, struct p2p_device, list) {
87 if (dev->last_seen.sec + P2P_PEER_EXPIRATION_AGE >= now.sec)
92 dev->info.p2p_device_addr)) {
97 os_get_time(&dev->last_seen);
103 p2p->groups[i], dev->info.p2p_device_addr))
111 os_get_time(&dev->last_seen);
123 "entry " MACSTR, MAC2STR(dev->info.p2p_device_addr));
126 if(&dev->list == p2p->sd_dev_list)
127 p2p->sd_dev_list = dev->list.next;
129 dl_list_del(&dev->list);
130 p2p_device_free(p2p, dev);
185 struct p2p_device *dev = NULL;
190 dev = p2p_get_device(p2p, addr);
191 if (dev)
192 return dev->wps_prov_info;
200 struct p2p_device *dev = NULL;
205 dev = p2p_get_device(p2p, addr);
206 if (dev)
207 dev->wps_prov_info = 0;
368 struct p2p_device *dev;
369 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list)
370 dev->flags &= ~P2P_DEV_REPORTED;
382 struct p2p_device *dev;
383 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
384 if (os_memcmp(dev->info.p2p_device_addr, addr, ETH_ALEN) == 0)
385 return dev;
400 struct p2p_device *dev;
401 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
402 if (os_memcmp(dev->interface_addr, addr, ETH_ALEN) == 0)
403 return dev;
421 struct p2p_device *dev, *oldest = NULL;
424 dev = p2p_get_device(p2p, addr);
425 if (dev)
426 return dev;
428 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
431 os_time_before(&dev->last_seen, &oldest->last_seen))
432 oldest = dev;
447 dev = os_zalloc(sizeof(*dev));
448 if (dev == NULL)
450 dl_list_add(&p2p->devices, &dev->list);
451 os_memcpy(dev->info.p2p_device_addr, addr, ETH_ALEN);
453 return dev;
457 static void p2p_copy_client_info(struct p2p_device *dev,
460 os_memcpy(dev->info.device_name, cli->dev_name, cli->dev_name_len);
461 dev->info.device_name[cli->dev_name_len] = '\0';
462 dev->info.dev_capab = cli->dev_capab;
463 dev->info.config_methods = cli->config_methods;
464 os_memcpy(dev->info.pri_dev_type, cli->pri_dev_type, 8);
465 dev->info.wps_sec_dev_type_list_len = 8 * cli->num_sec_dev_types;
466 os_memcpy(dev->info.wps_sec_dev_type_list, cli->sec_dev_types,
467 dev->info.wps_sec_dev_type_list_len);
477 struct p2p_device *dev;
489 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
490 if (os_memcmp(dev->member_in_go_iface, go_interface_addr,
492 os_memset(dev->member_in_go_iface, 0, ETH_ALEN);
493 os_memset(dev->member_in_go_dev, 0, ETH_ALEN);
502 dev = p2p_get_device(p2p, cli->p2p_device_addr);
503 if (dev) {
504 if (dev->flags & (P2P_DEV_GROUP_CLIENT_ONLY |
510 p2p_copy_client_info(dev, cli);
517 dev->info.dev_capab &=
519 dev->info.dev_capab |=
523 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
524 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
527 dev = p2p_create_device(p2p, cli->p2p_device_addr);
528 if (dev == NULL)
530 dev->flags |= P2P_DEV_GROUP_CLIENT_ONLY;
531 p2p_copy_client_info(dev, cli);
532 dev->oper_freq = freq;
534 dev->info.p2p_device_addr,
535 &dev->info, 1);
536 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
539 os_memcpy(dev->interface_addr, cli->p2p_interface_addr,
541 os_get_time(&dev->last_seen);
542 os_memcpy(dev->member_in_go_dev, go_dev_addr, ETH_ALEN);
543 os_memcpy(dev->member_in_go_iface, go_interface_addr,
551 static void p2p_copy_wps_info(struct p2p_device *dev, int probe_req,
554 os_memcpy(dev->info.device_name, msg->device_name,
555 sizeof(dev->info.device_name));
558 msg->manufacturer_len < sizeof(dev->info.manufacturer)) {
559 os_memset(dev->info.manufacturer, 0,
560 sizeof(dev->info.manufacturer));
561 os_memcpy(dev->info.manufacturer, msg->manufacturer,
566 msg->model_name_len < sizeof(dev->info.model_name)) {
567 os_memset(dev->info.model_name, 0,
568 sizeof(dev->info.model_name));
569 os_memcpy(dev->info.model_name, msg->model_name,
574 msg->model_number_len < sizeof(dev->info.model_number)) {
575 os_memset(dev->info.model_number, 0,
576 sizeof(dev->info.model_number));
577 os_memcpy(dev->info.model_number, msg->model_number,
582 msg->serial_number_len < sizeof(dev->info.serial_number)) {
583 os_memset(dev->info.serial_number, 0,
584 sizeof(dev->info.serial_number));
585 os_memcpy(dev->info.serial_number, msg->serial_number,
590 os_memcpy(dev->info.pri_dev_type, msg->pri_dev_type,
591 sizeof(dev->info.pri_dev_type));
593 os_memcpy(dev->info.pri_dev_type, msg->wps_pri_dev_type,
594 sizeof(dev->info.pri_dev_type));
597 os_memcpy(dev->info.wps_sec_dev_type_list,
600 dev->info.wps_sec_dev_type_list_len =
609 dev->info.dev_capab &= P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY;
610 dev->info.dev_capab |= msg->capability[0] &
612 dev->info.group_capab = msg->capability[1];
616 dev->ext_listen_period = WPA_GET_LE16(msg->ext_listen_timing);
617 dev
626 dev->info.config_methods != new_config_methods) {
629 MAC2STR(dev->info.p2p_device_addr),
630 dev->info.config_methods,
632 dev->info.config_methods = new_config_methods;
660 struct p2p_device *dev;
695 dev = p2p_create_device(p2p, p2p_dev_addr);
696 if (dev == NULL) {
710 if (dev->last_seen.sec > 0 &&
711 os_time_before(rx_time, &dev->last_seen)) {
717 (unsigned int) dev->last_seen.sec,
718 (unsigned int) dev->last_seen.usec);
723 os_memcpy(&dev->last_seen, rx_time, sizeof(struct os_time));
725 dev->flags &= ~(P2P_DEV_PROBE_REQ_ONLY | P2P_DEV_GROUP_CLIENT_ONLY);
728 os_memcpy(dev->interface_addr, addr, ETH_ALEN);
733 os_memcpy(dev->oper_ssid, msg.ssid + 2, msg.ssid[1]);
734 dev->oper_ssid_len = msg.ssid[1];
753 if (dev->listen_freq && dev->listen_freq != freq && scan_res) {
757 MAC2STR(dev->info.p2p_device_addr), dev->listen_freq,
761 dev->listen_freq = freq;
763 dev->oper_freq = freq;
765 dev->info.level = level;
767 p2p_copy_wps_info(dev, 0, &msg);
770 wpabuf_free(dev->info.wps_vendor_ext[i]);
771 dev->info.wps_vendor_ext[i] = NULL;
777 dev->info.wps_vendor_ext[i] = wpabuf_alloc_copy(
779 if (dev->info.wps_vendor_ext[i] == NULL)
784 wpabuf_free(dev->info.wfd_subelems);
785 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
795 if (p2p_pending_sd_req(p2p, dev))
796 dev->flags |= P2P_DEV_SD_SCHEDULE;
798 if (dev->flags & P2P_DEV_REPORTED)
805 if (dev->flags & P2P_DEV_USER_REJECTED) {
811 if (dev->info.config_methods == 0 &&
833 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
834 !(dev->flags & P2P_DEV_REPORTED_ONCE));
835 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
841 static void p2p_device_free(struct p2p_data *p2p, struct p2p_device *dev)
845 if (p2p->go_neg_peer == dev) {
849 p2p_go_neg_failed(p2p, dev, -1);
852 if (p2p->invite_peer == dev)
854 if (p2p->sd_peer == dev)
856 if (p2p->pending_client_disc_go == dev)
860 if (dev->flags & P2P_DEV_REPORTED_ONCE)
862 dev->info.p2p_device_addr);
865 wpabuf_free(dev->info.wps_vendor_ext[i]);
866 dev->info.wps_vendor_ext[i] = NULL;
869 wpabuf_free(dev->info.wfd_subelems);
871 os_free(dev);
987 struct p2p_device *dev;
1031 dev = p2p_get_device(p2p, p2p->after_scan_peer);
1032 if (dev == NULL) {
1037 p2p_connect_send(p2p, dev);
1319 * @dev: Selected peer device
1329 int p2p_prepare_channel(struct p2p_data *p2p, struct p2p_device *dev,
1345 dev->flags |= P2P_DEV_FORCE_FREQ;
1347 dev->flags &= ~P2P_DEV_FORCE_FREQ;
1353 static void p2p_set_dev_persistent(struct p2p_device *dev,
1358 dev->flags &= ~(P2P_DEV_PREFER_PERSISTENT_GROUP |
1362 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP;
1363 dev->flags &= ~P2P_DEV_PREFER_PERSISTENT_RECONN;
1366 dev->flags |= P2P_DEV_PREFER_PERSISTENT_GROUP |
1380 struct p2p_device *dev;
1389 dev = p2p_get_device(p2p, peer_addr);
1390 if (dev == NULL || (dev->flags & P2P_DEV_PROBE_REQ_ONLY)) {
1397 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq) < 0)
1400 if (dev->flags & P2P_DEV_GROUP_CLIENT_ONLY) {
1401 if (!(dev->info.dev_capab &
1409 if (dev->oper_freq <= 0) {
1433 dev->flags &= ~P2P_DEV_NOT_YET_READY;
1434 dev->flags &= ~P2P_DEV_USER_REJECTED;
1435 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
1436 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
1438 dev->flags |= P2P_DEV_PD_BEFORE_GO_NEG;
1440 dev->flags &= ~P2P_DEV_PD_BEFORE_GO_NEG;
1445 dev->dialog_token++;
1446 if (dev->dialog_token == 0)
1447 dev->dialog_token = 1;
1448 dev->tie_breaker = p2p->next_tie_breaker;
1451 dev->connect_reqs = 0;
1452 dev->go_neg_req_sent = 0;
1453 dev->go_state = UNKNOWN_GO;
1454 p2p_set_dev_persistent(dev, persistent_group);
1474 dev->wps_method = wps_method;
1475 dev->status = P2P_SC_SUCCESS;
1486 return p2p_connect_send(p2p, dev);
1497 struct p2p_device *dev;
1506 dev = p2p_get_device(p2p, peer_addr);
1507 if (dev == NULL) {
1514 if (p2p_prepare_channel(p2p, dev, force_freq, pref_freq) < 0)
1526 dev->flags &= ~P2P_DEV_NOT_YET_READY;
1527 dev->flags &= ~P2P_DEV_USER_REJECTED;
1528 dev->go_neg_req_sent = 0;
1529 dev->go_state = UNKNOWN_GO;
1530 p2p_set_dev_persistent(dev, persistent_group);
1534 dev->wps_method = wps_method;
1535 dev->status = P2P_SC_SUCCESS;
1542 struct p2p_device *dev, struct p2p_message *msg)
1544 os_get_time(&dev->last_seen);
1546 p2p_copy_wps_info(dev, 0, msg);
1565 MAC2STR(dev->info.p2p_device_addr),
1566 dev->listen_freq, freq);
1567 dev->listen_freq = freq;
1572 wpabuf_free(dev->info.wfd_subelems);
1573 dev->info.wfd_subelems = wpabuf_dup(msg->wfd_subelems);
1576 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
1577 dev->flags &= ~P2P_DEV_PROBE_REQ_ONLY;
1586 MAC2STR(dev->info.p2p_device_addr),
1587 dev->info.dev_capab, dev->info.group_capab,
1588 dev->info.device_name, dev->listen_freq);
1591 dev->flags &= ~P2P_DEV_GROUP_CLIENT_ONLY;
1593 if (dev->flags & P2P_DEV_USER_REJECTED) {
1599 p2p->cfg->dev_found(p2p->cfg->cb_ctx, addr, &dev->info,
1600 !(dev->flags & P2P_DEV_REPORTED_ONCE));
1601 dev->flags |= P2P_DEV_REPORTED | P2P_DEV_REPORTED_ONCE;
1865 struct p2p_device *dev;
1886 dev = p2p_get_device(p2p, addr);
1887 if (dev) {
1888 if (dev->country[0] == 0 && msg.listen_channel)
1889 os_memcpy(dev->country, msg.listen_channel, 3);
1890 os_get_time(&dev->last_seen);
1895 dev = p2p_create_device(p2p, addr);
1896 if (dev == NULL) {
1901 os_get_time(&dev->last_seen);
1902 dev->flags |= P2P_DEV_PROBE_REQ_ONLY;
1905 os_memcpy(dev->country, msg.listen_channel, 3);
1906 dev->listen_freq = p2p_channel_to_freq(dev->country,
1911 p2p_copy_wps_info(dev, 1, &msg);
1914 wpabuf_free(dev->info.wfd_subelems);
1915 dev->info.wfd_subelems = wpabuf_dup(msg.wfd_subelems);
1923 MAC2STR(dev->info.p2p_device_addr), dev->info.dev_capab,
1924 dev->info.group_capab, dev->info.device_name,
1925 dev->listen_freq);
1933 struct p2p_device *dev;
1935 dev = p2p_get_device(p2p, addr);
1936 if (dev) {
1937 os_get_time(&dev->last_seen);
1938 return dev; /* already known */
1941 dev = p2p_create_device(p2p, addr);
1942 if (dev == NULL)
1945 p2p_add_dev_info(p2p, addr, dev, msg);
1947 return dev;
2579 struct p2p_device *dev, *prev;
2581 dl_list_for_each_safe(dev, prev, &p2p->devices, struct p2p_device,
2583 dl_list_del(&dev->list);
2584 p2p_device_free(p2p, dev);
2598 struct p2p_device *dev;
2600 dev = p2p_get_device(p2p, addr);
2601 if (dev == NULL)
2607 if (p2p->go_neg_peer == dev)
2610 dev->wps_method = WPS_NOT_READY;
2611 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_RESPONSE;
2612 dev->flags &= ~P2P_DEV_WAIT_GO_NEG_CONFIRM;
2767 struct p2p_device *dev;
2772 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
2786 if ((&dev->list == p2p->sd_dev_list) ) {
2788 if (dev->list.next == &p2p->devices)
2794 p2p->sd_dev_list = &dev->list;
2795 wpa_printf(MSG_DEBUG, "P2P: ### Servicing %p dev->flags 0x%x SD schedule %s devaddr " MACSTR,
2796 p2p->sd_dev_list, dev->flags, dev->flags & P2P_DEV_SD_SCHEDULE ? "TRUE": "FALSE",
2797 MAC2STR(dev->info.p2p_device_addr));
2799 if (dev->flags & P2P_DEV_SD_SCHEDULE) {
2800 if (p2p_start_sd(p2p, dev) == 0)
2804 } else if (dev->req_config_methods &&
2805 !(dev->flags & P2P_DEV_PD_FOR_JOIN)) {
2809 MAC2STR(dev->info.p2p_device_addr),
2810 dev->req_config_methods);
2811 if (p2p_send_prov_disc_req(p2p, dev, 0, 0) == 0)
2855 struct p2p_device *dev;
2865 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
2867 dev->info.p2p_device_addr, ETH_ALEN) != 0)
2869 if (!dev->req_config_methods)
2875 MAC2STR(dev->info.p2p_device_addr),
2876 dev->req_config_methods);
2877 p2p_send_prov_disc_req(p2p, dev,
2878 dev->flags & P2P_DEV_PD_FOR_JOIN, 0);
3030 struct p2p_device *dev = p2p->go_neg_peer;
3037 if (dev == NULL) {
3044 if (dev->flags & P2P_DEV_USER_REJECTED) {
3048 } else if (dev->go_neg_req_sent) {
3050 dev->go_neg_req_sent--;
3054 (dev->info.dev_capab & P2P_DEV_CAPAB_CLIENT_DISCOVERABILITY) &&
3055 !is_zero_ether_addr(dev->member_in_go_dev)) {
3059 MAC2STR(dev->info.p2p_device_addr));
3061 p2p_send_dev_disc_req(p2p, dev);
3118 struct p2p_device *dev;
3145 dev = p2p->go_neg_peer;
3146 if (dev == NULL)
3149 p2p_go_complete(p2p, dev);
3374 struct p2p_device *dev = p2p->go_neg_peer;
3376 if (dev == NULL) {
3382 dev->wait_count++;
3383 if (dev->wait_count >= 120) {
3387 p2p_go_neg_failed(p2p, dev, -1);
3440 struct p2p_device *dev;
3443 dl_list_for_each(dev, &p2p->devices, struct p2p_device, list) {
3445 dev->info.p2p_device_addr, ETH_ALEN) != 0)
3447 if (dev->req_config_methods &&
3448 (dev->flags & P2P_DEV_PD_FOR_JOIN))
3583 struct p2p_device *dev;
3585 dev = p2p_get_device(p2p, peer_addr);
3588 if (dev == NULL) {
3593 dev->status = P2P_SC_FAIL_REJECTED_BY_USER;
3594 dev->flags |= P2P_DEV_USER_REJECTED;
3634 struct p2p_device *dev;
3637 dev = p2p_get_device(p2p, addr);
3639 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
3641 if (dev && next) {
3642 dev = dl_list_first(&dev->list, struct p2p_device, list);
3643 if (&dev->list == &p2p->devices)
3644 dev = NULL;
3647 if (dev == NULL)
3650 return &dev->info;
3657 struct p2p_device *dev;
3665 dev = (struct p2p_device *) (((u8 *) info) -
3690 (int) (now.sec - dev->last_seen.sec),
3691 dev->listen_freq,
3692 p2p_wps_method_text(dev->wps_method),
3693 MAC2STR(dev->interface_addr),
3694 MAC2STR(dev->member_in_go_dev),
3695 MAC2STR(dev->member_in_go_iface),
3696 dev->go_neg_req_sent,
3697 p2p_go_state_text(dev->go_state),
3698 dev->dialog_token,
3699 MAC2STR(dev->intended_addr),
3700 dev->country[0] ? dev->country[0] : '_',
3701 dev->country[1] ? dev->country[1] : '_',
3702 dev->oper_freq,
3703 dev->req_config_methods,
3704 dev->flags & P2P_DEV_PROBE_REQ_ONLY ?
3706 dev->flags & P2P_DEV_REPORTED ? "[REPORTED]" : "",
3707 dev->flags & P2P_DEV_NOT_YET_READY ?
3709 dev->flags & P2P_DEV_SD_INFO ? "[SD_INFO]" : "",
3710 dev->flags & P2P_DEV_SD_SCHEDULE ? "[SD_SCHEDULE]" :
3712 dev->flags & P2P_DEV_PD_PEER_DISPLAY ?
3714 dev->flags & P2P_DEV_PD_PEER_KEYPAD ?
3716 dev->flags & P2P_DEV_USER_REJECTED ?
3718 dev->flags & P2P_DEV_PEER_WAITING_RESPONSE ?
3720 dev->flags & P2P_DEV_PREFER_PERSISTENT_GROUP ?
3722 dev->flags & P2P_DEV_WAIT_GO_NEG_RESPONSE ?
3724 dev->flags & P2P_DEV_WAIT_GO_NEG_CONFIRM ?
3726 dev->flags & P2P_DEV_GROUP_CLIENT_ONLY ?
3728 dev->flags & P2P_DEV_FORCE_FREQ ?
3730 dev->flags & P2P_DEV_PD_FOR_JOIN ?
3732 dev->status,
3733 dev->wait_count,
3734 dev->invitation_reqs);
3739 if (dev->ext_listen_period) {
3743 dev->ext_listen_period,
3744 dev->ext_listen_interval);
3750 if (dev->oper_ssid_len) {
3753 wpa_ssid_txt(dev->oper_ssid,
3754 dev->oper_ssid_len));
3761 if (dev->info.wfd_subelems) {
3768 wpabuf_head(dev->info.wfd_subelems),
3769 wpabuf_len(dev->info.wfd_subelems));
4213 struct p2p_device *dev = p2p_get_device(p2p, dev_addr);
4214 if (dev == NULL || is_zero_ether_addr(dev->interface_addr))
4216 os_memcpy(iface_addr, dev->interface_addr, ETH_ALEN);
4224 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
4225 if (dev == NULL)
4227 os_memcpy(dev_addr, dev->info.p2p_device_addr, ETH_ALEN);
4257 struct p2p_device *dev = p2p_get_device_interface(p2p, iface_addr);
4258 if (dev == NULL)
4260 if (dev->oper_freq <= 0)
4262 return dev->oper_freq;
4342 struct p2p_device *dev;
4345 dev = p2p_get_device(p2p, addr);
4346 if (!dev)
4350 if (dev->flags & P2P_DEV_PROBE_REQ_ONLY)
4353 return &dev->info;
4356 dev = dl_list_first(&dev->list,
4359 if (&dev->list == &p2p->devices)
4361 } while (dev->flags & P2P_DEV_PROBE_REQ_ONLY);
4364 dev = dl_list_first(&p2p->devices, struct p2p_device, list);
4365 if (!dev)
4367 while (dev->flags & P2P_DEV_PROBE_REQ_ONLY) {
4368 dev = dl_list_first(&dev->list,
4371 if (&dev->list == &p2p->devices)
4376 return &dev->info;
