int AJ_Main(void) { #ifdef AJ_CONFIGURE_WIFI_UPON_START # error This sample cannot be built with AJ_CONFIGURE_WIFI_UPON_START defined #endif AJ_Status status = AJ_OK; AJ_BusAttachment bus; int32_t dhcp_attempts = 5; /* * One time initialization before calling any other AllJoyn APIs */ AJ_Initialize(); AJ_PrintXML(AppObjects); AJ_RegisterObjects(AppObjects, NULL); SetBusAuthPwdCallback(MyBusAuthPwdCB); // Windows, Linux and Arduino are already connected to the network when we get to this point. #if !(defined(ARDUINO) || defined(__linux) || defined(_WIN32) || defined(__MACH__)) #define AJ_DHCP_TIMEOUT 10000 // Step 1: connect to a WIFI network. // This will also attempt to acquire an IP from DHCP status = AJ_ConnectWiFi(ssid, secType, AJ_WIFI_CIPHER_CCMP, passphrase); // if DHCP timed out, try it again for up to five attempts while (status == AJ_ERR_TIMEOUT && --dhcp_attempts) { uint32_t ip, mask, gw; status = AJ_AcquireIPAddress(&ip, &mask, &gw, AJ_DHCP_TIMEOUT); if (status != AJ_OK) { AJ_ErrPrintf(("AJ_Net_Up(): AJ_AcquireIPAddress Failed\n")); } } if (status != AJ_OK) { printf("Unable to connect to wifi and acquire IP\n"); return status; } #endif //Now we need to find a daemon, connect to it and authenticate // see the ConnectToBus for an explanation. status = ConnectToBus(&bus); AJ_Sleep(10000); AJ_Disconnect(&bus); return status; }
static AJ_Status DoConnectWifi(AJOBS_Info* connectInfo) { AJ_Status status = AJ_OK; AJ_WiFiSecurityType secType = AJ_WIFI_SECURITY_NONE; AJ_WiFiCipherType cipherType = AJ_WIFI_CIPHER_NONE; AJOBS_AuthType fallback = AJOBS_AUTH_TYPE_OPEN; AJOBS_AuthType fallbackUntil = AJOBS_AUTH_TYPE_OPEN; uint8_t retries = 0; AJ_WiFiConnectState wifiConnectState; AJ_InfoPrintf(("Attempting to connect to %s with passcode=%s and auth=%d\n", connectInfo->ssid, connectInfo->pc, connectInfo->authType)); switch (connectInfo->authType) { case AJOBS_AUTH_TYPE_ANY: if (strlen(connectInfo->pc) == 0) { break; } fallback = AJOBS_AUTH_TYPE_WPA2_CCMP; fallbackUntil = AJOBS_AUTH_TYPE_OPEN; break; case AJOBS_AUTH_TYPE_WPA_AUTO: if (strlen(connectInfo->pc) == 0) { break; } fallback = AJOBS_AUTH_TYPE_WPA_CCMP; fallbackUntil = AJOBS_AUTH_TYPE_WPA_TKIP; break; case AJOBS_AUTH_TYPE_WPA2_AUTO: if (strlen(connectInfo->pc) == 0) { break; } fallback = AJOBS_AUTH_TYPE_WPA2_CCMP; fallbackUntil = AJOBS_AUTH_TYPE_WPA2_TKIP; break; default: fallback = connectInfo->authType; } secType = GetSecType(fallback); cipherType = GetCipherType(fallback); AJ_InfoPrintf(("Trying to connect with auth=%d (secType=%d, cipherType=%d)\n", fallback, secType, cipherType)); while (1) { if (connectInfo->state == AJOBS_STATE_CONFIGURED_NOT_VALIDATED) { connectInfo->state = AJOBS_STATE_CONFIGURED_VALIDATING; } uint8_t raw[(AJOBS_PASSCODE_MAX_LENGTH / 2) + 1]; char* password = connectInfo->pc; if (AJ_WIFI_CIPHER_WEP != cipherType) { size_t hexLen = strlen(connectInfo->pc); AJ_HexToRaw(connectInfo->pc, hexLen, raw, (AJOBS_PASSCODE_MAX_LENGTH / 2) + 1); password = (char*)raw; password[hexLen / 2] = '\0'; } status = AJ_ConnectWiFi(connectInfo->ssid, secType, cipherType, password); AJ_InfoPrintf(("AJ_ConnectWifi returned %s\n", AJ_StatusText(status))); wifiConnectState = AJ_GetWifiConnectState(); // Set last error and state if ((status == AJ_OK) /* (wifiConnectState == AJ_WIFI_CONNECT_OK)*/) { obLastError.code = AJOBS_STATE_LAST_ERROR_VALIDATED; obLastError.message[0] = '\0'; obState = AJOBS_STATE_CONFIGURED_VALIDATED; connectInfo->authType = fallback; } else if ((status == AJ_ERR_CONNECT) /* (wifiConnectState == AJ_WIFI_CONNECT_FAILED)*/) { obLastError.code = AJOBS_STATE_LAST_ERROR_UNREACHABLE; strncpy(obLastError.message, "Network unreachable!", AJOBS_ERROR_MESSAGE_LEN); if (connectInfo->state == AJOBS_STATE_CONFIGURED_VALIDATED || connectInfo->state == AJOBS_STATE_CONFIGURED_RETRY) { obState = AJOBS_STATE_CONFIGURED_RETRY; } else { obState = AJOBS_STATE_CONFIGURED_ERROR; } } else if ((status == AJ_ERR_SECURITY) /* (wifiConnectState == AJ_WIFI_AUTH_FAILED)*/) { obLastError.code = AJOBS_STATE_LAST_ERROR_UNAUTHORIZED; strncpy(obLastError.message, "Authorization failed!", AJOBS_ERROR_MESSAGE_LEN); if (connectInfo->state == AJOBS_STATE_CONFIGURED_VALIDATED || connectInfo->state == AJOBS_STATE_CONFIGURED_RETRY) { obState = AJOBS_STATE_CONFIGURED_RETRY; } else { obState = AJOBS_STATE_CONFIGURED_ERROR; } } else if (status == AJ_ERR_DRIVER) { obLastError.code = AJOBS_STATE_LAST_ERROR_ERROR_MESSAGE; strncpy(obLastError.message, "Driver error", AJOBS_ERROR_MESSAGE_LEN); obState = AJOBS_STATE_CONFIGURED_ERROR; } else if (status == AJ_ERR_DHCP) { obLastError.code = AJOBS_STATE_LAST_ERROR_ERROR_MESSAGE; strncpy(obLastError.message, "Failed to establish IP!", AJOBS_ERROR_MESSAGE_LEN); if (connectInfo->state == AJOBS_STATE_CONFIGURED_VALIDATED || connectInfo->state == AJOBS_STATE_CONFIGURED_RETRY) { obState = AJOBS_STATE_CONFIGURED_RETRY; } else { obState = AJOBS_STATE_CONFIGURED_ERROR; } } else { obLastError.code = AJOBS_STATE_LAST_ERROR_ERROR_MESSAGE; strncpy(obLastError.message, "Failed to connect! Unexpected error", AJOBS_ERROR_MESSAGE_LEN); obState = AJOBS_STATE_CONFIGURED_ERROR; } if (obState == AJOBS_STATE_CONFIGURED_VALIDATED) { break; } AJ_WarnPrintf(("Warning - DoConnectWifi wifiConnectState = %s\n", AJ_WiFiConnectStateText(wifiConnectState))); AJ_WarnPrintf(("Last error set to \"%s\" (code=%d)\n", obLastError.message, obLastError.code)); if (obState == AJOBS_STATE_CONFIGURED_ERROR || obState == AJOBS_STATE_CONFIGURED_RETRY) { if (retries++ >= obSettings->AJOBS_MAX_RETRIES) { if (obState == AJOBS_STATE_CONFIGURED_ERROR && connectInfo->state == AJOBS_STATE_CONFIGURED_VALIDATING) { if (connectInfo->authType < 0 && fallback > fallbackUntil) { obLastError.code = AJOBS_STATE_LAST_ERROR_UNSUPPORTED_PROTOCOL; strncpy(obLastError.message, "Unsupported protocol", AJOBS_ERROR_MESSAGE_LEN); fallback--; // Try next authentication protocol secType = GetSecType(fallback); cipherType = GetCipherType(fallback); retries = 0; AJ_InfoPrintf(("Trying to connect with fallback auth=%d (secType=%d, cipherType=%d)\n", fallback, secType, cipherType)); continue; } } break; } AJ_InfoPrintf(("Retry number %d out of %d\n", retries, obSettings->AJOBS_MAX_RETRIES)); } } connectInfo->state = obState; status = (*obWriteInfo)(connectInfo); return status; }
void AJ_Main(void) { uint8_t i = 0; AJ_Status status = AJ_ERR_FAILURE; /* the glass is half-empty */ AJ_BusAttachment bus; /* these variables are used when kicking off DHCP */ uint32_t current_ip_address = 0; uint32_t current_subnet_mask = 0; uint32_t current_default_gateway = 0; AJ_Time dhcpTimer; uint32_t timeTakenForDhcp = 0; AJ_Initialize(); AJ_Printf("\nAllJoyn Release: %s\n\n", AJ_GetVersion()); AJ_Printf("INFO: The parameter RUN_NEGATIVE_TESTS is %s\n", (RUN_NEGATIVE_TESTS ? "true" : "false")); AJ_Printf("INFO: The parameter DELAY_BETWEEN_SCANS is %u ms\n", DELAY_BETWEEN_SCANS); AJ_Printf("INFO: The parameter DELAY_BETWEEN_ASSOCIATIONS is %u ms\n", DELAY_BETWEEN_ASSOCIATIONS); AJ_Printf("INFO: The parameter DHCP_TIMEOUT is %u ms\n", DHCP_TIMEOUT); AJ_Printf("INFO: The parameter DISCOVER_TIMEOUT is %u ms\n", DISCOVER_TIMEOUT); /* reset the wifi to start with a clean slate */ status = AJ_ResetWiFi(); if (AJ_OK != status) { AJ_Printf("WARN: AJ_ResetWiFi returned %s (code: %u).\n", AJ_StatusText(status), status); } /* * Repeatedly do the following: * a. scan for access points in the vicinity * b. For each open access point in the returned results: * i. associate using AJ_ConnectWiFi * ii. acquire an ip address using AJ_AcquireIPAddress * iii. perform a short-lived discovery on some random node prefix * using AJ_FindBusAndConnect * iv. disassociate using AJ_DisconnectWiFi * c. For each secured access point in the returned results: * i. Connect to it with intentionally incorrect parameters * (Negative test) */ while (TRUE) { AJ_RandBytes(¤tContext, sizeof(currentContext)); uint8_t currentMaxAps = 0; AJ_RandBytes(¤tMaxAps, sizeof(currentMaxAps)); /* Reset numValidScanEntries, before every scan attempt. */ numValidScanEntries = 0; status = AJ_WiFiScan((void*) (sentinelForWifiScanContext + currentContext), wifiScanResultCallback, currentMaxAps); if (AJ_OK != status) { if (AJ_ERR_FAILURE == status && 0 != currentMaxAps) { scanStats.numFailed++; } else if (AJ_ERR_RESOURCES == status) { scanStats.numFailed++; } AJ_Printf("Failed to scan: %s (code: %u)\n", AJ_StatusText(status), status); /* No point in attempting to do wifi operations, when scan failed */ continue; } else { /* * A success was returned from AJ_WiFiScan. Were any results * returned after all?? */ if (0 < numValidScanEntries) { scanStats.numSuccessful++; } else { AJ_Printf("WARN: AJ_WiFiScan returned %s (code: %u), but returned ZERO scan results...\n", AJ_StatusText(status), status); scanStats.numFailed++; /* When num of scan results is zero, there is nothing to do */ continue; } } /* numValidScanEntries is an index into the array. Hence +1. */ if (currentMaxAps < numValidScanEntries + 1) { AJ_Printf("WARN: Scan returned more results (%u) than requested (%u).\n", numValidScanEntries + 1, currentMaxAps); } else { AJ_Printf("Wifi scan successful (got %u results).\n", numValidScanEntries); } for (i = 0; i < numValidScanEntries; i++) { if (AJ_WIFI_SECURITY_NONE != wifiScanInfo[i].secType) { /* On some targets, it is not possible to check for 802.11 * authentication failure when security type is WEP. * Hence, run negative tests only for WPA/WPA2-based APs. */ if (RUN_NEGATIVE_TESTS && AJ_WIFI_SECURITY_WEP != wifiScanInfo[i].secType) { /* Run a negative test for wifi association */ AJ_Printf("RUN (negative test): Attempting to associate with %s using a randomly generated passphrase...", wifiScanInfo[i].ssid); char random_passphrase[128 + 1]; AJ_RandHex(random_passphrase, sizeof(random_passphrase), (sizeof(random_passphrase) - 1) / 2); /* Set a random passphrase length based on security type */ uint8_t randomPassphraseLen = 0; /* WPA / WPA2 - assuming min len is 8 and max is 64 */ AJ_RandBytes(&randomPassphraseLen, sizeof(randomPassphraseLen)); randomPassphraseLen = 8 + randomPassphraseLen % (64 - 8 + 1); random_passphrase[randomPassphraseLen] = '\0'; status = AJ_ConnectWiFi(wifiScanInfo[i].ssid, wifiScanInfo[i].secType, wifiScanInfo[i].cipherType, random_passphrase); if (AJ_OK == status) { /* negative test failed */ AJ_Printf("FAIL (negative test): Associated with SSID: %s BSSID: %x:%x:%x:%x:%x:%x Security: %s(%s) Passphrase: %s RSSI: %u ...\n", wifiScanInfo[i].ssid, wifiScanInfo[i].bssid[0], wifiScanInfo[i].bssid[1], wifiScanInfo[i].bssid[2], wifiScanInfo[i].bssid[3], wifiScanInfo[i].bssid[4], wifiScanInfo[i].bssid[5], secStr[wifiScanInfo[i].secType], ciphStr[wifiScanInfo[i].cipherType], random_passphrase, wifiScanInfo[i].rssi); /* negative test failed - don't go any further */ AJ_ASSERT(0); } else { AJ_Printf("Done (negative test).\n"); } status = AJ_DisconnectWiFi(); AJ_Sleep(DELAY_BETWEEN_ASSOCIATIONS); } continue; } else { AJ_Printf("Attempting to associate with SSID: %s BSSID: %x:%x:%x:%x:%x:%x Security: %s(%s) RSSI: %u ...\n", wifiScanInfo[i].ssid, wifiScanInfo[i].bssid[0], wifiScanInfo[i].bssid[1], wifiScanInfo[i].bssid[2], wifiScanInfo[i].bssid[3], wifiScanInfo[i].bssid[4], wifiScanInfo[i].bssid[5], secStr[wifiScanInfo[i].secType], ciphStr[wifiScanInfo[i].cipherType], wifiScanInfo[i].rssi); status = AJ_ConnectWiFi(wifiScanInfo[i].ssid, wifiScanInfo[i].secType, wifiScanInfo[i].cipherType, ""); if (AJ_OK != status) { associationStats.numFailed++; AJ_Printf("Failed to associate : %s (code: %u)\n", AJ_StatusText(status), status); /* * No point in proceeding any further when WiFi association * has failed */ continue; } else { associationStats.numSuccessful++; } AJ_Printf("Successfully associated. Attempting to get IP Address via DHCP...\n"); AJ_InitTimer(&dhcpTimer); status = AJ_AcquireIPAddress(¤t_ip_address, ¤t_subnet_mask, ¤t_default_gateway, DHCP_TIMEOUT); timeTakenForDhcp = AJ_GetElapsedTime(&dhcpTimer, FALSE); if (AJ_OK != status) { if (AJ_ERR_TIMEOUT == status) { dhcpStats.numTimedout++; AJ_Printf("Timedout (%u ms) while trying to get IP Address via DHCP\n", timeTakenForDhcp); /* * Discovery timed out. * Check whether the API returned in a timely manner. * See whether the actual duration is off by +/- 500ms. * Delay beyond that is unusual. */ if (500 < abs(DHCP_TIMEOUT - timeTakenForDhcp)) { AJ_Printf("WARN: AJ_AcquireIPAddress API did not return in a timely manner. Timeout parameter: %u Actual time elapsed: %u\n", DHCP_TIMEOUT, timeTakenForDhcp); } } else { dhcpStats.numFailed++; AJ_Printf("Failed to get IP Address via DHCP : %s (code: %u)\n", AJ_StatusText(status), status); } /* * No point in proceeding any further when IP address was * not acquired */ continue; } else { dhcpStats.numSuccessful++; AJ_Printf("Successfully obtained\n"); AJ_Printf("\tIP Addresss : %s\n", TestAddrStr(current_ip_address)); AJ_Printf("\tSubnet Mask : %s\n", TestAddrStr(current_subnet_mask)); AJ_Printf("\tDefault Gateway: %s\n", TestAddrStr(current_default_gateway)); } /* Generate a random name using routingNodePrefix */ char currentRoutingNodeName[32 + 1]; strncpy(currentRoutingNodeName, routingNodePrefix, sizeof(routingNodePrefix)); AJ_RandHex(currentRoutingNodeName + strlen(routingNodePrefix), sizeof(currentRoutingNodeName) - sizeof(routingNodePrefix), (sizeof(currentRoutingNodeName) - sizeof(routingNodePrefix) - 1) / 2); currentRoutingNodeName[32] = '\0'; /* just to be safe */ AJ_Printf("Attempting to discover routing node: %s...", currentRoutingNodeName); status = AJ_FindBusAndConnect(&bus, currentRoutingNodeName, DISCOVER_TIMEOUT); if (AJ_ERR_TIMEOUT == status) { /* this is the expected result */ discoverStats.numTimedout++; AJ_Printf("Done (discovery of routing node).\n"); } else if (AJ_OK != status) { discoverStats.numFailed++; AJ_Printf("Failed to connect to routing node: %s (code: %u)\n", AJ_StatusText(status), status); } else if (AJ_OK == status) { /* * the test attempted to discovery a randomly generated * routing node prefix and it worked - highly unlikely event */ AJ_Printf("FATAL: Was able to discover and connect to routing node with prefix %s. Got unique address %s.", currentRoutingNodeName, AJ_GetUniqueName(&bus)); AJ_ASSERT(0); } status = AJ_DisconnectWiFi(); if (AJ_OK != status) { disassociationStats.numFailed++; AJ_Printf("Failed to disassociate: %s (code: %u)\n", AJ_StatusText(status), status); } else { disassociationStats.numSuccessful++; AJ_Printf("Disassociated from access point. "); } AJ_Sleep(DELAY_BETWEEN_ASSOCIATIONS); } } PrintStats(); AJ_Sleep(DELAY_BETWEEN_SCANS); } }
AJ_Status ConfigureWifi() { if (AJ_ResetWiFi() == AJ_OK) { return AJ_ConnectWiFi("Teleperse", 0, 0, "sg15gu25"); } return AJ_ERR_NULL; }