/[resiprocate]/main/resip/dum/test/certServer.cxx
ViewVC logotype

Annotation of /main/resip/dum/test/certServer.cxx

Parent Directory Parent Directory | Revision Log Revision Log


Revision 4010 - (hide annotations) (download)
Sat Mar 19 03:54:17 2005 UTC (14 years, 8 months ago) by jason
Original Path: main/sip/resiprocate/dum/test/certServer.cxx
File size: 12442 byte(s)
merged changes from b-teltel-20041118-invitesession 3484:HEAD into the trunk


1 jason 4010 #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/MasterProfile.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());
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     setMasterProfile(&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     MasterProfile 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