psnetworkclient.cxx

SIP（Session Initiation Protocol）是由IETF定义

/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact [e-mail].
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 */

static const char* const PSNetworkClient_cxx_Version =
    "$Id: PSNetworkClient.cxx,v 1.2 2002/09/26 01:14:02 bko Exp $";

#include "PSNetworkClient.hxx"
#include "Vpp_def.h"
#include "cpLog.h"
#include <stdio.h>


PSNetworkClient::PSNetworkClient(const NetworkAddress& server,
				 bool closeCon,
				 bool blocking,
                                 bool useTls)
    :mySocket(server, closeCon, blocking),
     myConnection(0),
     myUseTls(useTls)
{
}


Connection&
PSNetworkClient::getConn(Data password) throw (VNetworkException&)
{
#if VOCAL_HAS_OPENSSL
    if(myConnection)
    {
        delete myConnection;
        myConnection = 0;
    }
#endif

    mySocket.connect();
    Connection* conn = &mySocket.getConn();

    LocalScopeAllocator lo;
    char buf[256];

    Data result;
    int length;
    Data junk;

    if(TlsConnection::hasTls() && myUseTls)
    {
        // do the TLS stuff if you need to.

        // first, negotiate a TLS connection.

        sprintf(buf, "TLS . %s\n", VPP_VERSION);
        if(sendCommand(*conn, buf, result, length, junk, true) && result == "200 OK\n")
        {
                cpLog(LOG_DEBUG, "trying TLS");
                myConnection = new TlsConnection(*conn);
                int result = myConnection->initTlsClient();
                if(result > 0)
                {
                    cpLog(LOG_DEBUG, "TLS OK!");
                    conn = myConnection;
                }
                else
                {
                    LocalScopeAllocator lo;
                    Data tmp = myConnection->getErrMsg(-1);
                    cpLog(LOG_DEBUG, "TLS failed: %s!",
                          tmp.getData(lo));
                }
        }
        else
        {
            // if this is not OK, you should fail.
            cpLog(LOG_DEBUG, "failed TLS negotiation");
        }
    }

    if(password.length() > 200)
    {
	password = password.substring(0, 199);
    }

    sprintf(buf, "AUTH %s %s\n",
	    password.getData(lo),
 	    VPP_VERSION);

    if(sendCommand(*conn, buf, result, length, junk, true))
    {
        if(result == "200 OK\n")
        {
            return *conn;
        }
    }

    throw VNetworkException("Failed to connect: incorrect password",
			    __FILE__, __LINE__, -1);
}


Data
readLineBlock(Connection& conn)
{
    char rdbuf[MAXLINE];
    int nRead;
    // read a real line, or die trying
    Data result;
    while(1)
    {
        int err = conn.readLine((void*)rdbuf, (sizeof(rdbuf) - 1), nRead);

        if(nRead >= 0)
        {
            rdbuf[nRead] = '\0';
        }
        result += rdbuf;

        if(err < 0)
        {
            throw VNetworkException("lost connection",
			    __FILE__, __LINE__, -1);
        }
        if(nRead > 0 && rdbuf[nRead-1] == '\n')
        {
            break;
        }
    }
    return result;
}


Data
readDataBlock(Connection& conn, int length)
{
    int newLength = length;
    char rdbuf[MAXLINE];
    int nRead = 0;
    // read a real line, or die trying
    Data result;

    while(1)
    {
        rdbuf[0] = '\0';
        nRead = 0;

        int bufsize = sizeof(rdbuf) - 1;
        if(newLength < bufsize)
        {
            bufsize = newLength;
        }

        int err = conn.readn((void*)rdbuf, bufsize, nRead);

        if(nRead >= 0)
        {
            assert(result.length() + newLength == length);
            int oldlen = result.length();
            rdbuf[nRead] = '\0';
//            assert(strlen(rdbuf) == nRead);
            if(nRead > newLength)
            {
                result += Data(rdbuf, newLength);
                newLength = newLength - newLength;
            } 
            else 
            {
                result += Data(rdbuf, nRead);
                newLength = newLength - nRead;
            }
//            assert(result.length() == oldlen + nRead);
            assert(result.length() + newLength == length);
        }

        if(err < 0)
        {
            throw VNetworkException("lost connection",
			    __FILE__, __LINE__, -1);
        }

        if(newLength <= 0)
        {
            cpLog(LOG_DEBUG_STACK, "%d %d", length, result.length());
            assert(length == result.length());
            break;
        }
    }
    return result;
}


bool sendCommand(Connection& conn, 
                 const char* cmd,
                 Data& result,
                 int& length,
                 Data& data,
                 bool concatData)
{
    cpLog(LOG_DEBUG_STACK, "sending command to pserver: %s", cmd);
    conn.writeData(const_cast<char*>(cmd), strlen(cmd));

    Data resultCode;
    Data contentLength;
    try
    {
        resultCode = readLineBlock(conn);
        contentLength = readLineBlock(conn);
    }
    catch (VNetworkException)
    {
        // this is no good
        return false;
    }

    data = resultCode;
    data += contentLength;

    LocalScopeAllocator lo;
    cpLog(LOG_DEBUG, "resultCode: %s", resultCode.getData(lo));
    cpLog(LOG_DEBUG, "contentLength: %s", contentLength.getData(lo));

    bool matchfail;

    Data contentLengthHead = contentLength.parse(": ", &matchfail);

    if(resultCode.length() > 0 && !matchfail && contentLengthHead == "Content-Length" && contentLength.length() > 0)
    {
        cpLog(LOG_DEBUG, "command got something");
        length = contentLength.convertInt();
        result = resultCode;

        if(length > 0)
        {
            cpLog(LOG_DEBUG, "reading %d bytes", length);
            // read some more data...
            Data tmp = readDataBlock(conn, length);
            cpLog(LOG_DEBUG, "done reading %d bytes", length);
            if(tmp.length() != length)
            {
                cpLog(LOG_DEBUG, "failed!");
                return false;
            }

            if(concatData)
            {
                data += tmp;
            }
            else
            {
                data = tmp;
            }

        }

        return true;
    }
    cpLog(LOG_DEBUG, "command didn't work!");
 
    return false;
}

/* Local Variables: */
/* c-file-style: "stroustrup" */
/* indent-tabs-mode: nil */
/* c-file-offsets: ((access-label . -) (inclass . ++)) */
/* c-basic-offset: 4 */
/* End: */