1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Unit tests for invalid messages: message size is wrong,

    15 *               message type is wrong, messages sent in wrong order etc.

    16 *

    17 */

    18 

    19 #include <sstream>

    20 #include <string>

    21 #include "TestHarness.h"

    22 #include "echoserver.h"

    23 #include "transport.h"

    24 

    25 using namespace java::comms;

    26 

    27 class DummyListener : public IpcListener

    28 {

    29 public:

    30     virtual void processMessage(const ipcMessage_t* /*aMsg*/) {};

    31     virtual void onStart() {};

    32     virtual void onExit() {};

    33 };

    34 

    35 #ifdef __SYMBIAN32__

    36 #include "javasymbianoslayer.h"

    37 enum ECommsOperations

    38 {

    39     ESend,

    40     EReceive,

    41     ECancelReceive

    42 };

    43 

    44 class RBadClient : public RSessionBase

    45 {

    46 public:

    47     TInt connect(int aAddr)

    48     {

    49         std::stringstream address;

    50         address << "java-comms-" << aAddr;

    51         std::auto_ptr<HBufC> serverName(stringToDes(address.str().c_str()));

    52 

    53         TInt rc = CreateSession(serverName->Des(), TVersion(1,1,1));

    54         return rc;

    55     };

    56 

    57     TInt send(const TDesC8& aData)

    58     {

    59         return SendReceive(ESend, TIpcArgs(&aData));

    60     };

    61 

    62     TInt cancel()

    63     {

    64         return SendReceive(ECancelReceive, TIpcArgs(&KNullDesC8));

    65     };

    66 

    67     void receive(RBuf8& aBuffer, TPckgBuf<TInt>& aRequiredSize, TRequestStatus& aStatus)

    68     {

    69         TIpcArgs args;

    70         args.Set(0, &aBuffer);

    71         args.Set(1, &aRequiredSize);

    72 

    73         SendReceive(EReceive, args, aStatus);

    74     };

    75     using RSessionBase::SendReceive;

    76 };

    77 #endif

    78 

    79 TEST_GROUP(InvalidMessage)

    80 {

    81     EchoServer server;

    82 

    83     TEST_SETUP()

    84     {

    85         server.start(IPC_ADDRESS_COMMS_MODULE_TEST);

    86     }

    87 

    88     TEST_TEARDOWN()

    89     {

    90         server.stop();

    91     }

    92 };

    93 

    94 #ifdef __SYMBIAN32__

    95 TEST(InvalidMessage, invalidMessage)

    96 {

    97     EXPECT_N_LEAKS(1);

    98     DummyListener listener;

    99     std::auto_ptr<IpcConnectionInterface> client(IpcConnectionFactory::createConnection(&listener));

   100 

   101     CHECK(!client->connect(IPC_ADDRESS_COMMS_MODULE_TEST));

   102 

   103     ipcMessage_t msg;

   104 

   105     msg.ipcHeader.length = 0;

   106     int rc = client->send(&msg);

   107     CHECK(rc != 0);

   108 

   109     msg.ipcHeader.length = 1;

   110     rc = client->send(&msg);

   111     CHECK(rc != 0);

   112 

   113     msg.ipcHeader.length = sizeof(ipcHeader_t)-1;

   114     rc = client->send(&msg);

   115     CHECK(rc != 0);

   116 

   117     msg.ipcHeader.length = sizeof(ipcHeader_t);

   118     rc = client->send(&msg);

   119     CHECK(rc == 0);

   120 

   121     client->disconnect();

   122 }

   123 

   124 TEST(InvalidMessage, messageAndHeaderSizeMismatch)

   125 {

   126     EXPECT_N_LEAKS(1);

   127     RBadClient client;

   128     CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));

   129 

   130     int realSize = sizeof(ipcHeader_t);

   131     std::auto_ptr<HBufC8> data(HBufC8::New(realSize));

   132     TPtr8 ptr = data->Des();

   133 

   134     ipcMessage_t msg;

   135     TPtr8 ptr8((TUint8 *)&msg, realSize);

   136     ptr8.SetLength(realSize);

   137 

   138     // length in header is too big

   139     msg.ipcHeader.length = realSize + 1;

   140     ptr.Copy(ptr8);

   141     int rc = client.send(data->Des());

   142     CHECK(rc != 0);

   143 

   144     // length in header is too small

   145     msg.ipcHeader.length = realSize -1;

   146     ptr.Copy(ptr8);

   147     rc = client.send(data->Des());

   148     CHECK(rc != 0);

   149 

   150     // length in header is correct

   151     msg.ipcHeader.length = realSize;

   152     ptr.Copy(ptr8);

   153     rc = client.send(data->Des());

   154     CHECK(rc == 0);

   155 

   156     // empty message

   157     rc = client.send(KNullDesC8);

   158     CHECK(rc != 0);

   159 

   160     client.Close();

   161 }

   162 

   163 TEST(InvalidMessage, invalidMessageOrder)

   164 {

   165     EXPECT_N_LEAKS(1);

   166     RBadClient client;

   167     CHECK(!client.connect(IPC_ADDRESS_COMMS_MODULE_TEST));

   168 

   169     // multiple cancels when no receive sent

   170     CHECK(!client.cancel());

   171     CHECK(!client.cancel());

   172 

   173     // multiple sends when no receive sent

   174     int size = sizeof(ipcHeader_t);

   175     std::auto_ptr<HBufC8> data(HBufC8::New(size));

   176     TPtr8 ptr = data->Des();

   177 

   178     ipcMessage_t msg;

   179     TPtr8 ptr8((TUint8 *)&msg, size);

   180     ptr8.SetLength(size);

   181     msg.ipcHeader.length = size;

   182     ptr.Copy(ptr8);

   183 

   184     CHECK(!client.send(data->Des()));

   185     CHECK(!client.send(data->Des()));

   186 

   187     // receive sent messages

   188     RBuf8 buffer;

   189     buffer.Create(100);

   190     TPckgBuf<TInt> requiredLength;

   191     TRequestStatus status;

   192 

   193     client.receive(buffer, requiredLength, status);

   194     User::WaitForRequest(status);

   195     CHECK(status.Int() == KErrNone);

   196 

   197     client.receive(buffer, requiredLength, status);

   198     User::WaitForRequest(status);

   199     CHECK(status.Int() == KErrNone);

   200 

   201     // cancel receive message

   202     client.receive(buffer, requiredLength, status);

   203     CHECK(!client.cancel());

   204     User::WaitForRequest(status);

   205     CHECK(status.Int() == KErrCancel);

   206 

   207     // receive message with too small buffer

   208     buffer.Close();

   209     buffer.Create(1);

   210     client.receive(buffer, requiredLength, status);

   211 

   212     client.send(data->Des());

   213     User::WaitForRequest(status);

   214     CHECK(status.Int() == KErrOverflow);

   215     CHECK(!client.cancel());

   216 

   217     // invalid message type

   218     CHECK(client.SendReceive(313, TIpcArgs(&KNullDesC8)) == KErrNotSupported);

   219 

   220     buffer.Close();

   221     client.Close();

   222 }

   223 #endif

   224