← Back to branch summary

~registry/scalestack/trunk

« back to all changes in this revision

Viewing changes to scalestack/network/datagram.cc

  • Committer: Eric Day
  • Date: 2010-12-04 17:17:34 UTC
  • mfrom: (56.1.9)
  • Revision ID: git-v1:9c392b034d652023a4b28ae2976aca128bb856c2
Merged Eric's branch with style updates, config file support, and other cleanup.

Show diffs side-by-side

added added

removed removed

Lines of Context:
scalestack/network/datagram.cc
69
69
{
70
70
  int file_descriptor = socket(family, SOCK_DGRAM, 0);
71
71
  if (file_descriptor == -1)
72
 
    _module.log_fatal(_("Error creating datagram socket: %s"), strerror(errno));
 
72
  {
 
73
    _module.log_fatal(_("Error creating datagram socket: %s:%d"),
 
74
                      strerror(errno), errno);
 
75
  }
73
76
 
74
77
  set_file_descriptor(file_descriptor);
75
78
}
76
79
 
77
 
void datagram_provider::bind(const struct sockaddr& address,
78
 
                             socklen_t address_size)
 
80
void datagram_provider::create(const struct sockaddr& local,
 
81
                               socklen_t local_size)
79
82
{
80
 
  create(address.sa_family);
 
83
  create(local.sa_family);
81
84
 
82
 
  int return_code = ::bind(_file_descriptor, &address, address_size);
 
85
  int return_code = ::bind(_file_descriptor, &local, local_size);
83
86
  if (return_code == -1)
84
87
  {
85
88
    if (errno == EADDRINUSE)
86
 
      _module.log_fatal(_("Bind failed, address already in use"));
 
89
      _module.log_fatal(_("Bind failed, local address already in use"));
87
90
 
88
 
    _module.log_fatal(_("Error binding datagram socket, bind: %s"), strerror(errno));
 
91
    _module.log_fatal(_("Error binding datagram socket, bind: %s:%d"),
 
92
                      strerror(errno), errno);
89
93
  }
90
94
}
91
95
 
92
 
void datagram_provider::set_peer(const struct sockaddr& peer, socklen_t peer_size)
 
96
void datagram_provider::set_peer(const struct sockaddr& peer,
 
97
                                 socklen_t peer_size)
93
98
{
94
99
  memcpy(_peer, &peer, peer_size);
95
100
  _peer_size = peer_size;
140
145
    return 0;
141
146
  }
142
147
 
143
 
  _module.log_error(_("Datagram send failed: %s"), strerror(errno));
 
148
  _module.log_error(_("Datagram send failed: %s:%d"), strerror(errno), errno);
144
149
  error();
145
150
  return 0;
146
151
}
160
165
 
161
166
void datagram_provider::read_ready(int)
162
167
{
163
 
  if (_receive_buffer_size > 0)
164
 
  {
165
 
    /* Can only buffer a single packet, and we already have one */
166
 
    return;
167
 
  }
168
 
 
169
 
  _peer_size = sizeof(_peer_storage);
170
 
 
171
 
  ssize_t received = ::recvfrom(_file_descriptor,
172
 
                                _receive_buffer,
173
 
                                _receive_buffer_max_size,
174
 
                                0,
175
 
                                _peer,
176
 
                                &_peer_size);
177
 
 
178
 
  if (received > 0)
179
 
  {
 
168
  while (_receive_buffer_size == 0)
 
169
  {
 
170
    _peer_size = sizeof(_peer_storage);
 
171
 
 
172
    ssize_t received = ::recvfrom(_file_descriptor,
 
173
                                  _receive_buffer,
 
174
                                  _receive_buffer_max_size,
 
175
                                  0,
 
176
                                  _peer,
 
177
                                  &_peer_size);
 
178
 
 
179
    if (received == 0)
 
180
      return;
 
181
    else if (received == -1)
 
182
    {
 
183
      if (errno == EAGAIN)
 
184
      {
 
185
        watch_read();
 
186
        return;
 
187
      }
 
188
      else if (errno == EINTR)
 
189
        continue;
 
190
 
 
191
      _module.log_error(_("Datagram receive failed: %s:%d"),
 
192
                        strerror(errno), errno);
 
193
      error();
 
194
      return;
 
195
    }
 
196
 
180
197
    _module.log_debug(_("Received %d bytes"), received);
181
198
 
182
 
    _receive_buffer_size = static_cast<size_t>(received);
 
199
    _receive_buffer_size = received;
183
200
 
184
201
    _consume(receive(_receive_buffer, _receive_buffer_size, *_peer, _peer_size));
185
 
 
186
 
    if (_receive_buffer_size == 0)
187
 
    {
188
 
      return;
189
 
    }
190
 
 
191
 
    if (_receive_buffer_size != static_cast<size_t>(received))
192
 
    {
193
 
      /* caller must consume all or none of the receive buffer */
194
 
 
195
 
      _module.log_fatal(_("Caller consumed partial datagram receive buffer"));
196
 
      return;
197
 
    }
198
 
 
199
 
    return;
200
 
  }
201
 
 
202
 
  if (received < 0)
203
 
  {
204
 
    if (errno == EAGAIN)
205
 
    {
206
 
      watch_read();
207
 
      return;
208
 
    }
209
 
 
210
 
    _module.log_error(_("Datagram receive failed: %s"), strerror(errno));
211
 
    error();
212
 
    return;
213
 
  }
214
 
 
215
 
  _module.log_debug(_("Received %d bytes"), received);
216
 
  watch_read();
217
 
 
218
 
  return;
 
202
  }
219
203
}
220
204
 
221
205
void datagram_provider::write_ready(int)