Next: libdat, Previous: libcns, Up: C API [Contents][Index]

### 5.13 libcnx

#### 5.13.1 Overview

View lcov test coverage results on http://www.gnu.org/software/liquidwar6/coverage/src/lib/cnx/index.html.

#### 5.13.2 API

Function: void lw6cnx_backlog_zero (lw6cnx_backlog_t * backlog)

  backlog: struct to initialize

  Fills the struct with zeros, ignoring what was in there before

  Return value: none.

Function: void lw6cnx_backlog_reset (lw6cnx_backlog_t * backlog)

  backlog: struct to reset

  Resets the structure, freeing any ressource it was holding.

  Return value: none.

Function: void lw6cnx_backlog_push (lw6cnx_backlog_t * backlog, char * str)

  backlog: struct to add stuff to

  str: string to add

  Adds a string to the backlog. Be careful, the function will not duplicate the string but assume it’s been dynamically allocated, and will free it when it’s done with it.

  Return value: none.

Function: void lw6cnx_backlog_filter (lw6cnx_backlog_t * backlog, lw6cnx_backlog_filter_func_t func, lw6cnx_backlog_filter_data_t * func_data)

  backlog: struct to filter

  func: function used for filter

  func_data: additionnal data passed to function

  Filters the internal backlog list, the filter function, as standard list filter funcs, should return 1 if the record is to be kept, and 0 if it must be deleted, typically because it finally has been sent.

  Return value: none.

Function: lw6cnx_connection_t * lw6cnx_connection_new (const char * local_url, const char * remote_url, const char * remote_ip, int remote_port, const char * password, u_int64_t local_id, u_int64_t remote_id, int dns_ok, int network_reliability, lw6cnx_recv_callback_t recv_callback_func, void * recv_callback_data)

  local_url: the local public URL

  remote_url: the remote public URL

  remote_ip: the remote IP address

  remote_port: the remote port

  password: the password to use

  local_id: the local ID

  remote_id: the remote ID

  dns_ok: 1 if no DNS mismatch, 0 if IP does not match public URL

  network_reliability: drop 1 out of X packets

  recv_callback_func: a callback to call when data is received

  recv_callback_data: additionnal data to pass to the callback

  Create a connection object. This object in itself does nothing, it’s just to share common structures among modules, more precisely, between cli and srv code. It’s the responsability off the caller/backend to handle the `backend_specific_data` field which is NULL after this call.

  Return value: newly allocated object.

Function: void lw6cnx_connection_free (lw6cnx_connection_t * connection)

  connection: object to free

  Frees a connection object. It’s the responsibility of the caller/backend to handle the `backend_specific_data` field.

  Return value: none.

Function: int lw6cnx_connection_should_send_foo (lw6cnx_connection_t * connection, int64_t now)

  connection: the connection concerned

  now: the current timestamp

  Tells wether a new foo message must be issued.

  Return value: 1 if true, 0 if false.

Function: void lw6cnx_connection_init_foo_bar_key (lw6cnx_connection_t * connection, int64_t now, int next_foo_delay)

  connection: the connection concerned

  now: the current timestamp

  next_foo_delay: the delay (msec) before next foo message is sent

  Generates a new foo_bar_key, and schedules the next foo message send timestamp.

  Return value: none.

Function: int lw6cnx_connection_lock_send (lw6cnx_connection_t * connection)

  connection: the connexion to lock

  Acquires a "send" lock on the connexion, the idea is to avoid too threads sending data using the same socket at the same time. Note that each backend must call this when accessing the socket, there’s no top-level lock for the sake of performance.

  Return value: 1 on success, 0 if not.

Function: void lw6cnx_connection_unlock_send (lw6cnx_connection_t * connection)

  connection: the connexion to lock

  Releases a "send" lock on the connexion, the idea is to avoid too threads sending data using the same socket at the same time. Note that each backend must call this when accessing the socket, there’s no top-level lock for the sake of performance.

  Return value: none.

Function: int lw6cnx_connection_reliability_filter (lw6cnx_connection_t * connection)

  connection: the connexion concerned

  Will filter and return true only in "rare" cases when packets must be artificially dropped for testing purpose.

  Return value: 1 if message must be sent/received, 0 if not

Function: char * lw6cnx_password_checksum (const char * seed, const char * password)

  seed: a seed to blur the password, can be NULL

  password: the password, can be NULL

  Calculates the checksum of a password, and returns it as a string, ready to be sent on the network. If password is empty or NULL, then an empty (but not NULL unless internal error) string will be returned. All LW6 protocols should send these checksums instead of real passwords, then on server side value can be checked against both real password and its checksum. The seed is here so that eavesdropper can’t reuse the checksum to connect on random sessions. Seed can typically be the node ’public_url’ value.

  Return value: a dynamically allocated string

Function: int lw6cnx_password_verify (const char * seed, const char * password_here, const char * password_received)

  seed: a seed to blur the password, can be NULL

  password_here: the local password, can be NULL

  password_received: the password received from network, can be NULL

  Tells wether a password received over the network is valid. The `password_here` argument (the local password) will be checksumed so that `password_received` is checked against both clear and checksumed values, so it can be in any form.

  Return value: 1 if OK, passwords are the same, 0 if not.

Function: int lw6cnx_test_register (int mode)

  mode: test mode (bitmask)

  Registers all tests for the libcnx module.

  Return value: 1 if test is successfull, 0 on error.

Function: int lw6cnx_test_run (int mode)

  mode: test mode (bitmask)

  Runs the `cnx` module test suite, testing most (if not all...) functions.

  Return value: 1 if test is successfull, 0 on error.

Function: void lw6cnx_ticket_table_zero (lw6cnx_ticket_table_t * ticket_table)

  ticket_table: the ticket table to fill with zero

  Fills the ticket table struct with 0s.

  Return value: none.

Function: int lw6cnx_ticket_table_init (lw6cnx_ticket_table_t * ticket_table, int hash_size)

  ticket_table: the ticket table to init

  hash_size: the hash size for both recv/send hashs

  Initialize a ticket table, that is, set it up with two empty hashs. Recv hash is filled automatically as it’s queried for tickets, send hash must be filled explicitely with info from the network.

  Return value: none.

Function: void lw6cnx_ticket_table_clear (lw6cnx_ticket_table_t * ticket_table)

  ticket_table: the ticket table to clear

  Clears the object (frees memory).

  Return value: none.

Function: u_int64_t lw6cnx_ticket_table_get_recv (lw6cnx_ticket_table_t * ticket_table, const char * peer_id)

  ticket_table: the ticket table to query

  peer_id: the id of remote node

  Gets the ticket used to communicate with peer, to check its incoming (recv) messages. If ticket does not exist yet, it’s automatically generated so tunction will always return a non-zero value.

  Return value: the ticket used to check incoming messages.

Function: void lw6cnx_ticket_table_ack_recv (lw6cnx_ticket_table_t * ticket_table, const char * peer_id, int ack_delay_msec)

  ticket_table: the ticket table to query

  peer_id: the id of remote node

  ack_delay_msec: delay before which we’ll consider the ticket as really received

  Acknowledges the ticket used to communicate with peer, to check its incoming (recv) messages has been received. This is to avoid sending it again when it has been received, as it’s kept "forever" by peer, we never need to send it again. The delay is here to avoid checking tickets too quickly, for instance one could have sent the ticket yet, but for some reason some unsigned messages are still in the pipe, typically they transit through another slow channel such as httpd while the ticket was sent on udp.

  Return value: none.

Function: int lw6cnx_ticket_table_was_recv_exchanged (lw6cnx_ticket_table_t * ticket_table, const char * peer_id)

  ticket_table: the ticket table to query

  peer_id: the id of remote node

  Acknowledges the ticket used to communicate with peer, to check its incoming (recv) messages has been received. This is to avoid sending it again when it has been received, as it’s kept "forever" by peer, we never need to send it again.

  Return value: the ticket used to check incoming messages.

Function: u_int64_t lw6cnx_ticket_table_get_send (lw6cnx_ticket_table_t * ticket_table, const char * peer_id)

  ticket_table: the ticket table to query

  peer_id: the id of remote node

  Gets the ticket used to communicate with peer, to stamp the outgoing messages. If ticket does not exist yet, 0 is returned, indeed this value must be initialized with the value the peer gives us.

  Return value: the ticket used to stamp outgoing messages.

Function: void lw6cnx_ticket_table_set_send (lw6cnx_ticket_table_t * ticket_table, const char * peer_id, u_int64_t send_ticket)

  ticket_table: the ticket table to query

  peer_id: the id of remote node

  send_ticket: the ticket to use to stamp outgoing messages

  Sets the ticket used to communicate with peer, to stamp the outgoing (send) messages. This value should be received from the network. Note that once it’s set, it’s impossible to change it, it will remain the same for the whole duration of the node existence.

  Return value: NULL

Struct: lw6cnx_backlog_filter_data_s

  Structure used to filter backlog data, that is, data we try to send but were unable to send. The idea is to have the information of the current timestamp (now) + a reference to the last failure timestamp, so that if it failed just now, we don’t try anymore.

Member of lw6cnx_backlog_filter_data_s: specific_data

  Type: `void *`

  Definition: `void* lw6cnx_backlog_filter_data_s::specific_data`

  Pointer specific data, depends on backend using the connection and backlog.

Member of lw6cnx_backlog_filter_data_s: now

  Type: `int64_t`

  Definition: `int64_t lw6cnx_backlog_filter_data_s::now`

  Current timestamp, we could technically use a call to a function to get it but the idea is to cache it for both performance and the fact it’s easier to detect the fact that it failed during the current filtering.

Struct: lw6cnx_backlog_item_s

  Holds an item backlog, that is a message associated to a timestamp and whatever usesfull metadata that can help handling the message.

Member of lw6cnx_backlog_item_s: timestamp

  Type: `int64_t`

  Definition: `int64_t lw6cnx_backlog_item_s::timestamp`

  Timestamp when the message was first put in the backlog, this is used for sorting messages and also to find out messages that were in the queue for a very very long time.

Member of lw6cnx_backlog_item_s: str

  Type: `const char *`

  Definition: `const char* lw6cnx_backlog_item_s::str`

  The message itself, dynamically allocated string.

Struct: lw6cnx_backlog_s

  Used to hold per-connection message backlog, the connection might use it or not, it’s up to it to decide wether this backlog is usefull, however the code is mutualized.

Member of lw6cnx_backlog_s: list

  Type: `lw6sys_list_t *`

  Definition: `lw6sys_list_t* lw6cnx_backlog_s::list`

  List of lw6cnx_backlog_t items.

Struct: lw6cnx_connection_s

  This structure holds all data associated to a physical connexion with a remote peer. This includes informations about the local node, informations about the peer, and protocol specific details. Depending on which backend is used to handle the connection, it will behave differently. If you search for attributes such as socket id, search for them in backend_specific_data which is, in fact, handle by the backend code.

Member of lw6cnx_connection_s: local_url

  Type: `char *`

  Definition: `char* lw6cnx_connection_s::local_url`

  URL of our local node.

Member of lw6cnx_connection_s: remote_url

  Type: `char *`

  Definition: `char* lw6cnx_connection_s::remote_url`

  URL of the remote node.

Member of lw6cnx_connection_s: remote_ip

  Type: `char *`

  Definition: `char* lw6cnx_connection_s::remote_ip`

  IP address of the remote node.

Member of lw6cnx_connection_s: remote_port

  Type: `int`

  Definition: `int lw6cnx_connection_s::remote_port`

  IP port of the remote node.

Member of lw6cnx_connection_s: password

  Type: `char *`

  Definition: `char* lw6cnx_connection_s::password`

  Password as clear text.

Member of lw6cnx_connection_s: password_send_checksum

  Type: `char *`

  Definition: `char* lw6cnx_connection_s::password_send_checksum`

  Password as a checksum, what will be sent on the network.

Member of lw6cnx_connection_s: local_id_int

  Type: `u_int64_t`

  Definition: `u_int64_t lw6cnx_connection_s::local_id_int`

  ID of the local node, as an unsigned 64-bit integer.

Member of lw6cnx_connection_s: local_id_str

  Type: `char *`

  Definition: `char* lw6cnx_connection_s::local_id_str`

  ID of the local node, as an hexa string.

Member of lw6cnx_connection_s: remote_id_int

  Type: `u_int64_t`

  Definition: `u_int64_t lw6cnx_connection_s::remote_id_int`

  ID of the remote node, as an unsigned 64-bit integer.

Member of lw6cnx_connection_s: remote_id_str

  Type: `char *`

  Definition: `char* lw6cnx_connection_s::remote_id_str`

  ID of the local node, as an hexa string.

Member of lw6cnx_connection_s: dns_ok

  Type: `int`

  Definition: `int lw6cnx_connection_s::dns_ok`

  Will be set to 1 if the peer domain name is the same as the one reported in the URL. For instance, if we get a connection from 23.45.23.45, but this host claims to be on www.foo.bar and DNS reports www.foo.bar as being 111.222.111.222 then there’s something strange. It could just be someone doing NAT, but in all cases it’s worth mentionning, so we keep the information here. Having 0 here is a bad point for the connection.

Member of lw6cnx_connection_s: network_reliability

  Type: `int`

  Definition: `int lw6cnx_connection_s::network_reliability`

  The higher, the most reliable message sending will be. It can never be perfect, LW6 will always drop some packets from time to time, just to simulate real packet loss and be sure if it happens, it’s handled nicely.

Member of lw6cnx_connection_s: properties

  Type: `lw6cnx_properties_t`

  Definition: `lw6cnx_properties_t lw6cnx_connection_s::properties`

  Properties got from the backend.

Member of lw6cnx_connection_s: recv_callback_func

  Type: `lw6cnx_recv_callback_t`

  Definition: `lw6cnx_recv_callback_t lw6cnx_connection_s::recv_callback_func`

  Function which will be called when receiving data. This one must clearly be reentrant, depending on the backend it could be called in a separate thread, at any time.

Member of lw6cnx_connection_s: recv_callback_data

  Type: `void *`

  Definition: `void* lw6cnx_connection_s::recv_callback_data`

  Data passed to recv_callback_func.

Member of lw6cnx_connection_s: send_mutex

  Type: `lw6sys_mutex_t *`

  Definition: `lw6sys_mutex_t* lw6cnx_connection_s::send_mutex`

  Send mutex, this will be used so that sending operations are properly serialized. Indeed, threads that respond on the fly could be likely to call this concurrently.

Member of lw6cnx_connection_s: foo_bar_key

  Type: `u_int32_t`

  Definition: `u_int32_t lw6cnx_connection_s::foo_bar_key`

  This is used to handle keepalive. Actually, the protocol is that from time to time FOO key is sent and then each connection (in a tentacle object, typically) is supposed to respond BAR key to show it has received the latest message. This field just stores the value so that when we receive a BAR message we know which key to check against.

Member of lw6cnx_connection_s: last_send_foo_timestamp

  Type: `int64_t`

  Definition: `int64_t lw6cnx_connection_s::last_send_foo_timestamp`

  The last time FOO was sent.

Member of lw6cnx_connection_s: next_send_foo_timestamp

  Type: `int64_t`

  Definition: `int64_t lw6cnx_connection_s::next_send_foo_timestamp`

  The next time FOO needs to be sent.

Member of lw6cnx_connection_s: ping_msec

  Type: `int`

  Definition: `int lw6cnx_connection_s::ping_msec`

  The current ping, updated when receiving BAR message.

Member of lw6cnx_connection_s: last_recv_timestamp

  Type: `int64_t`

  Definition: `int64_t lw6cnx_connection_s::last_recv_timestamp`

  Last time something was received on this connection.

Member of lw6cnx_connection_s: backend_specific_data

  Type: `void *`

  Definition: `void* lw6cnx_connection_s::backend_specific_data`

  Store backend data, this is when, for instance, a socket handle will be kept, or a library handle (CURL, to name it). Common code does not know what’s in there.

Struct: lw6cnx_properties_s

  Used to hold generic client/server properties, set up by the backend, can then be queried by the caller.

Member of lw6cnx_properties_s: hint_timeout

  Type: `int`

  Definition: `int lw6cnx_properties_s::hint_timeout`

  Gives an idea of what timeout one can expect with this backend, this is not necessarly the exact timeout but it gives an order of magnitude. Unit is seconds.

Member of lw6cnx_properties_s: ping_alter_base

  Type: `int`

  Definition: `int lw6cnx_properties_s::ping_alter_base`

  Modifies the ping returned by terrain experience, this is a way to help some kind of connections to be preferred over others. Set it to N to add N milliseconds to the real ping. Adding a few msecs, such as 1 or 5 will just give an advantage to a given connection while not giving really wrong results. High values like 50 or 100 seriously penalizes some kind of connections, which is whishable, think of the httpd way to send things for instance.

Member of lw6cnx_properties_s: ping_alter_percent

  Type: `int`

  Definition: `int lw6cnx_properties_s::ping_alter_percent`

  Modifies the ping returned by terrain experience, this is a way to help some kind of connections to be preferred over others. Set it to 100 for default value, means 100% of real ping delay, set it to 50 to make the algorithm believe lag is twice lower (this means, connection twice faster) and set it to 1000 to make believe that everything is slow. In practice only a slight alteration should be required, one should still favor really fast connections when it’s proved in real life that they are faster!

Member of lw6cnx_properties_s: reliable

  Type: `int`

  Definition: `int lw6cnx_properties_s::reliable`

  Wether this connexion is to be considered reliable or not. Well, in LW6, all connexions are unrealiable since LW6 will drop packets on purpose to simulate problems, but however, some are well-known to be unreliable (UDP...) while others are OK.

Member of lw6cnx_properties_s: backend_id

  Type: `const char *`

  Definition: `const char* lw6cnx_properties_s::backend_id`

  The backend id, beware, this is a static string, must not be freed, and depends on backend library to be here, if this one is unloaded, will point to nowhere.

Struct: lw6cnx_ticket_table_s

  A common, shared table, to store all the tickets associated with various connections. This needs to be in-memory and quite fast for it’s called very often (at each message, in fact) to perform sanity checks and avoid fakes/cheaters.

Member of lw6cnx_ticket_table_s: recv_spinlock

  Type: `lw6sys_spinlock_t *`

  Definition: `lw6sys_spinlock_t* lw6cnx_ticket_table_s::recv_spinlock`

  Lock for the recv_table hash.

Member of lw6cnx_ticket_table_s: recv_ack_spinlock

  Type: `lw6sys_spinlock_t *`

  Definition: `lw6sys_spinlock_t* lw6cnx_ticket_table_s::recv_ack_spinlock`

  Lock for the recv_ack_table hash.

Member of lw6cnx_ticket_table_s: send_spinlock

  Type: `lw6sys_spinlock_t *`

  Definition: `lw6sys_spinlock_t* lw6cnx_ticket_table_s::send_spinlock`

  Lock for the send_table hash.

Member of lw6cnx_ticket_table_s: recv_table

  Type: `lw6sys_hash_t *`

  Definition: `lw6sys_hash_t* lw6cnx_ticket_table_s::recv_table`

  Hash table containing the tickets for recv operations. This table is auto-generated, if one asks for a ticket for an unknown host, one is generated. The key is the ID (64-bit integer) of the host, as an hexa string.

Member of lw6cnx_ticket_table_s: recv_ack_table

  Type: `lw6sys_hash_t *`

  Definition: `lw6sys_hash_t* lw6cnx_ticket_table_s::recv_ack_table`

  Hash table containing wether the send ticket was received by a given host. The data is just a NULL pointer, only if the key is present, we know we don’t need to resend our key to the peer. An easy way to know that the key was sent is if the peer was abled to produce a valid message/checksum. The key is the ID (64-bit integer) of the host, as an hexa string.

Member of lw6cnx_ticket_table_s: send_table

  Type: `lw6sys_hash_t *`

  Definition: `lw6sys_hash_t* lw6cnx_ticket_table_s::send_table`

  Hash table containing the tickets for send operations. Those tickets are typically received from the peers themselves who generate them on the fly. The key is the ID (64-bit integer) of the host, as an hexa string.

Next: libdat, Previous: libcns, Up: C API [Contents][Index]