| /* |
| * |
| * Copyright (c) 2014-2017 Nest Labs, Inc. |
| * All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @file |
| * This file implements an application that is intended to be a |
| * comprehensive tester for all aspects of Weave Data Management |
| * (WDM) that one can test in standalone mode. As such, it tests |
| * data structures, subsystems and networked behaviors. The |
| * latter requires a mock device acting as a WDM server and using |
| * the same test profile. |
| * |
| */ |
| |
| #define __STDC_FORMAT_MACROS |
| #include <inttypes.h> |
| |
| #include <assert.h> |
| |
| // This code tests the legacy version of Weave Data Management |
| #define WEAVE_CONFIG_DATA_MANAGEMENT_NAMESPACE kWeaveManagedNamespace_Legacy |
| |
| #include "ToolCommon.h" |
| #include <Weave/Profiles/ProfileCommon.h> |
| #include <Weave/Profiles/data-management/DataManagement.h> |
| #include <Weave/Profiles/data-management/ProfileDatabase.h> |
| #include "TestProfile.h" |
| |
| using namespace ::nl::Inet; |
| using namespace ::nl::Weave; |
| using namespace ::nl::Weave::TLV; |
| using namespace ::nl::Weave::Profiles; |
| using namespace ::nl::Weave::Profiles::Common; |
| using namespace ::nl::Weave::Profiles::DataManagement; |
| using namespace ::nl::Weave::Profiles::StatusReporting; |
| |
| #define TOOL_NAME "TestDataManagement" |
| |
| static bool HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg); |
| static bool HandleNonOptionArgs(const char *progName, int argc, char *argv[]); |
| static void HandleConnectionReceived(WeaveMessageLayer *msgLayer, WeaveConnection *con); |
| static void HandleSecureSessionEstablished(WeaveSecurityManager *sm, WeaveConnection *con, void *reqState, uint16_t sessionKeyId, uint64_t peerNodeId, uint8_t encType); |
| static void HandleSecureSessionError(WeaveSecurityManager *sm, WeaveConnection *con, void *reqState, WEAVE_ERROR localErr, uint64_t peerNodeId, StatusReport *statusReport); |
| static void HandleConnectionClosed(WeaveConnection *con, WEAVE_ERROR conErr); |
| // static void HandleConnectionComplete(WeaveConnection *con, WEAVE_ERROR conErr); |
| |
| uint64_t DestNodeId; |
| IPAddress DestAddr = IPAddress::Any; // TODO BUG: This isn't used anywhere, despite being settable from the command-line. |
| bool Debug = false; |
| |
| /* |
| * in some circumstances we may want to use multiple clients and then |
| * we have to count them to know when we're done. |
| */ |
| |
| uint8_t gClientCount = 1; |
| uint8_t gClientCounter = 0; |
| int gCyclingCnt = 32; |
| |
| static OptionDef gToolOptionDefs[] = |
| { |
| { "dest-addr", kArgumentRequired, 'D' }, |
| { "cycling-cnt", kArgumentRequired, 'c' }, |
| #if WEAVE_CONFIG_SECURITY_TEST_MODE |
| { "allow-dups", kNoArgument, 'A' }, |
| #endif |
| { NULL } |
| }; |
| |
| static const char *gToolOptionHelp = |
| " -D, --dest-addr <dest-node-ip-addr>\n" |
| " Send weave messages to a specific IPv4/IPv6 address rather than one\n" |
| " derived the destination node id.\n" |
| "\n" |
| " -c, --cycling-cnt <num>" |
| " The count of the cycling test\n" |
| "\n" |
| #if WEAVE_CONFIG_SECURITY_TEST_MODE |
| " -A, --allow-dups\n" |
| " Allow reception of duplicate messages.\n" |
| "\n" |
| #endif |
| ""; |
| |
| static OptionSet gToolOptions = |
| { |
| HandleOption, |
| gToolOptionDefs, |
| "GENERAL OPTIONS", |
| gToolOptionHelp |
| }; |
| |
| static HelpOptions gHelpOptions( |
| TOOL_NAME, |
| "Usage: " TOOL_NAME " [<options...>] [<dest-node-id>]\n", |
| WEAVE_VERSION_STRING "\n" WEAVE_TOOL_COPYRIGHT |
| ); |
| |
| static OptionSet *gToolOptionSets[] = |
| { |
| &gToolOptions, |
| &gNetworkOptions, |
| &gWeaveNodeOptions, |
| &gFaultInjectionOptions, |
| &gHelpOptions, |
| NULL |
| }; |
| |
| #define EnterTest(_name_, _errName_) \ |
| WEAVE_ERROR _errName_ = ( \ |
| printf("\n\n" \ |
| _name_ \ |
| "---\n"), \ |
| WEAVE_NO_ERROR \ |
| ) |
| |
| #define DriveTest(_done_) \ |
| do { \ |
| while (!(_done_)) \ |
| { \ |
| struct timeval sleepTime; \ |
| sleepTime.tv_sec = 0; \ |
| sleepTime.tv_usec = 100000; \ |
| ServiceNetwork(sleepTime); \ |
| } \ |
| } while (0) |
| |
| #define ExitTest(_err_) \ |
| do { \ |
| if ((_err_) == WEAVE_NO_ERROR) \ |
| printf("Success\n"); \ |
| else \ |
| { \ |
| printf("error: %s\n", ErrorStr(_err_)); \ |
| exit(-1); \ |
| } \ |
| } while (0) |
| |
| WEAVE_ERROR ValidatePath(TLVReader &aReader, |
| const uint64_t &aTag, |
| uint32_t aProfileId, |
| const uint64_t &aInstanceId, |
| uint16_t aPathLen, |
| ...) |
| { |
| WEAVE_ERROR err; |
| |
| va_list pathTags; |
| |
| TLVType pathContainer; |
| TLVType profileContainer; |
| |
| uint32_t profileId; |
| uint64_t instanceId = kInstanceIdNotSpecified; |
| |
| // This following line must be executed before the execution flow could possibly reach the exit label, |
| // for we call va_end at there unconditionally. |
| va_start(pathTags, aPathLen); |
| |
| VerifyOrExit((aReader.GetType() == kTLVType_Path), err = WEAVE_ERROR_WRONG_TLV_TYPE); |
| |
| err = ValidateWDMTag(aTag, aReader); |
| SuccessOrExit(err); |
| |
| err = aReader.EnterContainer(pathContainer); |
| SuccessOrExit(err); |
| |
| /* |
| * the first element of a path under WDM should be a structure |
| * with 2 elements, one of which (the instance) is optional. |
| */ |
| |
| err = aReader.Next(); |
| SuccessOrExit(err); |
| |
| VerifyOrExit(aReader.GetType() == kTLVType_Structure, err = WEAVE_ERROR_UNEXPECTED_TLV_ELEMENT); |
| |
| err = ValidateWDMTag(kTag_WDMPathProfile, aReader); |
| SuccessOrExit(err); |
| |
| /* |
| * check the path profile and instance |
| */ |
| |
| err = aReader.EnterContainer(profileContainer); |
| SuccessOrExit(err); |
| |
| /* |
| * the first element here should be a profile ID |
| */ |
| |
| err = aReader.Next(); |
| SuccessOrExit(err); |
| |
| err = ValidateWDMTag(kTag_WDMPathProfileId, aReader); |
| SuccessOrExit(err); |
| |
| err = aReader.Get(profileId); |
| SuccessOrExit(err); |
| |
| VerifyOrExit(profileId == aProfileId, err = WEAVE_ERROR_INVALID_PROFILE_ID); |
| |
| /* |
| * and the second may be an instance |
| */ |
| |
| err = aReader.Next(); |
| |
| if (err != WEAVE_END_OF_TLV) |
| { |
| err = ValidateWDMTag(kTag_WDMPathProfileInstance, aReader); |
| SuccessOrExit(err); |
| |
| err = aReader.Get(instanceId); |
| SuccessOrExit(err); |
| } |
| |
| VerifyOrExit(instanceId == aInstanceId, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| err = aReader.ExitContainer(profileContainer); |
| SuccessOrExit(err); |
| |
| // now, the residual path elements, if any |
| |
| for (int i = 0; i < aPathLen; i++) |
| { |
| err = aReader.Next(); |
| SuccessOrExit(err); |
| |
| if (err == WEAVE_NO_ERROR) |
| { |
| if (aReader.GetTag() != va_arg(pathTags, uint64_t)) |
| { |
| err = WEAVE_ERROR_INVALID_TLV_TAG; |
| |
| break; |
| } |
| } |
| |
| else |
| { |
| err = WEAVE_ERROR_TLV_UNDERRUN; |
| break; |
| } |
| } |
| |
| /* |
| * again, don't hide the error that caused us to exit behind |
| * the error you might get trying to exit the conmtainer. |
| */ |
| |
| if (err == WEAVE_NO_ERROR) |
| err = aReader.ExitContainer(pathContainer); |
| |
| else |
| aReader.ExitContainer(pathContainer); |
| |
| exit: |
| va_end(pathTags); |
| |
| return err; |
| } |
| |
| /* |
| * one day we might want to include the other form of instance ID |
| * in testing. for now just leave this as a placeholder. |
| */ |
| |
| WEAVE_ERROR ValidatePath(nl::Weave::TLV::TLVReader &aReader, |
| const uint64_t &aTag, |
| uint32_t aProfileId, |
| uint32_t aInstanceIdLen, |
| uint8_t *aInstanceId, |
| uint16_t aPathLen, |
| ...) |
| { |
| return WEAVE_NO_ERROR; |
| } |
| |
| /* |
| * in order to use the "new improved" data management, we have to create |
| * a sub-class of the WDM client and supply the relevant methods as follows. |
| */ |
| |
| class DMTestClient : |
| public DMClient |
| { |
| public: |
| WEAVE_ERROR ViewConfirm(const uint64_t &aResponderId, StatusReport &aStatus, uint16_t aTxnId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| printf("processing: <view confirm - non-success status>\n"); |
| |
| Done = true; |
| |
| return err; |
| } |
| |
| WEAVE_ERROR ViewConfirm(const uint64_t &aResponderId, ReferencedTLVData &aDataList, uint16_t aTxnId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| printf("processing: <view confirm - success status>\n"); |
| |
| err = mDatabase.Store(aDataList); |
| |
| if (err != WEAVE_NO_ERROR) |
| printf("<view confirm> error: %x\n", err); |
| |
| Done = true; |
| |
| return err; |
| } |
| |
| WEAVE_ERROR UpdateConfirm(const uint64_t &aResponderId, StatusReport &aStatus, uint16_t aTxnId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| if (aStatus.success()) |
| printf("processing: <update confirm - success!>\n"); |
| |
| else |
| printf("processing: <update confirm - non-success status>\n"); |
| |
| Done = true; |
| |
| return err; |
| } |
| |
| void IncompleteIndication(const uint64_t &aPeerNodeId, StatusReport &aReport) |
| { |
| printf("processing: <incomplete indication>\n"); |
| } |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| WEAVE_ERROR SubscribeConfirm(const uint64_t &aResponderId, StatusReport &aStatus, uint16_t aTxnId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| printf("processing: <subscribe confirm - non-success status>\n"); |
| |
| gClientCounter++; |
| |
| if (gClientCounter == gClientCount) |
| Done = true; |
| |
| return err; |
| } |
| |
| WEAVE_ERROR SubscribeConfirm(const uint64_t &aResponderId, |
| const TopicIdentifier &aTopicId, |
| uint16_t aTxnId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| printf("processing: <subscribe confirm - success status, no data list>\n"); |
| |
| Done = true; |
| |
| return err; |
| } |
| |
| WEAVE_ERROR SubscribeConfirm(const uint64_t &aResponderId, |
| const TopicIdentifier &aTopicId, |
| ReferencedTLVData &aDataList, |
| uint16_t aTxnId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| printf("processing: <subscribe confirm - success status + data list>\n"); |
| |
| // and install the data |
| |
| err = mDatabase.Store(aDataList); |
| SuccessOrExit(err); |
| |
| gClientCounter++; |
| |
| if (gClientCounter == gClientCount) |
| Done = true; |
| |
| exit: |
| if (err != WEAVE_NO_ERROR) |
| printf("<subscribe confirm> error: %s\n", ErrorStr(err)); |
| |
| return err; |
| } |
| |
| WEAVE_ERROR UnsubscribeIndication(const uint64_t &aPublisherId, const TopicIdentifier &aTopicId, StatusReport &aReport) |
| { |
| printf("processing: <unsubscribe indication 0x%" PRIx64 ", 0x%" PRIx64 ">\n", aPublisherId, aTopicId); |
| |
| return WEAVE_NO_ERROR; |
| } |
| |
| WEAVE_ERROR CancelSubscriptionConfirm(const uint64_t &aResponderId, const TopicIdentifier &aTopicId, StatusReport &aStatus, uint16_t aTxnId) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| printf("processing: <cancel subscription confirm>\n"); |
| |
| if (aStatus.success()) |
| printf("status == success\n"); |
| |
| else |
| printf("non-success status: <%x, %x>\n", aStatus.mProfileId, aStatus.mStatusCode); |
| |
| gClientCounter++; |
| |
| if (gClientCounter == gClientCount) |
| Done = true; |
| |
| return err; |
| } |
| |
| WEAVE_ERROR NotifyIndication(const TopicIdentifier &aTopicId, ReferencedTLVData &aDataList) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| printf("processing: <notify indication>\n"); |
| |
| err = mDatabase.Store(aDataList); |
| |
| gClientCounter++; |
| |
| if (gClientCounter == gClientCount) |
| Done = true; |
| |
| return err; |
| } |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| /* |
| * the client comes with a profile database |
| */ |
| |
| TestProfileDB mDatabase; |
| }; |
| |
| /* |
| * and we need a test rig, which is basically a place to hang tests, all |
| * of which are run from the client side. |
| */ |
| |
| class DMClientTester |
| { |
| public: |
| DMClientTester(uint8_t aTransport) |
| { |
| mTransport = aTransport; |
| } |
| |
| /* |
| * test cases |
| */ |
| |
| void Test_InitialState() |
| { |
| DMTestClient client; |
| |
| EnterTest("InitialState", err); |
| |
| assert(client.mDatabase.mTestData.mVersion == 0); |
| assert(client.mDatabase.mTestData.mIntegerItem == 0); |
| |
| ExitTest(err); |
| } |
| |
| void Test_DBStore() |
| { |
| DMTestClient client; |
| |
| EnterTest("DBStore", err); |
| |
| uint8_t buf[kTestBufferSize]; |
| TLVWriter writer; |
| ReferencedTLVData dataList; |
| |
| // write a data list to store (including new version) |
| |
| writer.Init(buf, kTestBufferSize); |
| |
| err = StartDataList(writer); |
| SuccessOrExit(err); |
| |
| err = StartDataListElement(writer); |
| SuccessOrExit(err); |
| |
| err = EncodePath(writer, |
| ContextTag(kTag_WDMDataListElementPath), |
| kWeaveProfile_Test, |
| kInstanceIdNotSpecified, |
| 1, |
| ContextTag(kTag_IntegerItem)); |
| SuccessOrExit(err); |
| |
| err = writer.Put(ContextTag(kTag_WDMDataListElementVersion), (uint64_t)1); // increment version |
| SuccessOrExit(err); |
| |
| err = writer.Put(ContextTag(kTag_WDMDataListElementData), 1); // write 1 |
| SuccessOrExit(err); |
| |
| err = EndDataListElement(writer); |
| SuccessOrExit(err); |
| |
| err = EndList(writer); |
| SuccessOrExit(err); |
| |
| // now store it and confirm results |
| |
| err = dataList.init(writer.GetLengthWritten(), kTestBufferSize, buf); |
| SuccessOrExit(err); |
| |
| err = client.mDatabase.Store(dataList); |
| SuccessOrExit(err); |
| |
| assert(client.mDatabase.mTestData.mVersion == 1); // check for 1 |
| assert(client.mDatabase.mTestData.mIntegerItem == 1); // check for 1 |
| |
| exit: |
| ExitTest(err); |
| } |
| |
| void Test_DBRetrieve() |
| { |
| DMTestClient client; |
| |
| EnterTest("DBRetrieve", err); |
| |
| uint8_t pathBuf[kTestBufferSize]; |
| TLVWriter writer; |
| ReferencedTLVData pathList; |
| |
| uint8_t dataBuf[kTestBufferSize]; |
| ReferencedTLVData dataList; |
| |
| TLVReader dataListRdr; |
| TLVReader pathRdr; |
| uint64_t version; |
| |
| uint32_t item; |
| |
| // write a path list to extract a data item |
| |
| writer.Init(pathBuf, kTestBufferSize); |
| |
| err = StartPathList(writer); |
| SuccessOrExit(err); |
| |
| err = EncodePath(writer, AnonymousTag, kWeaveProfile_Test, kInstanceIdNotSpecified, 1, ContextTag(kTag_IntegerItem)); |
| SuccessOrExit(err); |
| |
| err = EndList(writer); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| err = pathList.init(writer.GetLengthWritten(), kTestBufferSize, pathBuf); |
| SuccessOrExit(err); |
| |
| // set up the data list to receive data |
| |
| err = dataList.init(0, kTestBufferSize, dataBuf); |
| SuccessOrExit(err); |
| |
| // now do the retrieve |
| |
| err = client.mDatabase.Retrieve(pathList, dataList); |
| SuccessOrExit(err); |
| |
| // validate the data list |
| |
| OpenDataList(dataList, dataListRdr); |
| SuccessOrExit(err); |
| |
| err = dataListRdr.Next(); |
| SuccessOrExit(err); |
| |
| err = OpenDataListElement(dataListRdr, pathRdr, version); |
| SuccessOrExit(err); |
| |
| err = ValidatePath(pathRdr, |
| ContextTag(kTag_WDMDataListElementPath), |
| kWeaveProfile_Test, |
| kInstanceIdNotSpecified, |
| 1, |
| ContextTag(kTag_IntegerItem)); |
| SuccessOrExit(err); |
| |
| assert(version == client.mDatabase.mTestData.mVersion); // check version |
| |
| assert(CheckWDMTag(kTag_WDMDataListElementData, dataListRdr)); // check data tag |
| |
| assert(dataListRdr.GetType() == kTLVType_UnsignedInteger); // check data type |
| |
| err = dataListRdr.Get(item); |
| SuccessOrExit(err); |
| assert(item == client.mDatabase.mTestData.mIntegerItem); // check data |
| |
| err = CloseDataListElement(dataListRdr); |
| SuccessOrExit(err); |
| |
| err = CloseList(dataListRdr); |
| SuccessOrExit(err); |
| |
| exit: |
| ExitTest(err); |
| } |
| |
| void Test_DBRetrieveAndStore() |
| { |
| DMTestClient client; |
| |
| EnterTest("DBRetrieveAndStore", err); |
| |
| uint8_t pathBuf[kTestBufferSize]; |
| TLVWriter writer; |
| ReferencedTLVData pathList; |
| |
| uint8_t dataBuf[kTestBufferSize]; |
| ReferencedTLVData dataList; |
| |
| // check inital state |
| |
| assert(client.mDatabase.mTestData.mVersion == 0); |
| assert(client.mDatabase.mTestData.mIntegerItem == 0); |
| |
| // write a path list to extract the whole bucket |
| |
| writer.Init(pathBuf, kTestBufferSize); |
| |
| err = StartPathList(writer); |
| SuccessOrExit(err); |
| |
| err = EncodePath(writer, AnonymousTag, kWeaveProfile_Test, kInstanceIdNotSpecified, 0); |
| SuccessOrExit(err); |
| |
| err = EndList(writer); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| err = pathList.init(writer.GetLengthWritten(), kTestBufferSize, pathBuf); |
| SuccessOrExit(err); |
| |
| // set up the data list to receive data |
| |
| err = dataList.init(0, kTestBufferSize, dataBuf); |
| SuccessOrExit(err); |
| |
| // now do the retrieve |
| |
| err = client.mDatabase.Retrieve(pathList, dataList); |
| SuccessOrExit(err); |
| |
| /* |
| * OK, so here's what we do now. we've got a data list capturing the |
| * original state. change the state and then verify that we can set it |
| * back by applying the data list. |
| */ |
| |
| client.mDatabase.mTestData.mVersion = 1; |
| client.mDatabase.mTestData.mIntegerItem = 1; |
| |
| err = client.mDatabase.Store(dataList); |
| SuccessOrExit(err); |
| |
| assert(client.mDatabase.mTestData.mVersion == 0); |
| assert(client.mDatabase.mTestData.mIntegerItem == 0); |
| |
| exit: |
| ExitTest(err); |
| } |
| |
| void Test_View(void) |
| { |
| DMTestClient client; |
| |
| uint8_t pathBuf[kTestBufferSize]; |
| |
| TLVWriter writer; |
| ReferencedTLVData pathList; |
| |
| EnterTest("DBView", err); |
| |
| // set up the client |
| |
| err = client.Init(&ExchangeMgr); |
| SuccessOrExit(err); |
| |
| err = client.BindRequest(DestNodeId, mTransport); |
| SuccessOrExit(err); |
| |
| // now, make a path list |
| |
| writer.Init(pathBuf, kTestBufferSize); |
| |
| err = StartPathList(writer); |
| SuccessOrExit(err); |
| |
| // first path |
| err = EncodePath(writer, AnonymousTag, kWeaveProfile_Test, kInstanceIdNotSpecified, 0); |
| SuccessOrExit(err); |
| |
| // second path |
| err = EncodePath(writer, AnonymousTag, kWeaveProfile_Test, kInstanceIdNotSpecified, 0); |
| SuccessOrExit(err); |
| |
| err = EndList(writer); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| err = pathList.init(writer.GetLengthWritten(), kTestBufferSize, pathBuf); |
| SuccessOrExit(err); |
| |
| /* |
| * do this a bunch of times to test resource management |
| */ |
| |
| for (int i = 0; i < gCyclingCnt; i++) |
| { |
| err = client.ViewRequest(pathList, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| // now drive |
| Done = false; |
| DriveTest(Done); |
| } |
| |
| err = client.ViewRequest(DestNodeId, pathList, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| // now drive |
| Done = false; |
| DriveTest(Done); |
| |
| exit: |
| ExitTest(err); |
| } |
| |
| void Test_Update(void) |
| { |
| DMTestClient client; |
| |
| uint8_t pathBuf[kTestBufferSize]; |
| TLVWriter writer; |
| ReferencedTLVData pathList; |
| |
| uint8_t dataBuf[kTestBufferSize]; |
| ReferencedTLVData dataList; |
| |
| EnterTest("DBUpdate", err); |
| |
| // set up the client |
| |
| err = client.Init(&ExchangeMgr); |
| SuccessOrExit(err); |
| |
| err = client.BindRequest(DestNodeId, mTransport); |
| SuccessOrExit(err); |
| |
| // now, make a path list |
| |
| writer.Init(pathBuf, kTestBufferSize); |
| |
| err = StartPathList(writer); |
| SuccessOrExit(err); |
| |
| // first path |
| err = EncodePath(writer, AnonymousTag, kWeaveProfile_Test, kInstanceIdNotSpecified, 1, ContextTag(kTag_IntegerItem)); |
| SuccessOrExit(err); |
| |
| // second path |
| err = EncodePath(writer, AnonymousTag, kWeaveProfile_Test, kInstanceIdNotSpecified, 1, ContextTag(kTag_IntegerItem)); |
| SuccessOrExit(err); |
| |
| err = EndList(writer); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| err = pathList.init(writer.GetLengthWritten(), kTestBufferSize, pathBuf); |
| SuccessOrExit(err); |
| |
| for (uint16_t i = 0; i < gCyclingCnt; i++) |
| { |
| uint64_t currentVersion = client.mDatabase.mTestData.mVersion; |
| client.mDatabase.mTestData.mIntegerItem = i; |
| |
| // use path list to extract a data list |
| |
| err = dataList.init(0, kTestBufferSize, dataBuf); |
| SuccessOrExit(err); |
| |
| err = client.mDatabase.Retrieve(pathList, dataList); |
| SuccessOrExit(err); |
| |
| // send an update |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| |
| // it we're allowing old message types, send some |
| |
| if (i % 3 == 0) |
| { |
| err = client.UpdateRequest(dataList, 1, kDefaultDMResponseTimeout, true); |
| SuccessOrExit(err); |
| } |
| else if (i % 3 == 1) |
| { |
| err = client.UpdateRequest(dataList, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| } |
| else if (i % 3 == 2) |
| { |
| err = client.UpdateRequest(DestNodeId, dataList, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| } |
| |
| #else |
| |
| err = client.UpdateRequest(dataList, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_LEGACY_MESSAGE_TYPES |
| |
| // now drive |
| |
| Done = false; |
| DriveTest(Done); |
| |
| // OK, now send a view |
| |
| err = client.ViewRequest(pathList, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| // and again... |
| |
| Done = false; |
| DriveTest(Done); |
| |
| // now check the results |
| |
| assert(client.mDatabase.mTestData.mIntegerItem == i); |
| assert(client.mDatabase.mTestData.mVersion > currentVersion); |
| } |
| |
| exit: |
| ExitTest(err); |
| } |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| void Test_CancelNonSubscription(void) |
| { |
| DMTestClient client; |
| |
| gClientCount = 1; |
| |
| EnterTest("CancelNonSubscription", err); |
| |
| // set up the client with subscription enabled |
| |
| err = client.Init(&ExchangeMgr); |
| SuccessOrExit(err); |
| |
| err = client.BindRequest(DestNodeId, mTransport); |
| SuccessOrExit(err); |
| |
| for (uint16_t i = 0; i < gCyclingCnt; i++) |
| { |
| /* |
| * insert the subscription so there'll be something there. |
| */ |
| |
| err = DMClient::sNotifier.InstallSubscription(kTopicIdNotSpecified, kTestTopic, DestNodeId, &client); |
| SuccessOrExit(err); |
| |
| // now cancel |
| |
| err = client.CancelSubscriptionRequest(kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| // drive |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| assert(!client.HasSubscription(kTestTopic)); |
| } |
| |
| exit: |
| ExitTest(err); |
| } |
| |
| void Test_SubscribeToTopic(void) |
| { |
| DMTestClient client; |
| |
| uint8_t pathBuf[kTestBufferSize]; |
| TLVWriter writer; |
| ReferencedTLVData pathList; |
| |
| gClientCount = 1; |
| |
| EnterTest("SubscribeToTopic", err); |
| |
| // set up the client with subscription enabled |
| |
| err = client.Init(&ExchangeMgr); |
| SuccessOrExit(err); |
| |
| err = client.BindRequest(DestNodeId, mTransport); |
| SuccessOrExit(err); |
| |
| writer.Init(pathBuf, kTestBufferSize); |
| |
| err = StartPathList(writer); |
| SuccessOrExit(err); |
| |
| // first path |
| err = EncodePath(writer, AnonymousTag, kWeaveProfile_Test, kInstanceIdNotSpecified, 1, ContextTag(kTag_IntegerItem)); |
| SuccessOrExit(err); |
| |
| err = EndList(writer); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| err = pathList.init(writer.GetLengthWritten(), kTestBufferSize, pathBuf); |
| SuccessOrExit(err); |
| |
| err = client.SubscribeRequest(DestNodeId, pathList, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| err = client.CancelSubscriptionRequest(kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| assert(!client.HasSubscription(kTestTopic)); |
| |
| err = client.SubscribeRequest(pathList, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| err = client.CancelSubscriptionRequest(kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| assert(!client.HasSubscription(kTestTopic)); |
| |
| err = client.SubscribeRequest(DestNodeId, kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| assert(client.HasSubscription(kTestTopic)); |
| |
| err = client.CancelSubscriptionRequest(kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| assert(!client.HasSubscription(kTestTopic)); |
| |
| err = client.CancelTransactionRequest(1, err); |
| SuccessOrExit(err); |
| |
| |
| for (uint16_t i = 0; i < gCyclingCnt; i++) |
| { |
| err = client.SubscribeRequest(kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| // now drive |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| assert(client.HasSubscription(kTestTopic)); |
| |
| // now wait for a notification |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| // now cancel |
| |
| err = client.CancelSubscriptionRequest(kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| // drive s'more |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| assert(!client.HasSubscription(kTestTopic)); |
| |
| } |
| |
| exit: |
| ExitTest(err); |
| } |
| |
| void Test_MultipleClients(void) |
| { |
| DMTestClient client1; |
| DMTestClient client2; |
| |
| gClientCount = 2; |
| |
| EnterTest("MultipleClients", err); |
| |
| // set up the client with subscription enabled |
| |
| err = client1.Init(&ExchangeMgr); |
| SuccessOrExit(err); |
| |
| err = client2.Init(&ExchangeMgr); |
| SuccessOrExit(err); |
| |
| err = client1.BindRequest(DestNodeId, mTransport); |
| SuccessOrExit(err); |
| err = client2.BindRequest(DestNodeId, mTransport); |
| SuccessOrExit(err); |
| |
| for (uint16_t i = 0; i < gCyclingCnt; i++) |
| { |
| err = client1.SubscribeRequest(kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| err = client2.SubscribeRequest(kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| // now drive |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| assert(client1.HasSubscription(kTestTopic)); |
| assert(client2.HasSubscription(kTestTopic)); |
| |
| // now wait for a notification |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| // now cancel |
| |
| err = client1.CancelSubscriptionRequest(kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| err = client2.CancelSubscriptionRequest(kTestTopic, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| // drive s'more |
| |
| Done = false; |
| gClientCounter = 0; |
| DriveTest(Done); |
| |
| assert(!client1.HasSubscription(kTestTopic)); |
| assert(!client2.HasSubscription(kTestTopic)); |
| } |
| |
| exit: |
| ExitTest(err); |
| } |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| void Test_CloseConnection(void) |
| { |
| DMTestClient client; |
| |
| uint8_t pathBuf[kTestBufferSize]; |
| TLVWriter writer; |
| ReferencedTLVData pathList; |
| |
| EnterTest("CloseConnection", err); |
| |
| // set up the client |
| |
| err = client.Init(&ExchangeMgr); |
| SuccessOrExit(err); |
| |
| err = client.BindRequest(DestNodeId, kTransport_TCP); |
| SuccessOrExit(err); |
| |
| // now, make a "special" path list |
| |
| writer.Init(pathBuf, kTestBufferSize); |
| |
| err = StartPathList(writer); |
| SuccessOrExit(err); |
| |
| err = EncodePath(writer, AnonymousTag, kWeaveProfile_Fail, kFailureInstance_CloseConnection, 0); |
| SuccessOrExit(err); |
| |
| err = EndList(writer); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| err = pathList.init(writer.GetLengthWritten(), kTestBufferSize, pathBuf); |
| SuccessOrExit(err); |
| |
| /* |
| * do this a bunch of times to test resource management |
| */ |
| |
| for (int i = 0; i < gCyclingCnt; i++) |
| { |
| err = client.ViewRequest(pathList, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| // now drive |
| Done = false; |
| DriveTest(Done); |
| } |
| |
| exit: |
| ExitTest(err); |
| } |
| |
| void Test_NoResponse(void) |
| { |
| DMTestClient client; |
| |
| uint8_t pathBuf[kTestBufferSize]; |
| TLVWriter writer; |
| ReferencedTLVData pathList; |
| |
| EnterTest("NoResponse", err); |
| |
| // set up the client |
| |
| err = client.Init(&ExchangeMgr); |
| SuccessOrExit(err); |
| |
| err = client.BindRequest(DestNodeId, mTransport); |
| SuccessOrExit(err); |
| |
| // now, make a "special" path list |
| |
| writer.Init(pathBuf, kTestBufferSize); |
| |
| err = StartPathList(writer); |
| SuccessOrExit(err); |
| |
| err = EncodePath(writer, AnonymousTag, kWeaveProfile_Fail, kFailureInstance_NoResponse, 0); |
| SuccessOrExit(err); |
| |
| err = EndList(writer); |
| SuccessOrExit(err); |
| |
| err = writer.Finalize(); |
| SuccessOrExit(err); |
| |
| err = pathList.init(writer.GetLengthWritten(), kTestBufferSize, pathBuf); |
| SuccessOrExit(err); |
| |
| /* |
| * do this a bunch of times to test resource management |
| */ |
| |
| for (int i = 0; i < gCyclingCnt; i++) |
| { |
| err = client.ViewRequest(pathList, 1, kDefaultDMResponseTimeout); |
| SuccessOrExit(err); |
| |
| // now drive |
| Done = false; |
| DriveTest(Done); |
| } |
| |
| exit: |
| ExitTest(err); |
| } |
| |
| static void Run(void) |
| { |
| printf("Running WDM client tests---\n"); |
| |
| /* |
| * check the profile database operaiton |
| */ |
| |
| { |
| DMClientTester tester(kTransport_UDP); |
| |
| tester.Test_InitialState(); |
| } |
| |
| { |
| DMClientTester tester(kTransport_UDP); |
| |
| tester.Test_DBStore(); |
| } |
| |
| { |
| DMClientTester tester(kTransport_UDP); |
| |
| tester.Test_DBRetrieve(); |
| } |
| |
| { |
| DMClientTester tester(kTransport_UDP); |
| |
| tester.Test_DBRetrieveAndStore(); |
| } |
| |
| /* |
| * then the client notifier stuff |
| */ |
| |
| /* |
| * and the server subscription table |
| */ |
| |
| /* |
| * OK, now test the stuff that actually requires communication |
| */ |
| |
| // test view |
| |
| { |
| DMClientTester tester(kTransport_UDP); |
| |
| tester.Test_View(); |
| } |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| { |
| DMClientTester tester(kTransport_WRMP); |
| |
| tester.Test_View(); |
| } |
| #endif |
| // and using TCP |
| |
| { |
| DMClientTester tester(kTransport_TCP); |
| |
| tester.Test_View(); |
| } |
| |
| // test update |
| |
| { |
| DMClientTester tester(kTransport_UDP); |
| |
| tester.Test_Update(); |
| } |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| { |
| DMClientTester tester(kTransport_WRMP); |
| |
| tester.Test_Update(); |
| } |
| #endif |
| { |
| DMClientTester tester(kTransport_TCP); |
| |
| tester.Test_Update(); |
| } |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| // cancel a non-existent subscription |
| |
| { |
| DMClientTester tester(kTransport_UDP); |
| |
| tester.Test_CancelNonSubscription(); |
| } |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| { |
| DMClientTester tester(kTransport_WRMP); |
| |
| tester.Test_CancelNonSubscription(); |
| } |
| #endif |
| { |
| DMClientTester tester(kTransport_TCP); |
| |
| tester.Test_CancelNonSubscription(); |
| } |
| |
| // now try establishing a topic subscription |
| |
| { |
| DMClientTester tester(kTransport_UDP); |
| |
| tester.Test_SubscribeToTopic(); |
| } |
| |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| { |
| DMClientTester tester(kTransport_WRMP); |
| |
| tester.Test_SubscribeToTopic(); |
| } |
| #endif |
| { |
| DMClientTester tester(kTransport_TCP); |
| |
| tester.Test_SubscribeToTopic(); |
| } |
| |
| // do the same with multiple clients |
| |
| { |
| DMClientTester tester(kTransport_UDP); |
| |
| tester.Test_MultipleClients(); |
| } |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| { |
| DMClientTester tester(kTransport_WRMP); |
| |
| tester.Test_MultipleClients(); |
| } |
| #endif |
| { |
| DMClientTester tester(kTransport_TCP); |
| |
| tester.Test_MultipleClients(); |
| } |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| // these are negative tests |
| |
| { |
| DMClientTester tester(kTransport_TCP); |
| |
| tester.Test_CloseConnection(); |
| } |
| |
| { |
| DMClientTester tester(kTransport_UDP); |
| |
| tester.Test_NoResponse(); |
| } |
| |
| { |
| DMClientTester tester(kTransport_TCP); |
| |
| tester.Test_NoResponse(); |
| } |
| #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING |
| { |
| DMClientTester tester(kTransport_WRMP); |
| |
| tester.Test_NoResponse(); |
| } |
| #endif |
| } |
| |
| // we need to keep the transport around since the DME one is protected |
| |
| uint8_t mTransport; |
| }; |
| |
| int main(int argc, char *argv[]) |
| { |
| gWeaveNodeOptions.FabricId = 0; |
| gWeaveNodeOptions.LocalNodeId = 0; |
| |
| if (argc == 1) |
| { |
| gHelpOptions.PrintBriefUsage(stderr); |
| exit(EXIT_FAILURE); |
| } |
| |
| if (!ParseArgsFromEnvVar(TOOL_NAME, TOOL_OPTIONS_ENV_VAR_NAME, gToolOptionSets, NULL, true) || |
| !ParseArgs(TOOL_NAME, argc, argv, gToolOptionSets, HandleNonOptionArgs)) |
| { |
| exit(EXIT_FAILURE); |
| } |
| |
| if (gNetworkOptions.LocalIPv6Addr != IPAddress::Any) |
| { |
| if (!gNetworkOptions.LocalIPv6Addr.IsIPv6ULA()) |
| { |
| printf("ERROR: Local address must be an IPv6 ULA\n"); |
| exit(EXIT_FAILURE); |
| } |
| |
| gWeaveNodeOptions.FabricId = gNetworkOptions.LocalIPv6Addr.GlobalId(); |
| gWeaveNodeOptions.LocalNodeId = IPv6InterfaceIdToWeaveNodeId(gNetworkOptions.LocalIPv6Addr.InterfaceId()); |
| gWeaveNodeOptions.SubnetId = gNetworkOptions.LocalIPv6Addr.Subnet(); |
| } |
| |
| // Default LocalNodeId to 1 if not set explicitly, or by means of setting the node address. |
| if (gWeaveNodeOptions.LocalNodeId == 0) |
| gWeaveNodeOptions.LocalNodeId = 1; |
| |
| InitSystemLayer(); |
| |
| InitNetwork(); |
| |
| InitWeaveStack(false, true); |
| |
| // Arrange to get called for various activity in the message layer. |
| MessageLayer.OnConnectionReceived = HandleConnectionReceived; |
| MessageLayer.OnReceiveError = HandleMessageReceiveError; |
| MessageLayer.OnAcceptError = HandleAcceptConnectionError; |
| |
| SecurityMgr.OnSessionEstablished = HandleSecureSessionEstablished; |
| SecurityMgr.OnSessionError = HandleSecureSessionError; |
| |
| if (DestAddr == IPAddress::Any) |
| DestAddr = FabricState.SelectNodeAddress(DestNodeId); |
| |
| PrintNodeConfig(); |
| |
| DMClientTester::Run(); |
| |
| printf("WDM Test is Completed!\n"); |
| |
| ShutdownWeaveStack(); |
| ShutdownNetwork(); |
| ShutdownSystemLayer(); |
| |
| return EXIT_SUCCESS; |
| } |
| |
| bool HandleOption(const char *progName, OptionSet *optSet, int id, const char *name, const char *arg) |
| { |
| switch (id) |
| { |
| case 'D': |
| if (!ParseIPAddress(arg, DestAddr)) |
| { |
| PrintArgError("%s: Invalid value specified for destination IP address: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| case 'c': |
| if (!ParseInt(arg, gCyclingCnt)) |
| { |
| PrintArgError("%s: Invalid value specified for cycling count: %s\n", progName, arg); |
| return false; |
| } |
| break; |
| default: |
| PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", progName, name); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool HandleNonOptionArgs(const char *progName, int argc, char *argv[]) |
| { |
| if (argc > 0) |
| { |
| if (argc > 1) |
| { |
| PrintArgError("%s: Unexpected argument: %s\n", progName, argv[1]); |
| return false; |
| } |
| |
| if (!ParseNodeId(argv[0], DestNodeId)) |
| { |
| PrintArgError("%s: Invalid value specified for destination node-id: %s\n", progName, argv[0]); |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| void HandleConnectionReceived(WeaveMessageLayer *msgLayer, WeaveConnection *con) |
| { |
| char ipAddrStr[64]; |
| con->PeerAddr.ToString(ipAddrStr, sizeof(ipAddrStr)); |
| |
| printf("Connection received from node 0x%" PRIx64 " (%s)\n", con->PeerNodeId, ipAddrStr); |
| |
| con->OnConnectionClosed = HandleConnectionClosed; |
| } |
| |
| void HandleSecureSessionEstablished(WeaveSecurityManager *sm, WeaveConnection *con, void *reqState, uint16_t sessionKeyId, uint64_t peerNodeId, uint8_t encType) |
| { |
| char ipAddrStr[64] = ""; |
| |
| if (con != NULL) |
| con->PeerAddr.ToString(ipAddrStr, sizeof(ipAddrStr)); |
| |
| printf("Secure session established with node 0x%" PRIx64 " (%s)\n", peerNodeId, ipAddrStr); |
| } |
| |
| void HandleSecureSessionError(WeaveSecurityManager *sm, WeaveConnection *con, void *reqState, WEAVE_ERROR localErr, uint64_t peerNodeId, StatusReport *statusReport) |
| { |
| char ipAddrStr[64] = ""; |
| |
| if (con != NULL) |
| { |
| con->PeerAddr.ToString(ipAddrStr, sizeof(ipAddrStr)); |
| con->Close(); |
| } |
| |
| if (localErr == WEAVE_ERROR_STATUS_REPORT_RECEIVED && statusReport != NULL) |
| printf("FAILED to establish secure session with node 0x%" PRIx64 " (%s): %s\n", peerNodeId, ipAddrStr, nl::StatusReportStr(statusReport->mProfileId, statusReport->mStatusCode)); |
| else |
| printf("FAILED to establish secure session with node 0x%" PRIx64 " (%s): %s\n", peerNodeId, ipAddrStr, ErrorStr(localErr)); |
| } |
| |
| void HandleConnectionClosed(WeaveConnection *con, WEAVE_ERROR conErr) |
| { |
| char ipAddrStr[64]; |
| // Note: by contract con MUST NOT be NULL, so it is used without the check. |
| con->PeerAddr.ToString(ipAddrStr, sizeof(ipAddrStr)); |
| |
| if (conErr == WEAVE_NO_ERROR) |
| printf("Connection closed to node 0x%" PRIx64 " (%s)\n", con->PeerNodeId, ipAddrStr); |
| else |
| printf("Connection ABORTED to node 0x%" PRIx64 " (%s): %s\n", con->PeerNodeId, ipAddrStr, ErrorStr(conErr)); |
| |
| con->Close(); |
| } |
| |
| /* |
| * |
| * we may have need of this some day but for now we're not using it and it's |
| * generating warnings to that effect. |
| * |
| void HandleConnectionComplete(WeaveConnection *con, WEAVE_ERROR err) |
| { |
| char ipAddrStr[64]; |
| con->PeerAddr.ToString(ipAddrStr, sizeof(ipAddrStr)); |
| |
| if (err == WEAVE_NO_ERROR) |
| { |
| printf("Connection established to %s\n", ipAddrStr); |
| |
| ExchangeMgr.AllowUnsolicitedMessages(con); |
| } |
| else |
| { |
| printf("Failed to establish connection to %s: %s\n", ipAddrStr, ErrorStr(err)); |
| con->Close(); |
| } |
| } |
| * |
| */ |
