Context Navigation

defaultprotocolfactory.cpp @ 749

Revision 749, 17.1 KB checked in by shiretu, 2 months ago (diff)

-- added JSON Variant protocol to the list of Variant protocols
-- added inbound HTTPS variants to the Variant protocol
-- tolerate EINTR when doing kqueue/epoll/select
-- fix for switching from indexvaluexxx to 0xXXXXXXXX notation for Variant indexes
-- fix for invoke id when returning _error and _result
-- support for RTMP Adobe authentication second style (the one without opaque)
-- properly send FCSubscribe and FCPublish invokes
-- fix for RTMP protocol ser/deser to return the parameters as an array for invokes
-- remove the query string from the stream name when FMLE (or someone else) is doing RTMP publish
-- fixed the upstream.tv disconnect problem

Line
1	/*
2	* Copyright (c) 2010,
3	* Gavriloaie Eugen-Andrei (shiretu@gmail.com)
4	*
5	* This file is part of crtmpserver.
6	* crtmpserver is free software: you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* crtmpserver is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with crtmpserver. If not, see <http://www.gnu.org/licenses/>.
18	*/
19
20	#include "protocols/defaultprotocolfactory.h"
21	#include "protocols/protocoltypes.h"
22	#include "protocols/tcpprotocol.h"
23	#include "protocols/rtmp/inboundrtmpprotocol.h"
24	#include "protocols/rtmp/outboundrtmpprotocol.h"
25	#include "protocols/ssl/inboundsslprotocol.h"
26	#include "protocols/ssl/outboundsslprotocol.h"
27	#include "protocols/dns/inbounddnsresolverprotocol.h"
28	#include "protocols/dns/outbounddnsresolverprotocol.h"
29	#include "protocols/ts/inboundtsprotocol.h"
30	#include "protocols/http/inboundhttpprotocol.h"
31	#include "protocols/rtmp/inboundhttp4rtmp.h"
32	#include "protocols/http/outboundhttpprotocol.h"
33	#include "protocols/liveflv/inboundliveflvprotocol.h"
34	#include "protocols/variant/xmlvariantprotocol.h"
35	#include "protocols/variant/binvariantprotocol.h"
36	#include "protocols/variant/jsonvariantprotocol.h"
37	#include "protocols/udpprotocol.h"
38	#include "protocols/rtp/rtspprotocol.h"
39	#include "protocols/rtp/inboundrtpprotocol.h"
40	#include "protocols/rtp/rtcpprotocol.h"
41	#include "protocols/cli/inboundjsoncliprotocol.h"
42	#include "protocols/rtmp/inboundrtmpsdiscriminatorprotocol.h"
43	#include "protocols/cli/http4cliprotocol.h"
44	#include "protocols/mms/mmsprotocol.h"
45	#include "protocols/rawhttpstream/inboundrawhttpstreamprotocol.h"
46	#include "protocols/rtp/nattraversalprotocol.h"
47
48	DefaultProtocolFactory::DefaultProtocolFactory()
49	: BaseProtocolFactory() {
50
51	}
52
53	DefaultProtocolFactory::~DefaultProtocolFactory() {
54	}
55
56	vector<uint64_t> DefaultProtocolFactory::HandledProtocols() {
57	vector<uint64_t> result;
58
59	ADD_VECTOR_END(result, PT_TCP);
60	ADD_VECTOR_END(result, PT_UDP);
61	ADD_VECTOR_END(result, PT_INBOUND_SSL);
62	ADD_VECTOR_END(result, PT_OUTBOUND_SSL);
63	#ifdef HAS_PROTOCOL_DNS
64	ADD_VECTOR_END(result, PT_INBOUND_DNS);
65	ADD_VECTOR_END(result, PT_OUTBOUND_DNS);
66	#endif /* HAS_PROTOCOL_DNS */
67	ADD_VECTOR_END(result, PT_TIMER);
68	#ifdef HAS_PROTOCOL_TS
69	ADD_VECTOR_END(result, PT_INBOUND_TS);
70	#endif /* HAS_PROTOCOL_TS */
71	#ifdef HAS_PROTOCOL_RTMP
72	ADD_VECTOR_END(result, PT_INBOUND_RTMP);
73	ADD_VECTOR_END(result, PT_INBOUND_RTMPS_DISC);
74	ADD_VECTOR_END(result, PT_OUTBOUND_RTMP);
75	ADD_VECTOR_END(result, PT_MONITOR_RTMP);
76	ADD_VECTOR_END(result, PT_RTMPE);
77	#ifdef HAS_PROTOCOL_HTTP
78	ADD_VECTOR_END(result, PT_INBOUND_HTTP_FOR_RTMP);
79	ADD_VECTOR_END(result, PT_OUTBOUND_HTTP_FOR_RTMP);
80	#endif /* HAS_PROTOCOL_HTTP */
81	#endif /* HAS_PROTOCOL_RTMP */
82	#ifdef HAS_PROTOCOL_HTTP
83	ADD_VECTOR_END(result, PT_INBOUND_HTTP);
84	ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
85	#endif /* HAS_PROTOCOL_HTTP */
86	#ifdef HAS_PROTOCOL_LIVEFLV
87	ADD_VECTOR_END(result, PT_INBOUND_LIVE_FLV);
88	ADD_VECTOR_END(result, PT_OUTBOUND_LIVE_FLV);
89	#endif /* HAS_PROTOCOL_LIVEFLV */
90	#ifdef HAS_PROTOCOL_VAR
91	ADD_VECTOR_END(result, PT_BIN_VAR);
92	ADD_VECTOR_END(result, PT_XML_VAR);
93	ADD_VECTOR_END(result, PT_JSON_VAR);
94	#endif /* HAS_PROTOCOL_VAR */
95	#ifdef HAS_PROTOCOL_RTP
96	ADD_VECTOR_END(result, PT_RTSP);
97	ADD_VECTOR_END(result, PT_RTCP);
98	ADD_VECTOR_END(result, PT_INBOUND_RTP);
99	ADD_VECTOR_END(result, PT_RTP_NAT_TRAVERSAL);
100	#endif /* HAS_PROTOCOL_RTP */
101	#ifdef HAS_PROTOCOL_CLI
102	ADD_VECTOR_END(result, PT_INBOUND_JSONCLI);
103	ADD_VECTOR_END(result, PT_HTTP_4_CLI);
104	#endif /* HAS_PROTOCOL_CLI */
105	#ifdef HAS_PROTOCOL_MMS
106	ADD_VECTOR_END(result, PT_OUTBOUND_MMS);
107	#endif /* HAS_PROTOCOL_MMS */
108	#ifdef HAS_PROTOCOL_RAWHTTPSTREAM
109	ADD_VECTOR_END(result, PT_INBOUND_RAW_HTTP_STREAM);
110	#endif /* HAS_PROTOCOL_RAWHTTPSTREAM */
111	return result;
112	}
113
114	vector<string> DefaultProtocolFactory::HandledProtocolChains() {
115	vector<string> result;
116	#ifdef HAS_PROTOCOL_DNS
117	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_DNS);
118	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_DNS);
119	#endif /* HAS_PROTOCOL_DNS */
120	#ifdef HAS_PROTOCOL_RTMP
121	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RTMP);
122	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_RTMP);
123	#ifdef HAS_PROTOCOL_HTTP
124	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RTMPS);
125	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RTMPT);
126	#endif /* HAS_PROTOCOL_HTTP */
127	#endif /* HAS_PROTOCOL_RTMP */
128	#ifdef HAS_PROTOCOL_TS
129	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_TCP_TS);
130	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_UDP_TS);
131	#endif /* HAS_PROTOCOL_TS */
132	#ifdef HAS_PROTOCOL_HTTP
133	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTP);
134	#endif /* HAS_PROTOCOL_HTTP */
135	#ifdef HAS_PROTOCOL_LIVEFLV
136	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_LIVE_FLV);
137	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_LIVE_FLV);
138	#endif /* HAS_PROTOCOL_LIVEFLV */
139	#ifdef HAS_PROTOCOL_VAR
140	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_XML_VARIANT);
141	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_BIN_VARIANT);
142	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_JSON_VARIANT);
143	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_XML_VARIANT);
144	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_BIN_VARIANT);
145	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_JSON_VARIANT);
146	#ifdef HAS_PROTOCOL_HTTP
147	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTP_XML_VARIANT);
148	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTP_BIN_VARIANT);
149	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTP_JSON_VARIANT);
150	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTPS_XML_VARIANT);
151	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTPS_BIN_VARIANT);
152	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTPS_JSON_VARIANT);
153	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTP_XML_VARIANT);
154	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTP_BIN_VARIANT);
155	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTP_JSON_VARIANT);
156	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTPS_XML_VARIANT);
157	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTPS_BIN_VARIANT);
158	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_HTTPS_JSON_VARIANT);
159	#endif /* HAS_PROTOCOL_HTTP */
160	#endif /* HAS_PROTOCOL_VAR */
161	#ifdef HAS_PROTOCOL_RTP
162	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RTSP);
163	ADD_VECTOR_END(result, CONF_PROTOCOL_RTSP_RTCP);
164	ADD_VECTOR_END(result, CONF_PROTOCOL_UDP_RTCP);
165	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RTSP_RTP);
166	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_UDP_RTP);
167	ADD_VECTOR_END(result, CONF_PROTOCOL_RTP_NAT_TRAVERSAL);
168	#endif /* HAS_PROTOCOL_RTP */
169	#ifdef HAS_PROTOCOL_CLI
170	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_CLI_JSON);
171	#ifdef HAS_PROTOCOL_HTTP
172	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_HTTP_CLI_JSON);
173	#endif /* HAS_PROTOCOL_HTTP */
174	#endif /* HAS_PROTOCOL_CLI */
175	#ifdef HAS_PROTOCOL_MMS
176	ADD_VECTOR_END(result, CONF_PROTOCOL_OUTBOUND_MMS);
177	#endif /* HAS_PROTOCOL_MMS */
178	#ifdef HAS_PROTOCOL_RAWHTTPSTREAM
179	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RAW_HTTP_STREAM);
180	ADD_VECTOR_END(result, CONF_PROTOCOL_INBOUND_RAW_HTTPS_STREAM);
181	#endif /* HAS_PROTOCOL_RAWHTTPSTREAM */
182	return result;
183	}
184
185	vector<uint64_t> DefaultProtocolFactory::ResolveProtocolChain(string name) {
186	vector<uint64_t> result;
187	if (false) {
188
189	}
190	#ifdef HAS_PROTOCOL_DNS
191	else if (name == CONF_PROTOCOL_INBOUND_DNS) {
192	ADD_VECTOR_END(result, PT_TCP);
193	ADD_VECTOR_END(result, PT_INBOUND_DNS);
194	} else if (name == CONF_PROTOCOL_OUTBOUND_DNS) {
195	ADD_VECTOR_END(result, PT_TCP);
196	ADD_VECTOR_END(result, PT_OUTBOUND_DNS);
197	}
198	#endif /* HAS_PROTOCOL_DNS */
199	#ifdef HAS_PROTOCOL_RTMP
200	else if (name == CONF_PROTOCOL_INBOUND_RTMP) {
201	ADD_VECTOR_END(result, PT_TCP);
202	ADD_VECTOR_END(result, PT_INBOUND_RTMP);
203	} else if (name == CONF_PROTOCOL_OUTBOUND_RTMP) {
204	ADD_VECTOR_END(result, PT_TCP);
205	ADD_VECTOR_END(result, PT_OUTBOUND_RTMP);
206	} else if (name == CONF_PROTOCOL_INBOUND_RTMPS) {
207	ADD_VECTOR_END(result, PT_TCP);
208	ADD_VECTOR_END(result, PT_INBOUND_SSL);
209	ADD_VECTOR_END(result, PT_INBOUND_RTMPS_DISC);
210	}
211	#ifdef HAS_PROTOCOL_HTTP
212	else if (name == CONF_PROTOCOL_INBOUND_RTMPT) {
213	ADD_VECTOR_END(result, PT_TCP);
214	ADD_VECTOR_END(result, PT_INBOUND_HTTP);
215	ADD_VECTOR_END(result, PT_INBOUND_HTTP_FOR_RTMP);
216	}
217	#endif /* HAS_PROTOCOL_HTTP */
218	#endif /* HAS_PROTOCOL_RTMP */
219	#ifdef HAS_PROTOCOL_TS
220	else if (name == CONF_PROTOCOL_INBOUND_TCP_TS) {
221	ADD_VECTOR_END(result, PT_TCP);
222	ADD_VECTOR_END(result, PT_INBOUND_TS);
223	} else if (name == CONF_PROTOCOL_INBOUND_UDP_TS) {
224	ADD_VECTOR_END(result, PT_UDP);
225	ADD_VECTOR_END(result, PT_INBOUND_TS);
226	}
227	#endif /* HAS_PROTOCOL_TS */
228	#ifdef HAS_PROTOCOL_RTP
229	else if (name == CONF_PROTOCOL_INBOUND_RTSP) {
230	ADD_VECTOR_END(result, PT_TCP);
231	ADD_VECTOR_END(result, PT_RTSP);
232	} else if (name == CONF_PROTOCOL_RTSP_RTCP) {
233	ADD_VECTOR_END(result, PT_TCP);
234	ADD_VECTOR_END(result, PT_RTSP);
235	ADD_VECTOR_END(result, PT_RTCP);
236	} else if (name == CONF_PROTOCOL_UDP_RTCP) {
237	ADD_VECTOR_END(result, PT_UDP);
238	ADD_VECTOR_END(result, PT_RTCP);
239	} else if (name == CONF_PROTOCOL_INBOUND_RTSP_RTP) {
240	ADD_VECTOR_END(result, PT_TCP);
241	ADD_VECTOR_END(result, PT_RTSP);
242	ADD_VECTOR_END(result, PT_INBOUND_RTP);
243	} else if (name == CONF_PROTOCOL_INBOUND_UDP_RTP) {
244	ADD_VECTOR_END(result, PT_UDP);
245	ADD_VECTOR_END(result, PT_INBOUND_RTP);
246	} else if (name == CONF_PROTOCOL_RTP_NAT_TRAVERSAL) {
247	ADD_VECTOR_END(result, PT_UDP);
248	ADD_VECTOR_END(result, PT_RTP_NAT_TRAVERSAL);
249	}
250	#endif /* HAS_PROTOCOL_RTP */
251	#ifdef HAS_PROTOCOL_HTTP
252	else if (name == CONF_PROTOCOL_OUTBOUND_HTTP) {
253	ADD_VECTOR_END(result, PT_TCP);
254	ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
255	}
256	#endif /* HAS_PROTOCOL_HTTP */
257	#ifdef HAS_PROTOCOL_LIVEFLV
258	else if (name == CONF_PROTOCOL_INBOUND_LIVE_FLV) {
259	ADD_VECTOR_END(result, PT_TCP);
260	ADD_VECTOR_END(result, PT_INBOUND_LIVE_FLV);
261	}
262	#endif /* HAS_PROTOCOL_LIVEFLV */
263	#ifdef HAS_PROTOCOL_VAR
264	else if (name == CONF_PROTOCOL_INBOUND_XML_VARIANT) {
265	ADD_VECTOR_END(result, PT_TCP);
266	ADD_VECTOR_END(result, PT_XML_VAR);
267	} else if (name == CONF_PROTOCOL_INBOUND_BIN_VARIANT) {
268	ADD_VECTOR_END(result, PT_TCP);
269	ADD_VECTOR_END(result, PT_BIN_VAR);
270	} else if (name == CONF_PROTOCOL_INBOUND_JSON_VARIANT) {
271	ADD_VECTOR_END(result, PT_TCP);
272	ADD_VECTOR_END(result, PT_JSON_VAR);
273	} else if (name == CONF_PROTOCOL_OUTBOUND_XML_VARIANT) {
274	ADD_VECTOR_END(result, PT_TCP);
275	ADD_VECTOR_END(result, PT_XML_VAR);
276	} else if (name == CONF_PROTOCOL_OUTBOUND_BIN_VARIANT) {
277	ADD_VECTOR_END(result, PT_TCP);
278	ADD_VECTOR_END(result, PT_BIN_VAR);
279	} else if (name == CONF_PROTOCOL_OUTBOUND_JSON_VARIANT) {
280	ADD_VECTOR_END(result, PT_TCP);
281	ADD_VECTOR_END(result, PT_JSON_VAR);
282	}
283	#ifdef HAS_PROTOCOL_HTTP
284	else if (name == CONF_PROTOCOL_INBOUND_HTTP_XML_VARIANT) {
285	ADD_VECTOR_END(result, PT_TCP);
286	ADD_VECTOR_END(result, PT_INBOUND_HTTP);
287	ADD_VECTOR_END(result, PT_XML_VAR);
288	} else if (name == CONF_PROTOCOL_INBOUND_HTTP_BIN_VARIANT) {
289	ADD_VECTOR_END(result, PT_TCP);
290	ADD_VECTOR_END(result, PT_INBOUND_HTTP);
291	ADD_VECTOR_END(result, PT_BIN_VAR);
292	} else if (name == CONF_PROTOCOL_INBOUND_HTTP_JSON_VARIANT) {
293	ADD_VECTOR_END(result, PT_TCP);
294	ADD_VECTOR_END(result, PT_INBOUND_HTTP);
295	ADD_VECTOR_END(result, PT_JSON_VAR);
296	} else if (name == CONF_PROTOCOL_INBOUND_HTTPS_XML_VARIANT) {
297	ADD_VECTOR_END(result, PT_TCP);
298	ADD_VECTOR_END(result, PT_INBOUND_SSL);
299	ADD_VECTOR_END(result, PT_INBOUND_HTTP);
300	ADD_VECTOR_END(result, PT_XML_VAR);
301	} else if (name == CONF_PROTOCOL_INBOUND_HTTPS_BIN_VARIANT) {
302	ADD_VECTOR_END(result, PT_TCP);
303	ADD_VECTOR_END(result, PT_INBOUND_SSL);
304	ADD_VECTOR_END(result, PT_INBOUND_HTTP);
305	ADD_VECTOR_END(result, PT_BIN_VAR);
306	} else if (name == CONF_PROTOCOL_INBOUND_HTTPS_JSON_VARIANT) {
307	ADD_VECTOR_END(result, PT_TCP);
308	ADD_VECTOR_END(result, PT_INBOUND_SSL);
309	ADD_VECTOR_END(result, PT_INBOUND_HTTP);
310	ADD_VECTOR_END(result, PT_JSON_VAR);
311	} else if (name == CONF_PROTOCOL_OUTBOUND_HTTP_XML_VARIANT) {
312	ADD_VECTOR_END(result, PT_TCP);
313	ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
314	ADD_VECTOR_END(result, PT_XML_VAR);
315	} else if (name == CONF_PROTOCOL_OUTBOUND_HTTP_BIN_VARIANT) {
316	ADD_VECTOR_END(result, PT_TCP);
317	ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
318	ADD_VECTOR_END(result, PT_BIN_VAR);
319	} else if (name == CONF_PROTOCOL_OUTBOUND_HTTP_JSON_VARIANT) {
320	ADD_VECTOR_END(result, PT_TCP);
321	ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
322	ADD_VECTOR_END(result, PT_JSON_VAR);
323	} else if (name == CONF_PROTOCOL_OUTBOUND_HTTPS_XML_VARIANT) {
324	ADD_VECTOR_END(result, PT_TCP);
325	ADD_VECTOR_END(result, PT_OUTBOUND_SSL);
326	ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
327	ADD_VECTOR_END(result, PT_XML_VAR);
328	} else if (name == CONF_PROTOCOL_OUTBOUND_HTTPS_BIN_VARIANT) {
329	ADD_VECTOR_END(result, PT_TCP);
330	ADD_VECTOR_END(result, PT_OUTBOUND_SSL);
331	ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
332	ADD_VECTOR_END(result, PT_BIN_VAR);
333	} else if (name == CONF_PROTOCOL_OUTBOUND_HTTPS_JSON_VARIANT) {
334	ADD_VECTOR_END(result, PT_TCP);
335	ADD_VECTOR_END(result, PT_OUTBOUND_SSL);
336	ADD_VECTOR_END(result, PT_OUTBOUND_HTTP);
337	ADD_VECTOR_END(result, PT_JSON_VAR);
338	}
339	#endif /* HAS_PROTOCOL_HTTP */
340	#endif /* HAS_PROTOCOL_VAR */
341	#ifdef HAS_PROTOCOL_CLI
342	else if (name == CONF_PROTOCOL_INBOUND_CLI_JSON) {
343	ADD_VECTOR_END(result, PT_TCP);
344	ADD_VECTOR_END(result, PT_INBOUND_JSONCLI);
345	}
346	#ifdef HAS_PROTOCOL_HTTP
347	else if (name == CONF_PROTOCOL_INBOUND_HTTP_CLI_JSON) {
348	ADD_VECTOR_END(result, PT_TCP);
349	ADD_VECTOR_END(result, PT_INBOUND_HTTP);
350	ADD_VECTOR_END(result, PT_HTTP_4_CLI);
351	ADD_VECTOR_END(result, PT_INBOUND_JSONCLI);
352	}
353	#endif /* HAS_PROTOCOL_HTTP */
354	#endif /* HAS_PROTOCOL_CLI */
355	#ifdef HAS_PROTOCOL_MMS
356	else if (name == CONF_PROTOCOL_OUTBOUND_MMS) {
357	ADD_VECTOR_END(result, PT_TCP);
358	ADD_VECTOR_END(result, PT_OUTBOUND_MMS);
359	}
360	#endif /* HAS_PROTOCOL_MMS */
361	#ifdef HAS_PROTOCOL_RAWHTTPSTREAM
362	else if (name == CONF_PROTOCOL_INBOUND_RAW_HTTP_STREAM) {
363	ADD_VECTOR_END(result, PT_TCP);
364	ADD_VECTOR_END(result, PT_INBOUND_RAW_HTTP_STREAM);
365	} else if (name == CONF_PROTOCOL_INBOUND_RAW_HTTPS_STREAM) {
366	ADD_VECTOR_END(result, PT_TCP);
367	ADD_VECTOR_END(result, PT_INBOUND_SSL);
368	ADD_VECTOR_END(result, PT_INBOUND_RAW_HTTP_STREAM);
369	}
370	#endif /* HAS_PROTOCOL_RAWHTTPSTREAM */
371	else {
372	FATAL("Invalid protocol chain: %s.", STR(name));
373	}
374	return result;
375	}
376
377	BaseProtocol *DefaultProtocolFactory::SpawnProtocol(uint64_t type, Variant &parameters) {
378	BaseProtocol *pResult = NULL;
379	switch (type) {
380	case PT_TCP:
381	pResult = new TCPProtocol();
382	break;
383	case PT_UDP:
384	pResult = new UDPProtocol();
385	break;
386	case PT_INBOUND_SSL:
387	pResult = new InboundSSLProtocol();
388	break;
389	case PT_OUTBOUND_SSL:
390	pResult = new OutboundSSLProtocol();
391	break;
392	#ifdef HAS_PROTOCOL_DNS
393	case PT_INBOUND_DNS:
394	pResult = new InboundDNSResolverProtocol();
395	break;
396	case PT_OUTBOUND_DNS:
397	pResult = new OutboundDNSResolverProtocol();
398	break;
399	#endif /* HAS_PROTOCOL_DNS */
400	#ifdef HAS_PROTOCOL_RTMP
401	case PT_INBOUND_RTMP:
402	pResult = new InboundRTMPProtocol();
403	break;
404	case PT_INBOUND_RTMPS_DISC:
405	pResult = new InboundRTMPSDiscriminatorProtocol();
406	break;
407	case PT_OUTBOUND_RTMP:
408	pResult = new OutboundRTMPProtocol();
409	break;
410	#ifdef HAS_PROTOCOL_HTTP
411	case PT_INBOUND_HTTP_FOR_RTMP:
412	pResult = new InboundHTTP4RTMP();
413	break;
414	#endif /* HAS_PROTOCOL_HTTP */
415	#endif /* HAS_PROTOCOL_RTMP */
416	#ifdef HAS_PROTOCOL_TS
417	case PT_INBOUND_TS:
418	pResult = new InboundTSProtocol();
419	break;
420	#endif /* HAS_PROTOCOL_TS */
421	#ifdef HAS_PROTOCOL_HTTP
422	case PT_INBOUND_HTTP:
423	pResult = new InboundHTTPProtocol();
424	break;
425	case PT_OUTBOUND_HTTP:
426	pResult = new OutboundHTTPProtocol();
427	break;
428	#endif /* HAS_PROTOCOL_HTTP */
429	#ifdef HAS_PROTOCOL_LIVEFLV
430	case PT_INBOUND_LIVE_FLV:
431	pResult = new InboundLiveFLVProtocol();
432	break;
433	#endif /* HAS_PROTOCOL_LIVEFLV */
434	#ifdef HAS_PROTOCOL_VAR
435	case PT_XML_VAR:
436	pResult = new XmlVariantProtocol();
437	break;
438	case PT_BIN_VAR:
439	pResult = new BinVariantProtocol();
440	break;
441	case PT_JSON_VAR:
442	pResult = new JsonVariantProtocol();
443	break;
444	#endif /* HAS_PROTOCOL_VAR */
445	#ifdef HAS_PROTOCOL_RTP
446	case PT_RTSP:
447	pResult = new RTSPProtocol();
448	break;
449	case PT_RTCP:
450	pResult = new RTCPProtocol();
451	break;
452	case PT_INBOUND_RTP:
453	pResult = new InboundRTPProtocol();
454	break;
455	case PT_RTP_NAT_TRAVERSAL:
456	pResult = new NATTraversalProtocol();
457	break;
458	#endif /* HAS_PROTOCOL_RTP */
459	#ifdef HAS_PROTOCOL_CLI
460	case PT_INBOUND_JSONCLI:
461	pResult = new InboundJSONCLIProtocol();
462	break;
463	case PT_HTTP_4_CLI:
464	pResult = new HTTP4CLIProtocol();
465	break;
466	#endif /* HAS_PROTOCOL_CLI */
467	#ifdef HAS_PROTOCOL_MMS
468	case PT_OUTBOUND_MMS:
469	pResult = new MMSProtocol();
470	break;
471	#endif /* HAS_PROTOCOL_MMS */
472	#ifdef HAS_PROTOCOL_RAWHTTPSTREAM
473	case PT_INBOUND_RAW_HTTP_STREAM:
474	pResult = new InboundRawHTTPStreamProtocol();
475	break;
476	#endif /* HAS_PROTOCOL_RAWHTTPSTREAM */
477	default:
478	FATAL("Spawning protocol %s not yet implemented",
479	STR(tagToString(type)));
480	break;
481	}
482	if (pResult != NULL) {
483	if (!pResult->Initialize(parameters)) {
484	FATAL("Unable to initialize protocol %s",
485	STR(tagToString(type)));
486	delete pResult;
487	pResult = NULL;
488	}
489	}
490	return pResult;
491	}
492

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/sources/thelib/src/protocols/defaultprotocolfactory.cpp @ 749

Download in other formats: