* DESCRIPTION
*
* This interface defines the SILC Client Library API for the application.
- * The client operations are defined first. These are callback functions that
- * the application MUST implement since the library may call the functions
- * at any time. At the end of file is the API for the application that
- * it can use from the library. This is the only file that the application
- * may include from the SIlC Client Library.
- *
- * o SILC Client Operations
- *
- * These functions must be implemented by the application calling the SILC
- * client library. The client library can call these functions at any time.
- *
- * To use this structure: define a static SilcClientOperations variable,
- * fill it and pass its pointer to silc_client_alloc function.
- *
- * o SILC Client Library API
- *
- * This is the API that is published by the SILC Client Library for the
- * applications. These functions are implemented in the SILC Client Library.
- * Application may freely call these functions from the library.
+ * The Client Library is a full featured SILC client without user interface.
+ * A simple interface called SILC Client Operations (SilcClientOperations)
+ * is provided for applications to implmeent the necessary functions to use
+ * the client library. The silcclient.h header file includes client library
+ * API, such as command handling and message sending. The silcclient_entry.h
+ * header file includes entry handling, such as channel and user entry
+ * handling.
+ *
+ * Practically all functions in the Client Library API accepts SilcClient
+ * and SilcClientConnection as their first two argument. The first argument
+ * is the actual SilcClient context and the second is the SilcClientConnection
+ * context of the connection in question. Application may create and handle
+ * multiple connections in one SilcClient. Connections can be created to
+ * servers and other clients.
+ *
+ * The Client Library support multiple threads and is threads safe if used
+ * correctly. Messages can be sent from multiple threads without any
+ * locking. Messages however are always received only in one thread unless
+ * message waiting (see silc_client_private_message_wait as an example) is
+ * used. The threads can be turned on and off by giving a parameter to the
+ * SilcClient. When turned on, each new connection to remote host is always
+ * executed in an own thread. All tasks related to that connection are then
+ * executed in that thread. This means that client operation callbacks for
+ * that connections may be called from threads and application will need to
+ * employ concurrency control if the callbacks need to access shared data
+ * in the application. Messages are also received in that thread.
*
***/
* by the `status'. It is called after the connection has been
* established to the remote host and when connection is disconnected
* by the remote host. The `context' is the context given as argument
- * to the connecting function.
+ * to the connecting function. If the `status' is an error the `error'
+ * may indicate more detailed error. If `error' is SILC_STATUS_OK no
+ * detailed error message is available.
*
* When the `status' is SILC_CLIENT_CONN_DISCONNECTED the `error' will
* indicate the reason for disconnection. If the `message' is non-NULL
* it delivers error or disconnection message.
*
+ * The `conn' is the connection to the remote host. In case error
+ * occurred the `conn' may be NULL, however, in some cases a valid `conn'
+ * is returned even in error. If `conn' is non-NULL the receiver is
+ * responsible of closing the connection with silc_client_close_connection
+ * function, except when SILC_CLINET_CONN_DISCONNECTED or some error
+ * was received. In these cases the library will close the connection.
+ *
***/
typedef void (*SilcClientConnectCallback)(SilcClient client,
SilcClientConnection conn,
SILC_CLIENT_MESSAGE_INFO, /* Informational */
SILC_CLIENT_MESSAGE_WARNING, /* Warning */
SILC_CLIENT_MESSAGE_ERROR, /* Error */
+ SILC_CLIENT_MESSAGE_COMMAND_ERROR, /* Error during command */
SILC_CLIENT_MESSAGE_AUDIT, /* Auditable */
} SilcClientMessageType;
/***/
Following format types are available:
%n nickname - the real nickname returned by the server (mandatory)
+ %a number - ascending number in case there are several
+ same nicknames (fe. nick#2 and nick#3)
%h hostname - the stripped hostname of the client
%H full hostname - the full hostname of the client
- %s server name - the server name the client is connected
- %S full server - the full server name the client is connected
- %a number - ascending number in case there are several
- same nicknames (fe. nick@host and nick@host2)
- Example format strings: "%n@%h%a" (fe. nick@host, nick@host2)
- "%a!%n@%s" (fe. nick@server, 2!nick@server)
- "%n@%H" (fe. nick@host.domain.com)
+ Example format strings: "%n#%a" (fe. nick#2, nick#3)
+ "%n@%h%a" (fe. nick@host, nick@host2)
+ "%a!%n@%h" (fe. nick@host, 2!nick@host)
Note that there must always be some separator characters around '%n'
format. It is not possible to put format characters before or after
- '%n' without separators (such ash '@'). Also note that the separator
+ '%n' without separators (such ash '#'). Also note that the separator
character should be a character that cannot be part of normal nickname.
*/
char nickname_format[32];
***/
void silc_client_run_one(SilcClient client);
-
/****f* silcclient/SilcClientAPI/silc_client_stop
*
* SYNOPSIS
/* Rekey timeout in seconds. The client will perform rekey in this
time interval. If set to zero, the default value will be used
(3600 seconds, 1 hour). */
- unsigned int rekey_secs;
+ SilcUInt32 rekey_secs;
/* If this is set to TRUE then the client will ignore all incoming
Requested Attributes queries and does not reply anything back. This
void silc_client_close_connection(SilcClient client,
SilcClientConnection conn);
-/* Message sending functions (client_channel.c and client_prvmsg.c) */
+/* Message sending functions */
/****f* silcclient/SilcClientAPI/silc_client_send_channel_message
*
* private key) is used.
*
* If the `flags' includes SILC_MESSAGE_FLAG_SIGNED the message will be
- * digitally signed with the SILC key pair.
+ * digitally signed with the SILC key pair. In this case the `hash'
+ * pointer must be provided as well.
*
* Returns TRUE if the message was sent, and FALSE if error occurred or
* the sending is not allowed due to channel modes (like sending is
unsigned char *data,
SilcUInt32 data_len);
-/* Block process until channel message from `channel' is received */
-SilcBool
-silc_client_receive_channel_message(SilcClient client,
- SilcClientConnection conn,
- SilcChannelEntry channel,
- SilcClientEntry *return_sender,
- SilcMessageFlags *return_flags,
- const unsigned char **return_message,
- SilcUInt32 *return_message_len);
-
/****f* silcclient/SilcClientAPI/silc_client_send_private_message
*
* SYNOPSIS
* not been set with this client then the message will be encrypted using
* normal session keys. If the `flags' includes SILC_MESSAGE_FLAG_SIGNED
* the message will be digitally signed with the SILC key pair. In this
- * case the caller must also provide the `hash' pointer. By default, the
- * hash function must be SHA-1.
+ * case the caller must also provide the `hash' pointer.
*
* Returns TRUE if the message was sent, and FALSE if error occurred.
* This function is thread safe and private messages can be sent from
unsigned char *data,
SilcUInt32 data_len);
+/****f* silcclient/SilcClientAPI/silc_client_private_message_wait_init
+ *
+ * SYNOPSIS
+ *
+ * SilcBool
+ * silc_client_private_message_wait_init(SilcClient client,
+ * SilcClientConnection conn);
+ *
+ * DESCRIPTION
+ *
+ * Initializes private message waiting functionality for the connection
+ * indicated by `conn'. Once this is called private message from remote
+ * connection indicated by `conn' for any client entry beloning to that
+ * connection may be waited for, for example in an thread. The function
+ * silc_client_private_message_wait is used to block the current thread
+ * until a private message is received from a specified client entry.
+ * Return FALSE on error.
+ *
+ ***/
+SilcBool silc_client_private_message_wait_init(SilcClient client,
+ SilcClientConnection conn);
+
+/****f* silcclient/SilcClientAPI/silc_client_private_message_wait_uninit
+ *
+ * SYNOPSIS
+ *
+ * void
+ * silc_client_private_message_wait_uninit(SilcClient client,
+ * SilcClientConnection conn);
+ *
+ * DESCRIPTION
+ *
+ * Unintializes private message waiting for connection indicated by
+ * `conn'. After this call private message cannot be waited anymore.
+ * This call may be called from any thread. This call will signal all
+ * private message waiting threads to stop waiting.
+ *
+ ***/
+void silc_client_private_message_wait_uninit(SilcClient client,
+ SilcClientConnection conn);
+
+/****f* silcclient/SilcClientAPI/silc_client_private_message_wait
+ *
+ * SYNOPSIS
+ *
+ * SilcBool
+ * silc_client_private_message_wait(SilcClient client,
+ * SilcClientConnection conn,
+ * SilcClientEntry client_entry,
+ * SilcMessagePayload *payload);
+ *
+ * DESCRIPTION
+ *
+ * Blocks current thread or process until a private message has been
+ * received from the remote client indicated by `client_entry'. Before
+ * private messages can be waited the silc_client_private_message_wait_init
+ * must be called. This function can be used from a thread to wait for
+ * private message from the specified client. Multiple threads can be
+ * created to wait messages from multiple clients. Any other private
+ * message received from the connection indicated by `conn' will be
+ * forwarded to the normal `private_message' client operation. The
+ * private messages from `client_entry' will not be delivered to the
+ * `private_message' client operation.
+ *
+ * Returns TRUE and the received private message into `payload'. The caller
+ * must free the returned SilcMessagePayload. If this function returns
+ * FALSE the private messages cannot be waited anymore. This happens
+ * when some other thread calls silc_client_private_message_wait_uninit.
+ * This returns FALSE also if silc_client_private_message_wait_init has
+ * not been called.
+ *
+ ***/
+SilcBool silc_client_private_message_wait(SilcClient client,
+ SilcClientConnection conn,
+ SilcClientEntry client_entry,
+ SilcMessagePayload *payload);
+
/****f* silcclient/SilcClientAPI/silc_client_on_channel
*
* SYNOPSIS
SilcClientConnection conn,
const char *command_line, ...);
-/* If FALSE is returned the callback will not be called again, even if there
- is more data coming in in the command reply. If there are other pending
- commands waiting for the reply, they will receive it even if some other
- command reply has returned FALSE. */
+/****f* silcclient/SilcClientAPI/SilcClientCommandReply
+ *
+ * SYNOPSIS
+ *
+ * typedef SilcBool (*SilcClientCommandReply)(SilcClient client,
+ * SilcClientConnection conn,
+ * SilcCommand command,
+ * SilcStatus status,
+ * SilcStatus error,
+ * void *context,
+ * va_list ap);
+ *
+ * DESCRIPTION
+ *
+ * The command reply callback function given as argument to functions
+ * silc_client_command_send and silc_client_command_pending. This is
+ * called to deliver the command replies to the caller. Each command
+ * reply received from the server to the `command' will be delivered
+ * separately to the caller by calling this callback. The `status' will
+ * indicate whether there is only one reply or multiple replies. The
+ * `error' will indicate if an error occurred. The `ap' will include
+ * command reply arguments. They are the same arguments as for
+ * `command_reply' client operation in SilcClientOperations.
+ *
+ * If `status' is SILC_STATUS_OK only one reply was received and error
+ * did not occur. If it is SILC_STATUS_LIST_START, SILC_STATUS_LIST_ITEM
+ * or SILC_STATUS_LIST_END, there are will be two or more replies. The
+ * first reply is SILC_STATUS_LIST_START and last one SILC_STATUS_LIST_END.
+ *
+ * If FALSE is returned in this function this callback will not be called
+ * again for `command' even if there are more comand replies. By returning
+ * FALSE the caller my stop the command reply handling when needed.
+ *
+ ***/
typedef SilcBool (*SilcClientCommandReply)(SilcClient client,
SilcClientConnection conn,
SilcCommand command,
* The `reply' callback must be provided, and it is called when the
* command reply is received from the server. Note that, when using this
* function the default `command_reply' client operation will not be
- * called, when reply is received. Note however that, `reply' is almost
- * identical with `command_reply' callback, and application may forward
- * the reply from `reply' to `command_reply' callback, if desired.
+ * called, when reply is received.
*
* Returns command identifier for this sent command. It can be used
* to additionally attach to the command reply using the function
void *context);
-/* Private Message key management (client_prvmsg.c) */
+/* Private Message key management */
/****f* silcclient/SilcClientAPI/silc_client_add_private_message_key
*
SilcUInt32 key_count);
-/* Channel private key management (client_channel.c,
- SilcChannelPrivateKey is defined in idlist.h) */
+/* Channel private key management */
/****f* silcclient/SilcClientAPI/silc_client_add_channel_private_key
*
*
* SYNOPSIS
*
- * void silc_client_set_away_message(SilcClient client,
- * SilcClientConnection conn,
- * char *message);
+ * SilcBool silc_client_set_away_message(SilcClient client,
+ * SilcClientConnection conn,
+ * char *message);
*
* DESCRIPTION
*
* automatically back to the the client who send private message. If
* away message is already set this replaces the old message with the
* new one. If `message' is NULL the old away message is removed.
- * The sender may freely free the memory of the `message'.
+ * The sender may freely free the memory of the `message'. Returns
+ * FALSE on error.
*
***/
-void silc_client_set_away_message(SilcClient client,
- SilcClientConnection conn,
- char *message);
+SilcBool silc_client_set_away_message(SilcClient client,
+ SilcClientConnection conn,
+ char *message);
/****d* silcclient/SilcClientAPI/SilcClientMonitorStatus
*
* File transmission session status types. These will indicate
* the status of the file transmission session.
*
+ * The SILC_CLIENT_FILE_MONITOR_KEY_AGREEMENT is called when session
+ * is key exchange phase.
+ *
+ * The SILC_CLIENT_FILE_MONITOR_SEND is called when data is being sent
+ * to remote client.
+ *
+ * The SILC_CLIENT_FILE_MONITOR_RECEIVE is called when data is being
+ * recieved from remote client.
+ *
+ * The SILC_CLIENT_FILE_MONITOR_CLOSED will be called when the user
+ * issues silc_client_file_close. If needed, it may be ignored in the
+ * monitor callback.
+ *
+ * The SILC_CLIENT_FILE_MONITOR_DISCONNECT will be called if remote
+ * disconnects the session connection. The silc_client_file_close must
+ * be called when this status is received. The session is over when
+ * this is received.
+ *
+ * The SILC_CLIENLT_FILE_MONITOR_ERROR is called in case some error
+ * occured. The SilcClientFileError will indicate more detailed error
+ * condition. The silc_client_file_close must be called when this status
+ * is received. The session is over when this is received.
+ *
* SOURCE
*/
typedef enum {
SILC_CLIENT_FILE_MONITOR_KEY_AGREEMENT, /* In key agreemenet phase */
SILC_CLIENT_FILE_MONITOR_SEND, /* Sending file */
SILC_CLIENT_FILE_MONITOR_RECEIVE, /* Receiving file */
- SILC_CLIENT_FILE_MONITOR_GET,
- SILC_CLIENT_FILE_MONITOR_PUT,
+ SILC_CLIENT_FILE_MONITOR_GET, /* Unsupported */
+ SILC_CLIENT_FILE_MONITOR_PUT, /* Unsupported */
SILC_CLIENT_FILE_MONITOR_CLOSED, /* Session closed */
+ SILC_CLIENT_FILE_MONITOR_DISCONNECT, /* Session disconnected */
SILC_CLIENT_FILE_MONITOR_ERROR, /* Error during session */
} SilcClientMonitorStatus;
/***/
*/
typedef enum {
SILC_CLIENT_FILE_OK,
- SILC_CLIENT_FILE_ERROR,
- SILC_CLIENT_FILE_UNKNOWN_SESSION,
- SILC_CLIENT_FILE_ALREADY_STARTED,
- SILC_CLIENT_FILE_NO_SUCH_FILE,
- SILC_CLIENT_FILE_PERMISSION_DENIED,
- SILC_CLIENT_FILE_KEY_AGREEMENT_FAILED,
+ SILC_CLIENT_FILE_ERROR, /* Generic error */
+ SILC_CLIENT_FILE_UNKNOWN_SESSION, /* Unknown session ID */
+ SILC_CLIENT_FILE_ALREADY_STARTED, /* Session already started */
+ SILC_CLIENT_FILE_NO_SUCH_FILE, /* No such file */
+ SILC_CLIENT_FILE_PERMISSION_DENIED, /* Permission denied */
+ SILC_CLIENT_FILE_KEY_AGREEMENT_FAILED, /* Key exchange failed */
+ SILC_CLIENT_FILE_CONNECT_FAILED, /* Error during connecting */
+ SILC_CLIENT_FILE_TIMEOUT, /* Connecting timedout */
+ SILC_CLIENT_FILE_NO_MEMORY, /* System out of memory */
} SilcClientFileError;
/***/
* currently transmitted amount of total `filesize'. The `client_entry'
* indicates the remote client, and the transmission session ID is the
* `session_id'. The filename being transmitted is indicated by the
- * `filepath'.
+ * `filepath'. The `conn' is NULL if the connection to remote client
+ * does not exist yet.
*
***/
typedef void (*SilcClientFileMonitor)(SilcClient client,
SilcClientFileError
silc_client_file_send(SilcClient client,
SilcClientConnection conn,
+ SilcClientEntry client_entry,
+ SilcClientConnectionParams *params,
+ SilcPublicKey public_key,
+ SilcPrivateKey private_key,
SilcClientFileMonitor monitor,
void *monitor_context,
- const char *local_ip,
- SilcUInt32 local_port,
- SilcBool do_not_bind,
- SilcClientEntry client_entry,
const char *filepath,
SilcUInt32 *session_id);
SilcClientFileError
silc_client_file_receive(SilcClient client,
SilcClientConnection conn,
+ SilcClientConnectionParams *params,
+ SilcPublicKey public_key,
+ SilcPrivateKey private_key,
SilcClientFileMonitor monitor,
void *monitor_context,
const char *path,
SilcClientEntry client_entry,
SilcBool priority);
+/****f* silcclient/SilcClientAPI/silc_client_nickname_parse
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_client_nickname_parse(SilcClient client,
+ * SilcClientConnection conn,
+ * char *nickname,
+ * char **ret_nick);
+ *
+ * DESCRIPTION
+ *
+ * Parses the `nickname' according to the format string given in the
+ * SilcClientParams. Returns the parsed nickname into the `ret_nick'.
+ * The caller must free the returned pointer. Returns FALSE if error
+ * occurred during parsing. Returns TRUE if the nickname was parsed,
+ * it was not formatted or if the format string has not been specified
+ * in SilcClientParams.
+ *
+ ***/
+SilcBool silc_client_nickname_parse(SilcClient client,
+ SilcClientConnection conn,
+ char *nickname,
+ char **ret_nick);
+
#ifdef __cplusplus
}
#endif
projects / silc.git / blobdiff