generic-library/libzmq
1
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2024-12-13 02:42:58 +01:00
Code Issues Projects Releases Wiki Activity

Merge pull request #2110 from c-rack/remove-tabs

Browse Source 
Problem: source conatins tabs and trailing spaces
This commit is contained in:
Luca Boccassi 2016-09-17 08:44:35 +01:00 committed by GitHub
commit f0945c85ef
14 changed files with 122 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/ctx.cpp
View File

@ -91,7 +91,7 @@ zmq::ctx_t::ctx_t () :
vmci_family = -1;
#endif
scoped_lock_t locker(crypto_sync);
scoped_lock_t locker(crypto_sync);
#if defined (ZMQ_USE_TWEETNACL)
// allow opening of /dev/urandom
unsigned char tmpbytes[4];
@ -510,13 +510,13 @@ void zmq::ctx_t::pend_connection (const std::string &addr_,
endpoints_t::iterator it = endpoints.find (addr_);
if (it == endpoints.end ()) {
// Still no bind.
// Still no bind.
endpoint_.socket->inc_seqnum ();
pending_connections.insert (pending_connections_t::value_type (addr_, pending_connection));
} else {
// Bind has happened in the mean time, connect directly
connect_inproc_sockets(it->second.socket, it->second.options, pending_connection, connect_side);
}
// Bind has happened in the mean time, connect directly
connect_inproc_sockets(it->second.socket, it->second.options, pending_connection, connect_side);
}
}
void zmq::ctx_t::connect_pending (const char *addr_, zmq::socket_base_t *bind_socket_)

2
src/decoder.hpp
View File

@ -119,7 +119,7 @@ namespace zmq
bytes_used_ = size_;
while (!to_read) {
const int rc =
const int rc =
(static_cast <T *> (this)->*next) (data_ + bytes_used_);
if (rc != 0)
return rc;

2
src/dgram.cpp
View File

@ -53,7 +53,7 @@ zmq::dgram_t::~dgram_t ()
void zmq::dgram_t::xattach_pipe (pipe_t *pipe_, bool subscribe_to_all_)
{
LIBZMQ_UNUSED(subscribe_to_all_);
LIBZMQ_UNUSED(subscribe_to_all_);
zmq_assert (pipe_);

2
src/ip.cpp
View File

@ -130,7 +130,7 @@ int zmq::get_peer_ip_address (fd_t sockfd_, std::string &ip_addr_)
rc = getpeername (sockfd_, (struct sockaddr*) &ss, &addrlen);
#ifdef ZMQ_HAVE_WINDOWS
if (rc == SOCKET_ERROR) {
const int last_error = WSAGetLastError();
const int last_error = WSAGetLastError();
wsa_assert (last_error != WSANOTINITIALISED &&
last_error != WSAEFAULT &&
last_error != WSAEINPROGRESS &&

108
src/norm_engine.cpp
View File

@ -9,14 +9,14 @@
zmq::norm_engine_t::norm_engine_t(io_thread_t* parent_,
const options_t& options_)
: io_object_t(parent_), zmq_session(NULL), options(options_),
norm_instance(NORM_INSTANCE_INVALID), norm_session(NORM_SESSION_INVALID),
: io_object_t(parent_), zmq_session(NULL), options(options_),
norm_instance(NORM_INSTANCE_INVALID), norm_session(NORM_SESSION_INVALID),
is_sender(false), is_receiver(false),
zmq_encoder(0), norm_tx_stream(NORM_OBJECT_INVALID),
tx_first_msg(true), tx_more_bit(false),
zmq_output_ready(false), norm_tx_ready(false),
zmq_encoder(0), norm_tx_stream(NORM_OBJECT_INVALID),
tx_first_msg(true), tx_more_bit(false),
zmq_output_ready(false), norm_tx_ready(false),
tx_index(0), tx_len(0),
zmq_input_ready(false)
zmq_input_ready(false)
{
int rc = tx_msg.init();
errno_assert(0 == rc);
@ -50,7 +50,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
{
ifacePtr = network_;
}
// Second, look for optional multicast ifaceName
char ifaceName[256];
const char* addrPtr = strchr(ifacePtr, ';');
@ -68,7 +68,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
addrPtr = ifacePtr;
ifacePtr = NULL;
}
// Finally, parse IP address and port number
const char* portPtr = strrchr(addrPtr, ':');
if (NULL == portPtr)
@ -76,7 +76,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
errno = EINVAL;
return -1;
}
char addr[256];
size_t addrLen = portPtr - addrPtr;
if (addrLen > 255) addrLen = 255;
@ -84,7 +84,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
addr[addrLen] = '\0';
portPtr++;
unsigned short portNumber = atoi(portPtr);
if (NORM_INSTANCE_INVALID == norm_instance)
{
if (NORM_INSTANCE_INVALID == (norm_instance = NormCreateInstance()))
@ -93,14 +93,14 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
return -1;
}
}
// TBD - What do we use for our local NormNodeId?
// (for now we use automatic, IP addr based assignment or passed in 'id')
// a) Use ZMQ Identity somehow?
// b) Add function to use iface addr
// c) Randomize and implement a NORM session layer
// conflict detection/resolution protocol
norm_session = NormCreateSession(norm_instance, addr, portNumber, localId);
if (NORM_SESSION_INVALID == norm_session)
{
@ -129,7 +129,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
NormSetMulticastInterface(norm_session, ifacePtr);
}
}
if (recv)
{
// The alternative NORM_SYNC_CURRENT here would provide "instant"
@ -148,7 +148,7 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
}
is_receiver = true;
}
if (send)
{
// Pick a random sender instance id (aka norm sender session id)
@ -163,10 +163,10 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
norm_instance = NORM_INSTANCE_INVALID;
errno = savedErrno;
return -1;
}
}
NormSetCongestionControl(norm_session, true);
norm_tx_ready = true;
is_sender = true;
is_sender = true;
if (NORM_OBJECT_INVALID == (norm_tx_stream = NormStreamOpen(norm_session, 2*1024*1024)))
{
// errno set by whatever failed
@ -178,11 +178,11 @@ int zmq::norm_engine_t::init(const char* network_, bool send, bool recv)
return -1;
}
}
//NormSetMessageTrace(norm_session, true);
//NormSetDebugLevel(3);
//NormOpenDebugLog(norm_instance, "normLog.txt");
return 0; // no error
} // end zmq::norm_engine_t::init()
@ -192,12 +192,12 @@ void zmq::norm_engine_t::shutdown()
if (is_receiver)
{
NormStopReceiver(norm_session);
// delete any active NormRxStreamState
rx_pending_list.Destroy();
rx_ready_list.Destroy();
msg_ready_list.Destroy();
is_receiver = false;
}
if (is_sender)
@ -224,20 +224,20 @@ void zmq::norm_engine_t::plug (io_thread_t* io_thread_, session_base_t *session_
zmq_session = session_;
if (is_sender) zmq_output_ready = true;
if (is_receiver) zmq_input_ready = true;
fd_t normDescriptor = NormGetDescriptor(norm_instance);
norm_descriptor_handle = add_fd(normDescriptor);
// Set POLLIN for notification of pending NormEvents
set_pollin(norm_descriptor_handle);
set_pollin(norm_descriptor_handle);
if (is_sender) send_data();
} // end zmq::norm_engine_t::init()
void zmq::norm_engine_t::unplug()
{
rm_fd(norm_descriptor_handle);
zmq_session = NULL;
} // end zmq::norm_engine_t::unplug()
@ -253,7 +253,7 @@ void zmq::norm_engine_t::restart_output()
// There's new message data available from the session
zmq_output_ready = true;
if (norm_tx_ready) send_data();
} // end zmq::norm_engine_t::restart_output()
void zmq::norm_engine_t::send_data()
@ -289,7 +289,7 @@ void zmq::norm_engine_t::send_data()
// Need to pull and load a new message to send
if (-1 == zmq_session->pull_msg(&tx_msg))
{
// We need to wait for "restart_output()" to be called by ZMQ
// We need to wait for "restart_output()" to be called by ZMQ
zmq_output_ready = false;
break;
}
@ -301,7 +301,7 @@ void zmq::norm_engine_t::send_data()
// 'syncs' mid-stream. We key off the the state of the 'more_flag'
// I.e.,If more_flag _was_ false previously, this is the first
// frame of a ZMQ message.
if (tx_more_bit)
if (tx_more_bit)
tx_buffer[0] = (char)0xff; // this is not first frame of message
else
tx_buffer[0] = 0x00; // this is first frame of message
@ -339,7 +339,7 @@ void zmq::norm_engine_t::in_event()
zmq_assert(false);
return;
}
switch(event.type)
{
case NORM_TX_QUEUE_VACANCY:
@ -350,13 +350,13 @@ void zmq::norm_engine_t::in_event()
send_data();
}
break;
case NORM_RX_OBJECT_NEW:
//break;
case NORM_RX_OBJECT_UPDATED:
recv_data(event.object);
break;
case NORM_RX_OBJECT_ABORTED:
{
NormRxStreamState* rxState = (NormRxStreamState*)NormObjectGetUserData(event.object);
@ -370,7 +370,7 @@ void zmq::norm_engine_t::in_event()
}
delete rxState;
break;
}
}
case NORM_REMOTE_SENDER_INACTIVE:
// Here we free resources used for this formerly active sender.
// Note w/ NORM_SYNC_STREAM, if sender reactivates, we may
@ -380,11 +380,11 @@ void zmq::norm_engine_t::in_event()
// user configurable timeout here to wait some amount of time
// after this event to declare the remote sender truly dead
// and delete its state???
NormNodeDelete(event.sender);
NormNodeDelete(event.sender);
break;
default:
// We ignore some NORM events
// We ignore some NORM events
break;
}
} // zmq::norm_engine_t::in_event()
@ -396,7 +396,7 @@ void zmq::norm_engine_t::restart_input()
// Process any pending received messages
if (!msg_ready_list.IsEmpty())
recv_data(NORM_OBJECT_INVALID);
} // end zmq::norm_engine_t::restart_input()
void zmq::norm_engine_t::recv_data(NormObjectHandle object)
@ -447,19 +447,19 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object)
{
switch(rxState->Decode())
{
case 1: // msg completed
case 1: // msg completed
// Complete message decoded, move this stream to msg_ready_list
// to push the message up to the session below. Note the stream
// to push the message up to the session below. Note the stream
// will be returned to the "rx_ready_list" after that's done
rx_ready_list.Remove(*rxState);
msg_ready_list.Append(*rxState);
continue;
case -1: // decoding error (shouldn't happen w/ NORM, but ...)
// We need to re-sync this stream (decoder buffer was reset)
rxState->SetSync(false);
break;
default: // 0 - need more data
break;
}
@ -524,12 +524,12 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object)
rx_pending_list.Append(*rxState);
}
} // end while(NULL != (rxState = iterator.GetNextItem()))
if (zmq_input_ready)
{
// At this point, we've made a pass through the "rx_ready" stream list
// Now make a pass through the "msg_pending" list (if the zmq session
// ready for more input). This may possibly return streams back to
// Now make a pass through the "msg_pending" list (if the zmq session
// ready for more input). This may possibly return streams back to
// the "rx ready" stream list after their pending message is handled
NormRxStreamState::List::Iterator iterator(msg_ready_list);
NormRxStreamState* rxState;
@ -549,7 +549,7 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object)
{
// session rejected message?
// TBD - handle this better
zmq_assert(false);
zmq_assert(false);
}
}
// else message was accepted.
@ -561,15 +561,15 @@ void zmq::norm_engine_t::recv_data(NormObjectHandle object)
} // end while(NULL != (rxState = iterator.GetNextItem()))
} // end if (zmq_input_ready)
} // end while ((!rx_ready_list.empty() || (zmq_input_ready && !msg_ready_list.empty()))
// Alert zmq of the messages we have pushed up
zmq_session->flush();
} // end zmq::norm_engine_t::recv_data()
zmq::norm_engine_t::NormRxStreamState::NormRxStreamState(NormObjectHandle normStream,
zmq::norm_engine_t::NormRxStreamState::NormRxStreamState(NormObjectHandle normStream,
int64_t maxMsgSize)
: norm_stream(normStream), max_msg_size(maxMsgSize),
: norm_stream(normStream), max_msg_size(maxMsgSize),
in_sync(false), rx_ready(false), zmq_decoder(NULL), skip_norm_sync(false),
buffer_ptr(NULL), buffer_size(0), buffer_count(0),
prev(NULL), next(NULL), list(NULL)
@ -620,17 +620,17 @@ int zmq::norm_engine_t::NormRxStreamState::Decode()
{
// There's pending data for the decoder to decode
size_t processed = 0;
// This a bit of a kludgy approach used to weed
// out the NORM ZMQ message transport "syncFlag" byte
// from the ZMQ message stream being decoded (but it works!)
if (skip_norm_sync)
if (skip_norm_sync)
{
buffer_ptr++;
buffer_count--;
skip_norm_sync = false;
}
int rc = zmq_decoder->decode(buffer_ptr, buffer_count, processed);
buffer_ptr += processed;
buffer_count -= processed;
@ -651,7 +651,7 @@ int zmq::norm_engine_t::NormRxStreamState::Decode()
skip_norm_sync = false; // will get consumed by norm sync check
Init();
break;
case 0:
// need more data, keep decoding until buffer exhausted
break;
@ -662,7 +662,7 @@ int zmq::norm_engine_t::NormRxStreamState::Decode()
buffer_size = 0;
zmq_decoder->get_buffer(&buffer_ptr, &buffer_size);
return 0; // need more data
} // end zmq::norm_engine_t::NormRxStreamState::Decode()
zmq::norm_engine_t::NormRxStreamState::List::List()
@ -723,6 +723,6 @@ zmq::norm_engine_t::NormRxStreamState* zmq::norm_engine_t::NormRxStreamState::Li
if (NULL != nextItem) next_item = nextItem->next;
return nextItem;
} // end zmq::norm_engine_t::NormRxStreamState::List::Iterator::GetNextItem()
#endif // ZMQ_HAVE_NORM

72
src/norm_engine.hpp
View File

@ -16,17 +16,17 @@ namespace zmq
{
class io_thread_t;
class session_base_t;
class norm_engine_t : public io_object_t, public i_engine
{
public:
norm_engine_t (zmq::io_thread_t *parent_, const options_t &options_);
~norm_engine_t ();
// create NORM instance, session, etc
int init(const char* network_, bool send, bool recv);
void shutdown();
// i_engine interface implementation.
// Plug the engine to the session.
virtual void plug (zmq::io_thread_t *io_thread_,
@ -45,43 +45,43 @@ namespace zmq
virtual void restart_output ();
virtual void zap_msg_available () {};
// i_poll_events interface implementation.
// (we only need in_event() for NormEvent notification)
// (i.e., don't have any output events or timers (yet))
void in_event ();
private:
void unplug();
void send_data();
void recv_data(NormObjectHandle stream);
void recv_data(NormObjectHandle stream);
enum {BUFFER_SIZE = 2048};
// Used to keep track of streams from multiple senders
// Used to keep track of streams from multiple senders
class NormRxStreamState
{
public:
NormRxStreamState(NormObjectHandle normStream,
int64_t maxMsgSize);
~NormRxStreamState();
NormObjectHandle GetStreamHandle() const
{return norm_stream;}
bool Init();
void SetRxReady(bool state)
{rx_ready = state;}
bool IsRxReady() const
{return rx_ready;}
void SetSync(bool state)
{in_sync = state;}
bool InSync() const
{return in_sync;}
// These are used to feed data to decoder
// and its underlying "msg" buffer
char* AccessBuffer()
@ -98,21 +98,21 @@ namespace zmq
// occurs the 'sync' is dropped and the
// decoder re-initialized
int Decode();
class List
{
public:
List();
~List();
void Append(NormRxStreamState& item);
void Remove(NormRxStreamState& item);
bool IsEmpty() const
{return (NULL == head);}
void Destroy();
class Iterator
{
public:
@ -122,36 +122,36 @@ namespace zmq
NormRxStreamState* next_item;
};
friend class Iterator;
private:
NormRxStreamState* head;
NormRxStreamState* tail;
NormRxStreamState* tail;
}; // end class zmq::norm_engine_t::NormRxStreamState::List
friend class List;
List* AccessList()
{return list;}
private:
NormObjectHandle norm_stream;
int64_t max_msg_size;
bool in_sync;
bool in_sync;
bool rx_ready;
v2_decoder_t* zmq_decoder;
bool skip_norm_sync;
unsigned char* buffer_ptr;
size_t buffer_size;
size_t buffer_count;
NormRxStreamState* prev;
NormRxStreamState* next;
NormRxStreamState::List* list;
}; // end class zmq::norm_engine_t::NormRxStreamState
session_base_t* zmq_session;
options_t options;
NormInstanceHandle norm_instance;
@ -161,25 +161,25 @@ namespace zmq
bool is_receiver;
// Sender state
msg_t tx_msg;
v2_encoder_t zmq_encoder; // for tx messages (we use v2 for now)
v2_encoder_t zmq_encoder; // for tx messages (we use v2 for now)
NormObjectHandle norm_tx_stream;
bool tx_first_msg;
bool tx_more_bit;
bool zmq_output_ready; // zmq has msg(s) to send
bool zmq_output_ready; // zmq has msg(s) to send
bool norm_tx_ready; // norm has tx queue vacancy
// TBD - maybe don't need buffer if can access zmq message buffer directly?
char tx_buffer[BUFFER_SIZE];
unsigned int tx_index;
unsigned int tx_len;
// Receiver state
// Lists of norm rx streams from remote senders
bool zmq_input_ready; // zmq ready to receive msg(s)
NormRxStreamState::List rx_pending_list; // rx streams waiting for data reception
NormRxStreamState::List rx_ready_list; // rx streams ready for NormStreamRead()
NormRxStreamState::List msg_ready_list; // rx streams w/ msg ready for push to zmq
}; // end class norm_engine_t
}

6
src/pipe.cpp
View File

@ -390,12 +390,12 @@ void zmq::pipe_t::terminate (bool delay_)
// If terminate was already called, we can ignore the duplicate invocation.
if (state == term_req_sent1 || state == term_req_sent2) {
return;
}
}
// If the pipe is in the final phase of async termination, it's going to
// closed anyway. No need to do anything special here.
else if (state == term_ack_sent) {
return;
}
}
// The simple sync termination case. Ask the peer to terminate and wait
// for the ack.
else if (state == active) {
@ -422,7 +422,7 @@ void zmq::pipe_t::terminate (bool delay_)
// There are no other states.
else {
zmq_assert (false);
}
}
// Stop outbound flow of messages.
out_active = false;

6
src/select.cpp
View File

@ -432,9 +432,9 @@ bool zmq::select_t::is_retired_fd (const fd_entry_t &entry)
#if defined ZMQ_HAVE_WINDOWS
u_short zmq::select_t::get_fd_family (fd_t fd_)
{
// Use sockaddr_storage instead of sockaddr to accomodate differect structure sizes
sockaddr_storage addr = { 0 };
int addr_size = sizeof addr;
// Use sockaddr_storage instead of sockaddr to accomodate differect structure sizes
sockaddr_storage addr = { 0 };
int addr_size = sizeof addr;
int type;
int type_length = sizeof(int);

10
src/signaler.cpp
View File

@ -338,11 +338,11 @@ int zmq::signaler_t::recv_failable ()
#if defined ZMQ_HAVE_WINDOWS
int nbytes = ::recv (r, (char *) &dummy, sizeof (dummy), 0);
if (nbytes == SOCKET_ERROR) {
const int last_error = WSAGetLastError();
if (last_error == WSAEWOULDBLOCK) {
errno = EAGAIN;
const int last_error = WSAGetLastError();
if (last_error == WSAEWOULDBLOCK) {
errno = EAGAIN;
return -1;
}
}
wsa_assert (last_error == WSAEWOULDBLOCK);
}
#else
@ -388,7 +388,7 @@ int zmq::signaler_t::make_fdpair (fd_t *r_, fd_t *w_)
#elif defined ZMQ_HAVE_WINDOWS
# if !defined _WIN32_WCE
// Windows CE does not manage security attributes
// Windows CE does not manage security attributes
SECURITY_DESCRIPTOR sd;
SECURITY_ATTRIBUTES sa;
memset (&sd, 0, sizeof sd);

2
src/socket_base.cpp
View File

@ -432,7 +432,7 @@ int zmq::socket_base_t::getsockopt (int option_, void *optval_,
return -1;
}
memset(optval_, 0, *optvallen_);
*((int*) optval_) = thread_safe ? 1 : 0;
*((int*) optval_) = thread_safe ? 1 : 0;
*optvallen_ = sizeof (int);
return 0;
}

2
src/stream.cpp
View File

@ -60,7 +60,7 @@ zmq::stream_t::~stream_t ()
void zmq::stream_t::xattach_pipe (pipe_t *pipe_, bool subscribe_to_all_)
{
LIBZMQ_UNUSED(subscribe_to_all_);
LIBZMQ_UNUSED(subscribe_to_all_);
zmq_assert (pipe_);

16
src/tcp.cpp
View File

@ -189,7 +189,7 @@ void zmq::tune_tcp_maxrt (fd_t sockfd_, int timeout_)
// If not a single byte can be written to the socket in non-blocking mode
// we'll get an error (this may happen during the speculative write).
const int last_error = WSAGetLastError();
const int last_error = WSAGetLastError();
if (nbytes == SOCKET_ERROR && last_error == WSAEWOULDBLOCK)
return 0;
@ -201,7 +201,7 @@ void zmq::tune_tcp_maxrt (fd_t sockfd_, int timeout_)
last_error == WSAECONNABORTED ||
last_error == WSAETIMEDOUT ||
last_error == WSAECONNRESET
))
))
return -1;
// Circumvent a Windows bug:
@ -256,12 +256,12 @@ int zmq::tcp_read (fd_t s_, void *data_, size_t size_)
errno = EAGAIN;
}
else {
wsa_assert (last_error == WSAENETDOWN ||
last_error == WSAENETRESET ||
last_error == WSAECONNABORTED ||
last_error == WSAETIMEDOUT ||
last_error == WSAECONNRESET ||
last_error == WSAECONNREFUSED ||
wsa_assert (last_error == WSAENETDOWN ||
last_error == WSAENETRESET ||
last_error == WSAECONNABORTED ||
last_error == WSAETIMEDOUT ||
last_error == WSAECONNRESET ||
last_error == WSAECONNREFUSED ||
last_error == WSAENOTCONN);
errno = wsa_error_to_errno (last_error);
}

2
src/tcp_listener.cpp
View File

@ -281,7 +281,7 @@ zmq::fd_t zmq::tcp_listener_t::accept ()
#ifdef ZMQ_HAVE_WINDOWS
if (sock == INVALID_SOCKET) {
const int last_error = WSAGetLastError();
const int last_error = WSAGetLastError();
wsa_assert (last_error == WSAEWOULDBLOCK ||
last_error == WSAECONNRESET ||
last_error == WSAEMFILE ||

4
src/tweetnacl.c
View File

@ -573,8 +573,8 @@ int crypto_hashblocks(u8 *x,const u8 *m,u64 n)
b[3] += t;
FOR(j,8) a[(j+1)%8] = b[j];
if (i%16 == 15)
FOR(j,16)
w[j] += w[(j+9)%16] + sigma0(w[(j+1)%16]) + sigma1(w[(j+14)%16]);
FOR(j,16)
w[j] += w[(j+9)%16] + sigma0(w[(j+1)%16]) + sigma1(w[(j+14)%16]);
}
FOR(i,8) { a[i] += z[i]; z[i] = a[i]; }