00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "socketStream.h"
00016 #include "datagram.h"
00017 #include "datagramIterator.h"
00018 #include "httpChannel.h"
00019 #include "config_downloader.h"
00020
00021 #ifdef HAVE_OPENSSL
00022
00023
00024
00025
00026
00027
00028 SSReader::
00029 SSReader(istream *stream) : _istream(stream) {
00030 _data_expected = 0;
00031 _tcp_header_size = tcp_header_size;
00032
00033 #ifdef SIMULATE_NETWORK_DELAY
00034 _delay_active = false;
00035 _min_delay = 0.0;
00036 _delay_variance = 0.0;
00037 #endif // SIMULATE_NETWORK_DELAY
00038 }
00039
00040
00041
00042
00043
00044
00045 SSReader::
00046 ~SSReader() {
00047 }
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058 bool SSReader::
00059 do_receive_datagram(Datagram &dg) {
00060 if (_tcp_header_size == 0) {
00061 _data_expected = _data_so_far.length();
00062 }
00063 if (_data_expected == 0) {
00064
00065 while ((int)_data_so_far.length() < _tcp_header_size) {
00066 int ch = _istream->get();
00067 if (_istream->eof() || _istream->fail()) {
00068 _istream->clear();
00069 return false;
00070 }
00071 _data_so_far += (char)ch;
00072 }
00073
00074 Datagram header(_data_so_far);
00075 DatagramIterator di(header);
00076 if (_tcp_header_size == 2) {
00077 _data_expected = di.get_uint16();
00078 } else if (_tcp_header_size == 4) {
00079 _data_expected = di.get_uint32();
00080 }
00081 _data_so_far = _data_so_far.substr(_tcp_header_size);
00082
00083 if (_data_expected == 0) {
00084
00085 dg.clear();
00086 return true;
00087 }
00088 }
00089
00090
00091
00092 static const size_t buffer_size = 1024;
00093 char buffer[buffer_size];
00094
00095 size_t read_count = min(_data_expected - _data_so_far.length(),
00096 buffer_size);
00097 _istream->read(buffer, read_count);
00098 size_t count = _istream->gcount();
00099 while (count != 0) {
00100 _data_so_far.append(buffer, count);
00101
00102 read_count = min(_data_expected - _data_so_far.length(),
00103 buffer_size);
00104 _istream->read(buffer, read_count);
00105 count = _istream->gcount();
00106 }
00107
00108 if (_data_so_far.length() < _data_expected) {
00109
00110
00111 _istream->clear();
00112 return false;
00113 }
00114
00115 dg.clear();
00116 dg.append_data(_data_so_far);
00117
00118 _data_expected = 0;
00119 _data_so_far = string();
00120
00121 return true;
00122 }
00123
00124 #ifdef SIMULATE_NETWORK_DELAY
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139 void SSReader::
00140 start_delay(double min_delay, double max_delay) {
00141 _min_delay = min_delay;
00142 _delay_variance = max(max_delay - min_delay, 0.0);
00143 _delay_active = true;
00144 }
00145 #endif // SIMULATE_NETWORK_DELAY
00146
00147 #ifdef SIMULATE_NETWORK_DELAY
00148
00149
00150
00151
00152
00153
00154
00155 void SSReader::
00156 stop_delay() {
00157 _delay_active = false;
00158 }
00159 #endif // SIMULATE_NETWORK_DELAY
00160
00161 #ifdef SIMULATE_NETWORK_DELAY
00162
00163
00164
00165
00166
00167
00168 void SSReader::
00169 delay_datagram(const Datagram &datagram) {
00170 nassertv(_delay_active);
00171
00172 double now = TrueClock::get_global_ptr()->get_short_time();
00173 double reveal_time = now + _min_delay;
00174
00175 if (_delay_variance > 0.0) {
00176 reveal_time += _delay_variance * ((double)rand() / (double)RAND_MAX);
00177 }
00178 _delayed.push_back(DelayedDatagram());
00179 DelayedDatagram &dd = _delayed.back();
00180 dd._reveal_time = reveal_time;
00181 dd._datagram = datagram;
00182 }
00183 #endif // SIMULATE_NETWORK_DELAY
00184
00185 #ifdef SIMULATE_NETWORK_DELAY
00186
00187
00188
00189
00190
00191
00192
00193 bool SSReader::
00194 get_delayed(Datagram &datagram) {
00195 if (_delayed.empty()) {
00196 return false;
00197 }
00198 const DelayedDatagram &dd = _delayed.front();
00199 if (_delay_active) {
00200 double now = TrueClock::get_global_ptr()->get_short_time();
00201 if (dd._reveal_time > now) {
00202
00203 return false;
00204 }
00205 }
00206
00207 datagram = dd._datagram;
00208 _delayed.pop_front();
00209
00210 return true;
00211 }
00212 #endif // SIMULATE_NETWORK_DELAY
00213
00214
00215
00216
00217
00218
00219 SSWriter::
00220 SSWriter(ostream *stream) : _ostream(stream) {
00221 _collect_tcp = collect_tcp;
00222 _collect_tcp_interval = collect_tcp_interval;
00223 _queued_data_start = 0.0;
00224 _tcp_header_size = tcp_header_size;
00225 }
00226
00227
00228
00229
00230
00231
00232 SSWriter::
00233 ~SSWriter() {
00234 }
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245 bool SSWriter::
00246 send_datagram(const Datagram &dg) {
00247 Datagram header;
00248 if (_tcp_header_size == 2) {
00249 if (dg.get_length() >= 0x10000) {
00250 downloader_cat.error()
00251 << "Attempt to send TCP datagram of " << dg.get_length()
00252 << " bytes--too long!\n";
00253 nassert_raise("Datagram too long");
00254 return false;
00255 }
00256
00257 header.add_uint16(dg.get_length());
00258 } else if (_tcp_header_size == 4) {
00259 header.add_uint32(dg.get_length());
00260 }
00261
00262
00263
00264 _ostream->write((const char *)header.get_data(), header.get_length());
00265 _ostream->write((const char *)dg.get_data(), dg.get_length());
00266
00267
00268
00269 flush();
00270
00271 return !is_closed();
00272 }
00273
00274
00275
00276
00277
00278
00279 ISocketStream::
00280 ~ISocketStream() {
00281
00282 nassertv(_channel == NULL);
00283 }
00284
00285 #endif // HAVE_OPENSSL