1 //
2 // Copyright (c) ZeroC, Inc. All rights reserved.
3 //
4
5 #include <Ice/Exception.h>
6 #include <Ice/LocalException.h>
7 #include <Ice/Network.h>
8 #include <Ice/Plugin.h>
9 #include <Ice/SlicedData.h>
10 #include <Ice/OutputStream.h>
11 #include <Ice/InputStream.h>
12 #include <Ice/Initialize.h>
13 #include <IceUtil/StringUtil.h>
14 #ifdef ICE_OS_UWP
15 # include <Ice/StringConverter.h>
16 #endif
17 #include <iomanip>
18
19 using namespace std;
20 using namespace Ice;
21 using namespace IceInternal;
22
23 namespace
24 {
25
26 inline string
socketErrorToString(int error)27 socketErrorToString(int error)
28 {
29 if(error == 0)
30 {
31 return "unknown error";
32 }
33 #ifdef ICE_OS_UWP
34 if(error == E_ACCESSDENIED)
35 {
36 ostringstream os;
37 os << "access to a resource or feature is denied, ensure that you have requested the appropriate\n";
38 os << "capability and made the required declarations in the package manifest of your app.";
39 return os.str();
40 }
41 else
42 {
43 //
44 // Don't need to use a wide string converter as the wide string come
45 // from Windows API.
46 //
47 return wstringToString(
48 static_cast<Windows::Networking::Sockets::SocketErrorStatus>(error).ToString()->Data(),
49 getProcessStringConverter());
50 }
51 #else
52 return IceUtilInternal::errorToString(error);
53 #endif
54 }
55
56 };
57
58 namespace IceInternal
59 {
60
61 namespace Ex
62 {
63
64 void
throwUOE(const string & expectedType,const ValuePtr & v)65 throwUOE(const string& expectedType, const ValuePtr& v)
66 {
67 //
68 // If the object is an unknown sliced object, we didn't find an
69 // value factory, in this case raise a NoValueFactoryException
70 // instead.
71 //
72 UnknownSlicedValue* usv = dynamic_cast<UnknownSlicedValue*>(v.get());
73 if(usv)
74 {
75 throw NoValueFactoryException(__FILE__, __LINE__, "", usv->ice_id());
76 }
77
78 string type = v->ice_id();
79 throw Ice::UnexpectedObjectException(__FILE__, __LINE__,
80 "expected element of type `" + expectedType + "' but received `" +
81 type + "'", type, expectedType);
82 }
83
84 void
throwMemoryLimitException(const char * file,int line,size_t requested,size_t maximum)85 throwMemoryLimitException(const char* file, int line, size_t requested, size_t maximum)
86 {
87 ostringstream s;
88 s << "requested " << requested << " bytes, maximum allowed is " << maximum << " bytes (see Ice.MessageSizeMax)";
89 throw Ice::MemoryLimitException(file, line, s.str());
90 }
91
92 void
throwMarshalException(const char * file,int line,const string & reason)93 throwMarshalException(const char* file, int line, const string& reason)
94 {
95 throw Ice::MarshalException(file, line, reason);
96 }
97
98 }
99 }
100
101 namespace
102 {
103
104 const string userException_ids[] =
105 {
106 "::Ice::UserException"
107 };
108
109 }
110
111 const std::string&
ice_staticId()112 Ice::UserException::ice_staticId()
113 {
114 return userException_ids[0];
115 }
116
117 #ifdef ICE_CPP11_MAPPING
118 unique_ptr<Ice::UserException>
ice_clone() const119 Ice::UserException::ice_clone() const
120 {
121 return unique_ptr<UserException>(static_cast<UserException*>(ice_cloneImpl()));
122 }
123 #endif
124
125 Ice::SlicedDataPtr
ice_getSlicedData() const126 Ice::UserException::ice_getSlicedData() const
127 {
128 return ICE_NULLPTR;
129 }
130
131 void
_write(::Ice::OutputStream * os) const132 Ice::UserException::_write(::Ice::OutputStream* os) const
133 {
134 os->startException(0);
135 _writeImpl(os);
136 os->endException();
137 }
138
139 void
_read(::Ice::InputStream * is)140 Ice::UserException::_read(::Ice::InputStream* is)
141 {
142 is->startException();
143 _readImpl(is);
144 is->endException(false);
145 }
146
147 bool
_usesClasses() const148 Ice::UserException::_usesClasses() const
149 {
150 return false;
151 }
152
LocalException(const char * file,int line)153 Ice::LocalException::LocalException(const char* file, int line) :
154 Exception(file, line)
155 {
156 }
157
~LocalException()158 Ice::LocalException::~LocalException()
159 #ifndef ICE_CPP11_COMPILER
160 throw()
161 #endif
162 {
163 // Out of line to avoid weak vtable
164 }
165
166 #ifdef ICE_CPP11_MAPPING
167 unique_ptr<Ice::LocalException>
ice_clone() const168 Ice::LocalException::ice_clone() const
169 {
170 return unique_ptr<LocalException>(static_cast<LocalException*>(ice_cloneImpl()));
171 }
172 #endif
173
174 namespace
175 {
176
177 const string localException_ids[] =
178 {
179 "::Ice::LocalException"
180 };
181
182 }
183
184 const std::string&
ice_staticId()185 Ice::LocalException::ice_staticId()
186 {
187 return localException_ids[0];
188 }
189
SystemException(const char * file,int line)190 Ice::SystemException::SystemException(const char* file, int line) :
191 Exception(file, line)
192 {
193 }
194
~SystemException()195 Ice::SystemException::~SystemException()
196 #ifndef ICE_CPP11_COMPILER
197 throw()
198 #endif
199 {
200 }
201
202 #ifdef ICE_CPP11_MAPPING
203 unique_ptr<Ice::SystemException>
ice_clone() const204 Ice::SystemException::ice_clone() const
205 {
206 return unique_ptr<SystemException>(static_cast<SystemException*>(ice_cloneImpl()));
207 }
208 #endif
209
210 namespace
211 {
212
213 const string systemException_ids[] =
214 {
215 "::Ice::SystemException"
216 };
217
218 }
219
220 const std::string&
ice_staticId()221 Ice::SystemException::ice_staticId()
222 {
223 return systemException_ids[0];
224 }
225
226 void
ice_print(ostream & out) const227 Ice::InitializationException::ice_print(ostream& out) const
228 {
229 Exception::ice_print(out);
230 out << ":\ninitialization exception";
231 if(!reason.empty())
232 {
233 out << ":\n" << reason;
234 }
235 }
236
237 void
ice_print(ostream & out) const238 Ice::UnknownException::ice_print(ostream& out) const
239 {
240 Exception::ice_print(out);
241 out << ":\nunknown exception";
242 if(!unknown.empty())
243 {
244 out << ":\n" << unknown;
245 }
246 }
247
248 void
ice_print(ostream & out) const249 Ice::UnknownLocalException::ice_print(ostream& out) const
250 {
251 Exception::ice_print(out);
252 out << ":\nunknown local exception";
253 if(!unknown.empty())
254 {
255 out << ":\n" << unknown;
256 }
257 }
258
259 void
ice_print(ostream & out) const260 Ice::UnknownUserException::ice_print(ostream& out) const
261 {
262 Exception::ice_print(out);
263 out << ":\nunknown user exception";
264 if(!unknown.empty())
265 {
266 out << ":\n" << unknown;
267 }
268 }
269
270 void
ice_print(ostream & out) const271 Ice::VersionMismatchException::ice_print(ostream& out) const
272 {
273 Exception::ice_print(out);
274 out << ":\nIce library version mismatch";
275 }
276
277 void
ice_print(ostream & out) const278 Ice::CommunicatorDestroyedException::ice_print(ostream& out) const
279 {
280 Exception::ice_print(out);
281 out << ":\ncommunicator object destroyed";
282 }
283
284 void
ice_print(ostream & out) const285 Ice::ObjectAdapterDeactivatedException::ice_print(ostream& out) const
286 {
287 Exception::ice_print(out);
288 out << ":\nobject adapter `" << name << "' deactivated";
289 }
290
291 void
ice_print(ostream & out) const292 Ice::ObjectAdapterIdInUseException::ice_print(ostream& out) const
293 {
294 Exception::ice_print(out);
295 out << ":\nobject adapter with id `" << id << "' is already in use";
296 }
297
298 void
ice_print(ostream & out) const299 Ice::NoEndpointException::ice_print(ostream& out) const
300 {
301 Exception::ice_print(out);
302 out << ":\nno suitable endpoint available for proxy `" << proxy << "'";
303 }
304
305 void
ice_print(ostream & out) const306 Ice::EndpointParseException::ice_print(ostream& out) const
307 {
308 Exception::ice_print(out);
309 out << ":\nerror while parsing endpoint `" << str << "'";
310 }
311
312 void
ice_print(ostream & out) const313 Ice::EndpointSelectionTypeParseException::ice_print(ostream& out) const
314 {
315 Exception::ice_print(out);
316 out << ":\nerror while parsing endpoint selection type `" << str << "'";
317 }
318
319 void
ice_print(ostream & out) const320 Ice::VersionParseException::ice_print(ostream& out) const
321 {
322 Exception::ice_print(out);
323 out << ":\nerror while parsing version `" << str << "'";
324 }
325
326 void
ice_print(ostream & out) const327 Ice::IdentityParseException::ice_print(ostream& out) const
328 {
329 Exception::ice_print(out);
330 out << ":\nerror while parsing identity `" << str << "'";
331 }
332
333 void
ice_print(ostream & out) const334 Ice::ProxyParseException::ice_print(ostream& out) const
335 {
336 Exception::ice_print(out);
337 out << ":\nerror while parsing proxy `" << str << "'";
338 }
339
340 void
ice_print(ostream & out) const341 Ice::IllegalIdentityException::ice_print(ostream& out) const
342 {
343 Exception::ice_print(out);
344 out << ":\nillegal identity: `" << identityToString(id, ICE_ENUM(ToStringMode, Unicode)) << "'";
345 }
346
347 void
ice_print(ostream & out) const348 Ice::IllegalServantException::ice_print(ostream& out) const
349 {
350 Exception::ice_print(out);
351 out << ":\nillegal servant: `" << reason << "'";
352 }
353
354 static void
printFailedRequestData(ostream & out,const RequestFailedException & ex)355 printFailedRequestData(ostream& out, const RequestFailedException& ex)
356 {
357 out << ":\nidentity: `" << identityToString(ex.id, ICE_ENUM(ToStringMode, Unicode)) << "'";
358 out << "\nfacet: " << ex.facet;
359 out << "\noperation: " << ex.operation;
360 }
361
362 void
ice_print(ostream & out) const363 Ice::RequestFailedException::ice_print(ostream& out) const
364 {
365 Exception::ice_print(out);
366 out << ":\nrequest failed";
367 printFailedRequestData(out, *this);
368 }
369
370 void
ice_print(ostream & out) const371 Ice::ObjectNotExistException::ice_print(ostream& out) const
372 {
373 Exception::ice_print(out);
374 out << ":\nobject does not exist";
375 printFailedRequestData(out, *this);
376 }
377
378 void
ice_print(ostream & out) const379 Ice::FacetNotExistException::ice_print(ostream& out) const
380 {
381 Exception::ice_print(out);
382 out << ":\nfacet does not exist";
383 printFailedRequestData(out, *this);
384 }
385
386 void
ice_print(ostream & out) const387 Ice::OperationNotExistException::ice_print(ostream& out) const
388 {
389 Exception::ice_print(out);
390 out << ":\noperation does not exist";
391 printFailedRequestData(out, *this);
392 }
393
394 void
ice_print(ostream & out) const395 Ice::SyscallException::ice_print(ostream& out) const
396 {
397 Exception::ice_print(out);
398 if(error != 0)
399 {
400 out << ":\nsyscall exception: " << IceUtilInternal::errorToString(error);
401 }
402 }
403
404 void
ice_print(ostream & out) const405 Ice::SocketException::ice_print(ostream& out) const
406 {
407 Exception::ice_print(out);
408 out << ":\nsocket exception: " << socketErrorToString(error);
409 }
410
411 void
ice_print(ostream & out) const412 Ice::FileException::ice_print(ostream& out) const
413 {
414 Exception::ice_print(out);
415 out << ":\nfile exception: ";
416 if(error == 0)
417 {
418 out << "couldn't open file";
419 }
420 else
421 {
422 out << IceUtilInternal::errorToString(error);
423 }
424 if(!path.empty())
425 {
426 out << "\npath: " << path;
427 }
428 }
429
430 void
ice_print(ostream & out) const431 Ice::ConnectFailedException::ice_print(ostream& out) const
432 {
433 Exception::ice_print(out);
434 out << ":\nconnect failed: " << socketErrorToString(error);
435 }
436
437 void
ice_print(ostream & out) const438 Ice::ConnectionRefusedException::ice_print(ostream& out) const
439 {
440 Exception::ice_print(out);
441 out << ":\nconnection refused: " << socketErrorToString(error);
442 }
443
444 void
ice_print(ostream & out) const445 Ice::ConnectionLostException::ice_print(ostream& out) const
446 {
447 Exception::ice_print(out);
448 out << ":\nconnection lost: ";
449 if(error == 0)
450 {
451 out << "recv() returned zero";
452 }
453 else
454 {
455 out << socketErrorToString(error);
456 }
457 }
458
459 void
ice_print(ostream & out) const460 Ice::DNSException::ice_print(ostream& out) const
461 {
462 Exception::ice_print(out);
463 out << ":\nDNS error: ";
464 #ifdef ICE_OS_UWP
465 out << socketErrorToString(error);
466 #else
467 out << errorToStringDNS(error);
468 #endif
469 out << "\nhost: " << host;
470 }
471
472 void
ice_print(ostream & out) const473 Ice::OperationInterruptedException::ice_print(ostream& out) const
474 {
475 Exception::ice_print(out);
476 out << ":\noperation interrupted";
477 }
478
479 void
ice_print(ostream & out) const480 Ice::TimeoutException::ice_print(ostream& out) const
481 {
482 Exception::ice_print(out);
483 out << ":\ntimeout while sending or receiving data";
484 }
485
486 void
ice_print(ostream & out) const487 Ice::ConnectTimeoutException::ice_print(ostream& out) const
488 {
489 Exception::ice_print(out);
490 out << ":\ntimeout while establishing a connection";
491 }
492
493 void
ice_print(ostream & out) const494 Ice::CloseTimeoutException::ice_print(ostream& out) const
495 {
496 Exception::ice_print(out);
497 out << ":\ntimeout while closing a connection";
498 }
499
500 void
ice_print(ostream & out) const501 Ice::ConnectionTimeoutException::ice_print(ostream& out) const
502 {
503 Exception::ice_print(out);
504 out << ":\nconnection has timed out";
505 }
506
507 void
ice_print(ostream & out) const508 Ice::InvocationTimeoutException::ice_print(ostream& out) const
509 {
510 Exception::ice_print(out);
511 out << ":\ninvocation has timed out";
512 }
513
514 void
ice_print(ostream & out) const515 Ice::InvocationCanceledException::ice_print(ostream& out) const
516 {
517 Exception::ice_print(out);
518 out << ":\ninvocation canceled";
519 }
520
521 void
ice_print(ostream & out) const522 Ice::ProtocolException::ice_print(ostream& out) const
523 {
524 Exception::ice_print(out);
525 out << ":\nprotocol exception";
526 if(!reason.empty())
527 {
528 out << ":\n" << reason;
529 }
530 }
531
532 void
ice_print(ostream & out) const533 Ice::BadMagicException::ice_print(ostream& out) const
534 {
535 Exception::ice_print(out);
536 out << ":\nunknown magic number: ";
537
538 ios_base::fmtflags originalFlags = out.flags(); // Save stream state
539 ostream::char_type originalFill = out.fill();
540
541 out.flags(ios_base::hex); // Change to hex
542 out.fill('0'); // Fill with leading zeros
543
544 out << "0x" << setw(2) << static_cast<unsigned int>(static_cast<unsigned char>(badMagic[0])) << ", ";
545 out << "0x" << setw(2) << static_cast<unsigned int>(static_cast<unsigned char>(badMagic[1])) << ", ";
546 out << "0x" << setw(2) << static_cast<unsigned int>(static_cast<unsigned char>(badMagic[2])) << ", ";
547 out << "0x" << setw(2) << static_cast<unsigned int>(static_cast<unsigned char>(badMagic[3]));
548
549 out.fill(originalFill); // Restore stream state
550 out.flags(originalFlags);
551
552 if(!reason.empty())
553 {
554 out << "\n" << reason;
555 }
556 }
557
558 void
ice_print(ostream & out) const559 Ice::UnsupportedProtocolException::ice_print(ostream& out) const
560 {
561 Exception::ice_print(out);
562 out << ":\nprotocol error: unsupported protocol version: " << bad;
563 out << "\n(can only support protocols compatible with version " << supported << ")";
564 }
565
566 void
ice_print(ostream & out) const567 Ice::UnsupportedEncodingException::ice_print(ostream& out) const
568 {
569 Exception::ice_print(out);
570 out << ":\nencoding error: unsupported encoding version: " << bad;
571 out << "\n(can only support encodings compatible with version " << supported << ")";
572 if(!reason.empty())
573 {
574 out << "\n" << reason;
575 }
576 }
577
578 void
ice_print(ostream & out) const579 Ice::UnknownMessageException::ice_print(ostream& out) const
580 {
581 Exception::ice_print(out);
582 out << ":\nprotocol error: unknown message type";
583 if(!reason.empty())
584 {
585 out << ":\n" << reason;
586 }
587 }
588
589 void
ice_print(ostream & out) const590 Ice::ConnectionNotValidatedException::ice_print(ostream& out) const
591 {
592 Exception::ice_print(out);
593 out << ":\nprotocol error: received message over unvalidated connection";
594 if(!reason.empty())
595 {
596 out << ":\n" << reason;
597 }
598 }
599
600 void
ice_print(ostream & out) const601 Ice::UnknownRequestIdException::ice_print(ostream& out) const
602 {
603 Exception::ice_print(out);
604 out << ":\nprotocol error: unknown request id";
605 if(!reason.empty())
606 {
607 out << ":\n" << reason;
608 }
609 }
610
611 void
ice_print(ostream & out) const612 Ice::UnknownReplyStatusException::ice_print(ostream& out) const
613 {
614 Exception::ice_print(out);
615 out << ":\nprotocol error: unknown reply status";
616 if(!reason.empty())
617 {
618 out << ":\n" << reason;
619 }
620 }
621
622 void
ice_print(ostream & out) const623 Ice::CloseConnectionException::ice_print(ostream& out) const
624 {
625 Exception::ice_print(out);
626 out << ":\nprotocol error: connection closed";
627 if(!reason.empty())
628 {
629 out << ":\n" << reason;
630 }
631 }
632
633 void
ice_print(ostream & out) const634 Ice::ConnectionManuallyClosedException::ice_print(ostream& out) const
635 {
636 Exception::ice_print(out);
637 out << ":\nprotocol error: connection manually closed (" << (graceful ? "gracefully" : "forcefully") << ")";
638 }
639
640 void
ice_print(ostream & out) const641 Ice::IllegalMessageSizeException::ice_print(ostream& out) const
642 {
643 Exception::ice_print(out);
644 out << ":\nprotocol error: illegal message size";
645 if(!reason.empty())
646 {
647 out << ":\n" << reason;
648 }
649 }
650
651 void
ice_print(ostream & out) const652 Ice::CompressionException::ice_print(ostream& out) const
653 {
654 Exception::ice_print(out);
655 out << ":\nprotocol error: failed to compress or uncompress data";
656 if(!reason.empty())
657 {
658 out << ":\n" << reason;
659 }
660 }
661
662 void
ice_print(ostream & out) const663 Ice::DatagramLimitException::ice_print(ostream& out) const
664 {
665 Exception::ice_print(out);
666 out << ":\nprotocol error: maximum datagram payload size exceeded";
667 if(!reason.empty())
668 {
669 out << ":\n" << reason;
670 }
671 }
672
673 void
ice_print(ostream & out) const674 Ice::MarshalException::ice_print(ostream& out) const
675 {
676 Exception::ice_print(out);
677 out << ":\nprotocol error: error during marshaling or unmarshaling";
678 if(!reason.empty())
679 {
680 out << ":\n" << reason;
681 }
682 }
683
684 void
ice_print(ostream & out) const685 Ice::ProxyUnmarshalException::ice_print(ostream& out) const
686 {
687 Exception::ice_print(out);
688 out << ":\nprotocol error: inconsistent proxy data during unmarshaling";
689 if(!reason.empty())
690 {
691 out << ":\n" << reason;
692 }
693 }
694
695 void
ice_print(ostream & out) const696 Ice::UnmarshalOutOfBoundsException::ice_print(ostream& out) const
697 {
698 Exception::ice_print(out);
699 out << ":\nprotocol error: out of bounds during unmarshaling";
700 if(!reason.empty())
701 {
702 out << ":\n" << reason;
703 }
704 }
705
706 void
ice_print(ostream & out) const707 Ice::NoValueFactoryException::ice_print(ostream& out) const
708 {
709 Exception::ice_print(out);
710 out << ":\nprotocol error: no suitable object factory found for `" << type << "'";
711 if(!reason.empty())
712 {
713 out << ":\n" << reason;
714 }
715 }
716
717 void
ice_print(ostream & out) const718 Ice::UnexpectedObjectException::ice_print(ostream& out) const
719 {
720 Exception::ice_print(out);
721 out << ":\nunexpected class instance of type `" << type <<
722 "'; expected instance of type `" << expectedType << "'";
723 if(!reason.empty())
724 {
725 out << ":\n" << reason;
726 }
727 }
728
729 void
ice_print(ostream & out) const730 Ice::MemoryLimitException::ice_print(ostream& out) const
731 {
732 Exception::ice_print(out);
733 out << ":\nprotocol error: memory limit exceeded";
734 if(!reason.empty())
735 {
736 out << ":\n" << reason;
737 }
738 }
739
740 void
ice_print(ostream & out) const741 Ice::StringConversionException::ice_print(ostream& out) const
742 {
743 Exception::ice_print(out);
744 out << ":\nprotocol error: string conversion failed";
745 if(!reason.empty())
746 {
747 out << ":\n" << reason;
748 }
749 }
750
751 void
ice_print(ostream & out) const752 Ice::EncapsulationException::ice_print(ostream& out) const
753 {
754 Exception::ice_print(out);
755 out << ":\nprotocol error: illegal encapsulation";
756 if(!reason.empty())
757 {
758 out << ":\n" << reason;
759 }
760 }
761
762 void
ice_print(ostream & out) const763 Ice::PluginInitializationException::ice_print(ostream& out) const
764 {
765 Exception::ice_print(out);
766 out << ":\nplug-in initialization failed";
767 if(!reason.empty())
768 {
769 out << ": " << reason;
770 }
771 }
772
773 void
ice_print(ostream & out) const774 Ice::CollocationOptimizationException::ice_print(ostream& out) const
775 {
776 Exception::ice_print(out);
777 out << ":\nrequested feature not available with collocation optimization";
778 }
779
780 void
ice_print(ostream & out) const781 Ice::AlreadyRegisteredException::ice_print(ostream& out) const
782 {
783 Exception::ice_print(out);
784 out << ":\n" << kindOfObject << " with id `" << id << "' is already registered";
785 }
786
787 void
ice_print(ostream & out) const788 Ice::NotRegisteredException::ice_print(ostream& out) const
789 {
790 Exception::ice_print(out);
791 out << ":\n no " << kindOfObject << " with id `" << id << "' is registered";
792 }
793
794 void
ice_print(ostream & out) const795 Ice::TwowayOnlyException::ice_print(ostream& out) const
796 {
797 Exception::ice_print(out);
798 out << ":\n operation `" << operation << "' can only be invoked as a twoway request";
799 }
800
801 void
ice_print(ostream & out) const802 Ice::CloneNotImplementedException::ice_print(ostream& out) const
803 {
804 Exception::ice_print(out);
805 out << ":\n ice_clone() must be implemented in classes derived from abstract base classes";
806 }
807
808 void
ice_print(ostream & out) const809 Ice::FeatureNotSupportedException::ice_print(ostream& out) const
810 {
811 Exception::ice_print(out);
812 out << ":\nfeature `" << unsupportedFeature << "' is not supported.";
813 }
814
815 void
ice_print(ostream & out) const816 Ice::SecurityException::ice_print(ostream& out) const
817 {
818 Exception::ice_print(out);
819 out << ":\nsecurity exception";
820 if(!reason.empty())
821 {
822 out << ":\n" << reason;
823 }
824 }
825
826 void
ice_print(ostream & out) const827 Ice::FixedProxyException::ice_print(ostream& out) const
828 {
829 Exception::ice_print(out);
830 out << ":\nfixed proxy exception";
831 }
832
833 void
ice_print(ostream & out) const834 Ice::ResponseSentException::ice_print(ostream& out) const
835 {
836 Exception::ice_print(out);
837 out << ":\nresponse sent exception";
838 }
839
840 void
ice_print(ostream & out) const841 Ice::CFNetworkException::ice_print(ostream& out) const
842 {
843 Exception::ice_print(out);
844 out << ":\nnetwork exception: domain: " << domain << " error: " << error;
845 }
846