| blob | 5812304c4dc42838c616ae1030fc1b0608befeb2 |
1 Only in libjingle-0.4.0: Makefile.in
2 diff -r libjingle-0.4.0/README libjingle/files/README
3 1,39c1,39
4 < Libjingle
5 <
6 < Libjingle is a set of components provided by Google to interoperate with Google
7 < Talk's peer-to-peer and voice capabilities. This package will create several
8 < static libraries you may link to your project as needed.
9 <
10 < -talk - No source files in talk/, just these subdirectories
11 < |-base - Contains basic low-level portable utility functions for
12 < | things like threads and sockets
13 < |-p2p - The P2P stack
14 < |-base - Base p2p functionality
15 < |-client - Hooks to tie it into XMPP
16 < |-session - Signaling
17 < |-phone - Signaling code specific to making phone calls
18 < |-third_party - Components that aren't ours
19 < |-mediastreamer - Media components for dealing with sound hardware and
20 < | voice codecs
21 < |-xmllite - XML parser
22 < |-xmpp - XMPP engine
23 <
24 < In addition, this package contains two examples in talk/examples which
25 < illustrate the basic concepts of how the provided classes work.
26 <
27 < The xmllite component of libjingle depends on expat. You can download expat
28 < from http://expat.sourceforge.net/.
29 <
30 < mediastreamer, the media components used by the example applications depend on
31 < the oRTP and iLBC components from linphone, which can be found at
32 < http://www.linphone.org. Linphone, in turn depends on GLib, which can be found
33 < at http://www.gtk.org. This GLib dependency should be removed in future
34 < releases.
35 <
36 < Building Libjingle
37 <
38 < Once the dependencies are installed, run ./configure. ./configure will return
39 < an error if it failed to locate the proper dependencies. If ./configure
40 < succeeds, run 'make' to build the components and examples.
41 <
42 < When the build is complete, you can run the call example from
43 ---
44 > Libjingle
45 >
46 > Libjingle is a set of components provided by Google to interoperate with Google
47 > Talk's peer-to-peer and voice capabilities. This package will create several
48 > static libraries you may link to your project as needed.
49 >
50 > -talk - No source files in talk/, just these subdirectories
51 > |-base - Contains basic low-level portable utility functions for
52 > | things like threads and sockets
53 > |-p2p - The P2P stack
54 > |-base - Base p2p functionality
55 > |-client - Hooks to tie it into XMPP
56 > |-session - Signaling
57 > |-phone - Signaling code specific to making phone calls
58 > |-third_party - Components that aren't ours
59 > |-mediastreamer - Media components for dealing with sound hardware and
60 > | voice codecs
61 > |-xmllite - XML parser
62 > |-xmpp - XMPP engine
63 >
64 > In addition, this package contains two examples in talk/examples which
65 > illustrate the basic concepts of how the provided classes work.
66 >
67 > The xmllite component of libjingle depends on expat. You can download expat
68 > from http://expat.sourceforge.net/.
69 >
70 > mediastreamer, the media components used by the example applications depend on
71 > the oRTP and iLBC components from linphone, which can be found at
72 > http://www.linphone.org. Linphone, in turn depends on GLib, which can be found
73 > at http://www.gtk.org. This GLib dependency should be removed in future
74 > releases.
75 >
76 > Building Libjingle
77 >
78 > Once the dependencies are installed, run ./configure. ./configure will return
79 > an error if it failed to locate the proper dependencies. If ./configure
80 > succeeds, run 'make' to build the components and examples.
81 >
82 > When the build is complete, you can run the call example from
83 41,57c41,57
84 <
85 < Relay Server
86 <
87 < Libjingle will also build a relay server that may be used to relay traffic
88 < when a direct peer-to-peer connection could not be established. The relay
89 < server will build in talk/p2p/base/relayserver and will listen on UDP
90 < ports 5000 and 5001. See the Libjingle Developer Guide at
91 < http://code.google.com/apis/talk/index.html for information about configuring
92 < a client to use this relay server.
93 <
94 < STUN Server
95 <
96 < Lastly, Libjingle builds a STUN server which implements the STUN protocol for
97 < Simple Traversal of UDP over NAT. The STUN server is built as
98 < talk/p2p/base/stunserver and listens on UDP port 7000. See the Libjingle
99 < Developer Guide at http://code.google.com/apis/talk/index.html for information
100 < about configuring a client to use this STUN server.
101 ---
102 >
103 > Relay Server
104 >
105 > Libjingle will also build a relay server that may be used to relay traffic
106 > when a direct peer-to-peer connection could not be established. The relay
107 > server will build in talk/p2p/base/relayserver and will listen on UDP
108 > ports 5000 and 5001. See the Libjingle Developer Guide at
109 > http://code.google.com/apis/talk/index.html for information about configuring
110 > a client to use this relay server.
111 >
112 > STUN Server
113 >
114 > Lastly, Libjingle builds a STUN server which implements the STUN protocol for
115 > Simple Traversal of UDP over NAT. The STUN server is built as
116 > talk/p2p/base/stunserver and listens on UDP port 7000. See the Libjingle
117 > Developer Guide at http://code.google.com/apis/talk/index.html for information
118 > about configuring a client to use this STUN server.
119 diff -r libjingle-0.4.0/README.win libjingle/files/README.win
120 1,24c1,24
121 < 1. Install Visual C++ Express 2005. It is free from this link:
122 < http://msdn.microsoft.com/vstudio/express/visualc/
123 <
124 < 2. Install the platform SDK and integrate it into VC++ express
125 < http://msdn.microsoft.com/vstudio/express/visualc/usingpsdk/
126 <
127 < 3. Download and install binary package for expat:
128 < http://sourceforge.net/project/showfiles.php?group_id=10127&package_id=11277
129 <
130 < 4. Update the Visual C++ directories in the Projects and Solutions section in the Options dialog box
131 < Library files: C:\expat-VERSION\StaticLibs
132 < Include files: C:\expat-VERSION\Source\Lib
133 < where VERSION is the version of expat you've downoaded
134 <
135 < 5. Unzip the libjingle files and open the solution.
136 <
137 < 6. If you wish to build the call example with GIPS Voice Engine Lite, download Voice Engine Lite from http://developer.globalipsound.com
138 <
139 < 7. Extract the Interface and Library directories from the Voice Engine Lite zip file into talk\third_party\gips
140 <
141 < 8. Open talk\third_party\gips\expiration.h and set the GIPS_EXPIRATION #defines to the expiration date provided by GIPS and remove the #error directive
142 <
143 < 9. Build the solution
144 <
145 ---
146 > 1. Install Visual C++ Express 2005. It is free from this link:
147 > http://msdn.microsoft.com/vstudio/express/visualc/
148 >
149 > 2. Install the platform SDK and integrate it into VC++ express
150 > http://msdn.microsoft.com/vstudio/express/visualc/usingpsdk/
151 >
152 > 3. Download and install binary package for expat:
153 > http://sourceforge.net/project/showfiles.php?group_id=10127&package_id=11277
154 >
155 > 4. Update the Visual C++ directories in the Projects and Solutions section in the Options dialog box
156 > Library files: C:\expat-VERSION\StaticLibs
157 > Include files: C:\expat-VERSION\Source\Lib
158 > where VERSION is the version of expat you've downoaded
159 >
160 > 5. Unzip the libjingle files and open the solution.
161 >
162 > 6. If you wish to build the call example with GIPS Voice Engine Lite, download Voice Engine Lite from http://developer.globalipsound.com
163 >
164 > 7. Extract the Interface and Library directories from the Voice Engine Lite zip file into talk\third_party\gips
165 >
166 > 8. Open talk\third_party\gips\expiration.h and set the GIPS_EXPIRATION #defines to the expiration date provided by GIPS and remove the #error directive
167 >
168 > 9. Build the solution
169 >
170 Only in libjingle-0.4.0: aclocal.m4
171 Only in libjingle-0.4.0: config.guess
172 diff -r libjingle-0.4.0/config.h libjingle/files/config.h
173 14c14
174 < #define HAVE_ALSA_ASOUNDLIB_H 1
175 ---
176 > /* #undef HAVE_ALSA_ASOUNDLIB_H */
177 23c23
178 < #define HAVE_GLIB 1
179 ---
180 > /* #undef HAVE_GLIB */
181 38c38
182 < #define HAVE_ORTP 1
183 ---
184 > /* #undef HAVE_ORTP */
185 41c41
186 < #define HAVE_SPEEX 1
187 ---
188 > /* #undef HAVE_SPEEX */
189 47c47
190 < #define HAVE_SPEEX_SPEEX_H 1
191 ---
192 > /* #undef HAVE_SPEEX_SPEEX_H */
193 71c71
194 < #define LINUX 1
195 ---
196 > /* #undef LINUX */
197 113c113
198 < #define __ALSA_ENABLED__ 1
199 ---
200 > /* #undef __ALSA_ENABLED__ */
201 Only in libjingle-0.4.0: config.h.in
202 Only in libjingle-0.4.0: config.sub
203 Only in libjingle-0.4.0: configure
204 Only in libjingle-0.4.0: depcomp
205 Only in libjingle-0.4.0: install-sh
206 Only in libjingle-0.4.0: ltmain.sh
207 Only in libjingle-0.4.0: missing
208 Only in libjingle-0.4.0/talk: Makefile.in
209 Only in libjingle-0.4.0/talk/base: Makefile.in
210 diff -r libjingle-0.4.0/talk/base/asynchttprequest.cc libjingle/files/talk/base/asynchttprequest.cc
211 73c73
212 < talk_base::SSLAdapter * ssl_adapter = talk_base::SSLAdapter::Create(socket);
213 ---
214 > talk_base::SSLAdapter * ssl_adapter = factory_->CreateSSLAdapter(socket);
215 75c75,81
216 < ssl_adapter->StartSSL(hostname_.c_str(), true);
217 ---
218 > int error = ssl_adapter->StartSSL(hostname_.c_str(),
219 > use_restartable_ssl_sockets_);
220 > if (error != 0) {
221 > LOG(LS_WARNING) << "Could not start SSL; error = " << error;
222 > delete ssl_adapter;
223 > return 0;
224 > }
225 diff -r libjingle-0.4.0/talk/base/asynchttprequest.h libjingle/files/talk/base/asynchttprequest.h
226 23,24c23
227 < public SignalThread,
228 < public sigslot::has_slots<> {
229 ---
230 > public SignalThread {
231 106c105,106
232 < binary_mode_(false), agent_(user_agent) { }
233 ---
234 > binary_mode_(false), agent_(user_agent),
235 > ignore_bad_cert_(false), use_restartable_ssl_sockets_(false) { }
236 114a115,120
237 > bool use_restartable_ssl_sockets() const {
238 > return use_restartable_ssl_sockets_;
239 > }
240 > void SetUseRestartableSSLSockets(bool use_restartable_ssl_sockets) {
241 > use_restartable_ssl_sockets_ = use_restartable_ssl_sockets;
242 > }
243 133a140
244 > bool use_restartable_ssl_sockets_;
245 diff -r libjingle-0.4.0/talk/base/asynctcpsocket.cc libjingle/files/talk/base/asynctcpsocket.cc
246 31a32,33
247 > #include <cstring>
248 >
249 diff -r libjingle-0.4.0/talk/base/autodetectproxy.cc libjingle/files/talk/base/autodetectproxy.cc
250 29c29
251 < #include "talk/base/httpcommon.h"
252 ---
253 > #include "talk/base/httpcommon-inl.h"
254 114c114
255 < Thread::Current()->MessageQueue::Stop();
256 ---
257 > Thread::Current()->Quit();
258 diff -r libjingle-0.4.0/talk/base/autodetectproxy.h libjingle/files/talk/base/autodetectproxy.h
259 22c22
260 < class AutoDetectProxy : public SignalThread, public sigslot::has_slots<> {
261 ---
262 > class AutoDetectProxy : public SignalThread {
263 diff -r libjingle-0.4.0/talk/base/base64.h libjingle/files/talk/base/base64.h
264 26,27c26,27
265 < static const std::string Base64::Base64Table;
266 < static const std::string::size_type Base64::DecodeTable[];
267 ---
268 > static const std::string Base64Table;
269 > static const std::string::size_type DecodeTable[];
270 diff -r libjingle-0.4.0/talk/base/common.h libjingle/files/talk/base/common.h
271 54c54
272 < #define stdmax(x,y) max(x,y)
273 ---
274 > #define stdmax(x,y) _max(x,y)
275 114,119d113
276 < // A macro to disallow the evil copy constructor and operator= functions
277 < // This should be used in the private: declarations for a class
278 < #define DISALLOW_EVIL_CONSTRUCTORS(TypeName) \
279 < TypeName(const TypeName&); \
280 < void operator=(const TypeName&)
281 <
282 diff -r libjingle-0.4.0/talk/base/criticalsection.h libjingle/files/talk/base/criticalsection.h
283 39c39
284 < #ifdef _DEBUG
285 ---
286 > #if !defined(NDEBUG)
287 41c41
288 < #endif // _DEBUG
289 ---
290 > #endif // !defined(NDEBUG)
291 83c83
292 < public:
293 ---
294 > public:
295 85a86
296 > pthread_mutexattr_init(&mutex_attribute);
297 87a89,90
298 > pthread_mutexattr_destroy(&mutex_attribute);
299 > TRACK_OWNER(thread_ = 0);
300 93a97
301 > TRACK_OWNER(thread_ = pthread_self());
302 95a100
303 > TRACK_OWNER(thread_ = 0);
304 98c103,110
305 < private:
306 ---
307 >
308 > #if CS_TRACK_OWNER
309 > bool CurrentThreadIsOwner() const {
310 > return pthread_equal(thread_, pthread_self());
311 > }
312 > #endif // CS_TRACK_OWNER
313 >
314 > private:
315 99a112
316 > TRACK_OWNER(pthread_t thread_);
317 diff -r libjingle-0.4.0/talk/base/cryptstring.h libjingle/files/talk/base/cryptstring.h
318 30a31
319 > #include <string.h>
320 diff -r libjingle-0.4.0/talk/base/diskcache.cc libjingle/files/talk/base/diskcache.cc
321 43c43
322 < #ifdef _DEBUG
323 ---
324 > #if !defined(NDEBUG)
325 45c45
326 < #else // !_DEBUG
327 ---
328 > #else // defined(NDEBUG)
329 47c47
330 < #endif // !_DEBUG
331 ---
332 > #endif // !defined(NDEBUG)
333 231c231
334 < #ifdef _DEBUG
335 ---
336 > #if !defined(NDEBUG)
337 238c238
338 < #endif // _DEBUG
339 ---
340 > #endif // !defined(NDEBUG)
341 diff -r libjingle-0.4.0/talk/base/diskcache_win32.cc libjingle/files/talk/base/diskcache_win32.cc
342 38c38
343 < entry->streams = max(entry->streams, index + 1);
344 ---
345 > entry->streams = _max(entry->streams, index + 1);
346 diff -r libjingle-0.4.0/talk/base/helpers.cc libjingle/files/talk/base/helpers.cc
347 38a39
348 > #include <wincrypt.h>
349 diff -r libjingle-0.4.0/talk/base/host.cc libjingle/files/talk/base/host.cc
350 30a31
351 > #include <cstdlib>
352 diff -r libjingle-0.4.0/talk/base/httpclient.cc libjingle/files/talk/base/httpclient.cc
353 670a671
354 > HttpAuthContext *context = context_.get();
355 676c677,678
356 < *context_.use(), response, auth_method);
357 ---
358 > context, response, auth_method);
359 > context_.reset(context);
360 diff -r libjingle-0.4.0/talk/base/httpcommon.h libjingle/files/talk/base/httpcommon.h
361 172c172
362 < inline const uint16 UrlDefaultPort(bool secure) {
363 ---
364 > inline uint16 UrlDefaultPort(bool secure) {
365 diff -r libjingle-0.4.0/talk/base/logging.cc libjingle/files/talk/base/logging.cc
366 27a28
367 > #include <stdio.h>
368 76c77
369 < #if _DEBUG
370 ---
371 > #if LOGGING
372 78c79
373 < #else // !_DEBUG
374 ---
375 > #else
376 80c81
377 < #endif // !_DEBUG
378 ---
379 > #endif
380 diff -r libjingle-0.4.0/talk/base/logging.h libjingle/files/talk/base/logging.h
381 67a68,69
382 >
383 > #if defined(SAFE_TO_DEFINE_TALK_BASE_LOGGING_MACROS)
384 70a73
385 > #endif // defined(SAFE_TO_DEFINE_TALK_BASE_LOGGING_MACROS)
386 195a199
387 > #if defined(SAFE_TO_DEFINE_TALK_BASE_LOGGING_MACROS)
388 197c201
389 < #if defined(_DEBUG) && !defined(NDEBUG)
390 ---
391 > #if !defined(NDEBUG)
392 290a295
393 > #endif // defined(SAFE_TO_DEFINE_TALK_BASE_LOGGING_MACROS)
394 diff -r libjingle-0.4.0/talk/base/messagequeue.cc libjingle/files/talk/base/messagequeue.cc
395 98,99c98,99
396 < new_ss = true;
397 < ss_ = new PhysicalSocketServer();
398 ---
399 > default_ss_.reset(new PhysicalSocketServer());
400 > ss_ = default_ss_.get();
401 103a104,107
402 > // The signal is done from here to ensure
403 > // that it always gets called when the queue
404 > // is going away.
405 > SignalQueueDestroyed();
406 108,109d111
407 < if (new_ss)
408 < delete ss_;
409 113,115d114
410 < if (new_ss)
411 < delete ss_;
412 < new_ss = false;
413 119c118
414 < void MessageQueue::Stop() {
415 ---
416 > void MessageQueue::Quit() {
417 124c123
418 < bool MessageQueue::IsStopping() {
419 ---
420 > bool MessageQueue::IsQuitting() {
421 diff -r libjingle-0.4.0/talk/base/messagequeue.h libjingle/files/talk/base/messagequeue.h
422 35a36
423 > #include "talk/base/scoped_ptr.h"
424 162,164c163,164
425 <
426 < virtual void Stop();
427 < virtual bool IsStopping();
428 ---
429 > virtual void Quit();
430 > virtual bool IsQuitting();
431 188a189,192
432 > // When this signal is sent out, any references to this queue should
433 > // no longer be used.
434 > sigslot::signal0<> SignalQueueDestroyed;
435 >
436 192a197,198
437 > // If a server isn't supplied in the constructor, use this one.
438 > scoped_ptr<SocketServer> default_ss_;
439 diff -r libjingle-0.4.0/talk/base/natserver.cc libjingle/files/talk/base/natserver.cc
440 28a29
441 > #include <cstring>
442 diff -r libjingle-0.4.0/talk/base/natsocketfactory.cc libjingle/files/talk/base/natsocketfactory.cc
443 29a30
444 > #include <cstring>
445 diff -r libjingle-0.4.0/talk/base/openssladapter.cc libjingle/files/talk/base/openssladapter.cc
446 619c619
447 < #ifdef _DEBUG
448 ---
449 > #if !defined(NDEBUG)
450 707c707
451 < #if _DEBUG
452 ---
453 > #if !defined(NDEBUG)
454 736c736
455 < #endif // _DEBUG
456 ---
457 > #endif // !defined(NDEBUG)
458 740c740
459 < #if _DEBUG
460 ---
461 > #if !defined(NDEBUG)
462 798c798
463 < #ifdef _DEBUG
464 ---
465 > #if !defined(NDEBUG)
466 diff -r libjingle-0.4.0/talk/base/openssladapter.h libjingle/files/talk/base/openssladapter.h
467 72c72
468 < #if _DEBUG
469 ---
470 > #if !defined(NDEBUG)
471 74c74
472 < #endif // !_DEBUG
473 ---
474 > #endif // !defined(NDEBUG)
475 diff -r libjingle-0.4.0/talk/base/physicalsocketserver.cc libjingle/files/talk/base/physicalsocketserver.cc
476 61a62
477 > #include "talk/base/winsock_initializer.h"
478 67,86d67
479 < #ifdef WIN32
480 < class WinsockInitializer {
481 < public:
482 < WinsockInitializer() {
483 < WSADATA wsaData;
484 < WORD wVersionRequested = MAKEWORD(1, 0);
485 < err_ = WSAStartup(wVersionRequested, &wsaData);
486 < }
487 < ~WinsockInitializer() {
488 < WSACleanup();
489 < }
490 < int error() {
491 < return err_;
492 < }
493 < private:
494 < int err_;
495 < };
496 < WinsockInitializer g_winsockinit;
497 < #endif
498 <
499 124a106,108
500 > #ifdef WIN32
501 > EnsureWinsockInit();
502 > #endif
503 187c171,177
504 < addr2.Resolve(); // TODO: Do this async later?
505 ---
506 > // TODO: Do this async later?
507 > if (!addr2.Resolve()) {
508 > LOG(LS_ERROR) << "Resolving addr failed";
509 > UpdateLastError();
510 > Close();
511 > return SOCKET_ERROR;
512 > }
513 265a256,259
514 > LOG(LS_WARNING) << "EOF from socket; deferring close event";
515 > // Must turn this back on so that the select() loop will notice the close
516 > // event.
517 > enabled_events_ |= kfRead;
518 402a397
519 > virtual bool IsDescriptorClosed() = 0;
520 452a448,451
521 > virtual bool IsDescriptorClosed() {
522 > return false;
523 > }
524 >
525 490a490,497
526 > virtual bool IsDescriptorClosed() {
527 > // We don't have a reliable way of distinguishing end-of-stream
528 > // from readability. So test on each readable call. Is this
529 > // inefficient? Probably.
530 > char ch;
531 > return (0 == ::recv(s_, &ch, 1, MSG_PEEK));
532 > }
533 >
534 546a554,557
535 > virtual bool IsDescriptorClosed() {
536 > return false;
537 > }
538 >
539 916c927,931
540 < ff |= kfRead;
541 ---
542 > if (pdispatcher->IsDescriptorClosed()) {
543 > ff |= kfClose;
544 > } else {
545 > ff |= kfRead;
546 > }
547 diff -r libjingle-0.4.0/talk/base/proxydetect.cc libjingle/files/talk/base/proxydetect.cc
548 205,206c205,206
549 < const char* list = slist.c_str();
550 < while (*list) {
551 ---
552 > const char* clist = slist.c_str();
553 > while (*clist) {
554 208,209c208,209
555 < if (isspace(*list)) {
556 < ++list;
557 ---
558 > if (isspace(*clist)) {
559 > ++clist;
560 214,217c214,217
561 < const char * start = list;
562 < if (const char * end = strchr(list, sep)) {
563 < len = (end - list);
564 < list += len + 1;
565 ---
566 > const char * start = clist;
567 > if (const char * end = strchr(clist, sep)) {
568 > len = (end - clist);
569 > clist += len + 1;
570 219,220c219,220
571 < len = strlen(list);
572 < list += len;
573 ---
574 > len = strlen(clist);
575 > clist += len;
576 diff -r libjingle-0.4.0/talk/base/schanneladapter.cc libjingle/files/talk/base/schanneladapter.cc
577 607c607
578 < size_t read = min(cb, readable.size());
579 ---
580 > size_t read = _min(cb, readable.size());
581 diff -r libjingle-0.4.0/talk/base/scoped_ptr.h libjingle/files/talk/base/scoped_ptr.h
582 36,257c36
583 < namespace talk_base {
584 <
585 < template <typename T>
586 < class scoped_ptr {
587 < private:
588 <
589 < T* ptr;
590 <
591 < scoped_ptr(scoped_ptr const &);
592 < scoped_ptr & operator=(scoped_ptr const &);
593 <
594 < public:
595 <
596 < typedef T element_type;
597 <
598 < explicit scoped_ptr(T* p = 0): ptr(p) {}
599 <
600 < ~scoped_ptr() {
601 < typedef char type_must_be_complete[sizeof(T)];
602 < delete ptr;
603 < }
604 <
605 < void reset(T* p = 0) {
606 < typedef char type_must_be_complete[sizeof(T)];
607 <
608 < if (ptr != p) {
609 < delete ptr;
610 < ptr = p;
611 < }
612 < }
613 <
614 < T& operator*() const {
615 < assert(ptr != 0);
616 < return *ptr;
617 < }
618 <
619 < T* operator->() const {
620 < assert(ptr != 0);
621 < return ptr;
622 < }
623 <
624 < T* get() const {
625 < return ptr;
626 < }
627 <
628 < void swap(scoped_ptr & b) {
629 < T* tmp = b.ptr;
630 < b.ptr = ptr;
631 < ptr = tmp;
632 < }
633 <
634 < T* release() {
635 < T* tmp = ptr;
636 < ptr = 0;
637 < return tmp;
638 < }
639 <
640 < T** accept() {
641 < if (ptr) {
642 < delete ptr;
643 < ptr = 0;
644 < }
645 < return &ptr;
646 < }
647 <
648 < T** use() {
649 < return &ptr;
650 < }
651 < };
652 <
653 < template<typename T> inline
654 < void swap(scoped_ptr<T>& a, scoped_ptr<T>& b) {
655 < a.swap(b);
656 < }
657 <
658 <
659 <
660 <
661 < // scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
662 < // is guaranteed, either on destruction of the scoped_array or via an explicit
663 < // reset(). Use shared_array or std::vector if your needs are more complex.
664 <
665 < template<typename T>
666 < class scoped_array {
667 < private:
668 <
669 < T* ptr;
670 <
671 < scoped_array(scoped_array const &);
672 < scoped_array & operator=(scoped_array const &);
673 <
674 < public:
675 <
676 < typedef T element_type;
677 <
678 < explicit scoped_array(T* p = 0) : ptr(p) {}
679 <
680 < ~scoped_array() {
681 < typedef char type_must_be_complete[sizeof(T)];
682 < delete[] ptr;
683 < }
684 <
685 < void reset(T* p = 0) {
686 < typedef char type_must_be_complete[sizeof(T)];
687 <
688 < if (ptr != p) {
689 < delete [] ptr;
690 < ptr = p;
691 < }
692 < }
693 <
694 < T& operator[](std::ptrdiff_t i) const {
695 < assert(ptr != 0);
696 < assert(i >= 0);
697 < return ptr[i];
698 < }
699 <
700 < T* get() const {
701 < return ptr;
702 < }
703 <
704 < void swap(scoped_array & b) {
705 < T* tmp = b.ptr;
706 < b.ptr = ptr;
707 < ptr = tmp;
708 < }
709 <
710 < T* release() {
711 < T* tmp = ptr;
712 < ptr = 0;
713 < return tmp;
714 < }
715 <
716 < T** accept() {
717 < if (ptr) {
718 < delete [] ptr;
719 < ptr = 0;
720 < }
721 < return &ptr;
722 < }
723 < };
724 <
725 < template<class T> inline
726 < void swap(scoped_array<T>& a, scoped_array<T>& b) {
727 < a.swap(b);
728 < }
729 <
730 < // scoped_ptr_malloc<> is similar to scoped_ptr<>, but it accepts a
731 < // second template argument, the function used to free the object.
732 <
733 < template<typename T, void (*FF)(void*) = free> class scoped_ptr_malloc {
734 < private:
735 <
736 < T* ptr;
737 <
738 < scoped_ptr_malloc(scoped_ptr_malloc const &);
739 < scoped_ptr_malloc & operator=(scoped_ptr_malloc const &);
740 <
741 < public:
742 <
743 < typedef T element_type;
744 <
745 < explicit scoped_ptr_malloc(T* p = 0): ptr(p) {}
746 <
747 < ~scoped_ptr_malloc() {
748 < typedef char type_must_be_complete[sizeof(T)];
749 < FF(static_cast<void*>(ptr));
750 < }
751 <
752 < void reset(T* p = 0) {
753 < typedef char type_must_be_complete[sizeof(T)];
754 <
755 < if (ptr != p) {
756 < FF(static_cast<void*>(ptr));
757 < ptr = p;
758 < }
759 < }
760 <
761 < T& operator*() const {
762 < assert(ptr != 0);
763 < return *ptr;
764 < }
765 <
766 < T* operator->() const {
767 < assert(ptr != 0);
768 < return ptr;
769 < }
770 <
771 < T* get() const {
772 < return ptr;
773 < }
774 <
775 < void swap(scoped_ptr_malloc & b) {
776 < T* tmp = b.ptr;
777 < b.ptr = ptr;
778 < ptr = tmp;
779 < }
780 <
781 < T* release() {
782 < T* tmp = ptr;
783 < ptr = 0;
784 < return tmp;
785 < }
786 <
787 < T** accept() {
788 < if (ptr) {
789 < FF(static_cast<void*>(ptr));
790 < ptr = 0;
791 < }
792 < return &ptr;
793 < }
794 < };
795 <
796 < template<typename T, void (*FF)(void*)> inline
797 < void swap(scoped_ptr_malloc<T,FF>& a, scoped_ptr_malloc<T,FF>& b) {
798 < a.swap(b);
799 < }
800 <
801 < } // namespace talk_base
802 <
803 < // TODO: get rid of this global using
804 < using talk_base::scoped_ptr;
805 ---
806 > #include "base/scoped_ptr.h"
807 diff -r libjingle-0.4.0/talk/base/signalthread.cc libjingle/files/talk/base/signalthread.cc
808 12a13,15
809 > main_->SignalQueueDestroyed.connect(this,
810 > &SignalThread::OnMainThreadDestroyed);
811 > refcount_ = 1;
812 15a19,23
813 > void SignalThread::OnMainThreadDestroyed() {
814 > EnterExit ee(this);
815 > main_ = NULL;
816 > }
817 >
818 19a28
819 > EnterExit ee(this);
820 25a35
821 > EnterExit ee(this);
822 27c37
823 < if (kInit == state_) {
824 ---
825 > if (kInit == state_ || kComplete == state_) {
826 36c46,47
827 < void SignalThread::Destroy() {
828 ---
829 > void SignalThread::Destroy(bool wait) {
830 > EnterExit ee(this);
831 39,40c50,51
832 < delete this;
833 < } else if (kRunning == state_) {
834 ---
835 > refcount_--;
836 > } else if (kRunning == state_ || kReleasing == state_) {
837 42,47c53,63
838 < // A couple tricky issues here:
839 < // 1) Thread::Stop() calls Join(), which we don't want... we just want
840 < // to stop the MessageQueue, which causes ContinueWork() to return false.
841 < // 2) OnWorkStop() must follow Stop(), so that when the thread wakes up
842 < // due to OWS(), ContinueWork() will return false.
843 < worker_.MessageQueue::Stop();
844 ---
845 > // OnWorkStop() must follow Quit(), so that when the thread wakes up due to
846 > // OWS(), ContinueWork() will return false.
847 > if (wait) {
848 > // Release the thread's lock so that it can return from ::Run.
849 > cs_.Leave();
850 > worker_.Stop();
851 > cs_.Enter();
852 > refcount_--;
853 > } else {
854 > worker_.Quit();
855 > }
856 54a71
857 > EnterExit ee(this);
858 57c74
859 < delete this;
860 ---
861 > refcount_--;
862 66a84
863 > EnterExit ee(this);
864 71a90
865 > EnterExit ee(this);
866 81a101,111
867 > // Before signaling that the work is done, make sure that the worker
868 > // thread actually is done. We got here because DoWork() finished and
869 > // Run() posted the ST_MSG_WORKER_DONE message. This means the worker
870 > // thread is about to go away anyway, but sometimes it doesn't actually
871 > // finish before SignalWorkDone is processed, and for a reusable
872 > // SignalThread this makes an assert in thread.cc fire.
873 > //
874 > // Calling Stop() on the worker ensures that the OS thread that underlies
875 > // the worker will finish, and will be set to NULL, enabling us to call
876 > // Start() again.
877 > worker_.Stop();
878 85c115
879 < delete this;
880 ---
881 > refcount_--;
882 92c122,127
883 < main_->Post(this, ST_MSG_WORKER_DONE);
884 ---
885 > {
886 > EnterExit ee(this);
887 > if (main_) {
888 > main_->Post(this, ST_MSG_WORKER_DONE);
889 > }
890 > }
891 diff -r libjingle-0.4.0/talk/base/signalthread.h libjingle/files/talk/base/signalthread.h
892 15a16,19
893 > // Periodic tasks: Wait for SignalWorkDone, then eventually call Start()
894 > // again to repeat the task. When the instance isn't needed anymore,
895 > // call Release. DoWork, OnWorkStart and OnWorkStop are called again,
896 > // on a new thread.
897 22c26
898 < class SignalThread : protected MessageHandler {
899 ---
900 > class SignalThread : public sigslot::has_slots<>, protected MessageHandler {
901 35,36c39,41
902 < // SignalWorkDone will not be signalled.
903 < void Destroy();
904 ---
905 > // SignalWorkDone will not be signalled. If wait is true, does not return
906 > // until the thread is deleted.
907 > void Destroy(bool wait);
908 53c58
909 <
910 ---
911 >
912 57c62
913 < // Context: Worker Thread. Subclass should call periodically to
914 ---
915 > // Context: Worker Thread. Subclass should call periodically to
916 67c72
917 <
918 ---
919 >
920 79a85,106
921 > class EnterExit {
922 > friend class SignalThread;
923 >
924 > SignalThread * t_;
925 >
926 > EnterExit(SignalThread * t) : t_(t) {
927 > t_->cs_.Enter();
928 > t_->refcount_ += 1;
929 > }
930 > ~EnterExit() {
931 > bool d = (0 == (--(t_->refcount_)));
932 > t_->cs_.Leave();
933 > if (d)
934 > delete t_;
935 > }
936 > };
937 >
938 > friend class EnterExit;
939 >
940 > CriticalSection cs_;
941 > int refcount_;
942 >
943 80a108
944 > void OnMainThreadDestroyed();
945 84c112,118
946 < enum State { kInit, kRunning, kComplete, kStopping, kReleasing } state_;
947 ---
948 > enum State {
949 > kInit, // Initialized, but not started
950 > kRunning, // Started and doing work
951 > kReleasing, // Same as running, but to be deleted when work is done
952 > kComplete, // Work is done
953 > kStopping, // Work is being interrupted
954 > } state_;
955 diff -r libjingle-0.4.0/talk/base/sigslot.h libjingle/files/talk/base/sigslot.h
956 530c530
957 < #ifdef _DEBUG
958 ---
959 > #if !defined(NDEBUG)
960 676c676
961 < #ifdef _DEBUG
962 ---
963 > #if !defined(NDEBUG)
964 807c807
965 < #ifdef _DEBUG
966 ---
967 > #if !defined(NDEBUG)
968 937c937
969 < #ifdef _DEBUG
970 ---
971 > #if !defined(NDEBUG)
972 1067c1067
973 < #ifdef _DEBUG
974 ---
975 > #if !defined(NDEBUG)
976 1199c1199
977 < #ifdef _DEBUG
978 ---
979 > #if !defined(NDEBUG)
980 1331c1331
981 < #ifdef _DEBUG
982 ---
983 > #if !defined(NDEBUG)
984 1463c1463
985 < #ifdef _DEBUG
986 ---
987 > #if !defined(NDEBUG)
988 1596c1596
989 < #ifdef _DEBUG
990 ---
991 > #if !defined(NDEBUG)
992 diff -r libjingle-0.4.0/talk/base/socket.h libjingle/files/talk/base/socket.h
993 77a78
994 > #undef ETIMEDOUT // remove pthread.h's definition
995 diff -r libjingle-0.4.0/talk/base/socketadapters.cc libjingle/files/talk/base/socketadapters.cc
996 43a44,45
997 > #include <cstring>
998 >
999 diff -r libjingle-0.4.0/talk/base/socketaddress.cc libjingle/files/talk/base/socketaddress.cc
1000 52c52
1001 < #ifdef _DEBUG
1002 ---
1003 > #if !defined(NDEBUG)
1004 54c54
1005 < #else // !_DEBUG
1006 ---
1007 > #else // defined(NDEBUG)
1008 56c56
1009 < #endif // !_DEBUG
1010 ---
1011 > #endif // !defined(NDEBUG)
1012 diff -r libjingle-0.4.0/talk/base/socketfactory.h libjingle/files/talk/base/socketfactory.h
1013 32a33
1014 > #include "talk/base/ssladapter.h"
1015 46a48,52
1016 >
1017 > // Wraps the given socket in an SSL adapter.
1018 > virtual SSLAdapter* CreateSSLAdapter(AsyncSocket* socket) {
1019 > return SSLAdapter::Create(socket);
1020 > }
1021 diff -r libjingle-0.4.0/talk/base/socketpool.cc libjingle/files/talk/base/socketpool.cc
1022 142d141
1023 < ASSERT(false);
1024 189d187
1025 < ASSERT(false);
1026 diff -r libjingle-0.4.0/talk/base/ssladapter.cc libjingle/files/talk/base/ssladapter.cc
1027 34c34,35
1028 < #define SSL_USE_OPENSSL 1
1029 ---
1030 > // Turn off OpenSSL
1031 > //#define SSL_USE_OPENSSL 1
1032 84a86
1033 > #if SSL_USE_OPENSSL || SSL_USE_SCHANNEL
1034 85a88,90
1035 > #else
1036 > return NULL;
1037 > #endif
1038 diff -r libjingle-0.4.0/talk/base/stream.cc libjingle/files/talk/base/stream.cc
1039 27a28
1040 > #include <stdio.h>
1041 diff -r libjingle-0.4.0/talk/base/stringencode.cc libjingle/files/talk/base/stringencode.cc
1042 34a35
1043 > #include <stdlib.h>
1044 525c526
1045 < #ifdef _DEBUG
1046 ---
1047 > #if !defined(NDEBUG)
1048 575c576
1049 < #endif // _DEBUG
1050 ---
1051 > #endif // !defined(NDEBUG)
1052 diff -r libjingle-0.4.0/talk/base/stringutils.cc libjingle/files/talk/base/stringutils.cc
1053 72c72
1054 < #if _DEBUG
1055 ---
1056 > #if !defined(NDEBUG)
1057 76c76
1058 < #endif // _DEBUG
1059 ---
1060 > #endif // !defined(NDEBUG)
1061 diff -r libjingle-0.4.0/talk/base/stringutils.h libjingle/files/talk/base/stringutils.h
1062 33a34
1063 > #include <string.h>
1064 87a89
1065 > #if 0
1066 93a96
1067 > #endif
1068 200,208d202
1069 < size_t sprintfn(CTYPE* buffer, size_t buflen, const CTYPE* format, ...) {
1070 < va_list args;
1071 < va_start(args, format);
1072 < size_t len = vsprintfn(buffer, buflen, format, args);
1073 < va_end(args);
1074 < return len;
1075 < }
1076 <
1077 < template<class CTYPE>
1078 218a213,221
1079 > template<class CTYPE>
1080 > size_t sprintfn(CTYPE* buffer, size_t buflen, const CTYPE* format, ...) {
1081 > va_list args;
1082 > va_start(args, format);
1083 > size_t len = vsprintfn(buffer, buflen, format, args);
1084 > va_end(args);
1085 > return len;
1086 > }
1087 >
1088 272c275
1089 < inline static const char* Traits<char>::empty_str() { return ""; }
1090 ---
1091 > inline static const char* empty_str() { return ""; }
1092 diff -r libjingle-0.4.0/talk/base/task.cc libjingle/files/talk/base/task.cc
1093 5c5
1094 < * Redistribution and use in source and binary forms, with or without
1095 ---
1096 > * Redistribution and use in source and binary forms, with or without
1097 8c8
1098 < * 1. Redistributions of source code must retain the above copyright notice,
1099 ---
1100 > * 1. Redistributions of source code must retain the above copyright notice,
1101 13c13
1102 < * 3. The name of the author may not be used to endorse or promote products
1103 ---
1104 > * 3. The name of the author may not be used to endorse or promote products
1105 17c17
1106 < * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
1107 ---
1108 > * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
1109 19c19
1110 < * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
1111 ---
1112 > * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
1113 23,24c23,24
1114 < * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
1115 < * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
1116 ---
1117 > * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
1118 > * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
1119 141c141
1120 < if (aborted_ || done_)
1121 ---
1122 > if (done_)
1123 150c150
1124 < Wake(); // to self-delete
1125 ---
1126 > GetRunner()->WakeTasks();
1127 diff -r libjingle-0.4.0/talk/base/taskrunner.h libjingle/files/talk/base/taskrunner.h
1128 63a64,68
1129 > bool HasPendingTimeoutTask() {
1130 > return next_timeout_task_ != NULL &&
1131 > next_timeout_task_->TimedOut();
1132 > }
1133 >
1134 diff -r libjingle-0.4.0/talk/base/testclient.cc libjingle/files/talk/base/testclient.cc
1135 29a30
1136 > #include <cstring>
1137 diff -r libjingle-0.4.0/talk/base/thread.cc libjingle/files/talk/base/thread.cc
1138 100a101,105
1139 > bool ThreadManager::ThreadActive(Thread *thread) {
1140 > CritScope cs(&crit_);
1141 > return(std::find(threads_.begin(), threads_.end(), thread) != threads_.end());
1142 > }
1143 >
1144 103a109
1145 > stopped_ = false;
1146 124,125c130,135
1147 < pthread_create(&thread_, &attr, PreRun, this);
1148 < started_ = true;
1149 ---
1150 > CritScope cs(&started_crit_);
1151 > // Make sure Join() hasn't been called yet.
1152 > if (stopped_)
1153 > return;
1154 > if (pthread_create(&thread_, &attr, PreRun, this) == 0)
1155 > started_ = true;
1156 128a139,140
1157 > CritScope cs(&started_crit_);
1158 > stopped_ = true;
1159 131a144
1160 > started_ = false;
1161 168a182,185
1162 > CritScope cs(&started_crit_);
1163 > // Make sure Join() hasn't been called yet.
1164 > if (stopped_)
1165 > return;
1166 181a199,200
1167 > CritScope cs(&started_crit_);
1168 > stopped_ = true;
1169 191a211,213
1170 > // Make sure the thread hasn't been deleted.
1171 > if (!g_thmgr.ThreadActive(thread))
1172 > return NULL;
1173 207c229
1174 < MessageQueue::Stop();
1175 ---
1176 > MessageQueue::Quit();
1177 329c351
1178 < return false;
1179 ---
1180 > return !IsQuitting();
1181 diff -r libjingle-0.4.0/talk/base/thread.h libjingle/files/talk/base/thread.h
1182 57a58
1183 > bool ThreadActive(Thread *thread);
1184 134a136
1185 > CriticalSection started_crit_;
1186 135a138
1187 > bool stopped_;
1188 diff -r libjingle-0.4.0/talk/base/urlencode.cc libjingle/files/talk/base/urlencode.cc
1189 0a1,2
1190 > #include <stdlib.h>
1191 > #include <string.h>
1192 Only in libjingle-0.4.0/talk/base: win32socketserver.cc
1193 Only in libjingle-0.4.0/talk/base: win32socketserver.h
1194 Only in libjingle/files/talk/base: win32window.cc
1195 diff -r libjingle-0.4.0/talk/base/winping.cc libjingle/files/talk/base/winping.cc
1196 133c133
1197 < return sizeof(ICMP_ECHO_REPLY) + max(8UL, data_size);
1198 ---
1199 > return sizeof(ICMP_ECHO_REPLY) + _max((uint32)(8UL), data_size);
1200 317c317
1201 < } // namespace talk_base
1202 \ No newline at end of file
1203 ---
1204 > } // namespace talk_base
1205 Only in libjingle/files/talk/base: winsock_initializer.cc
1206 Only in libjingle/files/talk/base: winsock_initializer.h
1207 Only in libjingle-0.4.0/talk: examples
1208 Only in libjingle-0.4.0/talk: libjingle.sln
1209 Only in libjingle-0.4.0/talk: libjingle.vcproj
1210 Only in libjingle-0.4.0/talk: p2p
1211 Only in libjingle-0.4.0/talk: session
1212 Only in libjingle-0.4.0/talk: third_party
1213 Only in libjingle-0.4.0/talk/xmllite: Makefile.in
1214 diff -r libjingle-0.4.0/talk/xmllite/qname.cc libjingle/files/talk/xmllite/qname.cc
1215 39c39
1216 < int result = ns.size() * 101;
1217 ---
1218 > int result = static_cast<int>(ns.size()) * 101;
1219 diff -r libjingle-0.4.0/talk/xmllite/qname.h libjingle/files/talk/xmllite/qname.h
1220 64d63
1221 < refcount_(1),
1222 66c65,66
1223 < localPart_(local) {}
1224 ---
1225 > localPart_(local),
1226 > refcount_(1) {}
1227 diff -r libjingle-0.4.0/talk/xmllite/xmlelement.cc libjingle/files/talk/xmllite/xmlelement.cc
1228 88c88,89
1229 < pLastChild_(NULL) {
1230 ---
1231 > pLastChild_(NULL),
1232 > cdata_(false) {
1233 97c98,99
1234 < pLastChild_(NULL) {
1235 ---
1236 > pLastChild_(NULL),
1237 > cdata_(false) {
1238 125a128
1239 > cdata_ = elt.cdata_;
1240 133c136,137
1241 < pLastChild_(NULL) {
1242 ---
1243 > pLastChild_(NULL),
1244 > cdata_(false) {
1245 393a398,403
1246 > XmlElement::AddCDATAText(const char * buf, int len) {
1247 > cdata_ = true;
1248 > AddParsedText(buf, len);
1249 > }
1250 >
1251 > void
1252 diff -r libjingle-0.4.0/talk/xmllite/xmlelement.h libjingle/files/talk/xmllite/xmlelement.h
1253 203a204,206
1254 > // Note: CDATA is not supported by XMPP, therefore using this function will
1255 > // generate non-XMPP compatible XML.
1256 > void AddCDATAText(const char * buf, int len);
1257 217a221,222
1258 > bool IsCDATA() const { return cdata_; }
1259 >
1260 228a234
1261 > bool cdata_;
1262 diff -r libjingle-0.4.0/talk/xmllite/xmlparser.cc libjingle/files/talk/xmllite/xmlparser.cc
1263 28,29d27
1264 < #include "talk/xmllite/xmlparser.h"
1265 <
1266 35a34
1267 > #include "talk/xmllite/xmlconstants.h"
1268 38c37
1269 < #include "talk/xmllite/xmlconstants.h"
1270 ---
1271 > #include "talk/xmllite/xmlparser.h"
1272 119a119,121
1273 > context_.SetPosition(XML_GetCurrentLineNumber(expat_),
1274 > XML_GetCurrentColumnNumber(expat_),
1275 > XML_GetCurrentByteIndex(expat_));
1276 127a130,132
1277 > context_.SetPosition(XML_GetCurrentLineNumber(expat_),
1278 > XML_GetCurrentColumnNumber(expat_),
1279 > XML_GetCurrentByteIndex(expat_));
1280 134a140,142
1281 > context_.SetPosition(XML_GetCurrentLineNumber(expat_),
1282 > XML_GetCurrentColumnNumber(expat_),
1283 > XML_GetCurrentByteIndex(expat_));
1284 168c176,180
1285 < if (XML_Parse(expat_, data, static_cast<int>(len), isFinal) != XML_STATUS_OK)
1286 ---
1287 > if (XML_Parse(expat_, data, static_cast<int>(len), isFinal) !=
1288 > XML_STATUS_OK) {
1289 > context_.SetPosition(XML_GetCurrentLineNumber(expat_),
1290 > XML_GetCurrentColumnNumber(expat_),
1291 > XML_GetCurrentByteIndex(expat_));
1292 169a182
1293 > }
1294 193c206,209
1295 < raised_(XML_ERROR_NONE) {
1296 ---
1297 > raised_(XML_ERROR_NONE),
1298 > line_number_(0),
1299 > column_number_(0),
1300 > byte_index_(0) {
1301 247c263,285
1302 < XmlParser::ParseContext::~ParseContext() {
1303 ---
1304 > void
1305 > XmlParser::ParseContext::SetPosition(XML_Size line, XML_Size column,
1306 > XML_Index byte_index) {
1307 > line_number_ = line;
1308 > column_number_ = column;
1309 > byte_index_ = byte_index;
1310 > }
1311 >
1312 > void
1313 > XmlParser::ParseContext::GetPosition(unsigned long * line,
1314 > unsigned long * column,
1315 > unsigned long * byte_index) {
1316 > if (line != NULL) {
1317 > *line = static_cast<unsigned long>(line_number_);
1318 > }
1319 >
1320 > if (column != NULL) {
1321 > *column = static_cast<unsigned long>(column_number_);
1322 > }
1323 >
1324 > if (byte_index != NULL) {
1325 > *byte_index = static_cast<unsigned long>(byte_index_);
1326 > }
1327 249a288
1328 > XmlParser::ParseContext::~ParseContext() {
1329 251a291
1330 > }
1331 diff -r libjingle-0.4.0/talk/xmllite/xmlparser.h libjingle/files/talk/xmllite/xmlparser.h
1332 48a49,50
1333 > virtual void GetPosition(unsigned long * line, unsigned long * column,
1334 > unsigned long * byte_index) = 0;
1335 85a88,89
1336 > virtual void GetPosition(unsigned long * line, unsigned long * column,
1337 > unsigned long * byte_index);
1338 91a96
1339 > void SetPosition(XML_Size line, XML_Size column, XML_Index byte_index);
1340 96a102,104
1341 > XML_Size line_number_;
1342 > XML_Size column_number_;
1343 > XML_Index byte_index_;
1344 diff -r libjingle-0.4.0/talk/xmllite/xmlprinter.cc libjingle/files/talk/xmllite/xmlprinter.cc
1345 46a47
1346 > void PrintCDATAText(const std::string & text);
1347 134,136c135,141
1348 < if (pchild->IsText())
1349 < PrintBodyText(pchild->AsText()->Text());
1350 < else
1351 ---
1352 > if (pchild->IsText()) {
1353 > if (element->IsCDATA()) {
1354 > PrintCDATAText(pchild->AsText()->Text());
1355 > } else {
1356 > PrintBodyText(pchild->AsText()->Text());
1357 > }
1358 > } else
1359 188a194,197
1360 > void
1361 > XmlPrinterImpl::PrintCDATAText(const std::string & text) {
1362 > *pout_ << "<![CDATA[" << text << "]]>";
1363 > }
1364 Only in libjingle-0.4.0/talk/xmpp: Makefile.in
1365 Only in libjingle-0.4.0/talk/xmpp: constants.cc
1366 Only in libjingle-0.4.0/talk/xmpp: constants.h
1367 diff -r libjingle-0.4.0/talk/xmpp/jid.cc libjingle/files/talk/xmpp/jid.cc
1368 33c33
1369 < #include "talk/xmpp/constants.h"
1370 ---
1371 > #include "talk/xmpp/xmppconstants.h"
1372 diff -r libjingle-0.4.0/talk/xmpp/plainsaslhandler.h libjingle/files/talk/xmpp/plainsaslhandler.h
1373 31d30
1374 < #include "talk/xmpp/saslhandler.h"
1375 32a32,34
1376 > #include <string>
1377 >
1378 > #include "talk/xmpp/saslhandler.h"
1379 68a71,76
1380 >
1381 > virtual bool GetTlsServerInfo(const talk_base::SocketAddress& server,
1382 > std::string* tls_server_hostname,
1383 > std::string* tls_server_domain) {
1384 > return false;
1385 > }
1386 diff -r libjingle-0.4.0/talk/xmpp/prexmppauth.h libjingle/files/talk/xmpp/prexmppauth.h
1387 33d32
1388 < #include "talk/xmpp/saslhandler.h"
1389 64c63
1390 < class PreXmppAuth : public SaslHandler {
1391 ---
1392 > class PreXmppAuth {
1393 diff -r libjingle-0.4.0/talk/xmpp/saslcookiemechanism.h libjingle/files/talk/xmpp/saslcookiemechanism.h
1394 33c33
1395 < #include "talk/xmpp/constants.h"
1396 ---
1397 > #include "talk/xmpp/xmppconstants.h"
1398 40,41c40,55
1399 < SaslCookieMechanism(const std::string & mechanism, const std::string & username, const std::string & cookie) :
1400 < mechanism_(mechanism), username_(username), cookie_(cookie) {}
1401 ---
1402 > SaslCookieMechanism(const std::string & mechanism,
1403 > const std::string & username,
1404 > const std::string & cookie,
1405 > const std::string & token_service)
1406 > : mechanism_(mechanism),
1407 > username_(username),
1408 > cookie_(cookie),
1409 > token_service_(token_service) {}
1410 >
1411 > SaslCookieMechanism(const std::string & mechanism,
1412 > const std::string & username,
1413 > const std::string & cookie)
1414 > : mechanism_(mechanism),
1415 > username_(username),
1416 > cookie_(cookie),
1417 > token_service_("") {}
1418 48a63,67
1419 > if (!token_service_.empty()) {
1420 > el->AddAttr(
1421 > QName(true, "http://www.google.com/talk/protocol/auth", "service"),
1422 > token_service_);
1423 > }
1424 62a82
1425 > std::string token_service_;
1426 diff -r libjingle-0.4.0/talk/xmpp/saslhandler.h libjingle/files/talk/xmpp/saslhandler.h
1427 31a32,34
1428 > #include <vector>
1429 >
1430 > #include "talk/base/socketaddress.h"
1431 53a57,63
1432 >
1433 > // Fills in the tls server hostname/domain to use for the given
1434 > // server (and returns true). Return false if you want the defaults
1435 > // to be used.
1436 > virtual bool GetTlsServerInfo(const talk_base::SocketAddress& server,
1437 > std::string* tls_server_hostname,
1438 > std::string* tls_server_domain) = 0;
1439 diff -r libjingle-0.4.0/talk/xmpp/saslmechanism.cc libjingle/files/talk/xmpp/saslmechanism.cc
1440 30c30
1441 < #include "talk/xmpp/constants.h"
1442 ---
1443 > #include "talk/xmpp/xmppconstants.h"
1444 diff -r libjingle-0.4.0/talk/xmpp/xmppclient.cc libjingle/files/talk/xmpp/xmppclient.cc
1445 30c30
1446 < #include "talk/xmpp/constants.h"
1447 ---
1448 > #include "talk/xmpp/xmppconstants.h"
1449 32a33
1450 > #include "talk/xmpp/saslhandler.h"
1451 68a70
1452 > scoped_ptr<SaslHandler> sasl_handler_;
1453 93c95,99
1454 < XmppClient::Connect(const XmppClientSettings & settings, const std::string & lang, AsyncSocket * socket, PreXmppAuth * pre_auth) {
1455 ---
1456 > XmppClient::Connect(const XmppClientSettings & settings,
1457 > const std::string & lang,
1458 > AsyncSocket * socket,
1459 > PreXmppAuth * pre_auth,
1460 > SaslHandler * sasl_handler) {
1461 113,125c119,125
1462 < //
1463 < // The talk.google.com server expects you to use "gmail.com" in the
1464 < // stream, and expects the domain certificate to be "gmail.com" as well.
1465 < // For all other servers, we leave the strings empty, which causes
1466 < // the jid's domain to be used. "foo@example.com" -> stream to="example.com"
1467 < // tls certificate for "example.com"
1468 < //
1469 < // This is only true when using Gaia auth, so let's say if there's no preauth,
1470 < // we should use the actual server name
1471 < if ((settings.server().IPAsString() == buzz::STR_TALK_GOOGLE_COM ||
1472 < settings.server().IPAsString() == buzz::STR_TALKX_L_GOOGLE_COM) &&
1473 < pre_auth != NULL) {
1474 < d_->engine_->SetTlsServer(buzz::STR_GMAIL_COM, buzz::STR_GMAIL_COM);
1475 ---
1476 > if (sasl_handler) {
1477 > std::string tls_server_hostname, tls_server_domain;
1478 > if (sasl_handler->GetTlsServerInfo(settings.server(),
1479 > &tls_server_hostname,
1480 > &tls_server_domain)) {
1481 > d_->engine_->SetTlsServer(tls_server_hostname, tls_server_domain);
1482 > }
1483 139a140
1484 > d_->sasl_handler_.reset(sasl_handler);
1485 200a202,209
1486 > if (d_->sasl_handler_.get()) {
1487 > d_->engine_->SetSaslHandler(d_->sasl_handler_.release());
1488 > }
1489 > else {
1490 > d_->engine_->SetSaslHandler(new PlainSaslHandler(
1491 > d_->engine_->GetUser(), d_->pass_, d_->allow_plain_));
1492 > }
1493 >
1494 209,210d217
1495 < d_->engine_->SetSaslHandler(new PlainSaslHandler(
1496 < d_->engine_->GetUser(), d_->pass_, d_->allow_plain_));
1497 253,254d259
1498 < // transfer ownership of pre_auth_ to engine
1499 < d_->engine_->SetSaslHandler(d_->pre_auth_.release());
1500 261a267,268
1501 > d_->pre_engine_error_ = XmppEngine::ERROR_SOCKET;
1502 > d_->pre_engine_subcode_ = d_->socket_->GetError();
1503 347c354
1504 < //#ifdef _DEBUG
1505 ---
1506 > //#if !defined(NDEBUG)
1507 375c382
1508 < //#ifdef _DEBUG
1509 ---
1510 > //#if !defined(NDEBUG)
1511 diff -r libjingle-0.4.0/talk/xmpp/xmppclient.h libjingle/files/talk/xmpp/xmppclient.h
1512 42a43
1513 > class SaslHandler;
1514 80c81,82
1515 < PreXmppAuth * preauth);
1516 ---
1517 > PreXmppAuth * preauth,
1518 > SaslHandler * sasl_handler);
1519 141c143
1520 < std::string XmppClient::GetStateName(int state) const {
1521 ---
1522 > std::string GetStateName(int state) const {
1523 diff -r libjingle-0.4.0/talk/xmpp/xmppclientsettings.h libjingle/files/talk/xmpp/xmppclientsettings.h
1524 31d30
1525 < #include "talk/p2p/base/port.h"
1526 32a32,45
1527 > #include "talk/base/proxyinfo.h"
1528 >
1529 > namespace cricket {
1530 >
1531 > // This enum was taken from talk/p2p/base/port.h, which is the only
1532 > // thing we actually need from the p2p directory.
1533 > enum ProtocolType {
1534 > PROTO_UDP,
1535 > PROTO_TCP,
1536 > PROTO_SSLTCP,
1537 > PROTO_LAST = PROTO_SSLTCP
1538 > };
1539 >
1540 > } // namespace cricket
1541 59a73,75
1542 > void set_token_service(const std::string & token_service) {
1543 > token_service_ = token_service;
1544 > }
1545 75a92
1546 > const std::string & token_service() const { return token_service_; }
1547 93a111
1548 > std::string token_service_;
1549 Only in libjingle/files/talk/xmpp: xmppconstants.cc
1550 Only in libjingle/files/talk/xmpp: xmppconstants.h
1551 diff -r libjingle-0.4.0/talk/xmpp/xmppengineimpl.cc libjingle/files/talk/xmpp/xmppengineimpl.cc
1552 37c37
1553 < #include "talk/xmpp/constants.h"
1554 ---
1555 > #include "talk/xmpp/xmppconstants.h"
1556 diff -r libjingle-0.4.0/talk/xmpp/xmppengineimpl_iq.cc libjingle/files/talk/xmpp/xmppengineimpl_iq.cc
1557 32c32
1558 < #include "talk/xmpp/constants.h"
1559 ---
1560 > #include "talk/xmpp/xmppconstants.h"
1561 diff -r libjingle-0.4.0/talk/xmpp/xmpplogintask.cc libjingle/files/talk/xmpp/xmpplogintask.cc
1562 34c34
1563 < #include "talk/xmpp/constants.h"
1564 ---
1565 > #include "talk/xmpp/xmppconstants.h"
1566 44c44
1567 < #ifdef _DEBUG
1568 ---
1569 > #if !defined(NDEBUG)
1570 59c59
1571 < #endif // _DEBUG
1572 ---
1573 > #endif // !defined(NDEBUG)
1574 103c103
1575 < #if _DEBUG
1576 ---
1577 > #if !defined(NDEBUG)
1578 106c106
1579 < #endif // _DEBUG
1580 ---
1581 > #endif // !defined(NDEBUG)
1582 218a219,221
1583 > auth->SetAttr(QN_GOOGLE_ALLOW_GENERATED_JID_XMPP_LOGIN, "true");
1584 > auth->SetAttr(QN_GOOGLE_AUTH_CLIENT_USES_FULL_BIND_RESULT, "true");
1585 >
1586 diff -r libjingle-0.4.0/talk/xmpp/xmpplogintask.h libjingle/files/talk/xmpp/xmpplogintask.h
1587 93c93
1588 < #ifdef _DEBUG
1589 ---
1590 > #if !defined(NDEBUG)
1591 95c95
1592 < #endif // _DEBUG
1593 ---
1594 > #endif // !defined(NDEBUG)
1595 diff -r libjingle-0.4.0/talk/xmpp/xmppstanzaparser.cc libjingle/files/talk/xmpp/xmppstanzaparser.cc
1596 32c32
1597 < #include "talk/xmpp/constants.h"
1598 ---
1599 > #include "talk/xmpp/xmppconstants.h"
1600 diff -r libjingle-0.4.0/talk/xmpp/xmpptask.cc libjingle/files/talk/xmpp/xmpptask.cc
1601 31c31
1602 < #include "talk/xmpp/constants.h"
1603 ---
1604 > #include "talk/xmpp/xmppconstants.h"
1605 40c40
1606 < #ifdef _DEBUG
1607 ---
1608 > #if !defined(NDEBUG)
1609 88c88
1610 < #ifdef _DEBUG
1611 ---
1612 > #if !defined(NDEBUG)
1613 174c174
1614 < }
1615 \ No newline at end of file
1616 ---
1617 > }
1618 diff -r libjingle-0.4.0/talk/xmpp/xmpptask.h libjingle/files/talk/xmpp/xmpptask.h
1619 80c80
1620 < #ifdef _DEBUG
1621 ---
1622 > #if !defined(NDEBUG)
1623 106,107c106,107
1624 < XmlElement *MakeIqResult(const XmlElement* query);
1625 < XmlElement *MakeIq(const std::string& type,
1626 ---
1627 > static XmlElement *MakeIqResult(const XmlElement* query);
1628 > static XmlElement *MakeIq(const std::string& type,
1629 123c123
1630 < #ifdef _DEBUG
1631 ---
1632 > #if !defined(NDEBUG)
1633 diff -r libjingle-0.4.0/talk/base/common.cc libjingle/files/talk/base/common.cc
1634 62c62
1635 < } // namespace talk_base
1636 \ No newline at end of file
1637 ---
1638 > } // namespace talk_base
1639 diff -r libjingle-0.4.0/talk/base/httpbase.cc libjingle/files/talk/base/httpbase.cc
1640 154c154
1641 < if (sscanf(value, "%d", &data_size_) != 1) {
1642 ---
1643 > if (sscanf(value, "%zu", &data_size_) != 1) {
1644 diff -r libjingle-0.4.0/talk/base/httpcommon.cc libjingle/files/talk/base/httpcommon.cc
1645 339c339
1646 < &tval.tm_hour, &tval.tm_min, &tval.tm_sec, &zone)) {
1647 ---
1648 > &tval.tm_hour, &tval.tm_min, &tval.tm_sec, zone)) {
1649 472c472
1650 < uint32 vmajor, vminor;
1651 ---
1652 > unsigned long vmajor, vminor;
1653 549,550c549,550
1654 < uint32 vmajor, vminor;
1655 < if ((sscanf(line, "HTTP/%lu.%lu %lu%n", &vmajor, &vminor, &scode, &pos) != 3)
1656 ---
1657 > unsigned long vmajor, vminor;
1658 > if ((sscanf(line, "HTTP/%lu.%lu %lu%zu", &vmajor, &vminor, &scode, &pos) != 3)
1659 693c693
1660 < sprintf(buffer, "%d", time(0));
1661 ---
1662 > sprintf(buffer, "%ld", time(0));
1663 diff -r libjingle-0.4.0/talk/base/httpcommon.h libjingle/files/talk/base/httpcommon.h
1664 329c329
1665 < uint32 scode;
1666 ---
1667 > unsigned long scode;
1668 diff -r libjingle-0.4.0/talk/base/diskcache.cc libjingle/files/talk/base/diskcache.cc
1669 300c300
1670 < if (1 != sscanf(pathname.extension().c_str(), ".%u", index))
1671 ---
1672 > if (1 != sscanf(pathname.extension().c_str(), ".%zu", index))
1673 diff -r libjingle-0.4.0/talk/base/logging.cc libjingle/files/talk/base/logging.cc
1674 69c69
1675 < snprintf(buffer, sizeof(buffer), "0x%08lx", err);
1676 ---
1677 > snprintf(buffer, sizeof(buffer), "0x%08x", err);
1678 diff -r libjingle-0.4.0/talk/base/socketadapters.cc libjingle/files/talk/base/socketadapters.cc
1679 360,361c360,361
1680 < uint32 code;
1681 < if (sscanf(data, "HTTP/%*lu.%*lu %lu", &code) != 1) {
1682 ---
1683 > unsigned long code;
1684 > if (sscanf(data, "HTTP/%*u.%*u %lu", &code) != 1) {