dum/test/certServer.cxx

#ifdef WIN32
#  define usleep(t) Sleep(t)
#endif

#if defined (HAVE_POPT_H)
#include <popt.h>
#endif

#include <signal.h>

#include "resiprocate/NameAddr.hxx"
#include "resiprocate/Pkcs8Contents.hxx"
#include "resiprocate/SipMessage.hxx"
#include "resiprocate/Symbols.hxx"
#include "resiprocate/Uri.hxx"
#include "resiprocate/X509Contents.hxx"
#include "resiprocate/dum/AppDialogSet.hxx"
#include "resiprocate/dum/ClientAuthManager.hxx"
#include "resiprocate/dum/DialogUsageManager.hxx"
#include "resiprocate/dum/DumShutdownHandler.hxx"
#include "resiprocate/dum/OutOfDialogHandler.hxx"
#include "resiprocate/dum/Profile.hxx"
#include "resiprocate/dum/PublicationHandler.hxx"
#include "resiprocate/dum/RegistrationHandler.hxx"
#include "resiprocate/dum/ServerPublication.hxx"
#include "resiprocate/dum/ServerSubscription.hxx"
#include "resiprocate/dum/SubscriptionHandler.hxx"
#include "resiprocate/os/Log.hxx"
#include "resiprocate/os/Logger.hxx"
#include "resiprocate/os/Random.hxx"
#include "resiprocate/os/Subsystem.hxx"

#define RESIPROCATE_SUBSYSTEM Subsystem::TEST

using namespace std;
using namespace resip;

static bool finished=false;

void
signalHandler(int signo)
{
   std::cerr << "Shutting down" << endl;
   finished = true;
}

// When a publish comes in, we should let any outstanding subscriptions know
// about it. 

class CertSubscriptionHandler;
class PrivateKeySubscriptionHandler;

class CertPublicationHandler : public ServerPublicationHandler
{
   public:
      CertPublicationHandler(Security& security) : mSecurity(security)
      {
      }

      virtual void onInitial(ServerPublicationHandle h, 
                             const Data& etag, 
                             const SipMessage& pub, 
                             const Contents* contents,
                             const SecurityAttributes* attrs, 
                             int expires)
      {
         add(h, contents);
      }

      virtual void onExpired(ServerPublicationHandle h, const Data& etag)
      {
         mSecurity.removeUserCert(h->getPublisher());
      }

      virtual void onRefresh(ServerPublicationHandle, 
                             const Data& etag, 
                             const SipMessage& pub, 
                             const Contents* contents,
                             const SecurityAttributes* attrs,
                             int expires)
      {
      }

      virtual void onUpdate(ServerPublicationHandle h, 
                            const Data& etag, 
                            const SipMessage& pub, 
                            const Contents* contents,
                            const SecurityAttributes* attrs,
                            int expires)
      {
         add(h, contents);
      }

      virtual void onRemoved(ServerPublicationHandle h, const Data& etag, const SipMessage& pub, int expires)
      {
         mSecurity.removeUserCert(h->getPublisher());
      }
   private:
      void add(ServerPublicationHandle h, const Contents* contents)
      {
         if (h->getDocumentKey() == h->getPublisher())
         {
            const X509Contents* x509 = dynamic_cast<const X509Contents*>(contents);
            assert(x509);
            mSecurity.addUserCertDER(h->getPublisher(), x509->getBodyData());
            h->send(h->accept(200));
         }
         else
         {
            h->send(h->accept(403)); // !jf! is this the correct code? 
         }
      }

      Security& mSecurity;
};

class PrivateKeyPublicationHandler : public ServerPublicationHandler
{
   public:
      PrivateKeyPublicationHandler(Security& security) : mSecurity(security)
      {
      }

      virtual void onInitial(ServerPublicationHandle h, 
                             const Data& etag, 
                             const SipMessage& pub, 
                             const Contents* contents,
                             const SecurityAttributes* attrs, 
                             int expires)
      {
         add(h, contents);
      }

      virtual void onExpired(ServerPublicationHandle h, const Data& etag)
      {
         mSecurity.removeUserPrivateKey(h->getPublisher());
      }

      virtual void onRefresh(ServerPublicationHandle, 
                             const Data& etag, 
                             const SipMessage& pub, 
                             const Contents* contents,
                             const SecurityAttributes* attrs,
                             int expires)
      {
      }

      virtual void onUpdate(ServerPublicationHandle h, 
                            const Data& etag, 
                            const SipMessage& pub, 
                            const Contents* contents,
                            const SecurityAttributes* attrs,
                            int expires)
      {
         add(h, contents);
      }

      virtual void onRemoved(ServerPublicationHandle h, const Data& etag, const SipMessage& pub, int expires)
      {
         mSecurity.removeUserPrivateKey(h->getPublisher());
      }

   private:
      void add(ServerPublicationHandle h, const Contents* contents)
      {
         if (h->getDocumentKey() == h->getPublisher())
         {
            const Pkcs8Contents* pkcs8 = dynamic_cast<const Pkcs8Contents*>(contents);
            assert(pkcs8);
            mSecurity.addUserPrivateKeyDER(h->getPublisher(), pkcs8->getBodyData());
         }
         else
         {
            h->send(h->accept(403)); // !jf! is this the correct code? 
         }
      }
      
      Security& mSecurity;
};

class CertSubscriptionHandler : public ServerSubscriptionHandler
{
   public:
      CertSubscriptionHandler(Security& security) : mSecurity(security)
      {
      }

      virtual void onNewSubscription(ServerSubscriptionHandle h, const SipMessage& sub)
      {
         if (!mSecurity.hasUserCert(h->getDocumentKey()))
         {
            // !jf! really need to do this async. send neutral state in the meantime,
            // blah blah blah
            mSecurity.generateUserCert(h->getDocumentKey(), Data::Empty);
         }

         if (mSecurity.hasUserCert(h->getDocumentKey()))
         {
            X509Contents x509(mSecurity.getUserCertDER(h->getDocumentKey()));
            h->send(h->update(&x509));
         }
         else
         {
            h->reject(404);
         }
      }

      virtual void onPublished(ServerSubscriptionHandle associated, 
                               ServerPublicationHandle publication, 
                               const Contents* contents,
                               const SecurityAttributes* attrs)
      {
         associated->send(associated->update(contents));
      }
      

      virtual void onTerminated(ServerSubscriptionHandle)
      {
      }

      virtual void onError(ServerSubscriptionHandle, const SipMessage& msg)
      {
      }

   private:
      Security& mSecurity;
};

class PrivateKeySubscriptionHandler : public ServerSubscriptionHandler
{
   public:
      PrivateKeySubscriptionHandler(Security& security) : mSecurity(security)
      {
      }

      virtual void onNewSubscription(ServerSubscriptionHandle h, const SipMessage& sub)
      {
         if (h->getDocumentKey() != h->getSubscriber())
         {
            h->send(h->accept(403)); // !jf! is this the correct code? 
         }
         else if (mSecurity.hasUserCert(h->getDocumentKey()))
         {
            Pkcs8Contents pkcs(mSecurity.getUserPrivateKeyDER(h->getDocumentKey()));
            h->send(h->update(&pkcs));
         }
         else
         {
            h->reject(404);
         }
      }

      virtual void onPublished(ServerSubscriptionHandle associated, 
                               ServerPublicationHandle publication, 
                               const Contents* contents,
                               const SecurityAttributes* attrs)
      {
         associated->send(associated->update(contents));
      }

      virtual void onTerminated(ServerSubscriptionHandle)
      {
      }

      virtual void onError(ServerSubscriptionHandle, const SipMessage& msg)
      {
      }

   private:
      Security& mSecurity;
};
   
   

class CertServer : public OutOfDialogHandler,  public DialogUsageManager
{
   public:
      CertServer(const resip::NameAddr& me) : 
         DialogUsageManager(),
         mCertServer(getSecurity()),
         mPrivateKeyServer(getSecurity()),
         mCertUpdater(getSecurity()),
         mPrivateKeyUpdater(getSecurity()),
         mDone(false)
      {
         addTransport(UDP, 5100);
         addTransport(TCP, 5100);
         addTransport(TLS, 5101, V4, Data::Empty, me.uri().host(), Data::Empty);
         
         mProfile.clearSupportedMethods();
         mProfile.addSupportedMethod(PUBLISH);
         mProfile.addSupportedMethod(SUBSCRIBE);
         mProfile.validateAcceptEnabled() = true;
         mProfile.validateContentEnabled() = true;
         mProfile.addSupportedMimeType(Pkcs8Contents::getStaticType());
         mProfile.addSupportedMimeType(X509Contents::getStaticType());
         
         mProfile.setDefaultFrom(me);
         setProfile(&mProfile);

         addServerSubscriptionHandler(Symbols::Credential, &mPrivateKeyServer);
         addServerSubscriptionHandler(Symbols::Certificate, &mCertServer);
         addServerPublicationHandler(Symbols::Credential, &mPrivateKeyUpdater);
         addServerPublicationHandler(Symbols::Certificate, &mCertUpdater);
         addOutOfDialogHandler(OPTIONS, this);
         
         //setServerAuthManager(std::auto_ptr<ServerAuthManager>(new ServerAuthManager(mProfile)));

         DialogUsageManager::run();
      }

      ~CertServer()
      {
      }
      
      void run()
      {
         while ( !mDone )
         {
            while (process());
            usleep(5);

            if (finished)
            {
               // graceful shutdown
               exit(0);
            }
         }
      }

      virtual void onSuccess(ClientOutOfDialogReqHandle, const SipMessage& successResponse)
      {
      }
      
      virtual void onFailure(ClientOutOfDialogReqHandle, const SipMessage& errorResponse)
      {
      }

      virtual void onReceivedRequest(ServerOutOfDialogReqHandle, const SipMessage& request)
      {
      }

   private:
      Profile mProfile;
      CertSubscriptionHandler mCertServer;
      PrivateKeySubscriptionHandler mPrivateKeyServer;
      CertPublicationHandler mCertUpdater;
      PrivateKeyPublicationHandler mPrivateKeyUpdater;
      bool mDone;
};

int 
main (int argc, char** argv)
{
   char* logType = "COUT";
   char* logLevel = "DEBUG";
   char* myUrl = "sip:localhost:7001";
   char* bindAddr = 0;
   int v6 = 0;

#if defined(HAVE_POPT_H)
   struct poptOption table[] = {
      {"log-type",    'l', POPT_ARG_STRING, &logType,   0, "where to send logging messages", "syslog|cerr|cout"},
      {"log-level",   'v', POPT_ARG_STRING, &logLevel,  0, "specify the default log level", "DEBUG|INFO|WARNING|ALERT"},
      {"name" ,       'n', POPT_ARG_STRING, &myUrl,     0, "my url", 0},
      {"bind",        'b', POPT_ARG_STRING, &bindAddr,  0, "interface address to bind to",0},
      {"v6",          '6', POPT_ARG_NONE,   &v6     ,   0, "ipv6", 0},
      POPT_AUTOHELP
      { NULL, 0, 0, NULL, 0 }
   };
   poptContext context = poptGetContext(NULL, argc, const_cast<const char**>(argv), table, 0);
   poptGetNextOpt(context);
#endif
   Log::initialize(logType, logLevel, argv[0]);

#ifndef _WIN32
   if ( signal( SIGPIPE, SIG_IGN) == SIG_ERR)
   {
      cerr << "Couldn't install signal handler for SIGPIPE" << endl;
      exit(-1);
   }

   if ( signal( SIGINT, signalHandler ) == SIG_ERR )
   {
      cerr << "Couldn't install signal handler for SIGINT" << endl;
      exit( -1 );
   }

   if ( signal( SIGTERM, signalHandler ) == SIG_ERR )
   {
      cerr << "Couldn't install signal handler for SIGTERM" << endl;
      exit( -1 );
   }
#endif

   NameAddr domain(myUrl);
   CertServer server(domain);
   server.run();
   return 0;
}

1	#ifdef WIN32
2	# define usleep(t) Sleep(t)
3	#endif
4
5	#if defined (HAVE_POPT_H)
6	#include <popt.h>
7	#endif
8
9	#include <signal.h>
10
11	#include "resiprocate/NameAddr.hxx"
12	#include "resiprocate/Pkcs8Contents.hxx"
13	#include "resiprocate/SipMessage.hxx"
14	#include "resiprocate/Symbols.hxx"
15	#include "resiprocate/Uri.hxx"
16	#include "resiprocate/X509Contents.hxx"
17	#include "resiprocate/dum/AppDialogSet.hxx"
18	#include "resiprocate/dum/ClientAuthManager.hxx"
19	#include "resiprocate/dum/DialogUsageManager.hxx"
20	#include "resiprocate/dum/DumShutdownHandler.hxx"
21	#include "resiprocate/dum/OutOfDialogHandler.hxx"
22	#include "resiprocate/dum/Profile.hxx"
23	#include "resiprocate/dum/PublicationHandler.hxx"
24	#include "resiprocate/dum/RegistrationHandler.hxx"
25	#include "resiprocate/dum/ServerPublication.hxx"
26	#include "resiprocate/dum/ServerSubscription.hxx"
27	#include "resiprocate/dum/SubscriptionHandler.hxx"
28	#include "resiprocate/os/Log.hxx"
29	#include "resiprocate/os/Logger.hxx"
30	#include "resiprocate/os/Random.hxx"
31	#include "resiprocate/os/Subsystem.hxx"
32
33	#define RESIPROCATE_SUBSYSTEM Subsystem::TEST
34
35	using namespace std;
36	using namespace resip;
37
38	static bool finished=false;
39
40	void
41	signalHandler(int signo)
42	{
43	std::cerr << "Shutting down" << endl;
44	finished = true;
45	}
46
47	// When a publish comes in, we should let any outstanding subscriptions know
48	// about it.
49
50	class CertSubscriptionHandler;
51	class PrivateKeySubscriptionHandler;
52
53	class CertPublicationHandler : public ServerPublicationHandler
54	{
55	public:
56	CertPublicationHandler(Security& security) : mSecurity(security)
57	{
58	}
59
60	virtual void onInitial(ServerPublicationHandle h,
61	const Data& etag,
62	const SipMessage& pub,
63	const Contents* contents,
64	const SecurityAttributes* attrs,
65	int expires)
66	{
67	add(h, contents);
68	}
69
70	virtual void onExpired(ServerPublicationHandle h, const Data& etag)
71	{
72	mSecurity.removeUserCert(h->getPublisher());
73	}
74
75	virtual void onRefresh(ServerPublicationHandle,
76	const Data& etag,
77	const SipMessage& pub,
78	const Contents* contents,
79	const SecurityAttributes* attrs,
80	int expires)
81	{
82	}
83
84	virtual void onUpdate(ServerPublicationHandle h,
85	const Data& etag,
86	const SipMessage& pub,
87	const Contents* contents,
88	const SecurityAttributes* attrs,
89	int expires)
90	{
91	add(h, contents);
92	}
93
94	virtual void onRemoved(ServerPublicationHandle h, const Data& etag, const SipMessage& pub, int expires)
95	{
96	mSecurity.removeUserCert(h->getPublisher());
97	}
98	private:
99	void add(ServerPublicationHandle h, const Contents* contents)
100	{
101	if (h->getDocumentKey() == h->getPublisher())
102	{
103	const X509Contents* x509 = dynamic_cast<const X509Contents*>(contents);
104	assert(x509);
105	mSecurity.addUserCertDER(h->getPublisher(), x509->getBodyData());
106	h->send(h->accept(200));
107	}
108	else
109	{
110	h->send(h->accept(403)); // !jf! is this the correct code?
111	}
112	}
113
114	Security& mSecurity;
115	};
116
117	class PrivateKeyPublicationHandler : public ServerPublicationHandler
118	{
119	public:
120	PrivateKeyPublicationHandler(Security& security) : mSecurity(security)
121	{
122	}
123
124	virtual void onInitial(ServerPublicationHandle h,
125	const Data& etag,
126	const SipMessage& pub,
127	const Contents* contents,
128	const SecurityAttributes* attrs,
129	int expires)
130	{
131	add(h, contents);
132	}
133
134	virtual void onExpired(ServerPublicationHandle h, const Data& etag)
135	{
136	mSecurity.removeUserPrivateKey(h->getPublisher());
137	}
138
139	virtual void onRefresh(ServerPublicationHandle,
140	const Data& etag,
141	const SipMessage& pub,
142	const Contents* contents,
143	const SecurityAttributes* attrs,
144	int expires)
145	{
146	}
147
148	virtual void onUpdate(ServerPublicationHandle h,
149	const Data& etag,
150	const SipMessage& pub,
151	const Contents* contents,
152	const SecurityAttributes* attrs,
153	int expires)
154	{
155	add(h, contents);
156	}
157
158	virtual void onRemoved(ServerPublicationHandle h, const Data& etag, const SipMessage& pub, int expires)
159	{
160	mSecurity.removeUserPrivateKey(h->getPublisher());
161	}
162
163	private:
164	void add(ServerPublicationHandle h, const Contents* contents)
165	{
166	if (h->getDocumentKey() == h->getPublisher())
167	{
168	const Pkcs8Contents* pkcs8 = dynamic_cast<const Pkcs8Contents*>(contents);
169	assert(pkcs8);
170	mSecurity.addUserPrivateKeyDER(h->getPublisher(), pkcs8->getBodyData());
171	}
172	else
173	{
174	h->send(h->accept(403)); // !jf! is this the correct code?
175	}
176	}
177
178	Security& mSecurity;
179	};
180
181	class CertSubscriptionHandler : public ServerSubscriptionHandler
182	{
183	public:
184	CertSubscriptionHandler(Security& security) : mSecurity(security)
185	{
186	}
187
188	virtual void onNewSubscription(ServerSubscriptionHandle h, const SipMessage& sub)
189	{
190	if (!mSecurity.hasUserCert(h->getDocumentKey()))
191	{
192	// !jf! really need to do this async. send neutral state in the meantime,
193	// blah blah blah
194	mSecurity.generateUserCert(h->getDocumentKey(), Data::Empty);
195	}
196
197	if (mSecurity.hasUserCert(h->getDocumentKey()))
198	{
199	X509Contents x509(mSecurity.getUserCertDER(h->getDocumentKey()));
200	h->send(h->update(&x509));
201	}
202	else
203	{
204	h->reject(404);
205	}
206	}
207
208	virtual void onPublished(ServerSubscriptionHandle associated,
209	ServerPublicationHandle publication,
210	const Contents* contents,
211	const SecurityAttributes* attrs)
212	{
213	associated->send(associated->update(contents));
214	}
215
216
217	virtual void onTerminated(ServerSubscriptionHandle)
218	{
219	}
220
221	virtual void onError(ServerSubscriptionHandle, const SipMessage& msg)
222	{
223	}
224
225	private:
226	Security& mSecurity;
227	};
228
229	class PrivateKeySubscriptionHandler : public ServerSubscriptionHandler
230	{
231	public:
232	PrivateKeySubscriptionHandler(Security& security) : mSecurity(security)
233	{
234	}
235
236	virtual void onNewSubscription(ServerSubscriptionHandle h, const SipMessage& sub)
237	{
238	if (h->getDocumentKey() != h->getSubscriber())
239	{
240	h->send(h->accept(403)); // !jf! is this the correct code?
241	}
242	else if (mSecurity.hasUserCert(h->getDocumentKey()))
243	{
244	Pkcs8Contents pkcs(mSecurity.getUserPrivateKeyDER(h->getDocumentKey()));
245	h->send(h->update(&pkcs));
246	}
247	else
248	{
249	h->reject(404);
250	}
251	}
252
253	virtual void onPublished(ServerSubscriptionHandle associated,
254	ServerPublicationHandle publication,
255	const Contents* contents,
256	const SecurityAttributes* attrs)
257	{
258	associated->send(associated->update(contents));
259	}
260
261	virtual void onTerminated(ServerSubscriptionHandle)
262	{
263	}
264
265	virtual void onError(ServerSubscriptionHandle, const SipMessage& msg)
266	{
267	}
268
269	private:
270	Security& mSecurity;
271	};
272
273
274
275	class CertServer : public OutOfDialogHandler, public DialogUsageManager
276	{
277	public:
278	CertServer(const resip::NameAddr& me) :
279	DialogUsageManager(),
280	mCertServer(getSecurity()),
281	mPrivateKeyServer(getSecurity()),
282	mCertUpdater(getSecurity()),
283	mPrivateKeyUpdater(getSecurity()),
284	mDone(false)
285	{
286	addTransport(UDP, 5100);
287	addTransport(TCP, 5100);
288	addTransport(TLS, 5101, V4, Data::Empty, me.uri().host(), Data::Empty);
289
290	mProfile.clearSupportedMethods();
291	mProfile.addSupportedMethod(PUBLISH);
292	mProfile.addSupportedMethod(SUBSCRIBE);
293	mProfile.validateAcceptEnabled() = true;
294	mProfile.validateContentEnabled() = true;
295	mProfile.addSupportedMimeType(Pkcs8Contents::getStaticType());
296	mProfile.addSupportedMimeType(X509Contents::getStaticType());
297
298	mProfile.setDefaultFrom(me);
299	setProfile(&mProfile);
300
301	addServerSubscriptionHandler(Symbols::Credential, &mPrivateKeyServer);
302	addServerSubscriptionHandler(Symbols::Certificate, &mCertServer);
303	addServerPublicationHandler(Symbols::Credential, &mPrivateKeyUpdater);
304	addServerPublicationHandler(Symbols::Certificate, &mCertUpdater);
305	addOutOfDialogHandler(OPTIONS, this);
306
307	//setServerAuthManager(std::auto_ptr<ServerAuthManager>(new ServerAuthManager(mProfile)));
308
309	DialogUsageManager::run();
310	}
311
312	~CertServer()
313	{
314	}
315
316	void run()
317	{
318	while ( !mDone )
319	{
320	while (process());
321	usleep(5);
322
323	if (finished)
324	{
325	// graceful shutdown
326	exit(0);
327	}
328	}
329	}
330
331	virtual void onSuccess(ClientOutOfDialogReqHandle, const SipMessage& successResponse)
332	{
333	}
334
335	virtual void onFailure(ClientOutOfDialogReqHandle, const SipMessage& errorResponse)
336	{
337	}
338
339	virtual void onReceivedRequest(ServerOutOfDialogReqHandle, const SipMessage& request)
340	{
341	}
342
343	private:
344	Profile mProfile;
345	CertSubscriptionHandler mCertServer;
346	PrivateKeySubscriptionHandler mPrivateKeyServer;
347	CertPublicationHandler mCertUpdater;
348	PrivateKeyPublicationHandler mPrivateKeyUpdater;
349	bool mDone;
350	};
351
352	int
353	main (int argc, char** argv)
354	{
355	char* logType = "COUT";
356	char* logLevel = "DEBUG";
357	char* myUrl = "sip:localhost:7001";
358	char* bindAddr = 0;
359	int v6 = 0;
360
361	#if defined(HAVE_POPT_H)
362	struct poptOption table[] = {
363	{"log-type", 'l', POPT_ARG_STRING, &logType, 0, "where to send logging messages", "syslog\|cerr\|cout"},
364	{"log-level", 'v', POPT_ARG_STRING, &logLevel, 0, "specify the default log level", "DEBUG\|INFO\|WARNING\|ALERT"},
365	{"name" , 'n', POPT_ARG_STRING, &myUrl, 0, "my url", 0},
366	{"bind", 'b', POPT_ARG_STRING, &bindAddr, 0, "interface address to bind to",0},
367	{"v6", '6', POPT_ARG_NONE, &v6 , 0, "ipv6", 0},
368	POPT_AUTOHELP
369	{ NULL, 0, 0, NULL, 0 }
370	};
371	poptContext context = poptGetContext(NULL, argc, const_cast<const char**>(argv), table, 0);
372	poptGetNextOpt(context);
373	#endif
374	Log::initialize(logType, logLevel, argv[0]);
375
376	#ifndef _WIN32
377	if ( signal( SIGPIPE, SIG_IGN) == SIG_ERR)
378	{
379	cerr << "Couldn't install signal handler for SIGPIPE" << endl;
380	exit(-1);
381	}
382
383	if ( signal( SIGINT, signalHandler ) == SIG_ERR )
384	{
385	cerr << "Couldn't install signal handler for SIGINT" << endl;
386	exit( -1 );
387	}
388
389	if ( signal( SIGTERM, signalHandler ) == SIG_ERR )
390	{
391	cerr << "Couldn't install signal handler for SIGTERM" << endl;
392	exit( -1 );
393	}
394	#endif
395
396	NameAddr domain(myUrl);
397	CertServer server(domain);
398	server.run();
399	return 0;
400	}
401
webmaster AT resiprocate DOT org	ViewVC Help
Powered by ViewVC 1.1.27