dum/test/testSMIMEInvite.cxx

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "resip/dum/DialogUsageManager.hxx"
#include "resip/dum/ClientRegistration.hxx"
#include "resip/dum/ClientInviteSession.hxx"
#include "resip/dum/ServerInviteSession.hxx"
#include "resip/dum/ClientAuthManager.hxx"

#include "resip/dum/RegistrationHandler.hxx"
#include "resip/dum/InviteSessionHandler.hxx"
#include "resip/dum/DumShutdownHandler.hxx"

#include "resip/dum/MasterProfile.hxx"
#include "resip/stack/ShutdownMessage.hxx"

#include "resip/stack/SdpContents.hxx"
#include "resip/stack/Pkcs7Contents.hxx"
#include "resip/stack/MultipartSignedContents.hxx"
#include "resip/stack/MultipartAlternativeContents.hxx"
#include "resip/stack/Mime.hxx"

#include "resip/stack/SecurityAttributes.hxx"
#include "resip/stack/Helper.hxx"

#include "rutil/FdPoll.hxx"
#include "rutil/Log.hxx"
#include "rutil/Logger.hxx"

#ifdef WIN32
#include "resip/stack/ssl/WinSecurity.hxx"
#else
#include "resip/stack/ssl/Security.hxx"
#endif

#include "TestDumHandlers.hxx"

#include <time.h>
#include <sstream>

using namespace std;
using namespace resip;

#define RESIPROCATE_SUBSYSTEM Subsystem::TEST


class TestSMIMEInviteHandler : public TestClientRegistrationHandler,
                               public TestInviteSessionHandler,
                               public TestDumShutdownHandler
{
   public:
      
      TestSMIMEInviteHandler(Security *sec) : handles(0), security(sec), registered(0), done(0), dumShutDown(0), connected(0), callFailed(false)
      {
      }

      virtual ~TestSMIMEInviteHandler()
      {
      }

      void resetRegistered(void)
      {
         registered = 0;
      }

      bool isConnected(void)
      {
         return (connected == 2);
      }
      
      bool isDumShutDown(void)
      {
         return (dumShutDown == 2);
      }

      bool isRegistered(void)
      {
         return (registered == 2);
      }
      
      bool isDone(void)
      {
         return (done == 2);
         
      }

      bool isCallFailed(void)
      {
         return callFailed;
      }

      SdpContents* generateBody()
      {
         Data* txt = new Data("v=0\r\n"
                              "o=1900 369696545 369696545 IN IP4 192.168.2.15\r\n"
                              "s=X-Lite\r\n"
                              "c=IN IP4 192.168.2.15\r\n"
                              "t=0 0\r\n"
                              "m=audio 8000 RTP/AVP 8 3 101\r\n"
                              "a=rtpmap:8 pcma/8000\r\n"
                              "a=rtpmap:3 gsm/8000\r\n"
                              "a=rtpmap:101 telephone-event/8000\r\n"
                              "a=fmtp:101 0-15\r\n");
         
         HeaderFieldValue hfv(txt->data(), txt->size());
         SdpContents *sdp = new SdpContents(hfv, Mime("application", "sdp"));
         return sdp;
      }
   

      virtual void onSuccess(ClientRegistrationHandle r,
                             const SipMessage& response)
      {
         InfoLog( << "ClientRegistrationHandler::onSuccess" );
         handles.push_back(r);
         registered++;
      }

      virtual void onConnected(ClientInviteSessionHandle,
                               const SipMessage& msg)
      {
         InfoLog( << "ClientInviteSessionHandler::onConnected" );
         connected++;
      }

      using TestClientRegistrationHandler::onFailure;
      virtual void onFailure(ClientInviteSessionHandle,
                             const SipMessage& msg)
      {
         InfoLog( << "TestInviteSessionHander::onFailure" );
         callFailed = true;
      }

      using TestInviteSessionHandler::onNewSession;
      virtual void onNewSession(ServerInviteSessionHandle is,
                                InviteSession::OfferAnswerType oat,
                                const SipMessage& msg)
      {
         InfoLog( << "ServerInviteSessionHandler::onNewSession" );
         sis = is;
         is->provisional(180);
      }

      virtual void onConnected(InviteSessionHandle,
                               const SipMessage& msg)
      {
         InfoLog( << "InviteSessionHandler::onConnected()" );
         connected++;
      }

      virtual void onTerminated(InviteSessionHandle,
                                InviteSessionHandler::TerminatedReason reason,
                                const SipMessage* msg)
      {
         InfoLog( << "InviteSessionHandler::onTerminated");
         done++;
      }

      virtual void onOffer(InviteSessionHandle is,
                           const SipMessage& msg,
                           const SdpContents& sdp)
      {
         InfoLog( << "InviteSessionHandler::onOffer" );
         InfoLog( << "Server received SDP: " << sdp );

         const SecurityAttributes *attr = msg.getSecurityAttributes();
         if (attr)
         {
            InfoLog( << *attr );
         }
         else
         {
            InfoLog( << "no Security Attributes" );
         }

         if (sis.isValid())
         {
            NameAddr fromAor(msg.header(h_From).uri());
            NameAddr toAor(msg.header(h_To).uri());
            is->provideAnswer(*generateBody());
            sis->accept();
         }
      }
      
      virtual void onAnswer(InviteSessionHandle,
                            const SipMessage& msg,
                            const SdpContents& sdp)
      {
         InfoLog( << "InviteSessionHandler::onAnswer");
         InfoLog( << "Client received SDP: " << sdp );

         const SecurityAttributes *attr = msg.getSecurityAttributes();
         if (attr)
         {
            InfoLog( << *attr );
         }
         else
         {
            InfoLog( << "no Security Attributes" );
         }
         
      }

      virtual void onDumCanBeDeleted() 
      {
         InfoLog( << "DumShutDownHandler::onDumCanBeDeleted" );
         dumShutDown++;
      }

      virtual void onReferNoSub(InviteSessionHandle, const SipMessage& msg)
      {
         InfoLog(<< "InviteSessionHandler::onReferNoSub(): " << msg.brief());
      }

   public:
      std::vector<ClientRegistrationHandle> handles;
      ServerInviteSessionHandle sis;

   private:
      Security *security;
      int registered;
      int done;
      int dumShutDown;
      int connected;
      bool callFailed;
      
};


int 
main (int argc, char** argv)
{
   if ( argc < 5 ) {
      cout << "usage: " << argv[0] << " sip:user1 passwd1 sip:user2 passwd2" << endl;
      return 1;
   }

   Log::initialize(Log::Cout, Log::Debug, argv[0]);

   NameAddr clientAor(argv[1]);
   Data clientPasswd(argv[2]);
   NameAddr serverAor(argv[3]);
   Data serverPasswd(argv[4]);

#ifdef WIN32
   Security* security = new WinSecurity;
#else
   Security* security = new Security;
#endif

   TestSMIMEInviteHandler handler(security);

   // Shared FdPollGrp
   std::auto_ptr<FdPollGrp> pollGrp(FdPollGrp::create());

   // set up UAC
   SipStack clientStack(security,
                        DnsStub::EmptyNameserverList,
                        0,
                        false,
                        0,
                        0,
                        pollGrp.get());
   DialogUsageManager clientDum(clientStack);
   srand(time(NULL));
   clientDum.addTransport(UDP, 0, V4);
   clientDum.addTransport(TCP, 0, V4);
   clientDum.addTransport(TLS, 0, V4);
#ifdef USE_IPV6
   clientDum.addTransport(UDP, 0, V6);
   clientDum.addTransport(TCP, 0, V6);
   clientDum.addTransport(TLS, 0, V6);
#endif

   SharedPtr<MasterProfile> clientProfile(new MasterProfile);   
   auto_ptr<ClientAuthManager> clientAuth(new ClientAuthManager());   

   clientDum.setClientAuthManager(clientAuth);
   clientDum.setClientRegistrationHandler(&handler);
   clientDum.setInviteSessionHandler(&handler);

   clientProfile->setDefaultFrom(clientAor);
   clientProfile->setDigestCredential(clientAor.uri().host(),clientAor.uri().user(),clientPasswd);
   clientProfile->setDefaultRegistrationTime(60);
   clientProfile->addSupportedMethod(INVITE);
   clientProfile->addSupportedMimeType(INVITE, Mime("application", "pkcs7-mime"));
   clientProfile->addSupportedMimeType(INVITE, Mime("multipart", "signed"));
   clientProfile->addSupportedMimeType(INVITE, Mime("multipart", "alternative"));
   clientDum.setMasterProfile(clientProfile);

   //set up UAS
   SipStack serverStack(security,
                        DnsStub::EmptyNameserverList,
                        0,
                        false,
                        0,
                        0,
                        pollGrp.get());
   DialogUsageManager serverDum(serverStack);
   //serverDum.addTransport(UDP, 0, V4);
   serverDum.addTransport(TCP, 0, V4);
   //serverDum.addTransport(TLS, 0, V4);

   SharedPtr<MasterProfile> serverProfile(new MasterProfile);
   std::auto_ptr<ClientAuthManager> serverAuth(new ClientAuthManager);

   serverDum.setClientAuthManager(serverAuth);
   serverDum.setClientRegistrationHandler(&handler);
   serverDum.setInviteSessionHandler(&handler);

   serverProfile->setDefaultFrom(serverAor);
   serverProfile->setDigestCredential(serverAor.uri().host(),serverAor.uri().user(),serverPasswd);
   serverProfile->setDefaultRegistrationTime(60);
   serverProfile->addSupportedMethod(INVITE);
   serverProfile->addSupportedMimeType(INVITE, Mime("application", "pkcs7-mime"));
   serverProfile->addSupportedMimeType(INVITE, Mime("multipart", "signed"));
   serverProfile->addSupportedMimeType(INVITE, Mime("multipart", "alternative"));
   serverDum.setMasterProfile(serverProfile);

   enum
      {
         Registering,
         Inviting,
         Waiting,
         HangingUp,
         Unregistering,
         ShuttingDown,
         Finished
      } state;
   time_t endTime=0;

   // register client and server
   SharedPtr<SipMessage> clientRegMessage = clientDum.makeRegistration(clientAor);
   clientDum.send(clientRegMessage);
   SharedPtr<SipMessage> serverRegMessage = serverDum.makeRegistration(serverAor);
   serverDum.send(serverRegMessage);
   state = Registering;

   while (state != Finished)
   {
      // This waits on IO for both stacks; this is the canonical way to drive
      // multiple stacks with the same thread. We could make two calls to 
      // process(), but this requires more calls to epoll_wait/select.
      pollGrp->waitAndProcess(resipMin(clientStack.getTimeTillNextProcessMS(),
                                       serverStack.getTimeTillNextProcessMS()));
      clientStack.processTimers();
      serverStack.processTimers();

      while(clientDum.process() || serverDum.process());

      switch (state)
      {
         case Registering:
         {
            if (handler.isRegistered())
            {
               InfoLog( << "Sending INVITE request" );
               clientDum.send(clientDum.makeInviteSession(serverAor,
                                                          handler.generateBody()));
               state = Inviting;
            }
            break;
         }
         
         case Inviting:
         {
            if (handler.isConnected())
            {
               InfoLog( << "Starting timer, waiting for 5 seconds" );
               endTime = time(NULL) + 5;
               state = Waiting;
            }
            break;
         }
         
         case Waiting:
         {
            if (handler.isCallFailed())
            {
               InfoLog( << "Call Failed" );
               for (std::vector<ClientRegistrationHandle>::iterator it = handler.handles.begin();
                    it != handler.handles.end(); it++)
               {
                  (*it)->end();
               }
               state = Unregistering;
            }

            if (time(NULL) > endTime)
            {
               InfoLog( << "Timer expired, hanging up" );
               handler.sis->end();
               state = HangingUp;
            }
            break;
         }

         case HangingUp:
         {
            if (handler.isDone())
            {
               for (std::vector<ClientRegistrationHandle>::iterator it = handler.handles.begin();
                       it != handler.handles.end(); it++)
               {
                  (*it)->end();
               }
               state = Unregistering;
            }
            break;
         }
         
         case Unregistering:
         {
            if (handler.isRegistered())
            {
               InfoLog( << "Shutting down" );
               serverDum.shutdown(&handler);
               clientDum.shutdown(&handler);
               state = ShuttingDown;
            }
            break;
         }
         
         case ShuttingDown:
         {
            if (handler.isDumShutDown()) 
            {
               InfoLog( << "Finished" );
               state = Finished;
            }
            
            break;
         }

         default:
         {
            InfoLog( << "Unrecognised state" );
            assert(0);
         }
      }
      
   }

   return 0;

}

/* ====================================================================
 * 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 vocal@vovida.org.
 *
 * 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/>.
 *
 */
1	dpocock	9491	#ifdef HAVE_CONFIG_H
2			#include "config.h"
3			#endif
4
5	jason	5276	#include "resip/dum/DialogUsageManager.hxx"
6			#include "resip/dum/ClientRegistration.hxx"
7			#include "resip/dum/ClientInviteSession.hxx"
8			#include "resip/dum/ServerInviteSession.hxx"
9			#include "resip/dum/ClientAuthManager.hxx"
10	greg	5016
11	jason	5276	#include "resip/dum/RegistrationHandler.hxx"
12			#include "resip/dum/InviteSessionHandler.hxx"
13			#include "resip/dum/DumShutdownHandler.hxx"
14	greg	5016
15	jason	5276	#include "resip/dum/MasterProfile.hxx"
16	derek	5283	#include "resip/stack/ShutdownMessage.hxx"
17	greg	5016
18	derek	5283	#include "resip/stack/SdpContents.hxx"
19			#include "resip/stack/Pkcs7Contents.hxx"
20			#include "resip/stack/MultipartSignedContents.hxx"
21			#include "resip/stack/MultipartAlternativeContents.hxx"
22			#include "resip/stack/Mime.hxx"
23	greg	5016
24	derek	5283	#include "resip/stack/SecurityAttributes.hxx"
25			#include "resip/stack/Helper.hxx"
26	greg	5016
27	sgodin	9367	#include "rutil/FdPoll.hxx"
28	jason	5276	#include "rutil/Log.hxx"
29			#include "rutil/Logger.hxx"
30	greg	5016
31			#ifdef WIN32
32	bcampen	8228	#include "resip/stack/ssl/WinSecurity.hxx"
33	adam	8415	#else
34			#include "resip/stack/ssl/Security.hxx"
35	greg	5016	#endif
36
37			#include "TestDumHandlers.hxx"
38
39			#include <time.h>
40			#include <sstream>
41
42			using namespace std;
43			using namespace resip;
44
45			#define RESIPROCATE_SUBSYSTEM Subsystem::TEST
46
47
48			class TestSMIMEInviteHandler : public TestClientRegistrationHandler,
49			public TestInviteSessionHandler,
50			public TestDumShutdownHandler
51			{
52			public:
53
54			TestSMIMEInviteHandler(Security *sec) : handles(0), security(sec), registered(0), done(0), dumShutDown(0), connected(0), callFailed(false)
55			{
56			}
57
58			virtual ~TestSMIMEInviteHandler()
59			{
60			}
61
62			void resetRegistered(void)
63			{
64			registered = 0;
65			}
66
67			bool isConnected(void)
68			{
69			return (connected == 2);
70			}
71
72			bool isDumShutDown(void)
73			{
74			return (dumShutDown == 2);
75			}
76
77			bool isRegistered(void)
78			{
79			return (registered == 2);
80			}
81
82			bool isDone(void)
83			{
84			return (done == 2);
85
86			}
87
88			bool isCallFailed(void)
89			{
90			return callFailed;
91			}
92
93			SdpContents* generateBody()
94			{
95			Data* txt = new Data("v=0\r\n"
96			"o=1900 369696545 369696545 IN IP4 192.168.2.15\r\n"
97			"s=X-Lite\r\n"
98			"c=IN IP4 192.168.2.15\r\n"
99			"t=0 0\r\n"
100			"m=audio 8000 RTP/AVP 8 3 101\r\n"
101			"a=rtpmap:8 pcma/8000\r\n"
102			"a=rtpmap:3 gsm/8000\r\n"
103			"a=rtpmap:101 telephone-event/8000\r\n"
104			"a=fmtp:101 0-15\r\n");
105
106	sgodin	9367	HeaderFieldValue hfv(txt->data(), txt->size());
107	greg	5016	SdpContents *sdp = new SdpContents(hfv, Mime("application", "sdp"));
108			return sdp;
109			}
110
111
112			virtual void onSuccess(ClientRegistrationHandle r,
113			const SipMessage& response)
114			{
115			InfoLog( << "ClientRegistrationHandler::onSuccess" );
116			handles.push_back(r);
117			registered++;
118			}
119
120			virtual void onConnected(ClientInviteSessionHandle,
121			const SipMessage& msg)
122			{
123			InfoLog( << "ClientInviteSessionHandler::onConnected" );
124			connected++;
125			}
126
127	adam	8437	using TestClientRegistrationHandler::onFailure;
128	greg	5016	virtual void onFailure(ClientInviteSessionHandle,
129			const SipMessage& msg)
130			{
131			InfoLog( << "TestInviteSessionHander::onFailure" );
132			callFailed = true;
133			}
134
135	adam	8437	using TestInviteSessionHandler::onNewSession;
136	greg	5016	virtual void onNewSession(ServerInviteSessionHandle is,
137			InviteSession::OfferAnswerType oat,
138			const SipMessage& msg)
139			{
140			InfoLog( << "ServerInviteSessionHandler::onNewSession" );
141			sis = is;
142			is->provisional(180);
143			}
144
145			virtual void onConnected(InviteSessionHandle,
146			const SipMessage& msg)
147			{
148			InfoLog( << "InviteSessionHandler::onConnected()" );
149			connected++;
150			}
151
152			virtual void onTerminated(InviteSessionHandle,
153			InviteSessionHandler::TerminatedReason reason,
154			const SipMessage* msg)
155			{
156			InfoLog( << "InviteSessionHandler::onTerminated");
157			done++;
158			}
159
160			virtual void onOffer(InviteSessionHandle is,
161			const SipMessage& msg,
162			const SdpContents& sdp)
163			{
164			InfoLog( << "InviteSessionHandler::onOffer" );
165			InfoLog( << "Server received SDP: " << sdp );
166
167			const SecurityAttributes *attr = msg.getSecurityAttributes();
168			if (attr)
169			{
170			InfoLog( << *attr );
171			}
172			else
173			{
174			InfoLog( << "no Security Attributes" );
175			}
176
177			if (sis.isValid())
178			{
179			NameAddr fromAor(msg.header(h_From).uri());
180			NameAddr toAor(msg.header(h_To).uri());
181			is->provideAnswer(*generateBody());
182			sis->accept();
183			}
184			}
185
186			virtual void onAnswer(InviteSessionHandle,
187			const SipMessage& msg,
188	bcampen	7081	const SdpContents& sdp)
189	greg	5016	{
190			InfoLog( << "InviteSessionHandler::onAnswer");
191			InfoLog( << "Client received SDP: " << sdp );
192
193			const SecurityAttributes *attr = msg.getSecurityAttributes();
194			if (attr)
195			{
196			InfoLog( << *attr );
197			}
198			else
199			{
200			InfoLog( << "no Security Attributes" );
201			}
202
203			}
204
205			virtual void onDumCanBeDeleted()
206			{
207			InfoLog( << "DumShutDownHandler::onDumCanBeDeleted" );
208			dumShutDown++;
209			}
210
211	jozsef	5888	virtual void onReferNoSub(InviteSessionHandle, const SipMessage& msg)
212			{
213			InfoLog(<< "InviteSessionHandler::onReferNoSub(): " << msg.brief());
214			}
215
216	greg	5016	public:
217			std::vector<ClientRegistrationHandle> handles;
218			ServerInviteSessionHandle sis;
219
220			private:
221			Security *security;
222			int registered;
223	greg	5308	int done;
224	greg	5016	int dumShutDown;
225			int connected;
226			bool callFailed;
227
228			};
229
230
231			int
232			main (int argc, char** argv)
233			{
234			if ( argc < 5 ) {
235			cout << "usage: " << argv[0] << " sip:user1 passwd1 sip:user2 passwd2" << endl;
236	greg	5308	return 1;
237	greg	5016	}
238
239			Log::initialize(Log::Cout, Log::Debug, argv[0]);
240
241			NameAddr clientAor(argv[1]);
242			Data clientPasswd(argv[2]);
243			NameAddr serverAor(argv[3]);
244			Data serverPasswd(argv[4]);
245
246			#ifdef WIN32
247			Security* security = new WinSecurity;
248			#else
249			Security* security = new Security;
250			#endif
251
252			TestSMIMEInviteHandler handler(security);
253
254	sgodin	9367	// Shared FdPollGrp
255			std::auto_ptr<FdPollGrp> pollGrp(FdPollGrp::create());
256
257	greg	5016	// set up UAC
258	sgodin	9367	SipStack clientStack(security,
259			DnsStub::EmptyNameserverList,
260			0,
261			false,
262			0,
263			0,
264			pollGrp.get());
265	greg	5016	DialogUsageManager clientDum(clientStack);
266			srand(time(NULL));
267	sgodin	8838	clientDum.addTransport(UDP, 0, V4);
268			clientDum.addTransport(TCP, 0, V4);
269			clientDum.addTransport(TLS, 0, V4);
270	greg	5016	#ifdef USE_IPV6
271	sgodin	8838	clientDum.addTransport(UDP, 0, V6);
272			clientDum.addTransport(TCP, 0, V6);
273			clientDum.addTransport(TLS, 0, V6);
274	greg	5016	#endif
275
276			SharedPtr<MasterProfile> clientProfile(new MasterProfile);
277			auto_ptr<ClientAuthManager> clientAuth(new ClientAuthManager());
278
279			clientDum.setClientAuthManager(clientAuth);
280			clientDum.setClientRegistrationHandler(&handler);
281			clientDum.setInviteSessionHandler(&handler);
282
283			clientProfile->setDefaultFrom(clientAor);
284			clientProfile->setDigestCredential(clientAor.uri().host(),clientAor.uri().user(),clientPasswd);
285			clientProfile->setDefaultRegistrationTime(60);
286			clientProfile->addSupportedMethod(INVITE);
287			clientProfile->addSupportedMimeType(INVITE, Mime("application", "pkcs7-mime"));
288			clientProfile->addSupportedMimeType(INVITE, Mime("multipart", "signed"));
289			clientProfile->addSupportedMimeType(INVITE, Mime("multipart", "alternative"));
290			clientDum.setMasterProfile(clientProfile);
291
292			//set up UAS
293	sgodin	9367	SipStack serverStack(security,
294			DnsStub::EmptyNameserverList,
295			0,
296			false,
297			0,
298			0,
299			pollGrp.get());
300	greg	5016	DialogUsageManager serverDum(serverStack);
301	sgodin	8838	//serverDum.addTransport(UDP, 0, V4);
302			serverDum.addTransport(TCP, 0, V4);
303			//serverDum.addTransport(TLS, 0, V4);
304	greg	5016
305			SharedPtr<MasterProfile> serverProfile(new MasterProfile);
306			std::auto_ptr<ClientAuthManager> serverAuth(new ClientAuthManager);
307
308			serverDum.setClientAuthManager(serverAuth);
309			serverDum.setClientRegistrationHandler(&handler);
310			serverDum.setInviteSessionHandler(&handler);
311
312			serverProfile->setDefaultFrom(serverAor);
313			serverProfile->setDigestCredential(serverAor.uri().host(),serverAor.uri().user(),serverPasswd);
314			serverProfile->setDefaultRegistrationTime(60);
315			serverProfile->addSupportedMethod(INVITE);
316			serverProfile->addSupportedMimeType(INVITE, Mime("application", "pkcs7-mime"));
317			serverProfile->addSupportedMimeType(INVITE, Mime("multipart", "signed"));
318			serverProfile->addSupportedMimeType(INVITE, Mime("multipart", "alternative"));
319			serverDum.setMasterProfile(serverProfile);
320
321			enum
322			{
323			Registering,
324			Inviting,
325			Waiting,
326			HangingUp,
327			Unregistering,
328			ShuttingDown,
329			Finished
330			} state;
331	bcampen	9119	time_t endTime=0;
332	greg	5016
333			// register client and server
334	daniel	5759	SharedPtr<SipMessage> clientRegMessage = clientDum.makeRegistration(clientAor);
335	greg	5016	clientDum.send(clientRegMessage);
336	daniel	5759	SharedPtr<SipMessage> serverRegMessage = serverDum.makeRegistration(serverAor);
337	greg	5016	serverDum.send(serverRegMessage);
338			state = Registering;
339
340			while (state != Finished)
341			{
342	sgodin	9367	// This waits on IO for both stacks; this is the canonical way to drive
343			// multiple stacks with the same thread. We could make two calls to
344			// process(), but this requires more calls to epoll_wait/select.
345			pollGrp->waitAndProcess(resipMin(clientStack.getTimeTillNextProcessMS(),
346			serverStack.getTimeTillNextProcessMS()));
347			clientStack.processTimers();
348			serverStack.processTimers();
349	greg	5016
350			while(clientDum.process() \|\| serverDum.process());
351
352			switch (state)
353			{
354			case Registering:
355			{
356			if (handler.isRegistered())
357			{
358			InfoLog( << "Sending INVITE request" );
359			clientDum.send(clientDum.makeInviteSession(serverAor,
360			handler.generateBody()));
361			state = Inviting;
362			}
363			break;
364			}
365
366			case Inviting:
367			{
368			if (handler.isConnected())
369			{
370			InfoLog( << "Starting timer, waiting for 5 seconds" );
371			endTime = time(NULL) + 5;
372			state = Waiting;
373			}
374			break;
375			}
376
377			case Waiting:
378			{
379			if (handler.isCallFailed())
380			{
381			InfoLog( << "Call Failed" );
382			for (std::vector<ClientRegistrationHandle>::iterator it = handler.handles.begin();
383			it != handler.handles.end(); it++)
384			{
385			(*it)->end();
386			}
387			state = Unregistering;
388			}
389
390			if (time(NULL) > endTime)
391			{
392			InfoLog( << "Timer expired, hanging up" );
393			handler.sis->end();
394			state = HangingUp;
395			}
396			break;
397			}
398
399			case HangingUp:
400			{
401			if (handler.isDone())
402			{
403			for (std::vector<ClientRegistrationHandle>::iterator it = handler.handles.begin();
404			it != handler.handles.end(); it++)
405			{
406			(*it)->end();
407			}
408			state = Unregistering;
409			}
410			break;
411			}
412
413			case Unregistering:
414			{
415			if (handler.isRegistered())
416			{
417			InfoLog( << "Shutting down" );
418			serverDum.shutdown(&handler);
419			clientDum.shutdown(&handler);
420			state = ShuttingDown;
421			}
422			break;
423			}
424
425			case ShuttingDown:
426			{
427			if (handler.isDumShutDown())
428			{
429			InfoLog( << "Finished" );
430			state = Finished;
431			}
432
433			break;
434			}
435
436			default:
437			{
438			InfoLog( << "Unrecognised state" );
439			assert(0);
440			}
441			}
442
443			}
444
445	greg	5308	return 0;
446
447	greg	5016	}
448
449			/* ====================================================================
450			* The Vovida Software License, Version 1.0
451			*
452			* Copyright (c) 2000 Vovida Networks, Inc. All rights reserved.
453			*
454			* Redistribution and use in source and binary forms, with or without
455			* modification, are permitted provided that the following conditions
456			* are met:
457			*
458			* 1. Redistributions of source code must retain the above copyright
459			* notice, this list of conditions and the following disclaimer.
460			*
461			* 2. Redistributions in binary form must reproduce the above copyright
462			* notice, this list of conditions and the following disclaimer in
463			* the documentation and/or other materials provided with the
464			* distribution.
465			*
466			* 3. The names "VOCAL", "Vovida Open Communication Application Library",
467			* and "Vovida Open Communication Application Library (VOCAL)" must
468			* not be used to endorse or promote products derived from this
469			* software without prior written permission. For written
470			* permission, please contact vocal@vovida.org.
471			*
472			* 4. Products derived from this software may not be called "VOCAL", nor
473			* may "VOCAL" appear in their name, without prior written
474			* permission of Vovida Networks, Inc.
475			*
476			* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
477			* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
478			* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
479			* NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL VOVIDA
480			* NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
481			* IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
482			* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
483			* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
484			* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
485			* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
486			* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
487			* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
488			* DAMAGE.
489			*
490			* ====================================================================
491			*
492			* This software consists of voluntary contributions made by Vovida
493			* Networks, Inc. and many individuals on behalf of Vovida Networks,
494			* Inc. For more information on Vovida Networks, Inc., please see
495			* <http://www.vovida.org/>.
496			*
497			*/
webmaster AT resiprocate DOT org	ViewVC Help
Powered by ViewVC 1.1.27