* 1.7 Address management
*
* Transport service notifies ATS about changes to the addresses known to
- * him.
+ * it.
*
* 1.7.1 Adding an address
*
}
/* We run this task to make sure that the leader
has the stored the SET_KIND_LEADER set of himself,
- so he can participate in the rest of the gradecast
+ so it can participate in the rest of the gradecast
without the code having to handle any special cases. */
task = ((struct TaskEntry) {
.step = step,
break;
case CS_RINGING:
FPRINTF (stdout,
- _("We are calling `%s', his phone should be ringing.\n"),
+ _("We are calling `%s', their phone should be ringing.\n"),
peer_name);
break;
case CS_CONNECTED:
* messages being received or transmitted. This overall message is
* followed by the real message, or just the header of the real
* message (depending on the client's preferences). The receiver can
- * tell if he got the full message or only a partial message by
+ * tell if it got the full message or only a partial message by
* looking at the size field in the header of NotifyTrafficMessage and
* checking it with the size field in the message that follows.
*/
/**
* We will never be ready to transmit the given message in (disconnect
* or invalid request). Frees resources associated with @a car. We
- * don't explicitly tell the client, he'll learn with the disconnect
+ * don't explicitly tell the client, it'll learn with the disconnect
* (or violated the protocol).
*
* @param car request that now permanently failed; the
/**
* We will never be ready to transmit the given message in (disconnect
* or invalid request). Frees resources associated with @a car. We
- * don't explicitly tell the client, he'll learn with the disconnect
+ * don't explicitly tell the client, it'll learn with the disconnect
* (or violated the protocol).
*
* @param car request that now permanently failed; the
/**
- * We're sending an (encrypted) PING to the other peer to check if he
+ * We're sending an (encrypted) PING to the other peer to check if it
* can decrypt. The other peer should respond with a PONG with the
* same content, except this time encrypted with the receiver's key.
*/
}
else
{
- /* peer with "higher" identity starts a delayed KX, if the "lower" peer
- * does not start a KX since he sees no reasons to do so */
+ /* peer with "higher" identity starts a delayed KX, if the "lower" peer
+ * does not start a KX since it sees no reasons to do so */
kx->retry_set_key_task
= GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&set_key_retry_task,
/**
- * The other peer has indicated that he 'lost' the session
+ * The other peer has indicated that it 'lost' the session
* (KX down), reinitialize the session on our end, in particular
* this means to restart the typemap transmission.
*
/**
- * The other peer has indicated that he 'lost' the session
+ * The other peer has indicated that it 'lost' the session
* (KX down), reinitialize the session on our end, in particular
* this means to restart the typemap transmission.
*
/**
* Counts the number of items put in the current phase.
- * Once it hits #PUT_10, we progress tot he #RP_CUT phase
+ * Once it hits #PUT_10, we progress to the #RP_CUT phase
* or are done if @e i reaches #ITERATIONS.
*/
unsigned int j;
* a safe partition etc. The $HOME/.my.cnf can of course be a symbolic
* link. Even greater security risk can be achieved by setting no
* password for $USER. Luckily $USER has only priviledges to mess
- * up GNUnet's tables, nothing else (unless you give him more,
+ * up GNUnet's tables, nothing else (unless you give them more,
* of course).<p>
*
* 4) Still, perhaps you should briefly try if the DB connection
/**
* If we get content we already have from this peer, for how
- * long do we block him? Adjusted based on the fraction of
+ * long do we block it? Adjusted based on the fraction of
* redundant data we receive, between 1s and 1h.
*/
struct GNUNET_TIME_Relative migration_delay;
struct GNUNET_DNS_Advertisement
{
/**
- * Signature of the peer affirming that he is offering the service.
+ * Signature of the peer affirming that it is offering the service.
*/
struct GNUNET_CRYPTO_EddsaSignature signature;
/**
* The other peer has confirmed our session key + PING with a PONG
- * message encrypted with his session key (which we got). Key
+ * message encrypted with their session key (which we got). Key
* exchange is done.
*/
GNUNET_CORE_KX_STATE_UP,
/**
- * Retrieve the status of a process, waiting on him if dead.
+ * Retrieve the status of a process, waiting on it if dead.
* Nonblocking version.
*
* @param proc pointer to process structure
/**
- * Retrieve the status of a process, waiting on him if dead.
+ * Retrieve the status of a process, waiting on it if dead.
* Blocking version.
*
* @param proc pointer to process structure
enum GNUNET_PSYC_Policy
{
/**
- * Anyone can join the channel, without announcing his presence;
+ * Anyone can join the channel, without announcing their presence;
* all messages are always public and can be distributed freely.
* Joins may be announced, but this is not required.
*/
* published the same value, it will be decrypted.
*
* When the operation is canceled, the decrypt_cb is not called anymore, but the calling
- * peer may already have irrevocably contributed his share for the decryption of the value.
+ * peer may already have irrevocably contributed its share for the decryption of the value.
*
* @param cfg configuration to use
* @param share our secret share to use for decryption
* Cancel a decryption.
*
* The decrypt_cb is not called anymore, but the calling
- * peer may already have irrevocably contributed his share for the decryption of the value.
+ * peer may already have irrevocably contributed its share for the decryption of the value.
*
* @param dh to cancel
*/
/**
* Accept state in regex DFA. Peer affirms that
- * he offers the matching service.
+ * it offers the matching service.
*/
#define GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT 18
/**
* This is pobably followed by 'statistical' data (when we first saw
- * him, how did we get his ID, how many pushes (in a timeinterval),
+ * it, how did we get its ID, how many pushes (in a timeinterval),
* ...)
*/
};
return;
}
else
- { /* Other peer destroyed our sending channel that he is supposed to keep
+ { /* Other peer destroyed our sending channel that it is supposed to keep
* open. It probably went down. Remove it from our knowledge. */
Peers_cleanup_destroyed_channel (cls, channel);
remove_peer (peer);
struct GNUNET_CRYPTO_PaillierPublicKey paillier_public_key;
/**
- * The peer's commitment to his presecret.
+ * The peer's commitment to its presecret.
*/
gcry_mpi_t presecret_commitment;
* published the same value, it will be decrypted.
*
* When the operation is canceled, the decrypt_cb is not called anymore, but the calling
- * peer may already have irrevocably contributed his share for the decryption of the value.
+ * peer may already have irrevocably contributed its share for the decryption of the value.
*
* @param share our secret share to use for decryption
* @param ciphertext ciphertext to publish in order to decrypt it (if enough peers agree)
* Cancel a decryption.
*
* The decrypt_cb is not called anymore, but the calling
- * peer may already have irrevocably contributed his share for the decryption of the value.
+ * peer may already have irrevocably contributed its share for the decryption of the value.
*
* @param dh to cancel
*/
*/
struct GNUNET_CRYPTO_PaillierPublicKey pubkey;
/**
- * Commitment of 'peer' to his presecret.
+ * Commitment of 'peer' to its presecret.
*/
struct GNUNET_HashCode commitment GNUNET_PACKED;
};
* @param op operation that is created, should be initialized to
* begin the evaluation
* @param opaque_context message to be transmitted to the listener
- * to convince him to accept, may be NULL
+ * to convince it to accept, may be NULL
* @return operation-specific state to keep in @a op
*/
typedef struct OperationState *
/**
* Send our element count to the peer, in case our element count is
- * lower than his.
+ * lower than theirs.
*
* @param op intersection operation
*/
* @param op operation that is created, should be initialized to
* begin the evaluation
* @param opaque_context message to be transmitted to the listener
- * to convince him to accept, may be NULL
+ * to convince it to accept, may be NULL
* @return operation-specific state to keep in @a op
*/
static struct OperationState *
*
* We should notify the active peer once
* all our demands are satisfied, so that the active
- * peer can quit if we gave him everything.
+ * peer can quit if we gave it everything.
*/
GNUNET_CADET_receive_done (op->channel);
maybe_finish (op);
*
* @param op operation to perform (to be initialized)
* @param opaque_context message to be transmitted to the listener
- * to convince him to accept, may be NULL
+ * to convince it to accept, may be NULL
*/
static struct OperationState *
union_evaluate (struct Operation *op,
uint32_t strength;
/**
- * Is this peer listed here because he is a friend?
+ * Is this peer listed here because it is a friend?
*/
int is_friend;
/**
* Initialize a normal client. We got a start message from this
- * client, add him to the list of clients for broadcasting of inbound
+ * client, add it to the list of clients for broadcasting of inbound
* messages.
*
* @param cls the client
/**
* Initialize a blacklisting client. We got a blacklist-init
- * message from this client, add him to the list of clients
+ * message from this client, add it to the list of clients
* to query for blacklisting.
*
* @param cls the client
/**
- * Message we send to the other peer to notify him that we intentionally
+ * Message we send to the other peer to notify it that we intentionally
* are disconnecting (to reduce timeouts). This is just a friendly
* notification, peers must not rely on always receiving disconnect
* messages.
/**
* Send a ACK message to the neighbour to confirm that we
- * got his SYN_ACK.
+ * got its SYN_ACK.
*
* @param n neighbour to send the ACK to
*/
/**
- * Retrieve the status of a process, waiting on him if dead.
+ * Retrieve the status of a process, waiting on it if dead.
* Nonblocking version.
*
* @param proc process ID
/**
- * Retrieve the status of a process, waiting on him if dead.
+ * Retrieve the status of a process, waiting on it if dead.
* Nonblocking version.
*
* @param proc process ID
/**
- * Retrieve the status of a process, waiting on him if dead.
+ * Retrieve the status of a process, waiting on it if dead.
* Blocking version.
*
* @param proc pointer to process structure
projects / oweals / gnunet.git / commitdiff