Changeset 14 in chevmsgr


Ignore:
Timestamp:
08/30/15 21:31:39 (9 years ago)
Author:
cheese
Message:

테스트 코드 추가
UI 모양 작업
채팅되는 상태까지 확인

Location:
trunk
Files:
10 added
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/cf/task.cpp

    r4 r14  
    7777
    7878    cf::memory::free(mMutex);
     79    mMutex = NULL;
    7980}
    8081

  • trunk/msg.cpp

    r11 r14  
    4242    }
    4343
     44    std::string Message::serialize() const
     45    {
     46        return json::Serialize(mObject);
     47    }
     48
    4449    // request
    4550    void Request::setUserID(const std::string & id)
    … …  
    8388        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::LOGIN);
    8489
    85         obj[ProtocolType::PW] = mID + DELIMITER + pw;
     90        obj[ProtocolType::PW] = pw;
     91
     92        return json::Serialize(obj);
     93    }
     94
     95    std::string Request::logout() const
     96    {
     97        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::LOGOUT);
    8698
    8799        return json::Serialize(obj);
    … …  
    97109    }
    98110
    99     std::string Request::openSession(const std::string & to) const
     111    std::string Request::openSession(const std::vector<std::string> & idList) const
    100112    {
    101113        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::OPEN_SESSION);
    102114
    103         obj[ProtocolType::TO] = to;
     115        json::Array ar;
     116        std::vector<std::string>::const_iterator iter;
     117        for (iter = idList.begin(); iter != idList.end(); iter++)
     118            ar.push_back(*iter);
     119
     120        obj[ProtocolType::ID_LIST] = ar;
    104121
    105122        return json::Serialize(obj);
    106123    }
    107124
    108     std::string Request::chat(const std::string & sessid, const std::string & message, const int sensitive) const
     125    std::string Request::tell(const std::string & sessid, const std::string & message, const int sensitive) const
    109126    {
    110         DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::CHAT);
     127        DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::TELL);
    111128
    112129        obj[ProtocolType::FROM] = mID;
    … …  
    133150    std::string Response::result(const std::string & requestType, const bool status) const
    134151    {
    135         DECLARE_TEMPLATE_OBJECT(obj, ProtocolType::RESULT);
     152        DECLARE_TEMPLATE_OBJECT(obj, requestType);
    136153
    137154        obj[ProtocolType::RESULT] = status;

  • trunk/msg.hpp

    r12 r14  
    3232    DECLARE_KEY(PW);
    3333    DECLARE_KEY(LOGIN);
     34    DECLARE_KEY(LOGOUT);
    3435    DECLARE_KEY(ADD_FRIEND);
    3536    DECLARE_KEY(OPEN_SESSION);
    3637    DECLARE_KEY(TO);
    37     DECLARE_KEY(CHAT);
     38    DECLARE_KEY(LISTEN);
     39    DECLARE_KEY(TELL);
    3840    DECLARE_KEY(FROM);
    3941    DECLARE_KEY(SESSION_ID);
    … …  
    5052    class Message
    5153    {
    52     private:
     54    public:
    5355        json::Object mObject;
    5456
    55     public:
    5657        Message();
    5758
    … …  
    7980
    8081        std::string type() const;
     82
     83        std::string serialize() const;
    8184    };
    8285
    … …  
    105108        std::string login(const std::string & pw) const;
    106109
     110        std::string logout() const;
     111
    107112        std::string addFriend(const std::string & id) const;
    108113
    109         std::string openSession(const std::string & to) const;
     114        std::string openSession(const std::vector<std::string> & idList) const;
    110115
    111         std::string chat(const std::string & sessid, const std::string & message, const int sensitive) const;
     116        std::string tell(const std::string & sessid, const std::string & message, const int sensitive) const;
    112117
    113118        std::string getFriendList() const;
    … …  
    122127
    123128        std::string friendList(const std::vector<SFriend> & friendList) const;
    124 
    125         std::string openSession(const std::vector<std::string> & idList) const;
    126129    };
    127130};
    … …  
    156159
    157160    for (size_t iter = 1; iter < strings.size(); iter++)
    158         concat += strings[iter];
     161        concat += "," + strings[iter];
    159162
    160163    return concat;

  • trunk/msgclnt.cpp

    r12 r14  
    66
    77#include <stdlib.h>
     8
     9#include "cf/codec.h"
    810
    911// --------------------------------------------------------------
    … …  
    2123} SCallbackWorkerArg;
    2224
    23 static int messageQworekr(void * arg)
     25static int messageQworker(void * arg)
    2426{
    2527    SMessageQWorkerArg * inst = (SMessageQWorkerArg *)arg;
    2628
    2729    Protocol::Message message;
    28     cf::bin raw;
     30    cf::size_t size;
    2931
    3032    while (true)
    … …  
    3234        try
    3335        {
    34             raw = inst->socket->receive();
     36            size = 0;
     37
     38            cf::bin raw = inst->socket->receive();
     39            size = raw.size();
     40
    3541            message.parse(raw.toString());
    3642        }
    … …  
    4046
    4147            // closed
    42             if (raw.size() == 0)
     48            if (size == 0)
     49            {
     50                // dummy logout
     51                message.parse(Protocol::Request().logout());
     52                inst->messageQ->push(message);
    4353                break;
     54            }
    4455        }
    4556
    … …  
    5263}
    5364
    54 static inline SConversation toCnversation(const Protocol::Message & message)
     65static inline SConversation toConversation(const Protocol::Message & message)
    5566{
    5667    SConversation c;
     68    std::string chat = message.get<std::string>(ProtocolType::MESSAGE);
     69
     70    if (chat.length() > 0)
     71        c.message = cf::codec::hex::getInstance()->decode(chat).toString();
    5772
    5873    c.sessid = message.get<std::string>(ProtocolType::SESSION_ID);
    59     c.message = message.get<std::string>(ProtocolType::MESSAGE);
    6074    c.sensitive = message.get<int>(ProtocolType::SENSITIVE);
    61     c.isError = message.get<bool>(ProtocolType::RESULT);
    6275
    6376    c.from = message.get<std::string>(ProtocolType::FROM);
    … …  
    8497    while (true)
    8598    {
    86         message = inst->messageQ->pop(ProtocolType::CHAT, false);
     99        message = inst->messageQ->pop(ProtocolType::LISTEN, false);
    87100        if (message.type() != ProtocolType::NONE)
    88             inst->callback.onChat(toCnversation(message));
     101            inst->callback.onListen(toConversation(message));
    89102
    90103        message = inst->messageQ->pop(ProtocolType::OPEN_SESSION, false);
    91104        if (message.type() != ProtocolType::NONE)
    92105            inst->callback.onOpenSession(toOpenSession(message));
     106
     107        message = inst->messageQ->pop(ProtocolType::LOGOUT, false);
     108        if (message.type() != ProtocolType::NONE)
     109            break;
    93110    }
    94111
    … …  
    109126Protocol::Message MessageQ::pop(const std::string & requestType, bool isWait)
    110127{
    111     while (isWait)
    112     {
    113         SYNCHRONIZED(mutex)
    114         {
    115             Protocol::Message message = messageQ.front();
    116 
    117             if (message.type() == requestType)
    118             {
    119                 messageQ.erase(messageQ.begin());
    120 
    121                 return message;
    122             }
    123         }
    124     }
     128    do
     129    {
     130        mutex.lock();
     131        if (messageQ.size() == 0)
     132        {
     133            mutex.unlock();
     134            continue;
     135        }
     136
     137        Protocol::Message message = messageQ.front();
     138
     139        if (message.type() == requestType)
     140        {
     141            messageQ.erase(messageQ.begin());
     142            mutex.unlock();
     143            return message;
     144        }
     145        mutex.unlock();
     146    } while (isWait);
    125147
    126148    return Protocol::Message(); // return dummy NONE
    … …  
    130152
    131153chev::chev()
    132     : listener(messageQworekr),
     154    : listener(messageQworker),
    133155      caller(callbackWorker)
    134156{
    … …  
    138160{
    139161    socket.close();
     162    listener.join();
     163    caller.join();
    140164}
    141165
    … …  
    254278}
    255279
    256 std::string chev::getSessionID(std::vector<std::string> & idList)
    257 {
    258     try
    259     {
    260         idList.insert(idList.begin(), request.getUserID());
    261 
    262         if (idList.size() == 2)
    263             std::sort(idList.begin(), idList.end());
    264 
    265         std::string concat = joinStrings(idList);
     280std::string chev::getSessionID(const std::vector<std::string> & idList)
     281{
     282    try
     283    {
     284        std::vector<std::string> toList = idList;
     285        toList.insert(toList.begin(), request.getUserID());
     286
     287        std::string concat = joinStrings(toList);
    266288
    267289        if (sessionMap.find(concat) == sessionMap.end())
    268290        {
    269             socket.send(request.openSession(concat));
    270 
    271             Protocol::Message message = messageQ.pop(ProtocolType::SESSION_ID);
    272 
    273             if (!message.get<bool>(ProtocolType::RESULT))
    274                 THROW_EXCEPTION("failed to open session id");
     291            socket.send(request.openSession(toList));
     292
     293            Protocol::Message message = messageQ.pop(ProtocolType::OPEN_SESSION);
    275294
    276295            sessionMap[concat] = message.get<std::string>(ProtocolType::SESSION_ID);
    … …  
    291310    try
    292311    {
    293         const SConversation & c = conversation;
    294 
    295         socket.send(request.chat(c.sessid, c.message, c.sensitive));
    296 
    297         return messageQ.pop(ProtocolType::CHAT).get<bool>(ProtocolType::RESULT);
     312        SConversation c = conversation;
     313
     314        if (c.message.length() > 0)
     315            c.message = cf::codec::hex::getInstance()->encode(c.message);
     316
     317        socket.send(request.tell(c.sessid, c.message, c.sensitive));
     318
     319        return messageQ.pop(ProtocolType::TELL).get<bool>(ProtocolType::RESULT);
    298320    }
    299321    catch (cf::exception & e)

  • trunk/msgclnt.h

    r12 r14  
    1515    std::string message;
    1616    int sensitive;
    17     bool isError;
    1817
    1918    // only for listen
    … …  
    2928typedef struct SCallback
    3029{
    31     int(*onChat)(SConversation &);
     30    int(*onListen)(SConversation &);
    3231    int(*onOpenSession)(SOpenSession &);
    3332} SCallback;
    … …  
    7776    std::vector<SFriend> getFriendList();
    7877
    79     std::string getSessionID(std::vector<std::string> & idList);
     78    std::string getSessionID(const std::vector<std::string> & idList);
    8079
    8180    bool tell(const SConversation & conversation);

  • trunk/msgsrv.cpp

    r13 r14  
    1616// --------------------------------------------------------------
    1717
    18 typedef struct
     18typedef struct LoginSession
    1919{
    2020    cf::network::tcp * sock;
    … …  
    2222} LoginSession;
    2323std::map<std::string, LoginSession> gOnlineUsers;
    24 
    25 
    26 //================================================================
     24std::map<std::string, std::vector<std::string> > gSessionMap;
     25
     26// --------------------------------------------------------------
    2727
    2828int cb_getFriendList(void * userArg, int argc, char ** argv, char ** colName)
    … …  
    7575        : db(NULL)
    7676    {
     77        Init();
    7778    }
    7879   
    … …  
    139140        throw(cf::exception)
    140141    {
    141         int result;
    142         char * errMsg;
     142        int result = 0;
     143        char * errMsg = NULL;
    143144
    144145        result = sqlite3_exec(db, query.c_str(), cb, userArg, &errMsg);
    145146
    146147        if (result != SQLITE_OK)
    147             THROW_EXCEPTION (errMsg);
     148            THROW_EXCEPTION("[DBERROR][" << result << "] " << errMsg);
    148149    }
    149150
    … …  
    163164        {
    164165            FORWARD_EXCEPTION(e);
    165 
    166             return false;
    167166        }
    168167    }
    … …  
    175174            bool isExist = false;
    176175            std::string existQuery = "select * from T_ACCOUNT where id = '" + id + "'";
    177             std::string insertQuery = "insert into T_ACCOUNT values('" + id + "', '" + pw + "', '" + sms + "', '" + ip + "')";
     176            std::string insertQuery = "insert into T_ACCOUNT(id, pw) values('" + id + "', '" + pw + "')";
    178177
    179178            this->exec(existQuery, cb_join, &isExist);
    … …  
    282281{
    283282    gOnlineUsers.erase(id);
     283    LOG(STR(id << " was logged out"));
     284}
     285
     286static unsigned int generateSeed()
     287{
     288    unsigned int ret = 0;
     289    int t = (int)time(NULL);
     290
     291    cf::bin b;
     292    b.resize(sizeof(int));
     293
     294    b.set((cf::uint8_t*)&t, sizeof(int));
     295    cf::bin s = crypto().sha256(b);
     296
     297    memcpy(&ret, s.buffer(), sizeof(unsigned int));
     298
     299    return ret;
    284300}
    285301
    … …  
    287303{
    288304    char random[8] = {0x00,};
    289     sprintf(random, "%06d", rand() % 1000000);
     305    sprintf(random, "%06d", generateSeed() % 1000000);
    290306
    291307    return random;
    … …  
    294310static std::string httpSMS(const Protocol::Message & parser)
    295311{
    296     std::string phone = parser.get<std::string>("phone");
     312    std::string phone = parser.get<std::string>(ProtocolType::PHONE);
    297313
    298314#define CRLF    "\r\n"
    … …  
    306322        CRLF;
    307323
    308     Protocol::Response response;
    309324    cf::network::tcp smsSock;
    310325    cf::network::host smsServer(url, 80);
    … …  
    312327    smsSock.connect(smsServer);
    313328    smsSock.send(http);
     329    smsSock.receive();
    314330    smsSock.close();
    315331
    … …  
    329345}
    330346
    331 static bool login(const Protocol::Message & parser)
     347static bool login(const Protocol::Message & parser, cf::network::tcp & sock, cf::bin & key)
    332348    throw (cf::exception)
    333349{
    … …  
    335351    std::string pw = parser.get<std::string>(ProtocolType::PW);
    336352
    337     return dbmgr.login(id, pw);
    338 }
    339 
    340 static bool chat(const Protocol::Message & parser,
    341                  const std::string & message)
     353    bool result = dbmgr.login(id, pw);
     354    if (result)
     355    {
     356        LoginSession loginSess;
     357        loginSess.sock = &sock;
     358        loginSess.key = key;
     359        gOnlineUsers[id] = loginSess;
     360    }
     361
     362    return result;
     363}
     364
     365static bool chat(const Protocol::Message & message)
    342366{
    343367    bool result = false;
    344     std::string to = parser.get<std::string>(ProtocolType::TO);
    345 
    346     if (isOnline(to))
    347     {
    348         gOnlineUsers[to].sock->send(message);
     368    Protocol::Message parser = message;
     369    std::string sessid = parser.get<std::string>(ProtocolType::SESSION_ID);
     370    std::vector<std::string> idList = gSessionMap[sessid];
     371    std::string sender = parser.get<std::string>(ProtocolType::ID);
     372    parser.mObject[ProtocolType::TYPE] = ProtocolType::LISTEN;
     373    std::string serialized = parser.serialize();
     374
     375    for (size_t iter = 0; iter < idList.size(); iter++)
     376    {
     377        std::string id = idList[iter];
     378
     379        if (sender != id && isOnline(id))
     380            gOnlineUsers[id].sock->send(serialized);
     381
    349382        result = true;
    350383    }
    … …  
    362395}
    363396
    364 static bool opensession(const Protocol::Message & parser)
    365 {
     397static bool openSession(const Protocol::Message & message)
     398{
     399    Protocol::Message parser = message;
    366400    bool result = false;
    367401    std::string sessid;
    368402    std::vector<std::string> idList = parser.getList<std::string>(ProtocolType::ID_LIST);
    369     std::string concat = idList[0];
    370 
    371     for (size_t iter = 1; iter < concat.size(); iter++)
    372         concat += idList[iter];
     403    std::string concat = joinStrings(idList);
    373404
    374405    sessid = createSessionID(concat);
    375406
     407    parser.mObject[ProtocolType::SESSION_ID] = sessid;
     408    std::string serialized = parser.serialize();
     409
    376410    for (size_t iter = 0; iter < idList.size(); iter++)
    377411    {
    378         if (isOnline(idList[iter]))
    379             gOnlineUsers[idList[iter]].sock->send(sessid);
     412        std::string id = idList[iter];
     413        if (isOnline(id))
     414            gOnlineUsers[id].sock->send(serialized);
    380415
    381416        result = true;
    382417    }
    383418
     419    gSessionMap[sessid] = idList;
     420
    384421    return result;
    385422}
    … …  
    396433static std::string workerInitiator(cf::network::tcp & sock)
    397434{
     435    Protocol::Message parser;
     436
    398437    try
    399438    {
    400439        std::string sms;
     440        std::string id;
     441        bool loggedIn = false;
    401442
    402443        while (true)
    403444        {
    404             Protocol::Message parser;
    405445            parser.parse(sock.receive().toString());
    406446
    407             if (parser.type() == "sms")
     447            if (parser.type() == ProtocolType::SMS)
    408448            {
    409449                sms = httpSMS(parser);
    410450            }
    411             else if (parser.type() == "join")
     451            else if (parser.type() == ProtocolType::JOIN)
    412452            {
    413                 if (join(parser, sms, sock.peer().address()))
     453                if (!join(parser, sms, sock.peer().address()))
    414454                    THROW_EXCEPTION("user(" << parser.get<std::string>(ProtocolType::ID) << ") cannot join");
    415455            }
    416             else if (parser.type() == "login")
     456            else if (parser.type() == ProtocolType::LOGIN)
    417457            {
    418                 if (login(parser))
    419                     parser.get<std::string>(ProtocolType::ID);
    420             }           
     458                std::string ip = sock.peer().address();
     459                cf::bin seed = sms + DELIMITER + ip;
     460                cf::bin key = crypto().sha256(seed);
     461
     462                if (login(parser, sock, key))
     463                    id = parser.get<std::string>(ProtocolType::ID);
     464
     465                loggedIn = true;
     466            }
     467
     468            // success
     469            sock.send(Protocol::Response().result(parser.type(), true));
     470            if (loggedIn)
     471                return id;
    421472        }
    422473    }
    423474    catch (cf::exception & e)
    424475    {
     476        sock.send(Protocol::Response().result(parser.type(), false));
    425477        FORWARD_EXCEPTION(e);
    426478    }
    … …  
    436488    try
    437489    {
    438         workerInitiator(*sock);
     490        id = workerInitiator(*sock);
    439491
    440492        Protocol::Response response;
    … …  
    449501            LOG(message);
    450502
    451             if (parser.type() == "chat")
    452                 result = chat(parser, message);
    453             else if (parser.type() == "opensession")
    454                 result = opensession(parser);
    455 //          else if (parser.type() == "getFriendList")
    456 //              result =
    457 
    458             sock->send(response.result(parser.type(), result));
     503            if (parser.type() == ProtocolType::TELL)
     504            {
     505                result = chat(parser);
     506                sock->send(response.result(parser.type(), result));
     507            }
     508            else if (parser.type() == ProtocolType::OPEN_SESSION)
     509            {
     510                result = openSession(parser);
     511            }
    459512        }
    460513    }
    461514    catch (cf::exception & e)
    462515    {
    463         LOG(e.what());
     516        LOG(e.stackTrace());
    464517    }
    465518
    … …  
    472525{
    473526    cf::network::tcp sock;
    474 
    475     srand((unsigned int)time(NULL));
    476527
    477528    try

  • trunk/msvc14/ChevMsgrClient_MFC/ChevMsgrClient_MFC.h

    r4 r14  
    3131
    3232extern CChevMsgrClient_MFCApp theApp;
     33
     34#include <string>
     35
     36static std::string wstr2str(const std::wstring & wstr)
     37{
     38    return std::string().assign(wstr.begin(), wstr.end());
     39}
     40
     41static std::wstring str2wstr(const std::string & str)
     42{
     43    return std::wstring().assign(str.begin(), str.end());
     44}

  • trunk/msvc14/ChevMsgrClient_MFC/ChevMsgrClient_MFC.vcxproj

    r8 r14  
    192192    <ClInclude Include="ChevMsgrClient_MFC.h" />
    193193    <ClInclude Include="ChevMsgrClient_MFCDlg.h" />
     194    <ClInclude Include="LoginDlg.h" />
     195    <ClInclude Include="RegisterDlg.h" />
    194196    <ClInclude Include="Resource.h" />
     197    <ClInclude Include="SMSDlg.h" />
    195198    <ClInclude Include="stdafx.h" />
    196199    <ClInclude Include="targetver.h" />
    … …  
    199202    <ClCompile Include="ChevMsgrClient_MFC.cpp" />
    200203    <ClCompile Include="ChevMsgrClient_MFCDlg.cpp" />
     204    <ClCompile Include="LoginDlg.cpp" />
     205    <ClCompile Include="RegisterDlg.cpp" />
     206    <ClCompile Include="SMSDlg.cpp" />
    201207    <ClCompile Include="stdafx.cpp">
    202208      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>

  • trunk/msvc14/ChevMsgrClient_MFC/ChevMsgrClient_MFC.vcxproj.filters

    r4 r14  
    3434      <Filter>헤더 파일</Filter>
    3535    </ClInclude>
     36    <ClInclude Include="LoginDlg.h">
     37      <Filter>헤더 파일</Filter>
     38    </ClInclude>
     39    <ClInclude Include="RegisterDlg.h">
     40      <Filter>헤더 파일</Filter>
     41    </ClInclude>
     42    <ClInclude Include="SMSDlg.h">
     43      <Filter>헤더 파일</Filter>
     44    </ClInclude>
    3645  </ItemGroup>
    3746  <ItemGroup>
    … …  
    4352    </ClCompile>
    4453    <ClCompile Include="stdafx.cpp">
     54      <Filter>소스 파일</Filter>
     55    </ClCompile>
     56    <ClCompile Include="SMSDlg.cpp">
     57      <Filter>소스 파일</Filter>
     58    </ClCompile>
     59    <ClCompile Include="LoginDlg.cpp">
     60      <Filter>소스 파일</Filter>
     61    </ClCompile>
     62    <ClCompile Include="RegisterDlg.cpp">
    4563      <Filter>소스 파일</Filter>
    4664    </ClCompile>

  • trunk/msvc14/ChevMsgrClient_MFC/ChevMsgrClient_MFCDlg.cpp

    r4 r14  
    77#include "ChevMsgrClient_MFCDlg.h"
    88#include "afxdialogex.h"
     9
     10#include "LoginDlg.h"
     11#include "RegisterDlg.h"
     12#include "SMSDlg.h"
    913
    1014#ifdef _DEBUG
    … …  
    101105    // TODO: ¿©±â¿¡ Ãß°¡ ÃʱâÈ­ ÀÛ¾÷À» Ãß°¡ÇÕ´Ï´Ù.
    102106
     107    CLoginDlg loginDlg;
     108    CSMSDlg smsDlg;
     109    CRegisterDlg regDlg;
     110
     111    loginDlg.DoModal();
     112
    103113    return TRUE;  // Æ÷Ä¿½º¸¦ ÄÁÆ®·Ñ¿¡ ¼³Á¤ÇÏÁö ¾ÊÀ¸¸é TRUE¸¦ ¹ÝȯÇÕ´Ï´Ù.
    104114}

  • trunk/msvc14/chevmsgr.sln

    r13 r14  
    1212Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "client", "client\client.vcxproj", "{E1C8D6C3-6426-417E-9B20-8A8D0F824CDB}"
    1313    ProjectSection(ProjectDependencies) = postProject
     14        {A5238B12-5F59-4AF2-BC5C-DD93352082FD} = {A5238B12-5F59-4AF2-BC5C-DD93352082FD}
    1415        {39F45AE4-072E-44C4-8E2B-94DAC2333A5D} = {39F45AE4-072E-44C4-8E2B-94DAC2333A5D}
    1516    EndProjectSection
    … …  
    1819EndProject
    1920Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ChevMsgrClient_MFC", "ChevMsgrClient_MFC\ChevMsgrClient_MFC.vcxproj", "{D1A1A73A-7E56-40FA-9D43-B8737C585D18}"
     21    ProjectSection(ProjectDependencies) = postProject
     22        {E1C8D6C3-6426-417E-9B20-8A8D0F824CDB} = {E1C8D6C3-6426-417E-9B20-8A8D0F824CDB}
     23    EndProjectSection
    2024EndProject
    2125Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "crypto", "crypto\crypto.vcxproj", "{A5238B12-5F59-4AF2-BC5C-DD93352082FD}"
     26EndProject
     27Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testClient", "testClient\testClient.vcxproj", "{765F513C-69FF-40AA-8EAF-624AE2DCA5F0}"
     28    ProjectSection(ProjectDependencies) = postProject
     29        {E1C8D6C3-6426-417E-9B20-8A8D0F824CDB} = {E1C8D6C3-6426-417E-9B20-8A8D0F824CDB}
     30    EndProjectSection
    2231EndProject
    2332Global
    … …  
    6978        {A5238B12-5F59-4AF2-BC5C-DD93352082FD}.Release|x86.ActiveCfg = Release|Win32
    7079        {A5238B12-5F59-4AF2-BC5C-DD93352082FD}.Release|x86.Build.0 = Release|Win32
     80        {765F513C-69FF-40AA-8EAF-624AE2DCA5F0}.Debug|x64.ActiveCfg = Debug|x64
     81        {765F513C-69FF-40AA-8EAF-624AE2DCA5F0}.Debug|x64.Build.0 = Debug|x64
     82        {765F513C-69FF-40AA-8EAF-624AE2DCA5F0}.Debug|x86.ActiveCfg = Debug|Win32
     83        {765F513C-69FF-40AA-8EAF-624AE2DCA5F0}.Debug|x86.Build.0 = Debug|Win32
     84        {765F513C-69FF-40AA-8EAF-624AE2DCA5F0}.Release|x64.ActiveCfg = Release|x64
     85        {765F513C-69FF-40AA-8EAF-624AE2DCA5F0}.Release|x64.Build.0 = Release|x64
     86        {765F513C-69FF-40AA-8EAF-624AE2DCA5F0}.Release|x86.ActiveCfg = Release|Win32
     87        {765F513C-69FF-40AA-8EAF-624AE2DCA5F0}.Release|x86.Build.0 = Release|Win32
    7188    EndGlobalSection
    7289    GlobalSection(SolutionProperties) = preSolution
Note: See TracChangeset for help on using the changeset viewer.