/* Given the tagged parameter sets from a beacon packet, locate the AP's SSID and return its current channel number */ int parse_beacon_tags(const u_char *packet, size_t len) { char *ssid = NULL; const u_char *tag_data = NULL; unsigned char *ie = NULL, *channel_data = NULL; size_t ie_len = 0, ie_offset = 0, tag_len = 0, tag_offset = 0; int channel = 0; struct radio_tap_header *rt_header = NULL; rt_header = (struct radio_tap_header *) radio_header(packet, len); tag_offset = rt_header->len + sizeof(struct dot11_frame_header) + sizeof(struct beacon_management_frame); if(tag_offset < len) { tag_len = (len - tag_offset); tag_data = (const u_char *) (packet + tag_offset); /* If no SSID was manually specified, parse and save the AP SSID */ if(get_ssid() == NULL) { ie = parse_ie_data(tag_data, tag_len, (uint8_t) SSID_TAG_NUMBER, &ie_len, &ie_offset); if(ie) { /* Return data is not null terminated; allocate ie_len+1 and memcpy string */ ssid = malloc(ie_len+1); if(ssid) { memset(ssid, 0, (ie_len+1)); memcpy(ssid, ie, ie_len); set_ssid(ssid); free(ssid); } free(ie); } } ie = parse_ie_data(tag_data, tag_len, (uint8_t) RATES_TAG_NUMBER, &ie_len, &ie_offset); if(ie) { set_ap_rates(ie, ie_len); free(ie); } channel_data = parse_ie_data(tag_data, tag_len, (uint8_t) CHANNEL_TAG_NUMBER, &ie_len, &ie_offset); if(channel_data) { if(ie_len == 1) { memcpy((int *) &channel, channel_data, ie_len); } free(channel_data); } } return channel; }
/* Process auto-applied options from the database. read_ap_beacon should be called before this. */ void process_auto_options(void) { char **argv = NULL; int argc = 0, i = 0; char *bssid = NULL, *ssid = NULL; if(get_auto_detect_options()) { bssid = (char *) mac2str(get_bssid(), ':'); if(bssid) { /* If we didn't get the SSID from the beacon packet, check the database */ if(get_ssid() == NULL) { ssid = get_db_ssid(bssid); if(ssid) { set_ssid(ssid); free(ssid); } } argv = auto_detect_settings(bssid, &argc); if(argc > 1 && argv != NULL) { /* Process the command line arguments */ process_arguments(argc, argv); /* Clean up argument memory allocation */ for(i=0; i<argc; i++) { free(argv[i]); } free(argv); } free(bssid); } } return; }
int save_service_list (const service_list *sl) { struct gen_ssid_arg arg = { .ssid = "##", .ssid_len = 2, .last_pos = -1, .rc = ERR_SUCCESS, }; char *err_msg; int rc; char old_ssid[SSID_MAX_LEN]; ssize_t old_ssid_len; sqlite3_stmt *updt_stmt; if (!sl->has_service_list_tmp_table) { return ERR_SUCCESS; } /* Constructing the SSID */ if ((rc = sqlite3_exec (sl->db, "select " COLUMN_CAT_ID ", " COLUMN_DESC ", " COLUMN_POSITION " from " TABLE_SERVICE_LIST_TMP " order by " COLUMN_POSITION " asc", gen_ssid, &arg, &err_msg)) != SQLITE_ABORT && rc != SQLITE_OK) { SQLITE3_ERR_STR (err_msg, "Cannot select services to publish"); return ERR_SAVE_SERVICE_LIST; } if (rc == SQLITE_ABORT) { sqlite3_free (err_msg); l->APP_ERR (arg.rc, "Cannot publish services"); return arg.rc; } /* Preparing for reverting to the old SSID */ if ((old_ssid_len = get_ssid (old_ssid, sizeof (old_ssid))) == -1) { l->ERR ("Cannot retrieve old SSID"); return ERR_SAVE_SERVICE_LIST; } /* Give modification time to all records in the temporary table */ if (sqlite3_exec (sl->db, "update " TABLE_SERVICE_LIST_TMP " set " COLUMN_MOD_TIME " = strftime ('%s', 'now')", NULL, NULL, &err_msg)) { SQLITE3_ERR_STR (err_msg, "Cannot set service list new mod time"); return ERR_SAVE_SERVICE_LIST; } /* If there old and new records are the same, don't change the mod time */ if (sqlite3_prepare_v2 (sl->db, "update " TABLE_SERVICE_LIST_TMP " set " COLUMN_MOD_TIME " = ?" " where " COLUMN_POSITION " = ?" " and " COLUMN_CAT_ID " = ?" " and " COLUMN_DESC " = ?" " and " COLUMN_LONG_DESC " = ?" " and " COLUMN_URI " = ?", -1, &updt_stmt, NULL)) { SQLITE3_ERR (sl->db, "Cannot prepare mod time adjustment update statement"); return ERR_SAVE_SERVICE_LIST; } if ((rc = sqlite3_exec (sl->db, "select * from " TABLE_SERVICE_LIST, adjust_mod_time, updt_stmt, &err_msg))) { SQLITE3_ERR_STR (err_msg, "Cannot adjust mod time"); } if (sqlite3_finalize (updt_stmt)) { SQLITE3_ERR_STR (err_msg, "Cannot finalize mod time adjustment stmt"); return ERR_SAVE_SERVICE_LIST; } if (rc) { return ERR_SAVE_SERVICE_LIST; } /* The real saving process */ if (sqlite3_exec (sl->db, "begin exclusive", NULL, NULL, &err_msg)) { SQLITE3_ERR_STR (err_msg, "Cannot lock service list DB"); return ERR_SAVE_SERVICE_LIST; } if ((rc = set_ssid (arg.ssid, arg.ssid_len))) { l->APP_ERR (rc, "Cannot set SSID"); if (sqlite3_exec (sl->db, "rollback", NULL, NULL, &err_msg)) { SQLITE3_ERR_STR (err_msg, "Cannot unlock (rollback) service list DB"); } return rc; } if (sqlite3_exec (sl->db, "delete from " TABLE_SERVICE_LIST ";" "insert into " TABLE_SERVICE_LIST " select *" " from " TABLE_SERVICE_LIST_TMP ";" "commit", NULL, NULL, &err_msg)) { SQLITE3_ERR_STR (err_msg, "Cannot save services"); if ((rc = set_ssid (old_ssid, old_ssid_len))) { l->APP_ERR (rc, "Cannot revert back to the old SSID"); } if (sqlite3_exec (sl->db, "rollback", NULL, NULL, &err_msg)) { SQLITE3_ERR_STR (err_msg, "Cannot unlock (rollback) service list DB"); } return ERR_SAVE_SERVICE_LIST; } return ERR_SUCCESS; } /** * The callback function used with sqlite3_exec() to count the rows * of a table. The SQL select in sqlite3_exec() <strong>MUST</strong> * correct in returning only one row having only one column containing * the count to be extracted. * * @param [out] result where the counting result should be put. * @param [in] col_count the number of columns in this record. * @param [in] cols the columns of this record. * @param [in] col_names the column names of this record. * * @return 0 if there is no error or non-zero if there is one. */ static int get_row_count (void *result, int col_count, char **cols, char **col_names) { unsigned long *count = result; *count = strtoul (cols[0], NULL, 10); return 0; }
void publish_services (void) { struct gen_ssid_arg arg = { .ssid = "##", .ssid_len = 2, .last_pos = -1, .rc = ERR_SUCCESS, }; char *err_msg; int rc; sqlite3 *db; if (sqlite3_open_v2 (SERVICE_LIST_DB, &db, SQLITE_OPEN_READONLY, NULL)) { SQLITE3_ERR (db, "Cannot open DB in read-only mode for publishing services"); goto error; } if ((rc = sqlite3_exec (db, "select " COLUMN_CAT_ID ", " COLUMN_DESC ", " COLUMN_POSITION " from " TABLE_SERVICE_LIST " order by " COLUMN_POSITION " asc", gen_ssid, &arg, &err_msg)) != SQLITE_ABORT && rc != SQLITE_OK) { SQLITE3_ERR_STR (err_msg, "Cannot select services to publish"); goto error; } if (rc == SQLITE_ABORT) { sqlite3_free (err_msg); l->APP_ERR (arg.rc, "Cannot publish services"); goto error; } if ((rc = set_ssid (arg.ssid, arg.ssid_len))) { l->APP_ERR (rc, "Cannot set SSID"); } error: if (sqlite3_close (db)) { SQLITE3_ERR (db, "Cannot close read-only DB for reading published services"); } } /** * The callback function used with sqlite3_exec() to not change the modification * time of unmodified record. The SQL select in sqlite3_exec() * <strong>MUST</strong> select all columns with '*'. * * @param [in] stmt the prepared statement to adjust the modification time. * @param [in] col_count the number of columns in this record. * @param [in] cols the columns of this record. * @param [in] col_names the column names of this record. * * @return 0 if there is no error or non-zero if there is one. */ static int adjust_mod_time (void *stmt, int col_count, char **cols, char **col_names) { sqlite3_stmt *updt_stmt = stmt; sqlite3 *db = sqlite3_db_handle (updt_stmt); if (sqlite3_bind_text (stmt, 1, cols[COLPOS_MOD_TIME], -1, SQLITE_STATIC)) { SQLITE3_ERR (db, "Cannot bind mod_time to updt stmt"); return -1; } if (sqlite3_bind_text (stmt, 2, cols[COLPOS_POSITION], -1, SQLITE_STATIC)) { SQLITE3_ERR (db, "Cannot bind position to updt stmt"); return -1; } if (sqlite3_bind_text (stmt, 3, cols[COLPOS_CAT_ID], -1, SQLITE_STATIC)) { SQLITE3_ERR (db, "Cannot bind cat_id to updt stmt"); return -1; } if (sqlite3_bind_text (stmt, 4, cols[COLPOS_DESC], -1, SQLITE_STATIC)) { SQLITE3_ERR (db, "Cannot bind desc to updt stmt"); return -1; } if (sqlite3_bind_text (stmt, 5, cols[COLPOS_LONG_DESC], -1, SQLITE_STATIC)) { SQLITE3_ERR (db, "Cannot bind long_desc to updt stmt"); return -1; } if (sqlite3_bind_text (stmt, 6, cols[COLPOS_URI], -1, SQLITE_STATIC)) { SQLITE3_ERR (db, "Cannot bind uri to updt stmt"); return -1; } if (sqlite3_step (stmt) != SQLITE_DONE) { SQLITE3_ERR (db, "Cannot execute updt stmt"); return -1; } if (sqlite3_reset (stmt)) { SQLITE3_ERR (db, "Cannot reset updt stmt"); return -1; } if (sqlite3_clear_bindings (stmt)) { SQLITE3_ERR (db, "Cannot clear updt stmt bindings"); return -1; } return 0; }
void parse_wps_settings(const u_char *packet, struct pcap_pkthdr *header, char *target, int passive, int mode, int source) { struct radio_tap_header *rt_header = NULL; struct dot11_frame_header *frame_header = NULL; struct libwps_data *wps = NULL; enum encryption_type encryption = NONE; char *bssid = NULL, *ssid = NULL, *lock_display = NULL; int wps_parsed = 0, probe_sent = 0, channel = 0, rssi = 0; static int channel_changed = 0; wps = malloc(sizeof(struct libwps_data)); memset(wps, 0, sizeof(struct libwps_data)); if(packet == NULL || header == NULL || header->len < MIN_BEACON_SIZE) { goto end; } rt_header = (struct radio_tap_header *) radio_header(packet, header->len); frame_header = (struct dot11_frame_header *) (packet + rt_header->len); /* If a specific BSSID was specified, only parse packets from that BSSID */ if(!is_target(frame_header)) { goto end; } set_ssid(NULL); bssid = (char *) mac2str(frame_header->addr3, ':'); if(bssid) { if((target == NULL) || (target != NULL && strcmp(bssid, target) == 0)) { channel = parse_beacon_tags(packet, header->len); rssi = signal_strength(packet, header->len); ssid = (char *) get_ssid(); if(target != NULL && channel_changed == 0) { ualarm(0, 0); change_channel(channel); channel_changed = 1; } if(frame_header->fc.sub_type == PROBE_RESPONSE || frame_header->fc.sub_type == SUBTYPE_BEACON) { wps_parsed = parse_wps_parameters(packet, header->len, wps); } if(!is_done(bssid) && (get_channel() == channel || source == PCAP_FILE || !get_channel())) { if(frame_header->fc.sub_type == SUBTYPE_BEACON && mode == SCAN && !passive && should_probe(bssid)) { send_probe_request(get_bssid(), get_ssid()); probe_sent = 1; } if(!insert(bssid, ssid, wps, encryption, rssi)) { update(bssid, ssid, wps, encryption); } else if(wps->version > 0) { switch(wps->locked) { case WPSLOCKED: lock_display = YES; break; case UNLOCKED: case UNSPECIFIED: lock_display = NO; break; } cprintf(INFO, "%17s %2d %.2d %d.%d %s %s\n", bssid, channel, rssi, (wps->version >> 4), (wps->version & 0x0F), lock_display, ssid); } if(probe_sent) { update_probe_count(bssid); } /* * If there was no WPS information, then the AP does not support WPS and we should ignore it from here on. * If this was a probe response, then we've gotten all WPS info we can get from this AP and should ignore it from here on. */ if(!wps_parsed || frame_header->fc.sub_type == PROBE_RESPONSE) { mark_ap_complete(bssid); } } } /* Only update received signal strength if we are on the same channel as the AP, otherwise power measurements are screwy */ if(channel == get_channel()) { update_ap_power(bssid, rssi); } free(bssid); bssid = NULL; }
void parse_wps_settings(const u_char *packet, struct pcap_pkthdr *header, char *target, int passive, int mode, int source) { struct radio_tap_header *rt_header = NULL; struct dot11_frame_header *frame_header = NULL; struct libwps_data *wps = NULL; enum encryption_type encryption = NONE; char *bssid = NULL, *ssid = NULL, *lock_display = NULL; int wps_parsed = 0, probe_sent = 0, channel = 0, rssi = 0; static int channel_changed = 0; char info_manufac[500]; char info_modelnum[500]; char info_modelserial[500]; wps = malloc(sizeof(struct libwps_data)); memset(wps, 0, sizeof(struct libwps_data)); if(packet == NULL || header == NULL || header->len < MIN_BEACON_SIZE) { goto end; } rt_header = (struct radio_tap_header *) radio_header(packet, header->len); frame_header = (struct dot11_frame_header *) (packet + rt_header->len); /* If a specific BSSID was specified, only parse packets from that BSSID */ if(!is_target(frame_header)) { goto end; } set_ssid(NULL); bssid = (char *) mac2str(frame_header->addr3, ':'); set_bssid((unsigned char *) frame_header->addr3); if(bssid) { if((target == NULL) || (target != NULL && strcmp(bssid, target) == 0)) { channel = parse_beacon_tags(packet, header->len); rssi = signal_strength(packet, header->len); ssid = (char *) get_ssid(); if(target != NULL && channel_changed == 0) { ualarm(0, 0); change_channel(channel); channel_changed = 1; } if(frame_header->fc.sub_type == PROBE_RESPONSE || frame_header->fc.sub_type == SUBTYPE_BEACON) { wps_parsed = parse_wps_parameters(packet, header->len, wps); } if(!is_done(bssid) && (get_channel() == channel || source == PCAP_FILE)) { if(frame_header->fc.sub_type == SUBTYPE_BEACON && mode == SCAN && !passive && should_probe(bssid)) { send_probe_request(get_bssid(), get_ssid()); probe_sent = 1; } if(!insert(bssid, ssid, wps, encryption, rssi)) { update(bssid, ssid, wps, encryption); } else if(wps->version > 0) { switch(wps->locked) { case WPSLOCKED: lock_display = YES; break; case UNLOCKED: case UNSPECIFIED: lock_display = NO; break; } //ideas made by kcdtv if(get_chipset_output == 1) //if(1) { if (c_fix == 0) { //no use a fixed channel cprintf(INFO,"Option (-g) REQUIRES a channel to be set with (-c)\n"); exit(0); } FILE *fgchipset=NULL; char cmd_chipset[4000]; char cmd_chipset_buf[4000]; char buffint[5]; char *aux_cmd_chipset=NULL; memset(cmd_chipset, 0, sizeof(cmd_chipset)); memset(cmd_chipset_buf, 0, sizeof(cmd_chipset_buf)); memset(info_manufac, 0, sizeof(info_manufac)); memset(info_modelnum, 0, sizeof(info_modelnum)); memset(info_modelserial, 0, sizeof(info_modelserial)); strcat(cmd_chipset,"reaver -0 -s y -vv -i "); //need option to stop reaver in m1 stage strcat(cmd_chipset,get_iface()); strcat(cmd_chipset, " -b "); strcat(cmd_chipset, mac2str(get_bssid(),':')); strcat(cmd_chipset," -c "); snprintf(buffint, sizeof(buffint), "%d",channel); strcat(cmd_chipset, buffint); //cprintf(INFO,"\n%s\n",cmd_chipset); if ((fgchipset = popen(cmd_chipset, "r")) == NULL) { printf("Error opening pipe!\n"); //return -1; } while (fgets(cmd_chipset_buf, 4000, fgchipset) != NULL) { //[P] WPS Manufacturer: xxx //[P] WPS Model Number: yyy //[P] WPS Model Serial Number: zzz //cprintf(INFO,"\n%s\n",cmd_chipset_buf); aux_cmd_chipset = strstr(cmd_chipset_buf,"[P] WPS Manufacturer:"); if(aux_cmd_chipset != NULL) { //bug fix by alxchk strncpy(info_manufac, aux_cmd_chipset+21, sizeof(info_manufac)); } aux_cmd_chipset = strstr(cmd_chipset_buf,"[P] WPS Model Number:"); if(aux_cmd_chipset != NULL) { //bug fix by alxchk strncpy(info_modelnum, aux_cmd_chipset+21, sizeof(info_modelnum)); } aux_cmd_chipset = strstr(cmd_chipset_buf,"[P] WPS Model Serial Number:"); if(aux_cmd_chipset != NULL) { //bug fix by alxchk strncpy(info_modelserial, aux_cmd_chipset+28, sizeof(info_modelserial)); } } //cprintf(INFO,"\n%s\n",info_manufac); info_manufac[strcspn ( info_manufac, "\n" )] = '\0'; info_modelnum[strcspn ( info_modelnum, "\n" )] = '\0'; info_modelserial[strcspn ( info_modelserial, "\n" )] = '\0'; if(pclose(fgchipset)) { //printf("Command not found or exited with error status\n"); //return -1; } } if (o_file_p == 0) { cprintf(INFO, "%17s %2d %.2d %d.%d %s %s\n", bssid, channel, rssi, (wps->version >> 4), (wps->version & 0x0F), lock_display, ssid); } else { if(get_chipset_output == 1) { cprintf(INFO, "%17s|%2d|%.2d|%d.%d|%s|%s|%s|%s|%s\n", bssid, channel, rssi, (wps->version >> 4), (wps->version & 0x0F), lock_display, ssid, info_manufac, info_modelnum, info_modelserial); }else { cprintf(INFO, "%17s|%2d|%.2d|%d.%d|%s|%s\n", bssid, channel, rssi, (wps->version >> 4), (wps->version & 0x0F), lock_display, ssid); } }
/* Processes Reaver command line options */ int process_arguments(int argc, char **argv) { int ret_val = EXIT_SUCCESS; int c = 0, channel = 0; int long_opt_index = 0; char bssid[MAC_ADDR_LEN] = { 0 }; char mac[MAC_ADDR_LEN] = { 0 }; char *short_options = "b:e:m:i:t:d:c:T:x:r:g:l:o:p:s:C:KZA5ELfnqvDShwN6J"; struct option long_options[] = { { "pixie-dust", no_argument, NULL, 'K' }, { "interface", required_argument, NULL, 'i' }, { "bssid", required_argument, NULL, 'b' }, { "essid", required_argument, NULL, 'e' }, { "mac", required_argument, NULL, 'm' }, { "timeout", required_argument, NULL, 't' }, { "m57-timeout", required_argument, NULL, 'T' }, { "delay", required_argument, NULL, 'd' }, { "lock-delay", required_argument, NULL, 'l' }, { "fail-wait", required_argument, NULL, 'x' }, { "channel", required_argument, NULL, 'c' }, { "session", required_argument, NULL, 's' }, { "recurring-delay", required_argument, NULL, 'r' }, { "max-attempts", required_argument, NULL, 'g' }, { "out-file", required_argument, NULL, 'o' }, { "pin", required_argument, NULL, 'p' }, { "exec", required_argument, NULL, 'C' }, { "no-associate", no_argument, NULL, 'A' }, { "ignore-locks", no_argument, NULL, 'L' }, { "no-nacks", no_argument, NULL, 'N' }, { "eap-terminate", no_argument, NULL, 'E' }, { "dh-small", no_argument, NULL, 'S' }, { "fixed", no_argument, NULL, 'f' }, { "daemonize", no_argument, NULL, 'D' }, { "5ghz", no_argument, NULL, '5' }, { "repeat-m6", no_argument, NULL, '6' }, { "nack", no_argument, NULL, 'n' }, { "quiet", no_argument, NULL, 'q' }, { "verbose", no_argument, NULL, 'v' }, { "win7", no_argument, NULL, 'w' }, { "help", no_argument, NULL, 'h' }, { "timeout-is-nack", no_argument, NULL, 'J' }, { 0, 0, 0, 0 } }; /* Since this function may be called multiple times, be sure to set opt index to 0 each time */ optind = 0; while((c = getopt_long(argc, argv, short_options, long_options, &long_opt_index)) != -1) { switch(c) { case 'Z': case 'K': pixie.do_pixie = 1; break; case 'i': set_iface(optarg); break; case 'b': str2mac(optarg, (unsigned char *) &bssid); set_bssid((unsigned char *) &bssid); break; case 'e': set_ssid(optarg); break; case 'm': str2mac(optarg, (unsigned char *) &mac); set_mac((unsigned char *) &mac); break; case 't': set_rx_timeout(atoi(optarg)); break; case 'T': set_m57_timeout(strtof(optarg, NULL) * SEC_TO_US); break; case 'c': channel = strtod(optarg, NULL); set_fixed_channel(1); break; case '5': set_wifi_band(AN_BAND); break; case '6': set_repeat_m6(1); break; case 'd': set_delay(atoi(optarg)); break; case 'l': set_lock_delay(atoi(optarg)); break; case 'p': parse_static_pin(optarg); break; case 's': set_session(optarg); break; case 'C': set_exec_string(optarg); break; case 'A': set_external_association(1); break; case 'L': set_ignore_locks(1); break; case 'o': set_log_file(fopen(optarg, "w")); break; case 'x': set_fail_delay(atoi(optarg)); break; case 'r': parse_recurring_delay(optarg); break; case 'g': set_max_pin_attempts(atoi(optarg)); break; case 'D': daemonize(); break; case 'E': set_eap_terminate(1); break; case 'S': set_dh_small(1); break; case 'n': cprintf(INFO, "[+] ignoring obsolete -n switch\n"); break; case 'J': set_timeout_is_nack(1); break; case 'f': set_fixed_channel(1); break; case 'v': set_debug(get_debug() + 1); break; case 'q': set_debug(CRITICAL); break; case 'w': set_win7_compat(1); break; case 'N': set_oo_send_nack(0); break; default: ret_val = EXIT_FAILURE; } } if(channel) { change_channel(channel); } return ret_val; }
void _setConfigurations(cJSON *root, s_config *config, char *http_packet) { cJSON *valueSetObj= cJSON_CreateObject(); cJSON *attribute; cJSON *key; cJSON *item; int array_size; int i; char cmd[MAX_BUF]; char result[MAX_BUF]; char ErrMesg[B_5_BUF]; cJSON *transaction_id = cJSON_GetObjectItem(root, "transaction_id"); char *conf_version; char *radio_index; char *profile_index; char *status; int flag =0; if(!transaction_id) { debug(LOG_ERR, "Can not find transaction_id parameter: %s", cJSON_GetErrorPtr()); create_http_json(valueSetObj, NULL, RESPONSE, SETCONFIGURATIONS, "failed", "3", "Missing parameter:{transaction_id}", config->sn, http_packet); return; } cJSON *valueSet = cJSON_GetObjectItem(root, "valueSet"); if(!valueSet) { debug(LOG_ERR, "Get valueSet faild[%s]", cJSON_GetErrorPtr()); create_http_json(valueSetObj, transaction_id->valuestring, RESPONSE, SETCONFIGURATIONS, "failed", "3", "Missing parameter:{valueSet}", config->sn, http_packet); return; } /* if((key = cJSON_GetObjectItem(valueSet, "conf_version")) == NULL || (conf_version = key->valuestring) == NULL) { create_http_json(valueSetObj, transaction_id->valuestring, RESPONSE, SETCONFIGURATIONS, "failed", "3", "Missing parameter:{conf_version}", config->sn, http_packet); return; } */ ErrMesg[0]=0; //setDeviceInfo// { if((attribute = cJSON_GetObjectItem(valueSet, "setDeviceInfo")) != NULL) { if((key = cJSON_GetObjectItem(attribute, "apname")) != NULL && key->valuestring != NULL) { /*snprintf(cmd, MAX_BUF, "config apname %s\n", key->valuestring); if(set_config(cmd, result)) strcpy(ErrMesg, result); */ set_apname(key->valuestring, result, sizeof(result)/sizeof(result[0])); } } } //setRadioInfo// { if((attribute = cJSON_GetObjectItem(valueSet, "setRadioInfo")) != NULL) { array_size = cJSON_GetArraySize(attribute); debug(LOG_DEBUG, "Array size of paras is %d",array_size); for(i=0; i< array_size; i++) { item = cJSON_GetArrayItem(attribute, i); //debug(LOG_DEBUG, "%s\n",item->valuestring); if((key = cJSON_GetObjectItem(item, "radio_index")) == NULL || (radio_index = radio_keywords[parse_radio_keywords(key->valuestring)].value) == NULL) { create_http_json(valueSetObj, transaction_id->valuestring, RESPONSE, SETCONFIGURATIONS, "failed", "3", "Missing parameter:{radio_index}", config->sn, http_packet); return; } /* if((key = cJSON_GetObjectItem(item, "radio")) != NULL && key->valuestring != NULL) { snprintf(cmd, MAX_BUF, "config interface wlan %s radio %s\n", cJSON_GetObjectItem(item, "radio_index")->valuestring, key->valuestring); if(set_config(cmd, result)) strcpy(ErrMesg, result); //debug(LOG_INFO, "result is %d", strlen(result)); } */ if((key = cJSON_GetObjectItem(item, "mode")) != NULL && key->valuestring != NULL) { /*snprintf(cmd, MAX_BUF, "config interface wlan %s mode %s\n", cJSON_GetObjectItem(item, "radio_index")->valuestring, key->valuestring); if(set_config(cmd, result)) strcpy(ErrMesg, result); */ set_mode(atoi(radio_index), key->valuestring, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } if((key = cJSON_GetObjectItem(item, "power")) != NULL && key->valuestring != NULL) { /* snprintf(cmd, MAX_BUF, "config interface wlan %s power %s\n", cJSON_GetObjectItem(item, "radio_index")->valuestring, key->valuestring); if(set_config(cmd, result)) strcpy(ErrMesg, result); */ set_power(atoi(radio_index), key->valuestring, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } if((key = cJSON_GetObjectItem(item, "channel")) != NULL && key->valuestring != NULL) { /* snprintf(cmd, MAX_BUF, "config interface wlan %s channel %s\n", cJSON_GetObjectItem(item, "radio_index")->valuestring, key->valuestring); if(set_config(cmd, result)) strcpy(ErrMesg, result); */ set_channel(atoi(radio_index), key->valuestring, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } if((key = cJSON_GetObjectItem(item, "channelwidth")) != NULL && key->valuestring != NULL) { /* snprintf(cmd, MAX_BUF, "config interface wlan %s channelwidth %s\n", cJSON_GetObjectItem(item, "radio_index")->valuestring, key->valuestring); if(set_config(cmd, result)) strcpy(ErrMesg, result); */ set_channelwidth(atoi(radio_index), key->valuestring, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } if((key = cJSON_GetObjectItem(item, "max-wireless-clients")) != NULL && key->valuestring != NULL) { /* snprintf(cmd, MAX_BUF, "config interface wlan %s max-wireless-clients %s\n", cJSON_GetObjectItem(item, "radio_index")->valuestring, key->valuestring); if(set_config(cmd, result)) strcpy(ErrMesg, result); */ set_max_assoc(atoi(radio_index), key->valuestring, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } if((key = cJSON_GetObjectItem(item, "client-isolation")) != NULL && key->valuestring != NULL) { /* snprintf(cmd, MAX_BUF, "config interface wlan %s client-isolation %s\n", cJSON_GetObjectItem(item, "radio_index")->valuestring, key->valuestring); if(set_config(cmd, result)) strcpy(ErrMesg, result); */ set_ap_isolate(atoi(radio_index), key->valuestring, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } /* if((key = cJSON_GetObjectItem(item, "rate")) != NULL && key->valuestring != NULL) { snprintf(cmd, MAX_BUF, "config interface wlan %s rate %s\n", cJSON_GetObjectItem(item, "radio_index")->valuestring, key->valuestring); if(set_config(cmd, result)) strcpy(ErrMesg, result); } */ } } } //setSSIDInfo// { if((attribute = cJSON_GetObjectItem(valueSet, "setSSIDInfo")) != NULL) { array_size = cJSON_GetArraySize(attribute); debug(LOG_DEBUG, "Array size of paras is %d",array_size); for(i=0; i< array_size; i++) { item = cJSON_GetArrayItem(attribute, i); if((key = cJSON_GetObjectItem(item, "radio_index")) == NULL || (radio_index = radio_keywords[parse_radio_keywords(key->valuestring)].value) == NULL) { create_http_json(valueSetObj, transaction_id->valuestring, RESPONSE, SETCONFIGURATIONS, "failed", "3", "Missing parameter:{radio_index}", config->sn, http_packet); return; } if((key = cJSON_GetObjectItem(item, "profile_index")) == NULL || (profile_index = key->valuestring) == NULL) { create_http_json(valueSetObj, transaction_id->valuestring, RESPONSE, SETCONFIGURATIONS, "failed", "3", "Missing parameter:{profile_index}", config->sn, http_packet); return; } if((key = cJSON_GetObjectItem(item, "status")) == NULL || (status = key->valuestring) == NULL) { create_http_json(valueSetObj, transaction_id->valuestring, RESPONSE, SETCONFIGURATIONS, "failed", "3", "Missing parameter:{status}", config->sn, http_packet); return; } if(atoi(profile_index)>0) { char vifs[128]; char viname[32]; sprintf(viname, "wl%d.%d", atoi(radio_index), atoi(profile_index)); read_vifs(atoi(radio_index), vifs, sizeof(vifs)/sizeof(vifs[0])); if(strstr(vifs, viname) && atoi(status)==0) { del_virtual_interface(atoi(radio_index), atoi(profile_index)); } else if(!strstr(vifs, viname) && atoi(status)==1) { add_virtual_interface(atoi(radio_index), atoi(profile_index)); } else if((!strstr(vifs, viname) && atoi(status)==0) || atoi(profile_index)>3) { continue; } } if((key = cJSON_GetObjectItem(item, "hide-network-name")) != NULL && key->valuestring != NULL) { set_status(atoi(radio_index), atoi(profile_index), key->valuestring, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } if((key = cJSON_GetObjectItem(item, "ssid")) != NULL && key->valuestring != NULL) { set_ssid(atoi(radio_index), atoi(profile_index), key->valuestring, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } if((key = cJSON_GetObjectItem(item, "authentication")) != NULL && key->valuestring != NULL) { set_security_mode(atoi(radio_index), atoi(profile_index), authentication_keywords[parse_authentication_keywords(key->valuestring)].value, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } if((key = cJSON_GetObjectItem(item, "encryption")) != NULL && key->valuestring != NULL) { set_crypto(atoi(radio_index), atoi(profile_index), encryption_keywords[parse_encryption_keywords(key->valuestring)].value, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } if((key = cJSON_GetObjectItem(item, "presharedkey")) != NULL && key->valuestring != NULL) { set_wpa_psk(atoi(radio_index), atoi(profile_index), key->valuestring, result, sizeof(result)/sizeof(result[0])); strcpy(ErrMesg, result); } flag =1; } } } { //apply_setting(); /* int result; pthread_t tid_init_service = 0; config->upgrade_lock = 1; debug(LOG_INFO, "create a new thread (thread_init_service)"); result = pthread_create(&tid_init_service, NULL, (void *)thread_init_service, NULL); if (result != 0) { debug(LOG_ERR, "FATAL: Failed to create a new thread (init_service) - exiting"); exit(1); }*/ system("nvram commit"); } if(strlen(ErrMesg)) { create_http_json(valueSetObj, transaction_id->valuestring, RESPONSE, SETCONFIGURATIONS, "failed", "1000", ErrMesg, config->sn, http_packet); } else { create_http_json(valueSetObj, transaction_id->valuestring, RESPONSE, SETCONFIGURATIONS, "success", "0", NULL, config->sn, http_packet); } if(flag) { safe_encrypt_http_send(config->httpfd, http_packet, strlen(http_packet), 0); shutdown(config->httpfd, SHUT_RDWR); system("reboot"); } }
int set_wlan_basic(int radio) { int vap_enable; int radio_nvram_enable; int i; int vap_num; int wlan_mode = -1; nvram_get_radio_status(radio, &radio_nvram_enable); nvram_get_wlan_mode(radio, &wlan_mode); if(RADIO_DOWN == radio_nvram_enable) { //Kill all the security daemon first // if(WLAN_MODE_AP == wlan_mode) // { radio_up_down(radio, RADIO_DOWN, wlan_mode); kill_all_authentication_daemon(radio, wlan_mode); //wds for(i=0;i<WDS_VAP_NUM;i++) { set_ap_wds_down(radio, i); } // } // else if(WLAN_MODE_STA == wlan_mode) // { // kill_all_authentication_daemon(radio, wlan_mode); // radio_up_down(radio, RADIO_DOWN, wlan_mode); // } return T_SUCCESS; } // if(WLAN_MODE_AP == wlan_mode) // { //Down all the VAPs first radio_up_down(radio, RADIO_DOWN, wlan_mode); //wds for(i=0;i<WDS_VAP_NUM;i++) { set_ap_wds_down(radio, i); } //Kill all the security daemon first kill_all_authentication_daemon(radio, wlan_mode); // } // else if(WLAN_MODE_STA == wlan_mode) // { //Kill all the security daemon first // kill_all_authentication_daemon(radio, wlan_mode); //Down all the VAPs first // radio_up_down(radio, RADIO_DOWN, wlan_mode); // } /*net mode and channel*/ set_ap_wirelessmode_channel(radio); /*ap isolation*/ vap_num = nvram_get_vap_num(radio); //for(i=1; i < vap_num; i++) for(i=0; i < vap_num; i++) { nvram_get_vap_status(radio, i, &vap_enable); if(VAP_ENABLE == vap_enable) { set_ssid(radio, WLAN_MODE_AP, i);//add by frank set_acl(radio, i); //set_enable_ssid(radio, WLAN_MODE_AP, i); set_hidden_ssid(radio, WLAN_MODE_AP, i);//add by frank set_bss_isolation(radio, WLAN_MODE_AP, i);//add by frank set_ap_security(radio, i); #if defined(VLAN_ENABLE) //Deleted by Mario Huang //set_wlan_vlan(radio,i); //preserve 3 seconds for main VAP #endif if(0==i) { sleep(3); } } else if(VAP_DISABLE == vap_enable) { //set_disable_ssid(radio, WLAN_MODE_AP, i); //vap_up_down(radio, i, WLAN_MODE_AP, VAP_DOWN); } } set_ap_isolation(radio);//add by frank, impl on 2014-02-17 //Deleted by Mario Huang 2014-08-12 //set_ap_wmm(radio, 0); //Added by Mario Huang for VLAN test #if defined(VLAN_ENABLE) updateVlan(); #endif //wds for(i=0;i<WDS_VAP_NUM;i++) { set_ap_wds_up(radio, i); } return T_SUCCESS; }
/* Given the tagged parameter sets from a beacon packet, locate the AP's SSID and return its current channel number */ int parse_beacon_tags(const unsigned char *packet, size_t len) { set_vendor(0, "\0\0\0"); char *ssid = NULL; const unsigned char *tag_data = NULL; unsigned char *ie = NULL, *channel_data = NULL; size_t ie_len = 0, ie_offset = 0, tag_len = 0, tag_offset = 0; int channel = 0; struct radio_tap_header *rt_header = NULL; rt_header = (struct radio_tap_header *) radio_header(packet, len); tag_offset = end_le16toh(rt_header->len) + sizeof(struct dot11_frame_header) + sizeof(struct beacon_management_frame); if(tag_offset < len) { tag_len = (len - tag_offset); /* this actually denotes length of the entire tag data area */ tag_data = (const unsigned char *) (packet + tag_offset); /* If no SSID was manually specified, parse and save the AP SSID */ if(get_ssid() == NULL) { ie = parse_ie_data(tag_data, tag_len, (uint8_t) SSID_TAG_NUMBER, &ie_len, &ie_offset); if(ie) { /* Return data is not null terminated; allocate ie_len+1 and memcpy string */ ssid = malloc(ie_len+1); if(ssid) { memset(ssid, 0, (ie_len+1)); memcpy(ssid, ie, ie_len); set_ssid(ssid); free(ssid); } free(ie); } } ie = parse_ie_data(tag_data, tag_len, HT_CAPS_TAG_NUMBER, &ie_len, &ie_offset); if(ie) { set_ap_htcaps(ie, ie_len); free(ie); } ie = parse_ie_data(tag_data, tag_len, (uint8_t) RATES_TAG_NUMBER, &ie_len, &ie_offset); if(ie) { set_ap_rates(ie, ie_len); free(ie); } ie = parse_ie_data(tag_data, tag_len, (uint8_t) ERATES_TAG_NUMBER, &ie_len, &ie_offset); if(ie) { set_ap_ext_rates(ie, ie_len); free(ie); } channel_data = parse_ie_data(tag_data, tag_len, (uint8_t) CHANNEL_TAG_NUMBER, &ie_len, &ie_offset); if(channel_data) { if(ie_len == 1) { channel = *(uint8_t*)channel_data; } free(channel_data); } size_t ie_iterator = 0; do { const unsigned char *tag = tag_data + ie_iterator; // check for the length of the tag, and that its not microsoft if(tag[0] == VENDOR_SPECIFIC_TAG && ie_iterator+2+3 < tag_len && ((tag[1] < 11 && memcmp(tag+2, "\x00\x14\x6c", 3) && memcmp(tag+2, "\x00\x50\xf2", 3)) || (tag[1] == 30 && !(memcmp(tag+2, "\x00\x26\x86", 3))))) { set_vendor(1, tag + 2); break; } } while(get_next_ie(tag_data, tag_len, &ie_iterator)); } return channel; }