int64 of at least the xintXX size. If void * is less that 4
bytes uint32 * will be used. Defined bool as boolean.
+ * Changed _ALL_ unsigned long and unsigned int to uint32,
+ unsgined short to uint16 in the source tree.
+
+ * Fixed a fatal bug in silc_server_remove_clients_by_server. Do
+ not handle clients that has entry->data.registered == FALSE.
+ They are not in the network anymore. Affected file is
+ silcd/server.c.
+
Tue Apr 3 16:39:19 EEST 2001 Pekka Riikonen <priikone@poseidon.pspt.fi>
* Implemented the sending of the SERVER_SIGNOFF notify in the
SilcClientEntry client_entry, client_entry2;
SilcChannelEntry channel_entry;
char *tmp = NULL;
- unsigned int tmp_int;
+ uint32 tmp_int;
va_start(vp, type);
case SILC_NOTIFY_TYPE_CMODE_CHANGE:
client_entry = va_arg(vp, SilcClientEntry);
- tmp_int = va_arg(vp, unsigned int);
+ tmp_int = va_arg(vp, uint32);
(void)va_arg(vp, char *);
(void)va_arg(vp, char *);
channel_entry = va_arg(vp, SilcChannelEntry);
case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
client_entry = va_arg(vp, SilcClientEntry);
- tmp_int = va_arg(vp, unsigned int);
+ tmp_int = va_arg(vp, uint32);
tmp = silc_client_chumode(tmp_int);
client_entry2 = va_arg(vp, SilcClientEntry);
channel_entry = va_arg(vp, SilcChannelEntry);
case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
{
SilcClientEntry *clients;
- unsigned int clients_count;
+ uint32 clients_count;
int i;
(void)va_arg(vp, void *);
clients = va_arg(vp, SilcClientEntry *);
- clients_count = va_arg(vp, unsigned int);
+ clients_count = va_arg(vp, uint32);
for (i = 0; i < clients_count; i++) {
if (clients[i]->server)
void silc_client_show_users(SilcClient client,
SilcClientConnection conn,
SilcClientEntry *clients,
- unsigned int clients_count,
+ uint32 clients_count,
void *context)
{
SilcChannelEntry channel = (SilcChannelEntry)context;
{
char buf[1024], *nickname, *username, *realname;
int len;
- unsigned int idle, mode;
+ uint32 idle, mode;
SilcBuffer channels;
if (status == SILC_STATUS_ERR_NO_SUCH_NICK ||
username = va_arg(vp, char *);
realname = va_arg(vp, char *);
channels = va_arg(vp, SilcBuffer);
- mode = va_arg(vp, unsigned int);
- idle = va_arg(vp, unsigned int);
+ mode = va_arg(vp, uint32);
+ idle = va_arg(vp, uint32);
memset(buf, 0, sizeof(buf));
silc_dlist_start(list);
while ((entry = silc_dlist_get(list)) != SILC_LIST_END) {
char *m = silc_client_chumode_char(silc_channel_get_mode(entry));
- unsigned int name_len;
+ uint32 name_len;
char *name = silc_channel_get_name(entry, &name_len);
if (m)
case SILC_COMMAND_JOIN:
{
- unsigned int mode;
+ uint32 mode;
char *topic;
SilcBuffer client_id_list;
- unsigned int list_count;
+ uint32 list_count;
SilcChannelEntry channel;
if (!success)
app->screen->bottom_line->channel = va_arg(vp, char *);
channel = va_arg(vp, SilcChannelEntry);
- mode = va_arg(vp, unsigned int);
- (void)va_arg(vp, unsigned int);
+ mode = va_arg(vp, uint32);
+ (void)va_arg(vp, uint32);
(void)va_arg(vp, unsigned char *);
(void)va_arg(vp, unsigned char *);
(void)va_arg(vp, unsigned char *);
topic = va_arg(vp, char *);
(void)va_arg(vp, unsigned char *);
- list_count = va_arg(vp, unsigned int);
+ list_count = va_arg(vp, uint32);
client_id_list = va_arg(vp, SilcBuffer);
if (topic)
case SILC_COMMAND_LIST:
{
char *topic, *name;
- unsigned int usercount;
+ int usercount;
unsigned char buf[256], tmp[16];
int i, len;
(void)va_arg(vp, SilcChannelEntry);
name = va_arg(vp, char *);
topic = va_arg(vp, char *);
- usercount = va_arg(vp, unsigned int);
+ usercount = va_arg(vp, int);
if (status == SILC_STATUS_LIST_START ||
status == SILC_STATUS_OK)
case SILC_COMMAND_UMODE:
{
- unsigned int mode;
+ uint32 mode;
if (!success)
return;
- mode = va_arg(vp, unsigned int);
+ mode = va_arg(vp, uint32);
if (!mode && app->screen->bottom_line->umode) {
silc_free(app->screen->bottom_line->umode);
int silc_verify_public_key(SilcClient client,
SilcClientConnection conn,
SilcSocketType conn_type,
- unsigned char *pk, unsigned int pk_len,
+ unsigned char *pk, uint32 pk_len,
SilcSKEPKType pk_type)
{
SilcSocketConnection sock = conn->sock;
/* The key already exists, verify it. */
SilcPublicKey public_key;
unsigned char *encpk;
- unsigned int encpk_len;
+ uint32 encpk_len;
/* Load the key file */
if (!silc_pkcs_load_public_key(filename, &public_key,
is found and FALSE if not. `conn' may be NULL. */
int silc_get_auth_method(SilcClient client, SilcClientConnection conn,
- char *hostname, unsigned short port,
+ char *hostname, uint16 port,
SilcProtocolAuthMeth *auth_meth,
unsigned char **auth_data,
- unsigned int *auth_data_len)
+ uint32 *auth_data_len)
{
SilcClientInternal app = (SilcClientInternal)client->application;
unsigned char *silc_ask_passphrase(SilcClient client,
SilcClientConnection conn);
int silc_verify_server_key(SilcClient client, SilcClientConnection conn,
- unsigned char *pk, unsigned int pk_len,
+ unsigned char *pk, uint32 pk_len,
SilcSKEPKType pk_type);
int silc_get_auth_method(SilcClient client, SilcClientConnection conn,
- char *hostname, unsigned short port,
+ char *hostname, uint16 port,
SilcProtocolAuthMeth *auth_meth,
unsigned char **auth_data,
- unsigned int *auth_data_len);
+ uint32 *auth_data_len);
void silc_failure(SilcClient client, SilcClientConnection conn,
SilcProtocol protocol, void *failure);
int silc_key_agreement(SilcClient client, SilcClientConnection conn,
SilcClientConfigParse *return_config)
{
int i, begin;
- int linenum;
+ uint32 linenum;
char line[1024], *cp;
SilcClientConfigSection *cptr = NULL;
SilcClientConfigParse parse = *return_config, first = NULL;
typedef struct SilcClientConfigSectionAlgStruct {
char *alg_name;
char *sim_name;
- unsigned int block_len;
- unsigned int key_len;
+ uint32 block_len;
+ uint32 key_len;
struct SilcClientConfigSectionAlgStruct *next;
struct SilcClientConfigSectionAlgStruct *prev;
#define SILC_CLIENT_CONFIG_MODNAME "builtin"
char *host;
int auth_meth;
char *auth_data;
- unsigned short port;
+ uint16 port;
struct SilcClientConfigSectionConnectionStruct *next;
struct SilcClientConfigSectionConnectionStruct *prev;
#define SILC_CLIENT_CONFIG_AUTH_METH_PASSWD "passwd"
typedef struct {
const char *section;
SilcClientConfigSectionType type;
- unsigned int maxfields;
+ int maxfields;
} SilcClientConfigSection;
/* List of all possible config sections in SILC client */
from a file to this structure before parsing it further. */
typedef struct SilcClientConfigParseStruct {
SilcBuffer line;
- unsigned int linenum;
+ int linenum;
SilcClientConfigSection *section;
struct SilcClientConfigParseStruct *next;
struct SilcClientConfigParseStruct *prev;
SilcClientConfigParse *return_config);
int silc_client_config_parse_lines(SilcClientConfig config,
SilcClientConfigParse parse_config);
-int silc_client_config_check_sections(unsigned int checkmask);
+int silc_client_config_check_sections(uint32 checkmask);
void silc_client_config_setlogfiles(SilcClientConfig config);
void silc_client_config_register_ciphers(SilcClientConfig config);
void silc_client_config_register_pkcs(SilcClientConfig config);
SilcPrivateKey prv_key;
SilcRng rng;
unsigned char *key;
- unsigned int key_len;
+ uint32 key_len;
char line[256];
char *pkfile = NULL, *prvfile = NULL;
SilcClientConnection conn = cmd->conn;
SilcClient client = cmd->client;
SilcClientEntry client_entry = NULL;
- unsigned int num = 0;
+ uint32 num = 0;
char *nickname = NULL, *server = NULL;
if (!cmd->conn) {
SilcClient client = cmd->client;
SilcClientEntry client_entry = NULL;
SilcChannelEntry channel_entry = NULL;
- unsigned int num = 0;
+ uint32 num = 0;
char *nickname = NULL, *server = NULL;
int command = 0, port = 0, type = 0;
char *hostname = NULL;
} else if (type == 2) {
/* Unset channel key(s) */
SilcChannelPrivateKey *keys;
- unsigned int keys_count;
+ uint32 keys_count;
int number;
if (cmd->argc == 4)
if (type == 1) {
SilcPrivateMessageKeys keys;
- unsigned int keys_count;
+ uint32 keys_count;
int k, i, len;
char buf[1024];
silc_client_free_private_message_keys(keys, keys_count);
} else if (type == 2) {
SilcChannelPrivateKey *keys;
- unsigned int keys_count;
+ uint32 keys_count;
int k, i, len;
char buf[1024];
/* Output windows */
WINDOW **output_win;
WINDOW **output_stat_line;
- unsigned int output_win_count;
+ uint32 output_win_count;
/* Input window at the bottom of the screen */
WINDOW *input_win;
unsigned char *input_buffer;
- unsigned int input_pos;
- unsigned int input_end;
- unsigned int cursor_pos;
+ uint32 input_pos;
+ uint32 input_end;
+ uint32 cursor_pos;
int virtual_window;
/* Bottom line on screen */
static void silc_client_process_message(SilcClientInternal app)
{
unsigned char *data;
- unsigned int len;
+ uint32 len;
SILC_LOG_DEBUG(("Start"));
if (data[0] == '/' && data[1] != ' ') {
/* Command */
- unsigned int argc = 0;
+ uint32 argc = 0;
unsigned char **argv, *tmpcmd;
- unsigned int *argv_lens, *argv_types;
+ uint32 *argv_lens, *argv_types;
SilcClientCommand *cmd;
SilcClientCommandContext ctx;
cs = app->config->commands;
while(cs) {
- unsigned int argc = 0;
+ uint32 argc = 0;
unsigned char **argv, *tmpcmd;
- unsigned int *argv_lens, *argv_types;
+ uint32 *argv_lens, *argv_types;
SilcClientCommand *cmd;
SilcClientCommandContext ctx;
#ifdef SILC_SIM
/* SIM (SILC Module) table */
SilcSimContext **sim;
- unsigned int sim_count;
+ uint32 sim_count;
#endif
/* The allocated client */
silc_server_command_send_status_data(SilcServerCommandContext cmd,
SilcCommand command,
SilcCommandStatus status,
- unsigned int arg_type,
+ uint32 arg_type,
unsigned char *arg,
- unsigned int arg_len);
+ uint32 arg_len);
SILC_TASK_CALLBACK(silc_server_command_process_timeout);
/* Server command list. */
#define SILC_SERVER_COMMAND_CHECK_ARGC(command, context, min, max) \
do { \
- unsigned int _argc = silc_argument_get_arg_num(cmd->args); \
+ uint32 _argc = silc_argument_get_arg_num(cmd->args); \
\
SILC_LOG_DEBUG(("Start")); \
\
void silc_server_command_pending(SilcServer server,
SilcCommand reply_cmd,
- unsigned short ident,
+ uint16 ident,
SilcServerPendingDestructor destructor,
SilcCommandCb callback,
void *context)
void silc_server_command_pending_del(SilcServer server,
SilcCommand reply_cmd,
- unsigned short ident)
+ uint16 ident)
{
SilcServerCommandPending *r;
int silc_server_command_pending_check(SilcServer server,
SilcServerCommandReplyContext ctx,
SilcCommand command,
- unsigned short ident)
+ uint16 ident)
{
SilcServerCommandPending *r;
silc_server_command_send_status_data(SilcServerCommandContext cmd,
SilcCommand command,
SilcCommandStatus status,
- unsigned int arg_type,
+ uint32 arg_type,
unsigned char *arg,
- unsigned int arg_len)
+ uint32 arg_len)
{
SilcBuffer buffer;
static int
silc_server_command_whois_parse(SilcServerCommandContext cmd,
SilcClientID ***client_id,
- unsigned int *client_id_count,
+ uint32 *client_id_count,
char **nickname,
char **server_name,
int *count,
SilcCommand command)
{
unsigned char *tmp;
- unsigned int len;
- unsigned int argc = silc_argument_get_arg_num(cmd->args);
+ uint32 len;
+ uint32 argc = silc_argument_get_arg_num(cmd->args);
int i, k;
/* If client ID is in the command it must be used instead of nickname */
static char
silc_server_command_whois_check(SilcServerCommandContext cmd,
SilcClientEntry *clients,
- unsigned int clients_count)
+ uint32 clients_count)
{
SilcServer server = cmd->server;
int i;
if (!entry->nickname || !entry->username || !entry->userinfo) {
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
if (!entry->router)
continue;
static void
silc_server_command_whois_send_reply(SilcServerCommandContext cmd,
SilcClientEntry *clients,
- unsigned int clients_count,
+ uint32 clients_count,
int count)
{
SilcServer server = cmd->server;
SilcBuffer packet, idp, channels;
SilcClientEntry entry;
SilcCommandStatus status;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint16 ident = silc_command_get_ident(cmd->payload);
char nh[128], uh[128];
unsigned char idle[4], mode[4];
SilcSocketConnection hsock;
{
SilcServer server = cmd->server;
char *nick = NULL, *server_name = NULL;
- int count = 0, clients_count = 0;
+ int count = 0;
SilcClientEntry *clients = NULL, entry;
SilcClientID **client_id = NULL;
- unsigned int client_id_count = 0;
+ uint32 client_id_count = 0, clients_count = 0;
int i, ret = 0;
/* Protocol dictates that we must always send the received WHOIS request
if (server->server_type == SILC_SERVER && !cmd->pending &&
!server->standalone) {
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
{
SilcServer server = cmd->server;
char *nick = NULL, *server_name = NULL;
- int count = 0, clients_count = 0;
+ int count = 0;
SilcClientEntry *clients = NULL, entry;
SilcClientID **client_id = NULL;
- unsigned int client_id_count = 0;
+ uint32 client_id_count = 0, clients_count = 0;
int i, ret = 0;
/* Parse the whois request */
int *count)
{
unsigned char *tmp;
- unsigned int len;
+ uint32 len;
tmp = silc_argument_get_arg_type(cmd->args, 1, &len);
if (!tmp) {
static char
silc_server_command_whowas_check(SilcServerCommandContext cmd,
SilcClientEntry *clients,
- unsigned int clients_count)
+ uint32 clients_count)
{
SilcServer server = cmd->server;
int i;
if (!entry->nickname || !entry->username) {
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
if (!entry->router)
continue;
static void
silc_server_command_whowas_send_reply(SilcServerCommandContext cmd,
SilcClientEntry *clients,
- unsigned int clients_count)
+ uint32 clients_count)
{
SilcServer server = cmd->server;
char *tmp;
SilcBuffer packet, idp;
SilcClientEntry entry = NULL;
SilcCommandStatus status;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint16 ident = silc_command_get_ident(cmd->payload);
char found = FALSE;
char nh[256], uh[256];
{
SilcServer server = cmd->server;
char *nick = NULL, *server_name = NULL;
- int count = 0, clients_count = 0;
+ int count = 0;
SilcClientEntry *clients = NULL;
+ uint32 clients_count = 0;
int ret = 0;
/* Protocol dictates that we must always send the received WHOWAS request
if (server->server_type == SILC_SERVER &&
!cmd->pending && !server->standalone) {
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
{
SilcServer server = cmd->server;
char *nick = NULL, *server_name = NULL;
- int count = 0, clients_count = 0;
+ int count = 0;
SilcClientEntry *clients = NULL;
+ uint32 clients_count = 0;
int ret = 0;
/* Parse the whowas request */
static char
silc_server_command_identify_check(SilcServerCommandContext cmd,
SilcClientEntry *clients,
- unsigned int clients_count)
+ uint32 clients_count)
{
SilcServer server = cmd->server;
int i;
if (!entry->nickname) {
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
if (!entry->router)
continue;
static void
silc_server_command_identify_send_reply(SilcServerCommandContext cmd,
SilcClientEntry *clients,
- unsigned int clients_count,
+ uint32 clients_count,
int count)
{
SilcServer server = cmd->server;
SilcBuffer packet, idp;
SilcClientEntry entry;
SilcCommandStatus status;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint16 ident = silc_command_get_ident(cmd->payload);
char nh[256], uh[256];
SilcSocketConnection hsock;
{
SilcServer server = cmd->server;
char *nick = NULL, *server_name = NULL;
- int count = 0, clients_count = 0;
+ int count = 0;
SilcClientEntry *clients = NULL, entry;
SilcClientID **client_id = NULL;
- unsigned int client_id_count = 0;
+ uint32 client_id_count = 0, clients_count = 0;
int i, ret = 0;
/* Protocol dictates that we must always send the received IDENTIFY request
if (server->server_type == SILC_SERVER &&
!cmd->pending && !server->standalone) {
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
{
SilcServer server = cmd->server;
char *nick = NULL, *server_name = NULL;
- int count = 0, clients_count = 0;
+ int count = 0;
SilcClientEntry *clients = NULL, entry;
SilcClientID **client_id = NULL;
- unsigned int client_id_count = 0;
+ uint32 client_id_count = 0, clients_count = 0;
int i, ret = 0;
/* Parse the IDENTIFY request */
SilcBuffer packet, nidp, oidp;
SilcClientID *new_id;
char *nick;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint16 ident = silc_command_get_ident(cmd->payload);
if (cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
static void
silc_server_command_list_send_reply(SilcServerCommandContext cmd,
SilcChannelEntry *lch,
- unsigned int lch_count,
+ uint32 lch_count,
SilcChannelEntry *gch,
- unsigned int gch_count)
+ uint32 gch_count)
{
int i;
SilcBuffer packet, idp;
SilcChannelEntry entry;
SilcCommandStatus status;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint16 ident = silc_command_get_ident(cmd->payload);
char *topic;
unsigned char usercount[4];
- unsigned int users;
+ uint32 users;
for (i = 0; i < lch_count; i++)
if (lch[i]->mode & SILC_CHANNEL_MODE_SECRET)
SilcServer server = cmd->server;
SilcChannelID *channel_id = NULL;
unsigned char *tmp;
- unsigned int tmp_len;
+ uint32 tmp_len;
SilcChannelEntry *lchannels = NULL, *gchannels = NULL;
- unsigned int lch_count = 0, gch_count = 0;
+ uint32 lch_count = 0, gch_count = 0;
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_LIST, cmd, 0, 2);
SilcChannelClientEntry chl;
SilcBuffer packet, idp;
unsigned char *tmp;
- unsigned int argc, tmp_len;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint32 argc, tmp_len;
+ uint16 ident = silc_command_get_ident(cmd->payload);
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_TOPIC, cmd, 1, 2);
SilcIDListData idata;
SilcBuffer idp, idp2, packet;
unsigned char *tmp, *add, *del;
- unsigned int len;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint32 len;
+ uint16 ident = silc_command_get_ident(cmd->payload);
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_INVITE, cmd, 1, 4);
SilcSocketConnection sock = cmd->sock;
QuitInternal q;
unsigned char *tmp = NULL;
- unsigned int len = 0;
+ uint32 len = 0;
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_QUIT, cmd, 0, 1);
SilcClientEntry remote_client;
SilcClientID *client_id;
unsigned char *tmp, *comment;
- unsigned int tmp_len, tmp_len2;
+ uint32 tmp_len, tmp_len2;
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_KILL, cmd, 1, 2);
SilcServer server = cmd->server;
SilcBuffer packet, idp;
unsigned char *tmp;
- unsigned int tmp_len;
+ uint32 tmp_len;
char *dest_server, *server_info = NULL, *server_name;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint16 ident = silc_command_get_ident(cmd->payload);
SilcServerEntry entry = NULL;
SilcServerID *server_id = NULL;
server->server_type == SILC_ROUTER && entry && !entry->server_info) {
/* Send to the server */
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
if (!entry && !cmd->pending && !server->standalone) {
/* Send to the primary router */
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
SilcServerID *id;
- unsigned int len;
+ uint32 len;
unsigned char *tmp;
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_INFO, cmd, 1, 2);
SilcChannelEntry channel,
SilcClientID *client_id,
int created,
- unsigned int umode)
+ uint32 umode)
{
SilcSocketConnection sock = cmd->sock;
unsigned char *tmp;
- unsigned int tmp_len, user_count;
+ uint32 tmp_len, user_count;
unsigned char *passphrase = NULL, mode[4], tmp2[4], tmp3[4];
SilcClientEntry client;
SilcChannelClientEntry chl;
SilcBuffer reply, chidp, clidp, keyp = NULL, user_list, mode_list;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint16 ident = silc_command_get_ident(cmd->payload);
char check[512];
SILC_LOG_DEBUG(("Start"));
{
SilcServerCommandContext cmd = (SilcServerCommandContext)context;
SilcServer server = cmd->server;
- int tmp_len;
+ uint32 tmp_len;
char *tmp, *channel_name = NULL, *cipher, *hmac;
SilcChannelEntry channel;
- unsigned int umode = 0;
+ uint32 umode = 0;
int created = FALSE;
SilcClientID *client_id;
or joins the client to it). */
if (server->server_type == SILC_SERVER) {
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
SilcServer server = cmd->server;
SilcBuffer packet, idp;
char *motd, *dest_server;
- int motd_len;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint32 motd_len;
+ uint16 ident = silc_command_get_ident(cmd->payload);
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_MOTD, cmd, 1, 1);
entry && !entry->motd) {
/* Send to the server */
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
if (!entry && !cmd->pending && !server->standalone) {
/* Send to the primary router */
SilcBuffer tmpbuf;
- unsigned short old_ident;
+ uint16 old_ident;
old_ident = silc_command_get_ident(cmd->payload);
silc_command_set_ident(cmd->payload, silc_rng_get_rn16(server->rng));
SilcClientEntry client = (SilcClientEntry)cmd->sock->user_data;
SilcBuffer packet;
unsigned char *tmp_mask;
- unsigned int mask;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint32 mask;
+ uint16 ident = silc_command_get_ident(cmd->payload);
if (cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
int silc_server_check_cmode_rights(SilcChannelEntry channel,
SilcChannelClientEntry client,
- unsigned int mode)
+ uint32 mode)
{
int is_op = client->mode & SILC_CHANNEL_UMODE_CHANOP;
int is_fo = client->mode & SILC_CHANNEL_UMODE_CHANFO;
SilcBuffer packet, cidp;
unsigned char *tmp, *tmp_id, *tmp_mask;
char *cipher = NULL, *hmac = NULL;
- unsigned int mode_mask, tmp_len, tmp_len2;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint32 mode_mask, tmp_len, tmp_len2;
+ uint16 ident = silc_command_get_ident(cmd->payload);
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_CMODE, cmd, 2, 7);
if (mode_mask & SILC_CHANNEL_MODE_ULIMIT) {
/* User limit is set on channel */
- unsigned int user_limit;
+ uint32 user_limit;
/* Get user limit */
tmp = silc_argument_get_arg_type(cmd->args, 3, NULL);
SilcChannelClientEntry chl;
SilcBuffer packet, idp;
unsigned char *tmp_id, *tmp_ch_id, *tmp_mask;
- unsigned int target_mask, sender_mask = 0, tmp_len, tmp_ch_len;
+ uint32 target_mask, sender_mask = 0, tmp_len, tmp_ch_len;
int notify = FALSE;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint16 ident = silc_command_get_ident(cmd->payload);
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_CUMODE, cmd, 3, 4);
if (target_mask & SILC_CHANNEL_UMODE_CHANFO) {
/* The client tries to claim the founder rights. */
unsigned char *tmp_auth;
- unsigned int tmp_auth_len, auth_len;
+ uint32 tmp_auth_len, auth_len;
void *auth;
if (target_client != client) {
SilcChannelEntry channel;
SilcChannelClientEntry chl;
SilcBuffer idp;
- unsigned int tmp_len;
+ uint32 tmp_len;
unsigned char *tmp, *comment;
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_LEAVE, cmd, 1, 3);
SilcServer server = cmd->server;
SilcClientEntry client = (SilcClientEntry)cmd->sock->user_data;
unsigned char *username, *auth;
- unsigned int tmp_len;
+ uint32 tmp_len;
SilcServerConfigSectionAdminConnection *admin;
SilcIDListData idata = (SilcIDListData)client;
SilcServer server = cmd->server;
SilcClientEntry client = (SilcClientEntry)cmd->sock->user_data;
unsigned char *username, *auth;
- unsigned int tmp_len;
+ uint32 tmp_len;
SilcServerConfigSectionAdminConnection *admin;
SilcIDListData idata = (SilcIDListData)client;
SilcServer server = cmd->server;
SilcClientEntry client = (SilcClientEntry)cmd->sock->user_data;
unsigned char *tmp, *host;
- unsigned int tmp_len;
- unsigned int port = SILC_PORT;
+ uint32 tmp_len;
+ uint32 port = SILC_PORT;
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_CONNECT, cmd, 1, 2);
SilcChannelClientEntry chl;
SilcChannelID *channel_id = NULL;
unsigned char *id, *add, *del;
- unsigned int id_len, tmp_len;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint32 id_len, tmp_len;
+ uint16 ident = silc_command_get_ident(cmd->payload);
if (cmd->sock->type != SILC_SOCKET_TYPE_CLIENT)
goto out;
SilcServerEntry server_entry;
SilcSocketConnection sock;
unsigned char *tmp;
- unsigned int tmp_len;
+ uint32 tmp_len;
unsigned char *name;
- unsigned int port = SILC_PORT;
+ uint32 port = SILC_PORT;
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_CLOSE, cmd, 1, 2);
SilcClientEntry id_entry = (SilcClientEntry)cmd->sock->user_data;
SilcChannelID *id = NULL;
SilcChannelEntry channel;
- unsigned int len;
+ uint32 len;
unsigned char *tmp;
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_LEAVE, cmd, 1, 2);
SilcChannelID *id;
SilcBuffer packet;
unsigned char *channel_id;
- unsigned int channel_id_len;
+ uint32 channel_id_len;
SilcBuffer client_id_list;
SilcBuffer client_mode_list;
unsigned char lc[4];
- unsigned int list_count = 0;
- unsigned short ident = silc_command_get_ident(cmd->payload);
+ uint32 list_count = 0;
+ uint16 ident = silc_command_get_ident(cmd->payload);
SILC_SERVER_COMMAND_CHECK_ARGC(SILC_COMMAND_USERS, cmd, 1, 1);
SilcCommandCb callback;
SilcServerPendingDestructor destructor;
void *context;
- unsigned short ident;
+ uint16 ident;
struct SilcServerCommandPendingStruct *next;
} SilcServerCommandPending;
silc_server_command_dup(SilcServerCommandContext ctx);
void silc_server_command_pending(SilcServer server,
SilcCommand reply_cmd,
- unsigned short ident,
+ uint16 ident,
SilcServerPendingDestructor destructor,
SilcCommandCb callback,
void *context);
void silc_server_command_pending_del(SilcServer server,
SilcCommand reply_cmd,
- unsigned short ident);
+ uint16 ident);
int silc_server_command_pending_check(SilcServer server,
SilcServerCommandReplyContext ctx,
SilcCommand command,
- unsigned short ident);
+ uint16 ident);
SILC_SERVER_CMD_FUNC(whois);
SILC_SERVER_CMD_FUNC(whowas);
SILC_SERVER_CMD_FUNC(identify);
SilcServerCommandReplyContext ctx;
SilcCommandPayload payload;
SilcCommand command;
- unsigned short ident;
+ uint16 ident;
SILC_LOG_DEBUG(("Start"));
silc_server_command_reply_whois_save(SilcServerCommandReplyContext cmd)
{
SilcServer server = cmd->server;
- int len, id_len;
unsigned char *tmp, *id_data;
char *nickname, *username, *realname;
SilcClientID *client_id;
SilcIDCacheEntry cache = NULL;
char global = FALSE;
char *nick;
- unsigned int mode = 0;
+ uint32 mode = 0, len, id_len;
id_data = silc_argument_get_arg_type(cmd->args, 2, &id_len);
nickname = silc_argument_get_arg_type(cmd->args, 3, &len);
silc_server_command_reply_whowas_save(SilcServerCommandReplyContext cmd)
{
SilcServer server = cmd->server;
- int len, id_len;
+ uint32 len, id_len;
unsigned char *id_data;
char *nickname, *username, *realname;
SilcClientID *client_id;
silc_server_command_reply_identify_save(SilcServerCommandReplyContext cmd)
{
SilcServer server = cmd->server;
- int len, id_len;
+ uint32 len, id_len;
unsigned char *id_data;
char *nickname, *username;
SilcClientID *client_id;
SilcCommandStatus status;
SilcServerEntry entry;
SilcServerID *server_id;
- unsigned int tmp_len;
+ uint32 tmp_len;
unsigned char *tmp, *name;
COMMAND_CHECK_STATUS;
SilcCommandStatus status;
SilcServerEntry entry = NULL;
SilcServerID *server_id;
- unsigned int tmp_len;
+ uint32 tmp_len;
unsigned char *tmp;
COMMAND_CHECK_STATUS;
SilcClientID *client_id = NULL;
SilcChannelEntry entry;
SilcHmac hmac = NULL;
- unsigned int id_len, len, list_count;
+ uint32 id_len, len, list_count;
unsigned char *id_string;
char *channel_name, *tmp;
- unsigned int mode, created;
+ uint32 mode, created;
SilcBuffer keyp = NULL, client_id_list = NULL, client_mode_list = NULL;
COMMAND_CHECK_STATUS;
SilcBuffer client_id_list;
SilcBuffer client_mode_list;
unsigned char *tmp;
- unsigned int tmp_len;
- unsigned int list_count;
+ uint32 tmp_len;
+ uint32 list_count;
COMMAND_CHECK_STATUS;
SilcServerPendingDestructor destructor;
SilcCommandCb callback;
void *context;
- unsigned short ident;
+ uint16 ident;
} *SilcServerCommandReplyContext;
/* Macros */
SilcClientEntry
silc_idlist_add_client(SilcIDList id_list, unsigned char *nickname,
- unsigned int nickname_len, char *username,
+ uint32 nickname_len, char *username,
char *userinfo, SilcClientID *id,
SilcServerEntry router, void *connection)
{
int silc_idlist_get_clients_by_nickname(SilcIDList id_list, char *nickname,
char *server,
SilcClientEntry **clients,
- unsigned int *clients_count)
+ uint32 *clients_count)
{
SilcIDCacheList list = NULL;
SilcIDCacheEntry id_cache = NULL;
int silc_idlist_get_clients_by_hash(SilcIDList id_list, char *nickname,
SilcHash md5hash,
SilcClientEntry **clients,
- unsigned int *clients_count)
+ uint32 *clients_count)
{
SilcIDCacheList list = NULL;
SilcIDCacheEntry id_cache = NULL;
SilcChannelEntry *
silc_idlist_get_channels(SilcIDList id_list, SilcChannelID *channel_id,
- unsigned int *channels_count)
+ uint32 *channels_count)
{
SilcIDCacheList list = NULL;
SilcIDCacheEntry id_cache = NULL;
typedef struct {
void *context;
SilcChannelEntry channel;
- unsigned int key_len;
+ uint32 key_len;
} *SilcServerChannelRekey;
/*
/* HMAC and raw key data */
SilcHmac hmac;
unsigned char *hmac_key;
- unsigned int hmac_key_len;
+ uint32 hmac_key_len;
/* public key */
SilcPublicKey public_key;
Pointer to the client list. This is the client currently on channel.
- unsigned int mode
+ uint32 mode
Client's current mode on the channel.
*/
typedef struct SilcChannelClientEntryStruct {
SilcClientEntry client;
- unsigned int mode;
+ uint32 mode;
SilcChannelEntry channel;
struct SilcChannelClientEntryStruct *client_list;
struct SilcChannelClientEntryStruct *channel_list;
Logical name of the channel.
- unsigned int mode
+ uint32 mode
Current mode of the channel. See lib/silccore/silcchannel.h for
all modes.
SilcPublicKey founder_key
SilcAuthMethod founder_method
unsigned char *founder_passwd
- unsigned int founder_passwd_len
+ uint32 founder_passwd_len
If the SILC_CMODE_FOUNDER_AUTH has been set then these will include
the founder's public key, authentication method and the password
The key of the channel (the cipher actually).
unsigned char *key
- unsigned int key_len
+ uint32 key_len
Raw key data of the channel key.
*/
struct SilcChannelEntryStruct {
char *channel_name;
- unsigned int mode;
+ uint32 mode;
SilcChannelID *id;
int global_users;
char *topic;
SilcPublicKey founder_key;
SilcAuthMethod founder_method;
unsigned char *founder_passwd;
- unsigned int founder_passwd_len;
+ uint32 founder_passwd_len;
- unsigned int user_limit;
+ uint32 user_limit;
unsigned char *passphrase;
char *invite_list;
char *ban_list;
/* Channel keys */
SilcCipher channel_key;
unsigned char *key;
- unsigned int key_len;
+ uint32 key_len;
unsigned char iv[SILC_CIPHER_MAX_IV_SIZE];
SilcHmac hmac;
int silc_idlist_del_server(SilcIDList id_list, SilcServerEntry entry);
SilcClientEntry
silc_idlist_add_client(SilcIDList id_list, unsigned char *nickname,
- unsigned int nickname_len, char *username,
+ uint32 nickname_len, char *username,
char *userinfo, SilcClientID *id,
SilcServerEntry router, void *connection);
int silc_idlist_del_client(SilcIDList id_list, SilcClientEntry entry);
int silc_idlist_get_clients_by_nickname(SilcIDList id_list, char *nickname,
char *server,
SilcClientEntry **clients,
- unsigned int *clients_count);
+ uint32 *clients_count);
int silc_idlist_get_clients_by_hash(SilcIDList id_list, char *nickname,
SilcHash md5hash,
SilcClientEntry **clients,
- unsigned int *clients_count);
+ uint32 *clients_count);
SilcClientEntry
silc_idlist_find_client_by_hash(SilcIDList id_list, char *nickname,
SilcHash md5hash, SilcIDCacheEntry *ret_entry);
SilcChannelID *new_id);
SilcChannelEntry *
silc_idlist_get_channels(SilcIDList id_list, SilcChannelID *channel_id,
- unsigned int *channels_count);
+ uint32 *channels_count);
#endif
SilcServerEntry server_entry;
SilcChannelClientEntry chl;
SilcIDCacheEntry cache;
- unsigned int mode;
+ uint32 mode;
unsigned char *tmp;
- unsigned int tmp_len;
+ uint32 tmp_len;
SILC_LOG_DEBUG(("Start"));
* Distribute the notify to local clients on channels
*/
unsigned char *id;
- unsigned int id_len;
+ uint32 id_len;
SILC_LOG_DEBUG(("KILLED notify"));
{
SilcPacketContext *new;
SilcBuffer buffer;
- unsigned short len;
+ uint16 len;
SILC_LOG_DEBUG(("Processing New Notify List"));
sock->type == SILC_SOCKET_TYPE_ROUTER &&
!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
SilcBuffer chp;
- unsigned int iv_len, i;
- unsigned short data_len, flags;
+ uint32 iv_len, i;
+ uint16 data_len, flags;
iv_len = silc_cipher_get_block_len(channel->channel_key);
if (channel->iv[0] == '\0')
SilcServerID *server_id;
SilcIDListData idata;
unsigned char *server_name, *id_string;
- unsigned short id_len, name_len;
+ uint16 id_len, name_len;
int ret;
SILC_LOG_DEBUG(("Creating new server"));
{
SilcPacketContext *new_id;
SilcBuffer idp;
- unsigned short id_len;
+ uint16 id_len;
SILC_LOG_DEBUG(("Processing New ID List"));
SilcChannelPayload payload;
SilcChannelID *channel_id;
char *channel_name;
- unsigned int name_len;
+ uint32 name_len;
unsigned char *id;
- unsigned int id_len;
- unsigned int mode;
+ uint32 id_len;
+ uint32 mode;
SILC_LOG_DEBUG(("Processing New Channel"));
{
SilcPacketContext *new;
SilcBuffer buffer;
- unsigned short len1, len2;
+ uint16 len1, len2;
SILC_LOG_DEBUG(("Processing New Channel List"));
SilcPacketContext *packet)
{
SilcServerConfigSectionClientConnection *client = NULL;
- unsigned short conn_type;
+ uint16 conn_type;
int ret;
SilcAuthMethod auth_meth;
SilcPacketType type,
SilcPacketFlags flags,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send)
{
void *dst_id = NULL;
void *dst_id,
SilcIdType dst_id_type,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send)
{
SilcPacketContext packetdata;
SilcCipher cipher = NULL;
SilcHmac hmac = NULL;
unsigned char *dst_id_data = NULL;
- unsigned int dst_id_len = 0;
+ uint32 dst_id_len = 0;
SILC_LOG_DEBUG(("Sending packet, type %d", type));
void *dst_id,
SilcIdType dst_id_type,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send)
{
SilcPacketContext packetdata;
SilcCipher cipher = NULL;
SilcHmac hmac = NULL;
unsigned char *dst_id_data = NULL;
- unsigned int dst_id_len = 0;
+ uint32 dst_id_len = 0;
unsigned char *src_id_data = NULL;
- unsigned int src_id_len = 0;
+ uint32 src_id_len = 0;
SILC_LOG_DEBUG(("Sending packet, type %d", type));
SilcCipher cipher,
SilcHmac hmac,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int channel_message,
int force_send)
{
SilcPacketType type,
unsigned char route,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send)
{
SilcSocketConnection sock = NULL;
SilcServerEntry *routed = NULL;
SilcChannelClientEntry chl;
SilcIDListData idata;
- unsigned int routed_count = 0;
+ uint32 routed_count = 0;
/* This doesn't send channel message packets */
if (type == SILC_PACKET_CHANNEL_MESSAGE)
void *sender,
SilcIdType sender_type,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send)
{
int found = FALSE;
SilcClientEntry client = NULL;
SilcServerEntry *routed = NULL;
SilcChannelClientEntry chl;
- unsigned int routed_count = 0;
+ uint32 routed_count = 0;
SilcIDListData idata;
SILC_LOG_DEBUG(("Relaying packet to channel"));
SilcPacketType type,
SilcPacketFlags flags,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send)
{
SilcChannelClientEntry chl;
SilcSocketConnection sock)
{
char *motd;
- int motd_len;
+ uint32 motd_len;
if (server->config && server->config->motd &&
server->config->motd->motd_file) {
SilcSocketConnection sock,
int broadcast,
SilcNotifyType type,
- unsigned int argc, ...)
+ uint32 argc, ...)
{
va_list ap;
SilcBuffer packet;
SilcSocketConnection sock,
int broadcast,
SilcNotifyType type,
- unsigned int argc,
+ uint32 argc,
SilcBuffer args)
{
SilcBuffer packet;
int broadcast,
SilcChannelID *old_id,
SilcChannelID *new_id,
- unsigned int id_len)
+ uint32 id_len)
{
SilcBuffer idp1, idp2;
int broadcast,
SilcClientID *old_id,
SilcClientID *new_id,
- unsigned int id_len)
+ uint32 id_len)
{
SilcBuffer idp1, idp2;
int broadcast,
SilcChannelEntry channel,
SilcClientID *client_id,
- unsigned int client_id_len)
+ uint32 client_id_len)
{
SilcBuffer idp1, idp2;
int broadcast,
SilcChannelEntry channel,
SilcClientID *client_id,
- unsigned int client_id_len)
+ uint32 client_id_len)
{
SilcBuffer idp;
SilcSocketConnection sock,
int broadcast,
SilcChannelEntry channel,
- unsigned int mode_mask,
+ uint32 mode_mask,
void *id, SilcIdType id_type,
- unsigned int id_len,
+ uint32 id_len,
char *cipher, char *hmac)
{
SilcBuffer idp;
SilcSocketConnection sock,
int broadcast,
SilcChannelEntry channel,
- unsigned int mode_mask,
+ uint32 mode_mask,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
SilcClientID *target,
- unsigned int target_len)
+ uint32 target_len)
{
SilcBuffer idp1, idp2;
unsigned char mode[4];
SilcSocketConnection sock,
int broadcast,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
char *message)
{
SilcBuffer idp;
int broadcast,
SilcChannelEntry channel,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
char *topic)
{
SilcBuffer idp;
int broadcast,
SilcChannelEntry channel,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
char *comment)
{
SilcBuffer idp;
SilcSocketConnection sock,
int broadcast,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
char *comment)
{
SilcBuffer idp;
SilcSocketConnection sock,
int broadcast,
SilcClientID *client_id,
- unsigned int client_id_len,
- unsigned int mode_mask)
+ uint32 client_id_len,
+ uint32 mode_mask)
{
SilcBuffer idp;
unsigned char mode[4];
int broadcast,
SilcChannelEntry channel,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
char *add, char *del)
{
SilcBuffer idp, idp2;
void *dest_id,
SilcIdType dest_id_type,
SilcNotifyType type,
- unsigned int argc, ...)
+ uint32 argc, ...)
{
va_list ap;
SilcBuffer packet;
SilcChannelEntry channel,
unsigned char route_notify,
SilcNotifyType type,
- unsigned int argc, ...)
+ uint32 argc, ...)
{
va_list ap;
SilcBuffer packet;
SilcClientEntry sender,
SilcClientEntry client,
SilcNotifyType type,
- unsigned int argc, ...)
+ uint32 argc, ...)
{
int k;
SilcSocketConnection sock = NULL;
SilcPacketContext packetdata;
SilcClientEntry c;
SilcClientEntry *sent_clients = NULL;
- unsigned int sent_clients_count = 0;
+ uint32 sent_clients_count = 0;
SilcServerEntry *routed = NULL;
- unsigned int routed_count = 0;
+ uint32 routed_count = 0;
SilcChannelEntry channel;
SilcChannelClientEntry chl, chl2;
SilcIDListData idata;
SilcBuffer packet;
unsigned char *data;
- unsigned int data_len;
+ uint32 data_len;
int force_send = FALSE;
va_list ap;
SilcSocketConnection sock,
int broadcast,
void *id, SilcIdType id_type,
- unsigned int id_len)
+ uint32 id_len)
{
SilcBuffer idp;
int broadcast,
char *channel_name,
void *channel_id,
- unsigned int channel_id_len,
- unsigned int mode)
+ uint32 channel_id_len,
+ uint32 mode)
{
SilcBuffer packet;
unsigned char *cid;
- unsigned int name_len = strlen(channel_name);
+ uint32 name_len = strlen(channel_name);
SILC_LOG_DEBUG(("Start"));
{
SilcBuffer packet;
unsigned char *chid;
- unsigned int tmp_len;
+ uint32 tmp_len;
SILC_LOG_DEBUG(("Start"));
void silc_server_send_command(SilcServer server,
SilcSocketConnection sock,
SilcCommand command,
- unsigned int argc, ...)
+ uint32 argc, ...)
{
SilcBuffer packet;
va_list ap;
void silc_server_send_connection_auth_request(SilcServer server,
SilcSocketConnection sock,
- unsigned short conn_type,
+ uint16 conn_type,
SilcAuthMethod auth_meth)
{
SilcBuffer packet;
SilcPacketType type,
SilcPacketFlags flags,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send);
void silc_server_packet_send_dest(SilcServer server,
SilcSocketConnection sock,
void *dst_id,
SilcIdType dst_id_type,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send);
void silc_server_packet_send_srcdest(SilcServer server,
SilcSocketConnection sock,
void *dst_id,
SilcIdType dst_id_type,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send);
void silc_server_packet_broadcast(SilcServer server,
SilcSocketConnection sock,
SilcPacketType type,
unsigned char route,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send);
void silc_server_packet_relay_to_channel(SilcServer server,
SilcSocketConnection sender_sock,
void *sender,
SilcIdType sender_type,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send);
void silc_server_packet_send_local_channel(SilcServer server,
SilcChannelEntry channel,
SilcPacketType type,
SilcPacketFlags flags,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send);
void silc_server_send_private_message(SilcServer server,
SilcSocketConnection dst_sock,
SilcSocketConnection sock,
int broadcast,
SilcNotifyType type,
- unsigned int argc, ...);
+ uint32 argc, ...);
void silc_server_send_notify_args(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcNotifyType type,
- unsigned int argc,
+ uint32 argc,
SilcBuffer args);
void silc_server_send_notify_channel_change(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcChannelID *old_id,
SilcChannelID *new_id,
- unsigned int id_len);
+ uint32 id_len);
void silc_server_send_notify_nick_change(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcClientID *old_id,
SilcClientID *new_id,
- unsigned int id_len);
+ uint32 id_len);
void silc_server_send_notify_join(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcChannelEntry channel,
SilcClientID *client_id,
- unsigned int client_id_len);
+ uint32 client_id_len);
void silc_server_send_notify_leave(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcChannelEntry channel,
SilcClientID *client_id,
- unsigned int client_id_len);
+ uint32 client_id_len);
void silc_server_send_notify_cmode(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcChannelEntry channel,
- unsigned int mode_mask,
+ uint32 mode_mask,
void *id, SilcIdType id_type,
- unsigned int id_len,
+ uint32 id_len,
char *cipher, char *hmac);
void silc_server_send_notify_cumode(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcChannelEntry channel,
- unsigned int mode_mask,
+ uint32 mode_mask,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
SilcClientID *target,
- unsigned int target_len);
+ uint32 target_len);
void silc_server_send_notify_signoff(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
char *message);
void silc_server_send_notify_topic_set(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcChannelEntry channel,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
char *topic);
void silc_server_send_notify_kicked(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcChannelEntry channel,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
char *comment);
void silc_server_send_notify_killed(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
char *comment);
void silc_server_send_notify_umode(SilcServer server,
SilcSocketConnection sock,
int broadcast,
SilcClientID *client_id,
- unsigned int client_id_len,
- unsigned int mode_mask);
+ uint32 client_id_len,
+ uint32 mode_mask);
void silc_server_send_notify_ban(SilcServer server,
SilcSocketConnection sock,
int broadcast,
int broadcast,
SilcChannelEntry channel,
SilcClientID *client_id,
- unsigned int client_id_len,
+ uint32 client_id_len,
char *add, char *del);
void silc_server_send_notify_dest(SilcServer server,
SilcSocketConnection sock,
void *dest_id,
SilcIdType dest_id_type,
SilcNotifyType type,
- unsigned int argc, ...);
+ uint32 argc, ...);
void silc_server_send_notify_to_channel(SilcServer server,
SilcSocketConnection sender,
SilcChannelEntry channel,
unsigned char route_notify,
SilcNotifyType type,
- unsigned int argc, ...);
+ uint32 argc, ...);
void silc_server_send_notify_on_channels(SilcServer server,
SilcClientEntry sender,
SilcClientEntry client,
SilcNotifyType type,
- unsigned int argc, ...);
+ uint32 argc, ...);
void silc_server_send_new_id(SilcServer server,
SilcSocketConnection sock,
int broadcast,
void *id, SilcIdType id_type,
- unsigned int id_len);
+ uint32 id_len);
void silc_server_send_new_channel(SilcServer server,
SilcSocketConnection sock,
int broadcast,
char *channel_name,
void *channel_id,
- unsigned int channel_id_len,
- unsigned int mode);
+ uint32 channel_id_len,
+ uint32 mode);
void silc_server_send_channel_key(SilcServer server,
SilcSocketConnection sender,
SilcChannelEntry channel,
void silc_server_send_command(SilcServer server,
SilcSocketConnection sock,
SilcCommand command,
- unsigned int argc, ...);
+ uint32 argc, ...);
void silc_server_send_heartbeat(SilcServer server,
SilcSocketConnection sock);
void silc_server_relay_packet(SilcServer server,
int force_send);
void silc_server_send_connection_auth_request(SilcServer server,
SilcSocketConnection sock,
- unsigned short conn_type,
+ uint16 conn_type,
SilcAuthMethod auth_meth);
#endif
/* Check remote host version string */
SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
- unsigned int len)
+ uint32 len)
{
SilcSKEStatus status = SILC_SKE_STATUS_OK;
silc_server_public_key_authentication(SilcServer server,
SilcPublicKey pub_key,
unsigned char *sign,
- unsigned int sign_len,
+ uint32 sign_len,
SilcSKE ske)
{
SilcPKCS pkcs;
silc_server_get_public_key_auth(SilcServer server,
SilcPublicKey pub_key,
unsigned char *auth_data,
- unsigned int *auth_data_len,
+ uint32 *auth_data_len,
SilcSKE ske)
{
int len;
* We are receiving party
*/
int ret;
- unsigned short payload_len;
- unsigned short conn_type;
+ uint16 payload_len;
+ uint16 conn_type;
unsigned char *auth_data = NULL;
SILC_LOG_INFO(("Performing authentication protocol for %s (%s)",
SilcBuffer packet;
int payload_len = 0;
unsigned char *auth_data = NULL;
- unsigned int auth_data_len = 0;
+ uint32 auth_data_len = 0;
switch(ctx->auth_meth) {
case SILC_AUTH_NONE:
/* Auth method that must be used. This is resolved before this
connection authentication protocol is started. Used when we are
initiating. */
- unsigned int auth_meth;
+ uint32 auth_meth;
/* Authentication data if we alreay know it. This is filled before
starting the protocol if we know the authentication data. Otherwise
these are and remain NULL. Used when we are initiating. */
void *auth_data;
- unsigned int auth_data_len;
+ uint32 auth_data_len;
/* Destinations ID from KE protocol context */
void *dest_id;
SilcTask timeout_task;
SilcPacketContext *packet;
- unsigned short conn_type;
+ uint16 conn_type;
} SilcServerConnAuthInternalContext;
/* Prototypes */
/* Adds new route to the route cache. The argument `index' is the
index value generated by silc_server_route_hash. */
-void silc_server_route_add(unsigned int index, unsigned int dest,
+void silc_server_route_add(uint32 index, unsigned int dest,
SilcServerEntry router)
{
silc_route_cache[index].dest = dest;
/* Checksk whether destination has a specific router. Returns the
router data if found, NULL otherwise. */
-SilcServerEntry silc_server_route_check(unsigned int dest,
- unsigned short port)
+SilcServerEntry silc_server_route_check(uint32 dest,
+ uint16 port)
{
- unsigned int index;
+ uint32 index;
index = silc_server_route_hash(dest, port);
SilcIdType id_type)
{
if (server->server_type == SILC_ROUTER) {
- unsigned int dest;
- unsigned short port;
+ uint32 dest;
+ uint16 port;
SilcServerEntry router = NULL;
switch(id_type) {
Following short description of the fields.
- unsigned int dest
+ uint32 dest
Destination IPv4 address. Can be used to quickly check whether
the found route entry is what the caller wanted.
*/
typedef struct {
- unsigned int dest;
+ uint32 dest;
SilcServerEntry router;
} SilcServerRouteTable;
`port' argument may be zero (0) if it doesn't exist. This has been
taken from Linux kernel's route cache code. */
extern inline
-unsigned int silc_server_route_hash(unsigned int addr,
- unsigned short port)
+uint32 silc_server_route_hash(unsigned int addr,
+ uint16 port)
{
- unsigned int hash;
+ uint32 hash;
hash = ((addr & 0xf0f0f0f0) >> 4) | ((addr & 0x0f0f0f0f) << 4);
hash ^= port;
}
/* Prototypes */
-void silc_server_route_add(unsigned int index, unsigned int dest,
+void silc_server_route_add(uint32 index, unsigned int dest,
SilcServerEntry router);
-SilcServerEntry silc_server_route_check(unsigned int dest,
- unsigned short port);
+SilcServerEntry silc_server_route_check(uint32 dest,
+ uint16 port);
SilcSocketConnection silc_server_route_get(SilcServer server, void *id,
SilcIdType id_type);
{
unsigned char *public_key;
unsigned char *private_key;
- unsigned int pk_len, prv_len;
+ uint32 pk_len, prv_len;
struct stat st;
if (stat("pubkey.pub", &st) < 0 && stat("privkey.prv", &st) < 0) {
/* Creates connection to a remote router. */
void silc_server_create_connection(SilcServer server,
- char *remote_host, unsigned int port)
+ char *remote_host, uint32 port)
{
SilcServerConnection sconn;
SilcClientEntry client = NULL;
SilcBuffer idp;
SilcClientEntry *clients = NULL;
- unsigned int clients_c = 0;
+ uint32 clients_c = 0;
unsigned char **argv = NULL;
- unsigned int *argv_lens = NULL, *argv_types = NULL, argc = 0;
+ uint32 *argv_lens = NULL, *argv_types = NULL, argc = 0;
int i;
SILC_LOG_DEBUG(("Start"));
if (silc_idcache_list_first(list, &id_cache)) {
while (id_cache) {
client = (SilcClientEntry)id_cache->context;
-
+ if (client->data.registered == FALSE) {
+ if (!silc_idcache_list_next(list, &id_cache))
+ break;
+ else
+ continue;
+ }
+
if (client->router != entry) {
if (server_signoff && client->connection) {
clients = silc_realloc(clients,
if (silc_idcache_list_first(list, &id_cache)) {
while (id_cache) {
client = (SilcClientEntry)id_cache->context;
+ if (client->data.registered == FALSE) {
+ if (!silc_idcache_list_next(list, &id_cache))
+ break;
+ else
+ continue;
+ }
if (client->router != entry) {
if (server_signoff && client->connection) {
void silc_server_create_channel_key(SilcServer server,
SilcChannelEntry channel,
- unsigned int key_len)
+ uint32 key_len)
{
int i;
unsigned char channel_key[32], hash[32];
- unsigned int len;
+ uint32 len;
SILC_LOG_DEBUG(("Generating channel key"));
SilcChannelKeyPayload payload = NULL;
SilcChannelID *id = NULL;
unsigned char *tmp, hash[32];
- unsigned int tmp_len;
+ uint32 tmp_len;
char *cipher;
SILC_LOG_DEBUG(("Start"));
}
static SilcBuffer
-silc_server_announce_encode_join(unsigned int argc, ...)
+silc_server_announce_encode_join(uint32 argc, ...)
{
va_list ap;
SilcIDCacheEntry id_cache;
SilcChannelEntry channel;
unsigned char *cid;
- unsigned short name_len;
+ uint16 name_len;
int len;
SILC_LOG_DEBUG(("Start"));
SilcChannelEntry channel,
SilcBuffer *user_list,
SilcBuffer *mode_list,
- unsigned int *user_count)
+ uint32 *user_count)
{
SilcChannelClientEntry chl;
SilcBuffer client_id_list;
SilcBuffer client_mode_list;
SilcBuffer idp;
- unsigned int list_count = 0;
+ uint32 list_count = 0;
client_id_list = silc_buffer_alloc((SILC_ID_CLIENT_LEN + 4) *
silc_list_count(channel->user_list));
SilcClientID *noadd,
SilcBuffer user_list,
SilcBuffer mode_list,
- unsigned int user_count)
+ uint32 user_count)
{
int i;
whenever server sends notify message to channel. It means two things;
some user has joined or leaved the channel. XXX TODO! */
for (i = 0; i < user_count; i++) {
- unsigned short idp_len;
- unsigned int mode;
+ uint16 idp_len;
+ uint32 mode;
SilcClientID *client_id;
SilcClientEntry client;
SilcSocketConnection silc_server_get_client_route(SilcServer server,
unsigned char *id_data,
- unsigned int id_len,
+ uint32 id_len,
SilcClientID *client_id,
SilcIDListData *idata)
{
SilcChannelEntry channel;
SilcChannelClientEntry chl;
unsigned char *cid;
- unsigned short name_len;
+ uint16 name_len;
int len;
silc_list_start(client->channels);
*/
typedef struct {
- unsigned int retry_count;
- unsigned long retry_interval_min;
- unsigned long retry_interval_min_usec;
- unsigned long retry_interval_max;
+ uint32 retry_count;
+ uint32 retry_interval_min;
+ uint32 retry_interval_min_usec;
+ uint32 retry_interval_max;
char retry_keep_trying;
- unsigned long protocol_timeout;
- unsigned long protocol_timeout_usec;
+ uint32 protocol_timeout;
+ uint32 protocol_timeout_usec;
char require_reverse_mapping;
} *SilcServerParams;
SilcSocketConnection sock,
SilcPacketContext *packet);
void silc_server_create_connection(SilcServer server,
- char *remote_host, unsigned int port);
+ char *remote_host, uint32 port);
void silc_server_close_connection(SilcServer server,
SilcSocketConnection sock);
void silc_server_free_client_data(SilcServer server,
int broadcast);
void silc_server_create_channel_key(SilcServer server,
SilcChannelEntry channel,
- unsigned int key_len);
+ uint32 key_len);
SilcChannelEntry silc_server_save_channel_key(SilcServer server,
SilcBuffer key_payload,
SilcChannelEntry channel);
SilcChannelEntry channel,
SilcBuffer *user_list,
SilcBuffer *mode_list,
- unsigned int *user_count);
+ uint32 *user_count);
void silc_server_save_users_on_channel(SilcServer server,
SilcSocketConnection sock,
SilcChannelEntry channel,
SilcClientID *noadd,
SilcBuffer user_list,
SilcBuffer mode_list,
- unsigned int user_count);
+ uint32 user_count);
SilcSocketConnection silc_server_get_client_route(SilcServer server,
unsigned char *id_data,
- unsigned int id_len,
+ uint32 id_len,
SilcClientID *client_id,
SilcIDListData *idata);
SilcBuffer silc_server_get_client_channel_list(SilcServer server,
various things. */
typedef struct {
/* Local stats (server and router) */
- unsigned long my_clients; /* Locally connected clients */
- unsigned long my_servers; /* Locally connected servers */
- unsigned long my_routers; /* Locally connected routers */
- unsigned long my_channels; /* Locally created channels */
- unsigned long my_chanclients; /* Local clients on local channels */
- unsigned long my_aways; /* Local clients away (XXX) */
- unsigned long my_server_ops; /* Local server operators */
- unsigned long my_router_ops; /* Local router operators */
+ uint32 my_clients; /* Locally connected clients */
+ uint32 my_servers; /* Locally connected servers */
+ uint32 my_routers; /* Locally connected routers */
+ uint32 my_channels; /* Locally created channels */
+ uint32 my_chanclients; /* Local clients on local channels */
+ uint32 my_aways; /* Local clients away (XXX) */
+ uint32 my_server_ops; /* Local server operators */
+ uint32 my_router_ops; /* Local router operators */
/* Global stats (mainly for router) */
- unsigned long cell_clients; /* All clients in cell */
- unsigned long cell_servers; /* All servers in cell */
- unsigned long cell_channels; /* All channels in cell */
- unsigned long cell_chanclients; /* All clients on cell's channels */
- unsigned long clients; /* All clients */
- unsigned long servers; /* All servers */
- unsigned long routers; /* All routers */
- unsigned long channels; /* All channels */
- unsigned long chanclients; /* All clients on channels */
- unsigned long server_ops; /* All server operators */
- unsigned long router_ops; /* All router operators */
+ uint32 cell_clients; /* All clients in cell */
+ uint32 cell_servers; /* All servers in cell */
+ uint32 cell_channels; /* All channels in cell */
+ uint32 cell_chanclients; /* All clients on cell's channels */
+ uint32 clients; /* All clients */
+ uint32 servers; /* All servers */
+ uint32 routers; /* All routers */
+ uint32 channels; /* All channels */
+ uint32 chanclients; /* All clients on channels */
+ uint32 server_ops; /* All server operators */
+ uint32 router_ops; /* All router operators */
/* General */
- unsigned long conn_attempts; /* Connection attempts */
- unsigned long conn_failures; /* Connection failure */
- unsigned long auth_attempts; /* Authentication attempts */
- unsigned long auth_failures; /* Authentication failures */
- unsigned long packets_sent; /* Sent packets */
- unsigned long packets_received; /* Received packets */
+ uint32 conn_attempts; /* Connection attempts */
+ uint32 conn_failures; /* Connection failure */
+ uint32 auth_attempts; /* Authentication attempts */
+ uint32 auth_failures; /* Authentication failures */
+ uint32 packets_sent; /* Sent packets */
+ uint32 packets_received; /* Received packets */
} SilcServerStatistics;
typedef struct {
int remote_port;
/* Current connection retry info */
- unsigned int retry_count;
- unsigned int retry_timeout;
+ uint32 retry_count;
+ uint32 retry_timeout;
/* Back pointer to server */
SilcServer server;
int listenning;
SilcServerID *id;
unsigned char *id_string;
- unsigned int id_string_len;
+ uint32 id_string_len;
SilcIdType id_type;
/* Current command identifier, 0 not used */
- unsigned short cmd_ident;
+ uint16 cmd_ident;
/* Server's own ID entry. */
SilcServerEntry id_entry;
typedef struct {
SilcServer server;
SilcSocketConnection sock;
- unsigned int failure;
+ uint32 failure;
} *SilcServerFailureContext;
/* Macros */
int silc_server_config_parse(SilcServerConfig config, SilcBuffer buffer,
SilcServerConfigParse *return_config)
{
- int i, begin;
- unsigned int linenum;
+ int i, begin, linenum;
char line[1024], *cp;
SilcServerConfigSection *cptr = NULL;
SilcServerConfigParse parse = *return_config, first = NULL;
SilcServerConfigParse parse_config)
{
int ret, check = FALSE;
- unsigned int checkmask;
+ uint32 checkmask;
char *tmp;
SilcServerConfigParse pc = parse_config;
SilcBuffer line;
/* This function checks that the mask sent as argument includes all the
sections that are mandatory in SILC server. */
-int silc_server_config_check_sections(unsigned int checkmask)
+int silc_server_config_check_sections(uint32 checkmask)
{
if (!(checkmask & (1L << SILC_CONFIG_SERVER_SECTION_TYPE_SERVER_INFO))) {
{
SilcServerConfigSectionLogging *log;
char *info, *warning, *error, *fatal;
- unsigned int info_size, warning_size, error_size, fatal_size;
+ uint32 info_size, warning_size, error_size, fatal_size;
SILC_LOG_DEBUG(("Setting configured log file names"));
typedef struct SilcServerConfigSectionAlgStruct {
char *alg_name;
char *sim_name;
- unsigned int block_len;
- unsigned int key_len;
+ uint32 block_len;
+ uint32 key_len;
struct SilcServerConfigSectionAlgStruct *next;
struct SilcServerConfigSectionAlgStruct *prev;
#define SILC_CONFIG_SERVER_MODNAME "builtin"
char *server_name;
char *server_ip;
char *location;
- unsigned short port;
+ uint16 port;
} SilcServerConfigSectionServerInfo;
/* Holds server's administrative information from config file */
typedef struct SilcServerConfigSectionListenPortStruct {
char *host;
char *remote_ip;
- unsigned short port;
+ uint16 port;
struct SilcServerConfigSectionListenPortStruct *next;
struct SilcServerConfigSectionListenPortStruct *prev;
} SilcServerConfigSectionListenPort;
typedef struct SilcServerConfigSectionLoggingStruct {
char *logtype;
char *filename;
- unsigned int maxsize;
+ uint32 maxsize;
struct SilcServerConfigSectionLoggingStruct *next;
struct SilcServerConfigSectionLoggingStruct *prev;
/* Holds all configured connection classes */
typedef struct SilcServerConfigSectionConnectionClassStruct {
- unsigned int class;
- unsigned int ping_freq;
- unsigned int connect_freq;
- unsigned int max_links;
+ uint32 class;
+ uint32 ping_freq;
+ uint32 connect_freq;
+ uint32 max_links;
struct SilcServerConfigSectionConnectionClassStruct *next;
struct SilcServerConfigSectionConnectionClassStruct *prev;
} SilcServerConfigSectionConnectionClass;
char *host;
SilcAuthMethod auth_meth;
void *auth_data;
- unsigned int auth_data_len;
- unsigned short port;
- unsigned int class;
+ uint32 auth_data_len;
+ uint16 port;
+ uint32 class;
struct SilcServerConfigSectionClientConnectionStruct *next;
struct SilcServerConfigSectionClientConnectionStruct *prev;
} SilcServerConfigSectionClientConnection;
char *nickname;
SilcAuthMethod auth_meth;
void *auth_data;
- unsigned int auth_data_len;
+ uint32 auth_data_len;
struct SilcServerConfigSectionAdminConnectionStruct *next;
struct SilcServerConfigSectionAdminConnectionStruct *prev;
} SilcServerConfigSectionAdminConnection;
char *host;
SilcAuthMethod auth_meth;
void *auth_data;
- unsigned int auth_data_len;
- unsigned short port;
+ uint32 auth_data_len;
+ uint16 port;
char *version;
- unsigned int class;
+ uint32 class;
int initiator;
struct SilcServerConfigSectionServerConnectionStruct *next;
struct SilcServerConfigSectionServerConnectionStruct *prev;
char *host;
char *time;
char *comment;
- unsigned short port;
+ uint16 port;
} SilcServerConfigSectionDenyConnection;
/* Holds motd file */
typedef struct {
const char *section;
SilcServerConfigSectionType type;
- unsigned int maxfields;
+ int maxfields;
} SilcServerConfigSection;
/* LIst of all possible config sections in SILC server. */
from a file to this structure before parsing it further. */
typedef struct SilcServerConfigParseStruct {
SilcBuffer line;
- unsigned int linenum;
+ int linenum;
SilcServerConfigSection *section;
struct SilcServerConfigParseStruct *next;
struct SilcServerConfigParseStruct *prev;
SilcServerConfigParse *return_config);
int silc_server_config_parse_lines(SilcServerConfig config,
SilcServerConfigParse parse_config);
-int silc_server_config_check_sections(unsigned int checkmask);
+int silc_server_config_check_sections(uint32 checkmask);
void silc_server_config_setlogfiles(SilcServerConfig config);
void silc_server_config_register_ciphers(SilcServerConfig config);
void silc_server_config_register_pkcs(SilcServerConfig config);
#undef int16
#undef int32
#undef int64
-#undef bool
typedef unsigned char uint8;
typedef signed char int8;
typedef uint32 * void *;
#endif
-typedef unsigned char bool;
+#ifndef bool
+#define bool unsigned char
+#endif
/* Generic global SILC includes */
#include "bitmove.h"
SilcCipher cipher,
SilcHmac hmac,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send)
{
SilcPacketContext packetdata;
SilcChannelEntry silc_client_new_channel_id(SilcClient client,
SilcSocketConnection sock,
char *channel_name,
- unsigned int mode,
+ uint32 mode,
SilcIDPayload idp)
{
SilcClientConnection conn = (SilcClientConnection)sock->user_data;
/* Parses mode mask and returns the mode as string. */
-char *silc_client_chmode(unsigned int mode, SilcChannelEntry channel)
+char *silc_client_chmode(uint32 mode, SilcChannelEntry channel)
{
char string[100];
/* Parses channel user mode mask and returns te mode as string */
-char *silc_client_chumode(unsigned int mode)
+char *silc_client_chumode(uint32 mode)
{
char string[4];
/* Parses channel user mode and returns it as special mode character. */
-char *silc_client_chumode_char(unsigned int mode)
+char *silc_client_chumode_char(uint32 mode)
{
char string[4];
SilcPacketContext *packet)
{
SilcClientFailureContext *f;
- unsigned int failure = 0;
+ uint32 failure = 0;
if (sock->protocol) {
if (packet->buffer->len >= 4)
/* Decoded local ID so that the above defined ID would not have
to be decoded for every packet. */
unsigned char *local_id_data;
- unsigned int local_id_data_len;
+ uint32 local_id_data_len;
/* Own client entry. */
SilcClientEntry local_entry;
/* Decoded remote ID so that the above defined ID would not have
to be decoded for every packet. */
unsigned char *remote_id_data;
- unsigned int remote_id_data_len;
+ uint32 remote_id_data_len;
/*
* Common data
SilcCipher receive_key;
SilcHmac hmac;
unsigned char *hmac_key;
- unsigned int hmac_key_len;
+ uint32 hmac_key_len;
SilcHash hash;
/* Client ID and Channel ID cache. Messages transmitted in SILC network
SilcDList pending_commands;
/* Current command identifier, 0 not used */
- unsigned short cmd_ident;
+ uint16 cmd_ident;
/* Requested pings. */
SilcClientPing *ping;
- unsigned int ping_count;
+ uint32 ping_count;
/* Set away message */
SilcClientAway *away;
/* Table of connections in client. All the connection data is saved here. */
SilcClientConnection *conns;
- unsigned int conns_count;
+ uint32 conns_count;
/* Table of listenning sockets in client. Client can have listeners
(like key agreement protocol server) and those sockets are saved here.
This table is checked always if the connection object cannot be found
from the `conns' table. */
SilcSocketConnection *sockets;
- unsigned int sockets_count;
+ uint32 sockets_count;
/* Generic cipher and hash objects. These can be used and referenced
by the application as well. */
SilcCipher cipher,
SilcHmac hmac,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send);
void silc_client_disconnected_by_server(SilcClient client,
SilcSocketConnection sock,
SilcChannelEntry silc_client_new_channel_id(SilcClient client,
SilcSocketConnection sock,
char *channel_name,
- unsigned int mode,
+ uint32 mode,
SilcIDPayload idp);
void silc_client_save_channel_key(SilcClientConnection conn,
SilcBuffer key_payload,
SilcClientConnection conn,
SilcClientEntry old,
SilcClientEntry new);
-char *silc_client_chmode(unsigned int mode, SilcChannelEntry channel);
-char *silc_client_chumode(unsigned int mode);
-char *silc_client_chumode_char(unsigned int mode);
+char *silc_client_chmode(uint32 mode, SilcChannelEntry channel);
+char *silc_client_chumode(uint32 mode);
+char *silc_client_chumode_char(uint32 mode);
void silc_client_process_failure(SilcClient client,
SilcSocketConnection sock,
SilcPacketContext *packet);
SilcChannelPrivateKey key,
SilcMessageFlags flags,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send)
{
int i;
SilcCipher cipher;
SilcHmac hmac;
unsigned char *id_string;
- unsigned int iv_len;
+ uint32 iv_len;
SILC_LOG_DEBUG(("Sending packet to channel"));
SilcChannelEntry channel)
{
unsigned char *id_string, *key, *cipher, hash[32];
- unsigned int tmp_len;
+ uint32 tmp_len;
SilcChannelID *id;
SilcIDCacheEntry id_cache = NULL;
SilcChannelKeyPayload payload;
char *cipher,
char *hmac,
unsigned char *key,
- unsigned int key_len)
+ uint32 key_len)
{
SilcChannelPrivateKey entry;
unsigned char hash[32];
silc_client_list_channel_private_keys(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel,
- unsigned int *key_count)
+ uint32 *key_count)
{
SilcChannelPrivateKey *keys = NULL, entry;
- unsigned int count = 0;
+ uint32 count = 0;
if (!channel->private_keys)
return NULL;
/* Frees the SilcChannelPrivateKey array. */
void silc_client_free_channel_private_keys(SilcChannelPrivateKey *keys,
- unsigned int key_count)
+ uint32 key_count)
{
silc_free(keys);
}
typedef struct {
SilcClient client;
SilcSocketConnection sock;
- unsigned int failure;
+ uint32 failure;
} SilcClientFailureContext;
/* Protypes */
SilcClientEntry client_entry,
char *hostname,
int port,
- unsigned long timeout_secs,
+ uint32 timeout_secs,
SilcKeyAgreementCallback completion,
void *context)
{
silc_client_key_agreement_resolve_cb(SilcClient client,
SilcClientConnection conn,
SilcClientEntry *clients,
- unsigned int clients_count,
+ uint32 clients_count,
void *context)
{
SilcPacketContext *packet = (SilcPacketContext *)context;
SilcChannelUser chu;
SilcIDCacheEntry id_cache = NULL;
unsigned char *tmp;
- unsigned int tmp_len, mode;
+ uint32 tmp_len, mode;
payload = silc_notify_payload_parse(buffer);
if (!payload)
* from channels as they quit as well.
*/
SilcClientEntry *clients = NULL;
- unsigned int clients_count = 0;
+ uint32 clients_count = 0;
int i;
for (i = 1; i < silc_argument_get_arg_num(args); i++) {
SilcClientEntry client_entry,
SilcMessageFlags flags,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send)
{
SilcSocketConnection sock = conn->sock;
static void silc_client_private_message_cb(SilcClient client,
SilcClientConnection conn,
SilcClientEntry *clients,
- unsigned int clients_count,
+ uint32 clients_count,
void *context)
{
SilcPacketContext *packet = (SilcPacketContext *)context;
static void silc_client_private_message_key_cb(SilcClient client,
SilcClientConnection conn,
SilcClientEntry *clients,
- unsigned int clients_count,
+ uint32 clients_count,
void *context)
{
SilcPacketContext *packet = (SilcPacketContext *)context;
unsigned char *key;
- unsigned short key_len;
+ uint16 key_len;
unsigned char *cipher;
int ret;
SilcClientEntry client_entry,
char *cipher,
unsigned char *key,
- unsigned int key_len,
+ uint32 key_len,
int generate_key)
{
unsigned char private_key[32];
- unsigned int len;
+ uint32 len;
int i;
SilcSKEKeyMaterial *keymat;
SilcPrivateMessageKeys
silc_client_list_private_message_keys(SilcClient client,
SilcClientConnection conn,
- unsigned int *key_count)
+ uint32 *key_count)
{
SilcPrivateMessageKeys keys;
- unsigned int count = 0;
+ uint32 count = 0;
SilcIDCacheEntry id_cache;
SilcIDCacheList list;
SilcClientEntry entry;
silc_client_list_private_message_keys. */
void silc_client_free_private_message_keys(SilcPrivateMessageKeys keys,
- unsigned int key_count)
+ uint32 key_count)
{
silc_free(keys);
}
encoded into correct form and in correct order. */
void silc_client_send_command(SilcClient client, SilcClientConnection conn,
- SilcCommand command, unsigned short ident,
- unsigned int argc, ...)
+ SilcCommand command, uint16 ident,
+ uint32 argc, ...)
{
SilcBuffer packet;
va_list ap;
void silc_client_command_pending(SilcClientConnection conn,
SilcCommand reply_cmd,
- unsigned short ident,
+ uint16 ident,
SilcClientPendingDestructor destructor,
SilcCommandCb callback,
void *context)
void silc_client_command_pending_del(SilcClientConnection conn,
SilcCommand reply_cmd,
- unsigned short ident)
+ uint16 ident)
{
SilcClientCommandPending *r;
int silc_client_command_pending_check(SilcClientConnection conn,
SilcClientCommandReplyContext ctx,
SilcCommand command,
- unsigned short ident)
+ uint16 ident)
{
SilcClientCommandPending *r;
void silc_client_command_completion(SilcClient client,
SilcClientConnection conn,
SilcClientEntry clients,
- unsigned int clients_count,
+ uint32 clients_count,
void *context)
{
SilcClientEntry client_entry = NULL;
SilcChannelEntry channel;
SilcBuffer buffer, clidp, chidp;
- unsigned int num = 0, type = 0;
+ uint32 num = 0, type = 0;
char *nickname = NULL, *server = NULL, *name;
char *invite = NULL;
SilcClientConnection conn = cmd->conn;
SilcBuffer buffer, idp;
SilcClientEntry target;
- unsigned int num = 0;
+ uint32 num = 0;
char *nickname = NULL, *server = NULL;
if (!cmd->conn) {
SilcClientConnection conn = cmd->conn;
SilcBuffer buffer, idp;
unsigned char *cp, modebuf[4];
- unsigned int mode, add, len;
+ uint32 mode, add, len;
int i;
if (!cmd->conn) {
SilcChannelEntry channel;
SilcBuffer buffer, chidp, auth = NULL;
unsigned char *name, *cp, modebuf[4], tmp[4], *arg = NULL;
- unsigned int mode, add, type, len, arg_len = 0;
+ uint32 mode, add, type, len, arg_len = 0;
int i;
if (!cmd->conn) {
SilcClientEntry client_entry;
SilcBuffer buffer, clidp, chidp, auth = NULL;
unsigned char *name, *cp, modebuf[4];
- unsigned int mode = 0, add, len;
+ uint32 mode = 0, add, len;
char *nickname = NULL, *server = NULL;
- unsigned int num = 0;
+ uint32 num = 0;
int i;
if (!cmd->conn) {
SilcBuffer buffer, idp, idp2;
SilcClientEntry target;
char *name;
- unsigned int num = 0;
+ uint32 num = 0;
char *nickname = NULL, *server = NULL;
if (!cmd->conn) {
SilcClientConnection conn = cmd->conn;
SilcBuffer buffer;
unsigned char port[4];
- unsigned int tmp;
+ uint32 tmp;
if (!cmd->conn) {
SILC_NOT_CONNECTED(cmd->client, cmd->conn);
SilcClientConnection conn = cmd->conn;
SilcBuffer buffer;
unsigned char port[4];
- unsigned int tmp;
+ uint32 tmp;
if (!cmd->conn) {
SILC_NOT_CONNECTED(cmd->client, cmd->conn);
SilcCommand cmd;
char *name;
SilcCommandFlag flags;
- unsigned int max_args;
+ uint32 max_args;
} SilcClientCommand;
/* All client commands */
SilcClient client;
SilcClientConnection conn;
SilcClientCommand *command;
- unsigned int argc;
+ uint32 argc;
unsigned char **argv;
- unsigned int *argv_lens;
- unsigned int *argv_types;
+ uint32 *argv_lens;
+ uint32 *argv_types;
int pending; /* Command is being re-processed when TRUE */
int users; /* Reference counter */
} *SilcClientCommandContext;
SilcCommandCb callback;
SilcClientPendingDestructor destructor;
void *context;
- unsigned short ident;
+ uint16 ident;
struct SilcClientCommandPendingStruct *next;
} SilcClientCommandPending;
/* Prototypes (some prototypes are in the silcapi.h file) */
void silc_client_command_pending_del(SilcClientConnection conn,
SilcCommand reply_cmd,
- unsigned short ident);
+ uint16 ident);
int silc_client_command_pending_check(SilcClientConnection conn,
SilcClientCommandReplyContext ctx,
SilcCommand command,
- unsigned short ident);
+ uint16 ident);
SILC_CLIENT_CMD_FUNC(whois);
SILC_CLIENT_CMD_FUNC(whowas);
SilcClientCommandReplyContext ctx;
SilcCommandPayload payload;
SilcCommand command;
- unsigned short ident;
+ uint16 ident;
/* Get command reply payload from packet */
payload = silc_command_payload_parse(buffer);
SilcClientID *client_id;
SilcIDCacheEntry id_cache = NULL;
SilcClientEntry client_entry = NULL;
- int argc, len;
+ int argc;
+ uint32 len;
unsigned char *id_data, *tmp;
char *nickname = NULL, *username = NULL;
char *realname = NULL;
- unsigned int idle = 0, mode = 0;
+ uint32 idle = 0, mode = 0;
SilcBuffer channels = NULL;
argc = silc_argument_get_arg_num(cmd->args);
SilcClientID *client_id;
SilcIDCacheEntry id_cache = NULL;
SilcClientEntry client_entry = NULL;
- unsigned int len;
+ uint32 len;
unsigned char *id_data, *tmp;
char *nickname, *username;
char *realname = NULL;
SilcClientID *client_id;
SilcIDCacheEntry id_cache = NULL;
SilcClientEntry client_entry = NULL;
- int argc, len;
+ int argc;
+ uint32 len;
unsigned char *id_data;
char *nickname = NULL, *username = NULL;
SilcCommandStatus status;
SilcIDPayload idp;
unsigned char *tmp;
- unsigned int argc, len;
+ uint32 argc, len;
SILC_LOG_DEBUG(("Start"));
SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
SilcCommandStatus status;
unsigned char *tmp, *name, *topic;
- unsigned int usercount = 0;
+ uint32 usercount = 0;
tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
SILC_GET16_MSB(status, tmp);
SilcIDCacheEntry id_cache = NULL;
unsigned char *tmp;
char *topic;
- unsigned int argc, len;
+ uint32 argc, len;
SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL));
if (status != SILC_STATUS_OK) {
SilcChannelID *channel_id;
SilcIDCacheEntry id_cache;
unsigned char *tmp;
- unsigned int len;
+ uint32 len;
tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
SILC_GET16_MSB(status, tmp);
SilcChannelEntry channel;
SilcIDCacheEntry id_cache = NULL;
SilcChannelUser chu;
- unsigned int argc, mode, len, list_count;
+ uint32 argc, mode, len, list_count;
char *topic, *tmp, *channel_name = NULL, *hmac;
SilcBuffer keyp = NULL, client_id_list, client_mode_list;
int i;
/* Add clients we received in the reply to the channel */
for (i = 0; i < list_count; i++) {
- unsigned short idp_len;
- unsigned int mode;
+ uint16 idp_len;
+ uint32 mode;
SilcClientID *client_id;
SilcClientEntry client_entry;
SilcClientCommandReplyContext cmd = (SilcClientCommandReplyContext)context;
SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
SilcCommandStatus status;
- unsigned int argc, i;
+ uint32 argc, i;
unsigned char *tmp;
char *motd = NULL, *cp, line[256];
SilcClientConnection conn = (SilcClientConnection)cmd->sock->user_data;
SilcCommandStatus status;
unsigned char *tmp;
- unsigned int mode;
+ uint32 mode;
tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
SILC_GET16_MSB(status, tmp);
SilcIDCacheEntry id_cache = NULL;
SilcClientID *client_id;
unsigned char *tmp, *id;
- unsigned int len;
+ uint32 len;
SILC_GET16_MSB(status, silc_argument_get_arg_type(cmd->args, 1, NULL));
if (status != SILC_STATUS_OK) {
SilcBuffer client_id_list;
SilcBuffer client_mode_list;
unsigned char *tmp;
- unsigned int tmp_len, list_count;
+ uint32 tmp_len, list_count;
int i;
unsigned char **res_argv = NULL;
- unsigned int *res_argv_lens = NULL, *res_argv_types = NULL, res_argc = 0;
+ uint32 *res_argv_lens = NULL, *res_argv_types = NULL, res_argc = 0;
SILC_LOG_DEBUG(("Start"));
whenever server sends notify message to channel. It means two things;
some user has joined or leaved the channel. XXX! */
for (i = 0; i < list_count; i++) {
- unsigned short idp_len;
- unsigned int mode;
+ uint16 idp_len;
+ uint32 mode;
SilcClientID *client_id;
SilcClientEntry client;
SilcChannelEntry channel;
SilcChannelID *channel_id;
unsigned char *tmp;
- unsigned int len;
+ uint32 len;
tmp = silc_argument_get_arg_type(cmd->args, 1, NULL);
SILC_GET16_MSB(status, tmp);
SilcClientPendingDestructor destructor;
SilcCommandCb callback;
void *context;
- unsigned short ident;
+ uint16 ident;
} *SilcClientCommandReplyContext;
/* Macros */
{
GetClientInternal i = (GetClientInternal)context;
SilcClientEntry *clients;
- unsigned int clients_count;
+ uint32 clients_count;
/* Get the clients */
clients = silc_client_get_clients_local(i->cmd->client, i->cmd->conn,
SilcClientConnection conn,
char *nickname,
char *server,
- unsigned int *clients_count)
+ uint32 *clients_count)
{
SilcIDCacheEntry id_cache;
SilcIDCacheList list = NULL;
typedef struct {
SilcClient client;
SilcClientConnection conn;
- unsigned int list_count;
+ uint32 list_count;
SilcBuffer client_id_list;
SilcGetClientCallback completion;
void *context;
SilcIDCacheEntry id_cache = NULL;
SilcBuffer client_id_list = i->client_id_list;
SilcClientEntry *clients = NULL;
- unsigned int clients_count = 0;
+ uint32 clients_count = 0;
int c;
for (c = 0; c < i->list_count; c++) {
- unsigned short idp_len;
+ uint16 idp_len;
SilcClientID *client_id;
/* Get Client ID */
void silc_client_get_clients_by_list(SilcClient client,
SilcClientConnection conn,
- unsigned int list_count,
+ uint32 list_count,
SilcBuffer client_id_list,
SilcGetClientCallback completion,
void *context)
SilcIDCacheEntry id_cache = NULL;
int i;
unsigned char **res_argv = NULL;
- unsigned int *res_argv_lens = NULL, *res_argv_types = NULL, res_argc = 0;
+ uint32 *res_argv_lens = NULL, *res_argv_types = NULL, res_argc = 0;
GetClientsByListInternal in;
in = silc_calloc(1, sizeof(*in));
in->context = context;
for (i = 0; i < list_count; i++) {
- unsigned short idp_len;
+ uint16 idp_len;
SilcClientID *client_id;
SilcClientEntry entry;
SilcClientConnection conn,
char *nickname,
char *server,
- unsigned int num,
+ uint32 num,
int query)
{
SilcIDCacheEntry id_cache;
char *username; /* username[@host] */
char *server; /* SILC server name */
char *realname; /* Realname (userinfo) */
- unsigned int num;
- unsigned int mode; /* User mode in SILC */
+ uint32 num;
+ uint32 mode; /* User mode in SILC */
SilcClientID *id; /* The Client ID */
SilcCipher send_key; /* Private message key for sending */
SilcCipher receive_key; /* Private message key for receiving */
unsigned char *key; /* Set only if appliation provided the
key material. NULL if the library
generated the key. */
- unsigned int key_len;
+ uint32 key_len;
int generated; /* TRUE if library generated the key */
SilcClientKeyAgreement ke; /* Current key agreement context or NULL */
} *SilcClientEntry;
/* Client and its mode on a channel */
typedef struct SilcChannelUserStruct {
SilcClientEntry client;
- unsigned int mode;
+ uint32 mode;
struct SilcChannelUserStruct *next;
} *SilcChannelUser;
SilcCipher cipher; /* The cipher and key */
SilcHmac hmac; /* The HMAC and hmac key */
unsigned char *key; /* The key data */
- unsigned int key_len; /* The key length */
+ uint32 key_len; /* The key length */
} *SilcChannelPrivateKey;
/* Channel entry context. This is allocate for every channel client has
typedef struct SilcChannelEntryStruct {
char *channel_name;
SilcChannelID *id;
- unsigned int mode;
+ uint32 mode;
int on_channel;
/* Joined clients */
/* Channel keys */
SilcCipher channel_key; /* The channel key */
unsigned char *key; /* Raw key data */
- unsigned int key_len;
+ uint32 key_len;
unsigned char iv[SILC_CIPHER_MAX_IV_SIZE]; /* Current IV */
SilcHmac hmac; /* Current HMAC */
SilcDList private_keys; /* List of private keys or NULL */
SilcClientConnection conn,
char *nickname,
char *server,
- unsigned int num,
+ uint32 num,
int query);
#endif
SilcSKEStatus silc_client_protocol_ke_verify_key(SilcSKE ske,
unsigned char *pk_data,
- unsigned int pk_len,
+ uint32 pk_len,
SilcSKEPKType pk_type,
void *context)
{
/* Checks the version string of the server. */
SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
- unsigned int len)
+ uint32 len)
{
SilcClientConnection conn = (SilcClientConnection)ske->sock->user_data;
SilcClient client = (SilcClient)ske->user_data;
silc_client_get_public_key_auth(SilcClient client,
char *filepath,
unsigned char *auth_data,
- unsigned int *auth_data_len,
+ uint32 *auth_data_len,
SilcSKE ske)
{
int len;
SilcBuffer packet;
int payload_len = 0;
unsigned char *auth_data = NULL;
- unsigned int auth_data_len = 0;
+ uint32 auth_data_len = 0;
switch(ctx->auth_meth) {
case SILC_AUTH_NONE:
starting the protocol if we know the authentication data. Otherwise
these are and remain NULL. */
unsigned char *auth_data;
- unsigned int auth_data_len;
+ uint32 auth_data_len;
SilcTask timeout_task;
} SilcClientConnAuthInternalContext;
void *context);
SilcSKEStatus silc_client_protocol_ke_verify_key(SilcSKE ske,
unsigned char *pk_data,
- unsigned int pk_len,
+ uint32 pk_len,
SilcSKEPKType pk_type,
void *context);
void silc_client_protocol_ke_set_keys(SilcSKE ske,
provided it. This is NULL if the
library generated the key or if
the SKE key material was used. */
- unsigned int key_len; /* The key length */
+ uint32 key_len; /* The key length */
} *SilcPrivateMessageKeys;
/******************************************************************************
and `auth_data_len'. The function returns TRUE if authentication method
is found and FALSE if not. `conn' may be NULL. */
int (*get_auth_method)(SilcClient client, SilcClientConnection conn,
- char *hostname, unsigned short port,
+ char *hostname, uint16 port,
SilcProtocolAuthMeth *auth_meth,
unsigned char **auth_data,
- unsigned int *auth_data_len);
+ uint32 *auth_data_len);
/* Verifies received public key. The `conn_type' indicates which entity
(server, client etc.) has sent the public key. If user decides to trust
TRUE. */
int (*verify_public_key)(SilcClient client, SilcClientConnection conn,
SilcSocketType conn_type, unsigned char *pk,
- unsigned int pk_len, SilcSKEPKType pk_type);
+ uint32 pk_len, SilcSKEPKType pk_type);
/* Ask (interact, that is) a passphrase from user. Returns the passphrase
or NULL on error. */
SilcChannelPrivateKey key,
SilcMessageFlags flags,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send);
/* Sends private message to remote client. If private message key has
SilcClientEntry client_entry,
SilcMessageFlags flags,
unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
int force_send);
typedef void (*SilcGetClientCallback)(SilcClient client,
SilcClientConnection conn,
SilcClientEntry *clients,
- unsigned int clients_count,
+ uint32 clients_count,
void *context);
/* Finds client entry or entries by the `nickname' and `server'. The
SilcClientConnection conn,
char *nickname,
char *server,
- unsigned int *clients_count);
+ uint32 *clients_count);
/* Gets client entries by the list of client ID's `client_id_list'. This
always resolves those client ID's it does not know yet from the server
will be called after the entries are available. */
void silc_client_get_clients_by_list(SilcClient client,
SilcClientConnection conn,
- unsigned int list_count,
+ uint32 list_count,
SilcBuffer client_id_list,
SilcGetClientCallback completion,
void *context);
/* Generic function to send any command. The arguments must be sent already
encoded into correct form and in correct order. */
void silc_client_send_command(SilcClient client, SilcClientConnection conn,
- SilcCommand command, unsigned short ident,
- unsigned int argc, ...);
+ SilcCommand command, uint16 ident,
+ uint32 argc, ...);
/* Pending Command callback destructor. This is called after calling the
pending callback or if error occurs while processing the pending command.
identifier `ident'. */
void silc_client_command_pending(SilcClientConnection conn,
SilcCommand reply_cmd,
- unsigned short ident,
+ uint16 ident,
SilcClientPendingDestructor destructor,
SilcCommandCb callback,
void *context);
SilcClientEntry client_entry,
char *cipher,
unsigned char *key,
- unsigned int key_len,
+ uint32 key_len,
int generate_key);
/* Same as above but takes the key material from the SKE key material
SilcPrivateMessageKeys
silc_client_list_private_message_keys(SilcClient client,
SilcClientConnection conn,
- unsigned int *key_count);
+ uint32 *key_count);
/* Frees the SilcPrivateMessageKeys array returned by the function
silc_client_list_private_message_keys. */
void silc_client_free_private_message_keys(SilcPrivateMessageKeys keys,
- unsigned int key_count);
+ uint32 key_count);
/* Channel private key management (client_channel.c,
char *cipher,
char *hmac,
unsigned char *key,
- unsigned int key_len);
+ uint32 key_len);
/* Removes all private keys from the `channel'. The old channel key is used
after calling this to protect the channel messages. Returns FALSE on
silc_client_list_channel_private_keys(SilcClient client,
SilcClientConnection conn,
SilcChannelEntry channel,
- unsigned int *key_count);
+ uint32 *key_count);
/* Frees the SilcChannelPrivateKey array. */
void silc_client_free_channel_private_keys(SilcChannelPrivateKey *keys,
- unsigned int key_count);
+ uint32 key_count);
/* Key Agreement routines (client_keyagr.c) */
SilcClientEntry client_entry,
char *hostname,
int port,
- unsigned long timeout_secs,
+ uint32 timeout_secs,
SilcKeyAgreementCallback completion,
void *context);
/* Converts string to a ID */
-void *silc_id_str2id(unsigned char *id, unsigned int id_len, SilcIdType type)
+void *silc_id_str2id(unsigned char *id, uint32 id_len, SilcIdType type)
{
switch(type) {
/* Returns length of the ID */
-unsigned int silc_id_get_len(SilcIdType type)
+uint32 silc_id_get_len(SilcIdType type)
{
switch(type) {
case SILC_ID_SERVER:
#define SILC_ID_CHANNEL 3
/* Type definition for the ID types. */
-typedef unsigned short SilcIdType;
+typedef uint16 SilcIdType;
/*
64 bit SilcServerID structure:
*/
typedef struct {
struct in_addr ip; /* 32 bit IP */
- unsigned short port; /* 16 bit port */
- unsigned short rnd; /* 16 bit random number */
+ uint16 port; /* 16 bit port */
+ uint16 rnd; /* 16 bit random number */
} SilcServerID;
/*
*/
typedef struct {
struct in_addr ip; /* 32 bit IP */
- unsigned short port; /* 16 bit port */
- unsigned short rnd; /* 16 bit random number */
+ uint16 port; /* 16 bit port */
+ uint16 rnd; /* 16 bit random number */
} SilcChannelID;
/* Macros */
/* Prototypes */
unsigned char *silc_id_id2str(void *id, SilcIdType type);
-void *silc_id_str2id(unsigned char *id, unsigned int id_len, SilcIdType type);
-unsigned int silc_id_get_len(SilcIdType type);
+void *silc_id_str2id(unsigned char *id, uint32 id_len, SilcIdType type);
+uint32 silc_id_get_len(SilcIdType type);
void *silc_id_dup(void *id, SilcIdType type);
#endif
Table of the cache entries allocated by silc_idcache_add function.
This table is reallocated when new entry is added into the cache.
- unsigned int cache_count
+ uint32 cache_count
Number of cache entries in the cache.
*/
struct SilcIDCacheStruct {
SilcIDCacheEntry cache;
- unsigned int cache_count;
+ uint32 cache_count;
int sorted;
int fast_access[256];
SilcIDCacheDestructor destructor;
struct SilcIDCacheListStruct {
SilcIDCacheEntry cache[64];
SilcIDCacheEntry *cache_dyn;
- unsigned int cache_dyn_count;
- unsigned int cache_count;
- unsigned int pos;
+ uint32 cache_dyn_count;
+ uint32 cache_count;
+ uint32 pos;
};
/* Allocates new ID cache object. The initial amount of allocated entries
can be sent as argument. If `count' is 0 the system uses default values. */
-SilcIDCache silc_idcache_alloc(unsigned int count,
+SilcIDCache silc_idcache_alloc(uint32 count,
SilcIDCacheDestructor destructor)
{
SilcIDCache cache;
however, it is not mandatory. */
int silc_idcache_add(SilcIDCache cache, unsigned char *data,
- unsigned int data_len, SilcIdType id_type, void *id,
+ uint32 data_len, SilcIdType id_type, void *id,
void *context, int sort, int expire)
{
int i;
- unsigned int count;
- unsigned long curtime = time(NULL);
+ uint32 count;
+ uint32 curtime = time(NULL);
SilcIDCacheEntry c;
if (!cache || !cache->cache)
int silc_idcache_purge(SilcIDCache cache)
{
SilcIDCacheEntry c;
- unsigned long curtime = time(NULL);
+ uint32 curtime = time(NULL);
int i;
if (!cache || !cache->cache)
allocate any of these fields nor free them.
unsigned char *data
- unsigned int data_len;
+ uint32 data_len;
The data that is usually used to find the data from the cache.
For example for Client ID's this is nickname.
The actual ID.
- unsigned long expire
+ uint32 expire
Time when this cache entry expires. This is normal time() value
plus the validity. Cache entry has expired if current time is
*/
typedef struct {
unsigned char *data;
- unsigned int data_len;
+ uint32 data_len;
SilcIdType type;
void *id;
- unsigned long expire;
+ uint32 expire;
void *context;
} *SilcIDCacheEntry;
#define SILC_ID_CACHE_EXPIRE_DEF (time(NULL) + SILC_ID_CACHE_EXPIRE)
/* Prototypes */
-SilcIDCache silc_idcache_alloc(unsigned int count,
+SilcIDCache silc_idcache_alloc(uint32 count,
SilcIDCacheDestructor destructor);
void silc_idcache_free(SilcIDCache cache);
void silc_idcache_sort_by_data(SilcIDCache cache);
int silc_idcache_find_by_context(SilcIDCache cache, void *context,
SilcIDCacheEntry *ret);
int silc_idcache_add(SilcIDCache cache, unsigned char *data,
- unsigned int data_len, SilcIdType id_type, void *id,
+ uint32 data_len, SilcIdType id_type, void *id,
void *context, int sort, int expire);
int silc_idcache_del(SilcIDCache cache, SilcIDCacheEntry old);
int silc_idcache_del_by_data(SilcIDCache cache, unsigned char *data);
/* Authentication Payload structure */
struct SilcAuthPayloadStruct {
- unsigned short len;
- unsigned short auth_method;
- unsigned short random_len;
+ uint16 len;
+ uint16 auth_method;
+ uint16 random_len;
unsigned char *random_data;
- unsigned short auth_len;
+ uint16 auth_len;
unsigned char *auth_data;
};
/* Parses and returns Authentication Payload */
SilcAuthPayload silc_auth_payload_parse(unsigned char *data,
- unsigned int data_len)
+ uint32 data_len)
{
SilcBuffer buffer;
SilcAuthPayload new;
SilcBuffer silc_auth_payload_encode(SilcAuthMethod method,
unsigned char *random_data,
- unsigned short random_len,
+ uint16 random_len,
unsigned char *auth_data,
- unsigned short auth_len)
+ uint16 auth_len)
{
SilcBuffer buffer;
- unsigned int len;
+ uint32 len;
SILC_LOG_DEBUG(("Encoding Authentication Payload"));
/* Get the authentication data */
unsigned char *silc_auth_get_data(SilcAuthPayload payload,
- unsigned int *auth_len)
+ uint32 *auth_len)
{
if (auth_len)
*auth_len = payload->auth_len;
static unsigned char *
silc_auth_public_key_encode_data(SilcPublicKey public_key,
unsigned char *random,
- unsigned int random_len, void *id,
- SilcIdType type, unsigned int *ret_len)
+ uint32 random_len, void *id,
+ SilcIdType type, uint32 *ret_len)
{
SilcBuffer buf;
unsigned char *pk, *id_data, *ret;
- unsigned int pk_len, id_len;
+ uint32 pk_len, id_len;
pk = silc_pkcs_public_key_encode(public_key, &pk_len);
if (!pk)
{
unsigned char *random;
unsigned char auth_data[1024];
- unsigned int auth_len;
+ uint32 auth_len;
unsigned char *tmp;
- unsigned int tmp_len;
+ uint32 tmp_len;
SilcBuffer buf;
SilcPKCS pkcs;
void *id, SilcIdType type)
{
unsigned char *tmp;
- unsigned int tmp_len;
+ uint32 tmp_len;
SilcPKCS pkcs;
SILC_LOG_DEBUG(("Verifying authentication data"));
`auth_data_len' is ignored. */
int silc_auth_verify(SilcAuthPayload payload, SilcAuthMethod auth_method,
- void *auth_data, unsigned int auth_data_len,
+ void *auth_data, uint32 auth_data_len,
SilcHash hash, void *id, SilcIdType type)
{
SILC_LOG_DEBUG(("Verifying authentication"));
/* Same as above but parses the authentication payload before verify. */
-int silc_auth_verify_data(unsigned char *payload, unsigned int payload_len,
+int silc_auth_verify_data(unsigned char *payload, uint32 payload_len,
SilcAuthMethod auth_method, void *auth_data,
- unsigned int auth_data_len, SilcHash hash,
+ uint32 auth_data_len, SilcHash hash,
void *id, SilcIdType type)
{
SilcAuthPayload auth_payload;
/* The Key Agreement protocol structure */
struct SilcKeyAgreementPayloadStruct {
- unsigned short hostname_len;
+ uint16 hostname_len;
unsigned char *hostname;
- unsigned int port;
+ uint32 port;
};
/* Parses and returns an allocated Key Agreement payload. */
/* Encodes the Key Agreement protocol and returns the encoded buffer */
SilcBuffer silc_key_agreement_payload_encode(char *hostname,
- unsigned int port)
+ uint32 port)
{
SilcBuffer buffer;
- unsigned int len = hostname ? strlen(hostname) : 0;
+ uint32 len = hostname ? strlen(hostname) : 0;
SILC_LOG_DEBUG(("Encoding Key Agreement Payload"));
/* Returns the port in the payload */
-unsigned int silc_key_agreement_get_port(SilcKeyAgreementPayload payload)
+uint32 silc_key_agreement_get_port(SilcKeyAgreementPayload payload)
{
return payload->port;
}
typedef struct SilcKeyAgreementPayloadStruct *SilcKeyAgreementPayload;
/* Authentication method type */
-typedef unsigned short SilcAuthMethod;
+typedef uint16 SilcAuthMethod;
/* Authentication methods in SILC protocol */
#define SILC_AUTH_NONE 0
/* Prototypes */
SilcAuthPayload silc_auth_payload_parse(unsigned char *data,
- unsigned int data_len);
+ uint32 data_len);
SilcBuffer silc_auth_payload_encode(SilcAuthMethod method,
unsigned char *random_data,
- unsigned short random_len,
+ uint16 random_len,
unsigned char *auth_data,
- unsigned short auth_len);
+ uint16 auth_len);
void silc_auth_payload_free(SilcAuthPayload payload);
SilcAuthMethod silc_auth_get_method(SilcAuthPayload payload);
unsigned char *silc_auth_get_data(SilcAuthPayload payload,
- unsigned int *auth_len);
+ uint32 *auth_len);
SilcBuffer silc_auth_public_key_auth_generate(SilcPublicKey public_key,
SilcPrivateKey private_key,
SilcHash hash,
SilcHash hash,
void *id, SilcIdType type);
int silc_auth_verify(SilcAuthPayload payload, SilcAuthMethod auth_method,
- void *auth_data, unsigned int auth_data_len,
+ void *auth_data, uint32 auth_data_len,
SilcHash hash, void *id, SilcIdType type);
-int silc_auth_verify_data(unsigned char *payload, unsigned int payload_len,
+int silc_auth_verify_data(unsigned char *payload, uint32 payload_len,
SilcAuthMethod auth_method, void *auth_data,
- unsigned int auth_data_len, SilcHash hash,
+ uint32 auth_data_len, SilcHash hash,
void *id, SilcIdType type);
SilcKeyAgreementPayload silc_key_agreement_payload_parse(SilcBuffer buffer);
SilcBuffer silc_key_agreement_payload_encode(char *hostname,
- unsigned int port);
+ uint32 port);
void silc_key_agreement_payload_free(SilcKeyAgreementPayload payload);
char *silc_key_agreement_get_hostname(SilcKeyAgreementPayload payload);
-unsigned int silc_key_agreement_get_port(SilcKeyAgreementPayload payload);
+uint32 silc_key_agreement_get_port(SilcKeyAgreementPayload payload);
#endif
/* Channel Message Payload structure. Contents of this structure is parsed
from SILC packets. */
struct SilcChannelPayloadStruct {
- unsigned short name_len;
+ uint16 name_len;
unsigned char *channel_name;
- unsigned short id_len;
+ uint16 id_len;
unsigned char *channel_id;
- unsigned int mode;
+ uint32 mode;
};
/* Parses channel payload returning new channel payload structure. */
/* Encode new channel payload and returns it as buffer. */
SilcBuffer silc_channel_payload_encode(unsigned char *channel_name,
- unsigned short channel_name_len,
+ uint16 channel_name_len,
unsigned char *channel_id,
- unsigned int channel_id_len,
- unsigned int mode)
+ uint32 channel_id_len,
+ uint32 mode)
{
SilcBuffer buffer;
/* Return the channel name */
unsigned char *silc_channel_get_name(SilcChannelPayload payload,
- unsigned int *channel_name_len)
+ uint32 *channel_name_len)
{
if (channel_name_len)
*channel_name_len = payload->name_len;
/* Return the channel ID */
unsigned char *silc_channel_get_id(SilcChannelPayload payload,
- unsigned int *channel_id_len)
+ uint32 *channel_id_len)
{
if (channel_id_len)
*channel_id_len = payload->id_len;
channel or perhaps the mode of the client on the channel. The protocol
dictates what the usage of the mode is in different circumstances. */
-unsigned int silc_channel_get_mode(SilcChannelPayload payload)
+uint32 silc_channel_get_mode(SilcChannelPayload payload)
{
return payload->mode;
}
/* Channel Message Payload structure. Contents of this structure is parsed
from SILC packets. */
struct SilcChannelMessagePayloadStruct {
- unsigned short flags;
- unsigned short data_len;
+ uint16 flags;
+ uint16 data_len;
unsigned char *data;
unsigned char *mac;
unsigned char *iv;
SilcCipher cipher,
SilcHmac hmac)
{
- unsigned int iv_len, mac_len;
+ uint32 iv_len, mac_len;
unsigned char *end, *mac, mac2[32];
/* Decrypt the channel message. First push the IV out of the packet.
{
SilcChannelMessagePayload new;
int ret;
- unsigned int iv_len, mac_len;
+ uint32 iv_len, mac_len;
SILC_LOG_DEBUG(("Parsing channel message payload"));
encrypted separately from other parts of the packet padding must
be applied to the payload. */
-SilcBuffer silc_channel_message_payload_encode(unsigned short flags,
- unsigned short data_len,
+SilcBuffer silc_channel_message_payload_encode(uint16 flags,
+ uint16 data_len,
unsigned char *data,
- unsigned short iv_len,
+ uint16 iv_len,
unsigned char *iv,
SilcCipher cipher,
SilcHmac hmac)
{
int i;
SilcBuffer buffer;
- unsigned int len, pad_len, mac_len;
+ uint32 len, pad_len, mac_len;
unsigned char pad[SILC_PACKET_MAX_PADLEN];
unsigned char mac[32];
/* Return flags */
-unsigned short
+uint16
silc_channel_message_get_flags(SilcChannelMessagePayload payload)
{
return payload->flags;
/* Return data */
unsigned char *silc_channel_message_get_data(SilcChannelMessagePayload payload,
- unsigned int *data_len)
+ uint32 *data_len)
{
if (data_len)
*data_len = payload->data_len;
/* Channel Key Payload structrue. Channel keys are parsed from SILC
packets into this structure. */
struct SilcChannelKeyPayloadStruct {
- unsigned short id_len;
+ uint16 id_len;
unsigned char *id;
- unsigned short cipher_len;
+ uint16 cipher_len;
unsigned char *cipher;
- unsigned short key_len;
+ uint16 key_len;
unsigned char *key;
};
/* Encodes channel key payload into a buffer and returns it. This is used
to add channel key payload into a packet. */
-SilcBuffer silc_channel_key_payload_encode(unsigned short id_len,
+SilcBuffer silc_channel_key_payload_encode(uint16 id_len,
unsigned char *id,
- unsigned short cipher_len,
+ uint16 cipher_len,
unsigned char *cipher,
- unsigned short key_len,
+ uint16 key_len,
unsigned char *key)
{
SilcBuffer buffer;
- unsigned int len;
+ uint32 len;
SILC_LOG_DEBUG(("Encoding channel key payload"));
/* Return ID */
unsigned char *silc_channel_key_get_id(SilcChannelKeyPayload payload,
- unsigned int *id_len)
+ uint32 *id_len)
{
if (id_len)
*id_len = payload->id_len;
/* Return cipher name */
unsigned char *silc_channel_key_get_cipher(SilcChannelKeyPayload payload,
- unsigned int *cipher_len)
+ uint32 *cipher_len)
{
if (cipher_len)
*cipher_len = payload->cipher_len;
/* Return key */
unsigned char *silc_channel_key_get_key(SilcChannelKeyPayload payload,
- unsigned int *key_len)
+ uint32 *key_len)
{
if (key_len)
*key_len = payload->key_len;
typedef struct SilcChannelKeyPayloadStruct *SilcChannelKeyPayload;
/* The Message flag type */
-typedef unsigned short SilcMessageFlags;
+typedef uint16 SilcMessageFlags;
/* The message flags (shared by both channel and private messages) */
#define SILC_MESSAGE_FLAG_NONE 0x0000
SilcChannelPayload silc_channel_payload_parse(SilcBuffer buffer);
SilcDList silc_channel_payload_parse_list(SilcBuffer buffer);
SilcBuffer silc_channel_payload_encode(unsigned char *channel_name,
- unsigned short channel_name_len,
+ uint16 channel_name_len,
unsigned char *channel_id,
- unsigned int channel_id_len,
- unsigned int mode);
+ uint32 channel_id_len,
+ uint32 mode);
void silc_channel_payload_free(SilcChannelPayload payload);
void silc_channel_payload_list_free(SilcDList list);
unsigned char *silc_channel_get_name(SilcChannelPayload payload,
- unsigned int *channel_name_len);
+ uint32 *channel_name_len);
unsigned char *silc_channel_get_id(SilcChannelPayload payload,
- unsigned int *channel_id_len);
+ uint32 *channel_id_len);
SilcChannelID *silc_channel_get_id_parse(SilcChannelPayload payload);
-unsigned int silc_channel_get_mode(SilcChannelPayload payload);
+uint32 silc_channel_get_mode(SilcChannelPayload payload);
int silc_channel_message_payload_decrypt(unsigned char *data,
size_t data_len,
SilcCipher cipher,
silc_channel_message_payload_parse(SilcBuffer buffer,
SilcCipher cipher,
SilcHmac hmac);
-SilcBuffer silc_channel_message_payload_encode(unsigned short flags,
- unsigned short data_len,
+SilcBuffer silc_channel_message_payload_encode(uint16 flags,
+ uint16 data_len,
unsigned char *data,
- unsigned short iv_len,
+ uint16 iv_len,
unsigned char *iv,
SilcCipher cipher,
SilcHmac hmac);
void silc_channel_message_payload_free(SilcChannelMessagePayload payload);
-unsigned short
+uint16
silc_channel_message_get_flags(SilcChannelMessagePayload payload);
unsigned char *silc_channel_message_get_data(SilcChannelMessagePayload payload,
- unsigned int *data_len);
+ uint32 *data_len);
unsigned char *silc_channel_message_get_mac(SilcChannelMessagePayload payload);
unsigned char *silc_channel_message_get_iv(SilcChannelMessagePayload payload);
SilcChannelKeyPayload silc_channel_key_payload_parse(SilcBuffer buffer);
-SilcBuffer silc_channel_key_payload_encode(unsigned short id_len,
+SilcBuffer silc_channel_key_payload_encode(uint16 id_len,
unsigned char *id,
- unsigned short cipher_len,
+ uint16 cipher_len,
unsigned char *cipher,
- unsigned short key_len,
+ uint16 key_len,
unsigned char *key);
void silc_channel_key_payload_free(SilcChannelKeyPayload payload);
unsigned char *silc_channel_key_get_id(SilcChannelKeyPayload payload,
- unsigned int *id_len);
+ uint32 *id_len);
unsigned char *silc_channel_key_get_cipher(SilcChannelKeyPayload payload,
- unsigned int *cipher_len);
+ uint32 *cipher_len);
unsigned char *silc_channel_key_get_key(SilcChannelKeyPayload payload,
- unsigned int *key_len);
+ uint32 *key_len);
#endif
from SILC packets. */
struct SilcCommandPayloadStruct {
SilcCommand cmd;
- unsigned short ident;
+ uint16 ident;
SilcArgumentPayload args;
};
{
SilcCommandPayload new;
unsigned char args_num;
- unsigned short payload_len;
+ uint16 payload_len;
int ret;
SILC_LOG_DEBUG(("Parsing command payload"));
/* Encodes Command Payload returning it to SilcBuffer. */
SilcBuffer silc_command_payload_encode(SilcCommand cmd,
- unsigned int argc,
+ uint32 argc,
unsigned char **argv,
- unsigned int *argv_lens,
- unsigned int *argv_types,
- unsigned short ident)
+ uint32 *argv_lens,
+ uint32 *argv_types,
+ uint16 ident)
{
SilcBuffer buffer;
SilcBuffer args = NULL;
- unsigned int len = 0;
+ uint32 len = 0;
SILC_LOG_DEBUG(("Encoding command payload"));
{
SilcBuffer buffer;
SilcBuffer args = NULL;
- unsigned int len = 0;
- unsigned int argc = 0;
+ uint32 len = 0;
+ uint32 argc = 0;
SILC_LOG_DEBUG(("Encoding command payload"));
}
/* Encodes Command payload with variable argument list. The arguments
- must be: unsigned int, unsigned char *, unsigned int, ... One
- {unsigned int, unsigned char * and unsigned int} forms one argument,
- thus `argc' in case when sending one {unsigned int, unsigned char *
- and unsigned int} equals one (1) and when sending two of those it
+ must be: uint32, unsigned char *, unsigned int, ... One
+ {uint32, unsigned char * and unsigned int} forms one argument,
+ thus `argc' in case when sending one {uint32, unsigned char *
+ and uint32} equals one (1) and when sending two of those it
equals two (2), and so on. This has to be preserved or bad things
will happen. The variable arguments is: {type, data, data_len}. */
SilcBuffer silc_command_payload_encode_va(SilcCommand cmd,
- unsigned short ident,
- unsigned int argc, ...)
+ uint16 ident,
+ uint32 argc, ...)
{
va_list ap;
unsigned char **argv;
- unsigned int *argv_lens = NULL, *argv_types = NULL;
+ uint32 *argv_lens = NULL, *argv_types = NULL;
unsigned char *x;
- unsigned int x_len;
- unsigned int x_type;
+ uint32 x_len;
+ uint32 x_type;
SilcBuffer buffer;
int i, k;
va_start(ap, argc);
argv = silc_calloc(argc, sizeof(unsigned char *));
- argv_lens = silc_calloc(argc, sizeof(unsigned int));
- argv_types = silc_calloc(argc, sizeof(unsigned int));
+ argv_lens = silc_calloc(argc, sizeof(uint32));
+ argv_types = silc_calloc(argc, sizeof(uint32));
for (i = 0, k = 0; i < argc; i++) {
- x_type = va_arg(ap, unsigned int);
+ x_type = va_arg(ap, uint32);
x = va_arg(ap, unsigned char *);
- x_len = va_arg(ap, unsigned int);
+ x_len = va_arg(ap, uint32);
if (!x_type || !x || !x_len)
continue;
/* Same as above but with va_list. */
SilcBuffer silc_command_payload_encode_vap(SilcCommand cmd,
- unsigned short ident,
- unsigned int argc, va_list ap)
+ uint16 ident,
+ uint32 argc, va_list ap)
{
unsigned char **argv;
- unsigned int *argv_lens = NULL, *argv_types = NULL;
+ uint32 *argv_lens = NULL, *argv_types = NULL;
unsigned char *x;
- unsigned int x_len;
- unsigned int x_type;
+ uint32 x_len;
+ uint32 x_type;
SilcBuffer buffer;
int i, k;
argv = silc_calloc(argc, sizeof(unsigned char *));
- argv_lens = silc_calloc(argc, sizeof(unsigned int));
- argv_types = silc_calloc(argc, sizeof(unsigned int));
+ argv_lens = silc_calloc(argc, sizeof(uint32));
+ argv_types = silc_calloc(argc, sizeof(uint32));
for (i = 0, k = 0; i < argc; i++) {
- x_type = va_arg(ap, unsigned int);
+ x_type = va_arg(ap, uint32);
x = va_arg(ap, unsigned char *);
- x_len = va_arg(ap, unsigned int);
+ x_len = va_arg(ap, uint32);
if (!x_type || !x || !x_len)
continue;
SilcBuffer
silc_command_reply_payload_encode_va(SilcCommand cmd,
SilcCommandStatus status,
- unsigned short ident,
- unsigned int argc, ...)
+ uint16 ident,
+ uint32 argc, ...)
{
va_list ap;
unsigned char **argv;
- unsigned int *argv_lens = NULL, *argv_types = NULL;
+ uint32 *argv_lens = NULL, *argv_types = NULL;
unsigned char status_data[2];
unsigned char *x;
- unsigned int x_len;
- unsigned int x_type;
+ uint32 x_len;
+ uint32 x_type;
SilcBuffer buffer;
int i, k;
argc++;
argv = silc_calloc(argc, sizeof(unsigned char *));
- argv_lens = silc_calloc(argc, sizeof(unsigned int));
- argv_types = silc_calloc(argc, sizeof(unsigned int));
+ argv_lens = silc_calloc(argc, sizeof(uint32));
+ argv_types = silc_calloc(argc, sizeof(uint32));
SILC_PUT16_MSB(status, status_data);
argv[0] = silc_calloc(sizeof(status_data) + 1, sizeof(unsigned char));
argv_types[0] = 1;
for (i = 1, k = 1; i < argc; i++) {
- x_type = va_arg(ap, unsigned int);
+ x_type = va_arg(ap, uint32);
x = va_arg(ap, unsigned char *);
- x_len = va_arg(ap, unsigned int);
+ x_len = va_arg(ap, uint32);
if (!x_type || !x || !x_len)
continue;
/* Returns identifier */
-unsigned short silc_command_get_ident(SilcCommandPayload payload)
+uint16 silc_command_get_ident(SilcCommandPayload payload)
{
return payload->ident;
}
payloads are frequentlly resent in SILC and thusly this makes it easy
to set the identifier. */
-void silc_command_set_ident(SilcCommandPayload payload, unsigned short ident)
+void silc_command_set_ident(SilcCommandPayload payload, uint16 ident)
{
payload->ident = ident;
}
#define SILC_COMMAND_RESERVED 255
/* Command Status type */
-typedef unsigned short SilcCommandStatus;
+typedef uint16 SilcCommandStatus;
/* Command Status messages */
#define SILC_STATUS_OK 0
/* Prototypes */
SilcCommandPayload silc_command_payload_parse(SilcBuffer buffer);
SilcBuffer silc_command_payload_encode(SilcCommand cmd,
- unsigned int argc,
+ uint32 argc,
unsigned char **argv,
- unsigned int *argv_lens,
- unsigned int *argv_types,
- unsigned short ident);
+ uint32 *argv_lens,
+ uint32 *argv_types,
+ uint16 ident);
SilcBuffer silc_command_payload_encode_payload(SilcCommandPayload payload);
SilcBuffer silc_command_payload_encode_va(SilcCommand cmd,
- unsigned short ident,
- unsigned int argc, ...);
+ uint16 ident,
+ uint32 argc, ...);
SilcBuffer silc_command_payload_encode_vap(SilcCommand cmd,
- unsigned short ident,
- unsigned int argc, va_list ap);
+ uint16 ident,
+ uint32 argc, va_list ap);
SilcBuffer
silc_command_reply_payload_encode_va(SilcCommand cmd,
SilcCommandStatus status,
- unsigned short ident,
- unsigned int argc, ...);
+ uint16 ident,
+ uint32 argc, ...);
void silc_command_free_payload(SilcCommandPayload payload);
SilcCommand silc_command_get(SilcCommandPayload payload);
SilcArgumentPayload silc_command_get_args(SilcCommandPayload payload);
-unsigned short silc_command_get_ident(SilcCommandPayload payload);
-void silc_command_set_ident(SilcCommandPayload payload, unsigned short ident);
+uint16 silc_command_get_ident(SilcCommandPayload payload);
+void silc_command_set_ident(SilcCommandPayload payload, uint16 ident);
void silc_command_set_command(SilcCommandPayload payload, SilcCommand command);
#endif
SilcNotifyPayload silc_notify_payload_parse(SilcBuffer buffer)
{
SilcNotifyPayload new;
- unsigned short len;
+ uint16 len;
int ret;
SILC_LOG_DEBUG(("Parsing Notify payload"));
/* Encode notify payload with variable argument list. If `argc' is > 0
argument payloads will be associated to the notify payload. Variable
- arguments must be {usigned char *, unsigned int (len)}. */
+ arguments must be {usigned char *, uint32 (len)}. */
-SilcBuffer silc_notify_payload_encode(SilcNotifyType type, unsigned int argc,
+SilcBuffer silc_notify_payload_encode(SilcNotifyType type, uint32 argc,
va_list ap)
{
SilcBuffer buffer;
SilcBuffer args = NULL;
unsigned char **argv;
- unsigned int *argv_lens = NULL, *argv_types = NULL;
+ uint32 *argv_lens = NULL, *argv_types = NULL;
unsigned char *x;
- unsigned int x_len;
+ uint32 x_len;
int i, k = 0, len = 0;
if (argc) {
argv = silc_calloc(argc, sizeof(unsigned char *));
- argv_lens = silc_calloc(argc, sizeof(unsigned int));
- argv_types = silc_calloc(argc, sizeof(unsigned int));
+ argv_lens = silc_calloc(argc, sizeof(uint32));
+ argv_types = silc_calloc(argc, sizeof(uint32));
for (i = 0, k = 0; i < argc; i++) {
x = va_arg(ap, unsigned char *);
- x_len = va_arg(ap, unsigned int);
+ x_len = va_arg(ap, uint32);
if (!x || !x_len)
continue;
/* Same as above but takes argument from the `args' Argument Payload. */
SilcBuffer silc_notify_payload_encode_args(SilcNotifyType type,
- unsigned int argc,
+ uint32 argc,
SilcBuffer args)
{
SilcBuffer buffer;
/* Return argument nums */
-unsigned int silc_notify_get_arg_num(SilcNotifyPayload payload)
+uint32 silc_notify_get_arg_num(SilcNotifyPayload payload)
{
return payload->argc;
}
typedef struct SilcNotifyPayloadStruct *SilcNotifyPayload;
/* Type definition of notify type */
-typedef unsigned short SilcNotifyType;
+typedef uint16 SilcNotifyType;
/* SILC notify types. Server may send these notify types to client to
notify of some action. */
/* Prototypes */
SilcNotifyPayload silc_notify_payload_parse(SilcBuffer buffer);
-SilcBuffer silc_notify_payload_encode(SilcNotifyType type, unsigned int argc,
+SilcBuffer silc_notify_payload_encode(SilcNotifyType type, uint32 argc,
va_list ap);
SilcBuffer silc_notify_payload_encode_args(SilcNotifyType type,
- unsigned int argc,
+ uint32 argc,
SilcBuffer args);
void silc_notify_payload_free(SilcNotifyPayload payload);
SilcNotifyType silc_notify_get_type(SilcNotifyPayload payload);
-unsigned int silc_notify_get_arg_num(SilcNotifyPayload payload);
+uint32 silc_notify_get_arg_num(SilcNotifyPayload payload);
SilcArgumentPayload silc_notify_get_args(SilcNotifyPayload payload);
#endif
cannot be used. */
void silc_packet_encrypt(SilcCipher cipher, SilcHmac hmac,
- SilcBuffer buffer, unsigned int len)
+ SilcBuffer buffer, uint32 len)
{
unsigned char mac[32];
- unsigned int mac_len;
+ uint32 mac_len;
/* Compute HMAC. This assumes that HMAC is created from the entire
data area thus this uses the length found in buffer, not the length
outgoing buffer in SilcSocketConnection object. */
void silc_packet_send_prepare(SilcSocketConnection sock,
- unsigned int header_len,
- unsigned int padlen,
- unsigned int data_len)
+ uint32 header_len,
+ uint32 padlen,
+ uint32 data_len)
{
int totlen, oldlen;
/* Check MAC */
if (hmac) {
unsigned char mac[32];
- unsigned int mac_len;
+ uint32 mac_len;
SILC_LOG_DEBUG(("Verifying MAC"));
{
/* Decrypt rest of the header plus padding */
if (cipher) {
- unsigned short truelen, len1, len2, padlen;
+ uint16 truelen, len1, len2, padlen;
/* Pull MAC from packet before decryption */
if (hmac) {
Packet flags. Flags are defined above.
unsigned char *src_id
- unsigned short src_id_len
+ uint16 src_id_len
unsigned char src_id_type
Source ID, its length and type. On packet reception retuned ID's
are always the hash values of the ID's from the packet.
unsigned char *dst_id;
- unsigned short dst_id_len;
+ uint16 dst_id_len;
unsigned char src_id_type;
Destination ID, its length and type. On packet reception retuned
SilcPacketFlags flags;
unsigned char *src_id;
- unsigned short src_id_len;
+ uint16 src_id_len;
unsigned char src_id_type;
unsigned char *dst_id;
- unsigned short dst_id_len;
+ uint16 dst_id_len;
unsigned char dst_id_type;
- unsigned short truelen;
- unsigned short padlen;
+ uint16 truelen;
+ uint16 padlen;
/* Back pointers */
void *context;
int silc_packet_write(int sock, SilcBuffer src);
int silc_packet_send(SilcSocketConnection sock, int force_send);
void silc_packet_encrypt(SilcCipher cipher, SilcHmac hmac,
- SilcBuffer buffer, unsigned int len);
+ SilcBuffer buffer, uint32 len);
void silc_packet_assemble(SilcPacketContext *ctx);
void silc_packet_send_prepare(SilcSocketConnection sock,
- unsigned int header_len,
- unsigned int padlen,
- unsigned int data_len);
+ uint32 header_len,
+ uint32 padlen,
+ uint32 data_len);
int silc_packet_read(int sock, SilcBuffer dest);
int silc_packet_receive(SilcSocketConnection sock);
int silc_packet_decrypt(SilcCipher cipher, SilcHmac hmac,
struct SilcIDPayloadStruct {
SilcIdType type;
- unsigned short len;
+ uint16 len;
unsigned char *id;
};
/* Parses data and return ID payload into payload structure. */
SilcIDPayload silc_id_payload_parse_data(unsigned char *data,
- unsigned int len)
+ uint32 len)
{
SilcIDPayload new;
SilcBuffer buffer;
/* Return the ID directly from the raw payload data. */
-void *silc_id_payload_parse_id(unsigned char *data, unsigned int len)
+void *silc_id_payload_parse_id(unsigned char *data, uint32 len)
{
SilcBuffer buffer;
SilcIdType type;
- unsigned short idlen;
+ uint16 idlen;
unsigned char *id_data;
int ret;
void *id;
{
SilcBuffer buffer;
unsigned char *id_data;
- unsigned int len;
+ uint32 len;
SILC_LOG_DEBUG(("Encoding %s ID payload",
type == SILC_ID_CLIENT ? "Client" :
/* Get length of ID */
-unsigned int silc_id_payload_get_len(SilcIDPayload payload)
+uint32 silc_id_payload_get_len(SilcIDPayload payload)
{
return payload ? payload->len : 0;
}
******************************************************************************/
struct SilcArgumentPayloadStruct {
- unsigned int argc;
+ uint32 argc;
unsigned char **argv;
- unsigned int *argv_lens;
- unsigned int *argv_types;
- unsigned int pos;
+ uint32 *argv_lens;
+ uint32 *argv_types;
+ uint32 pos;
};
/* Parses arguments and returns them into Argument Payload structure. */
SilcArgumentPayload silc_argument_payload_parse(SilcBuffer buffer,
- unsigned int argc)
+ uint32 argc)
{
SilcArgumentPayload new;
- unsigned short payload_len = 0;
+ uint16 payload_len = 0;
unsigned char arg_num = 0;
unsigned char arg_type = 0;
- unsigned int pull_len = 0;
+ uint32 pull_len = 0;
int i = 0, ret;
SILC_LOG_DEBUG(("Parsing argument payload"));
new = silc_calloc(1, sizeof(*new));
new->argv = silc_calloc(argc, sizeof(unsigned char *));
- new->argv_lens = silc_calloc(argc, sizeof(unsigned int));
- new->argv_types = silc_calloc(argc, sizeof(unsigned int));
+ new->argv_lens = silc_calloc(argc, sizeof(uint32));
+ new->argv_types = silc_calloc(argc, sizeof(uint32));
/* Get arguments */
arg_num = 1;
/* Encodes arguments in to Argument Paylods returning them to SilcBuffer. */
-SilcBuffer silc_argument_payload_encode(unsigned int argc,
+SilcBuffer silc_argument_payload_encode(uint32 argc,
unsigned char **argv,
- unsigned int *argv_lens,
- unsigned int *argv_types)
+ uint32 *argv_lens,
+ uint32 *argv_types)
{
SilcBuffer buffer;
- unsigned int len;
+ uint32 len;
int i;
SILC_LOG_DEBUG(("Encoding Argument payload"));
SilcBuffer silc_argument_payload_encode_payload(SilcArgumentPayload payload)
{
SilcBuffer buffer;
- unsigned int len;
+ uint32 len;
int i;
SILC_LOG_DEBUG(("Encoding Argument payload"));
/* Returns number of arguments in payload */
-unsigned int silc_argument_get_arg_num(SilcArgumentPayload payload)
+uint32 silc_argument_get_arg_num(SilcArgumentPayload payload)
{
return payload ? payload->argc : 0;
}
/* Returns first argument from payload. */
unsigned char *silc_argument_get_first_arg(SilcArgumentPayload payload,
- unsigned int *ret_len)
+ uint32 *ret_len)
{
if (!payload)
return NULL;
/* Returns next argument from payload or NULL if no more arguments. */
unsigned char *silc_argument_get_next_arg(SilcArgumentPayload payload,
- unsigned int *ret_len)
+ uint32 *ret_len)
{
if (!payload)
return NULL;
/* Returns argument which type is `type'. */
unsigned char *silc_argument_get_arg_type(SilcArgumentPayload payload,
- unsigned int type,
- unsigned int *ret_len)
+ uint32 type,
+ uint32 *ret_len)
{
int i;
/* Prototypes */
SilcIDPayload silc_id_payload_parse(SilcBuffer buffer);
SilcIDPayload silc_id_payload_parse_data(unsigned char *data,
- unsigned int len);
-void *silc_id_payload_parse_id(unsigned char *data, unsigned int len);
+ uint32 len);
+void *silc_id_payload_parse_id(unsigned char *data, uint32 len);
SilcBuffer silc_id_payload_encode(void *id, SilcIdType type);
void silc_id_payload_free(SilcIDPayload payload);
SilcIdType silc_id_payload_get_type(SilcIDPayload payload);
void *silc_id_payload_get_id(SilcIDPayload payload);
unsigned char *silc_id_payload_get_data(SilcIDPayload payload);
-unsigned int silc_id_payload_get_len(SilcIDPayload payload);
+uint32 silc_id_payload_get_len(SilcIDPayload payload);
SilcArgumentPayload silc_argument_payload_parse(SilcBuffer buffer,
- unsigned int argc);
-SilcBuffer silc_argument_payload_encode(unsigned int argc,
+ uint32 argc);
+SilcBuffer silc_argument_payload_encode(uint32 argc,
unsigned char **argv,
- unsigned int *argv_lens,
- unsigned int *argv_types);
+ uint32 *argv_lens,
+ uint32 *argv_types);
SilcBuffer silc_argument_payload_encode_payload(SilcArgumentPayload payload);
void silc_argument_payload_free(SilcArgumentPayload payload);
-unsigned int silc_argument_get_arg_num(SilcArgumentPayload payload);
+uint32 silc_argument_get_arg_num(SilcArgumentPayload payload);
unsigned char *silc_argument_get_first_arg(SilcArgumentPayload payload,
- unsigned int *ret_len);
+ uint32 *ret_len);
unsigned char *silc_argument_get_next_arg(SilcArgumentPayload payload,
- unsigned int *ret_len);
+ uint32 *ret_len);
unsigned char *silc_argument_get_arg_type(SilcArgumentPayload payload,
- unsigned int type,
- unsigned int *ret_len);
+ uint32 type,
+ uint32 *ret_len);
#endif
/* Private Message Payload structure. Contents of this structure is parsed
from SILC packets. */
struct SilcPrivateMessagePayloadStruct {
- unsigned short flags;
- unsigned short nickname_len;
+ uint16 flags;
+ uint16 nickname_len;
unsigned char *nickname;
- unsigned short message_len;
+ uint16 message_len;
unsigned char *message;
};
the cipher is provided the packet is also encrypted here. It is provided
if the private message private keys are used. */
-SilcBuffer silc_private_message_payload_encode(unsigned short flags,
- unsigned int nickname_len,
+SilcBuffer silc_private_message_payload_encode(uint16 flags,
+ uint32 nickname_len,
unsigned char *nickname,
- unsigned short data_len,
+ uint16 data_len,
unsigned char *data,
SilcCipher cipher)
{
int i;
SilcBuffer buffer;
- unsigned int len, pad_len = 0;
+ uint32 len, pad_len = 0;
unsigned char pad[SILC_PACKET_MAX_PADLEN];
SILC_LOG_DEBUG(("Encoding private message payload"));
/* Return flags */
-unsigned short
+uint16
silc_private_message_get_flags(SilcPrivateMessagePayload payload)
{
return payload->flags;
unsigned char *
silc_private_message_get_nickname(SilcPrivateMessagePayload payload,
- unsigned int *nickname_len)
+ uint32 *nickname_len)
{
if (nickname_len)
*nickname_len = payload->nickname_len;
unsigned char *
silc_private_message_get_message(SilcPrivateMessagePayload payload,
- unsigned int *message_len)
+ uint32 *message_len)
{
if (message_len)
*message_len = payload->message_len;
SilcPrivateMessagePayload
silc_private_message_payload_parse(SilcBuffer buffer, SilcCipher cipher);
-SilcBuffer silc_private_message_payload_encode(unsigned short flags,
- unsigned int nickname_len,
+SilcBuffer silc_private_message_payload_encode(uint16 flags,
+ uint32 nickname_len,
unsigned char *nickname,
- unsigned short data_len,
+ uint16 data_len,
unsigned char *data,
SilcCipher cipher);
void silc_private_message_payload_free(SilcPrivateMessagePayload payload);
-unsigned short
+uint16
silc_private_message_get_flags(SilcPrivateMessagePayload payload);
unsigned char *
silc_private_message_get_nickname(SilcPrivateMessagePayload payload,
- unsigned int *nickname_len);
+ uint32 *nickname_len);
unsigned char *
silc_private_message_get_message(SilcPrivateMessagePayload payload,
- unsigned int *message_len);
+ uint32 *message_len);
#endif
`timeout_queue' is the application's scheduler timeout queue. */
void silc_socket_set_heartbeat(SilcSocketConnection sock,
- unsigned long heartbeat,
+ uint32 heartbeat,
void *hb_context,
SilcSocketConnectionHBCb hb_callback,
void *timeout_queue)
Protocol object for the socket. Currently only one protocol can be
executing at a time for a particular socket.
- unsigned int flags
+ uint32 flags
Socket flags that indicate the status of the socket. This can
indicate several different status that can affect the use of the
char *hostname
char *ip
- unsigned short port
+ uint16 port
Resolved hostname, IP address and port of the connection who owns
this object.
SilcSocketType type;
void *user_data;
SilcProtocol protocol;
- unsigned int flags;
+ uint32 flags;
int users;
char *hostname;
char *ip;
- unsigned short port;
+ uint16 port;
SilcBuffer inbuf;
SilcBuffer outbuf;
/* Heartbeat context */
struct SilcSocketConnectionHB {
- unsigned long heartbeat;
+ uint32 heartbeat;
SilcSocketConnectionHBCb hb_callback;
void *hb_context;
void *timeout_queue;
void silc_socket_free(SilcSocketConnection sock);
SilcSocketConnection silc_socket_dup(SilcSocketConnection sock);
void silc_socket_set_heartbeat(SilcSocketConnection sock,
- unsigned long heartbeat,
+ uint32 heartbeat,
void *hb_context,
SilcSocketConnectionHBCb hb_callback,
void *timeout_queue);
SILC_CIPHER_API_SET_KEY(aes)
{
- rijndael_set_key((RijndaelContext *)context, (unsigned int *)key, keylen);
+ rijndael_set_key((RijndaelContext *)context, (uint32 *)key, keylen);
return 1;
}
SILC_CIPHER_API_ENCRYPT_CBC(aes)
{
- unsigned int *in, *out, *tiv;
- unsigned int tmp[4];
+ uint32 *in, *out, *tiv;
+ uint32 tmp[4];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0] ^ tiv[0];
tmp[1] = in[1] ^ tiv[1];
SILC_CIPHER_API_DECRYPT_CBC(aes)
{
- unsigned int *tiv, *in, *out;
- unsigned int tmp[4], tmp2[4];
+ uint32 *tiv, *in, *out;
+ uint32 tmp[4], tmp2[4];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0];
tmp[1] = in[1];
/*
* Round loop unrolling macros, S is a pointer to a S-Box array
- * organized in 4 unsigned longs at a row.
+ * organized in 4 uint32s at a row.
*/
#define GET32_3(x) (((x) & 0xff))
/*
* $Id$
* $Log$
- * Revision 1.1 2000/06/27 11:36:54 priikone
- * Initial revision
+ * Revision 1.2 2001/04/03 19:54:10 priikone
+ * updates. New data types.
+ *
+ * Revision 1.1.1.1 2000/06/27 11:36:54 priikone
+ * Importet from internal CVS/Added Log headers.
*
*
*/
SILC_CIPHER_API_ENCRYPT_CBC(blowfish)
{
- unsigned int *in, *out, *tiv;
- unsigned int tmp[4];
+ uint32 *in, *out, *tiv;
+ uint32 tmp[4];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0] ^ tiv[0];
tmp[1] = in[1] ^ tiv[1];
SILC_CIPHER_API_DECRYPT_CBC(blowfish)
{
- unsigned int *in, *out, *tiv;
+ uint32 *in, *out, *tiv;
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
blowfish_decrypt((BlowfishContext *)context, in, out, 16);
out[0] ^= tiv[0];
/*
* $Id$
* $Log$
- * Revision 1.1 2000/06/27 11:36:54 priikone
- * Initial revision
+ * Revision 1.2 2001/04/03 19:54:10 priikone
+ * updates. New data types.
+ *
+ * Revision 1.1.1.1 2000/06/27 11:36:54 priikone
+ * Importet from internal CVS/Added Log headers.
*
*
*/
inline int silc_cast_init(void *context,
const unsigned char *key,
- unsigned int keylen)
+ uint32 keylen)
{
- cast_set_key((CastContext *)context, (unsigned int *)key, keylen);
+ cast_set_key((CastContext *)context, (uint32 *)key, keylen);
return 1;
}
inline int silc_cast_set_string_as_key(void *context,
const unsigned char *string,
- unsigned int stringlen)
+ uint32 stringlen)
{
/* SilcHash hash;
unsigned char key[16];
/* Returns the size of the cipher context. */
-inline unsigned int silc_cast_context_len()
+inline uint32 silc_cast_context_len()
{
return sizeof(CastContext);
}
inline int silc_cast_encrypt_cbc(void *context,
const unsigned char *src,
unsigned char *dst,
- unsigned int len,
+ uint32 len,
unsigned char *iv)
{
- unsigned int *in, *out, *tiv;
- unsigned int tmp[4];
+ uint32 *in, *out, *tiv;
+ uint32 tmp[4];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0] ^ tiv[0];
tmp[1] = in[1] ^ tiv[1];
inline int silc_cast_decrypt_cbc(void *context,
const unsigned char *src,
unsigned char *dst,
- unsigned int len,
+ uint32 len,
unsigned char *iv)
{
- unsigned int *in, *out, *tiv;
+ uint32 *in, *out, *tiv;
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
cast_decrypt((CastContext *)context, in, out);
out[0] ^= tiv[0];
/* General definitions for algorithms */
typedef unsigned char u1byte;
-typedef unsigned int u4byte;
-typedef unsigned int u32;
+typedef uint32 u4byte;
+typedef uint32 u32;
#define rotr(x, nr) (((x) >> ((int)(nr))) | ((x) << (32 - (int)(nr))))
#define rotl(x, nr) (((x) << ((int)(nr))) | ((x) >> (32 - (int)(nr))))
SILC_CIPHER_API_SET_KEY(mars)
{
- mars_set_key((MarsContext *)context, (unsigned int *)key, keylen);
+ mars_set_key((MarsContext *)context, (uint32 *)key, keylen);
return TRUE;
}
SILC_CIPHER_API_ENCRYPT_CBC(mars)
{
- unsigned int *in, *out, *tiv;
- unsigned int tmp[4];
+ uint32 *in, *out, *tiv;
+ uint32 tmp[4];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0] ^ tiv[0];
tmp[1] = in[1] ^ tiv[1];
SILC_CIPHER_API_DECRYPT_CBC(mars)
{
- unsigned int *in, *out, *tiv;
- unsigned int tmp[4], tmp2[4];
+ uint32 *in, *out, *tiv;
+ uint32 tmp[4], tmp2[4];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0];
tmp[1] = in[1];
#ifndef HIGHFIRST
#define byteReverse(buf, len) /* Nothing */
#else
-void byteReverse(unsigned char *buf, unsigned longs);
+void byteReverse(unsigned char *buf, uint32s);
#ifndef ASM_MD5
/*
* Note: this code is harmless on little-endian machines.
*/
-void byteReverse(unsigned char *buf, unsigned longs)
+void byteReverse(unsigned char *buf, uint32s)
{
uint32 t;
do {
#ifndef MD5_INTERNAL_H
#define MD5_INTERNAL_H
-typedef unsigned long uint32;
-
struct MD5Context {
uint32 buf[4];
uint32 bits[2];
* the rules defined in PKCS #1.
*/
static unsigned char *
-RSA_FormatOneBlock(unsigned int modulusLen, RSA_BlockType blockType,
- unsigned char *data, unsigned int data_len)
+RSA_FormatOneBlock(uint32 modulusLen, RSA_BlockType blockType,
+ unsigned char *data, uint32 data_len)
{
unsigned char *block;
unsigned char *bp;
}
static int
-RSA_FormatBlock(unsigned char **result, unsigned int *result_len,
- unsigned int modulusLen,
+RSA_FormatBlock(unsigned char **result, uint32 *result_len,
+ uint32 modulusLen,
RSA_BlockType blockType, unsigned char *data,
- unsigned int data_len)
+ uint32 data_len)
{
/*
* XXX For now assume that the data length fits in a single
*/
unsigned char *
RSA_DecodeOneBlock(unsigned char *data,
- unsigned int modulusLen,
- unsigned int expectedLen,
+ uint32 modulusLen,
+ uint32 expectedLen,
RSA_BlockType bt,
- unsigned int *pResultLen)
+ uint32 *pResultLen)
{
RSA_BlockType blockType;
unsigned char *dp, *res;
- unsigned int i, len = 0;
+ uint32 i, len = 0;
dp = data;
if (dp[0] != RSA_BLOCK_FIRST_OCTET) {
SilcInt mp_tmp;
SilcInt mp_dst;
unsigned char *padded;
- unsigned int padded_len, len = key->bits / 8;
+ uint32 padded_len, len = key->bits / 8;
/* Pad data */
if (!RSA_FormatBlock(&padded, &padded_len, len,
SilcInt mp_tmp;
SilcInt mp_dst;
unsigned char *padded, *unpadded;
- unsigned int padded_len;
+ uint32 padded_len;
silc_mp_init_set_ui(&mp_tmp, 0);
silc_mp_init_set_ui(&mp_dst, 0);
SilcInt mp_tmp;
SilcInt mp_dst;
unsigned char *padded;
- unsigned int padded_len;
- unsigned int len = key->bits / 8;
+ uint32 padded_len;
+ uint32 len = key->bits / 8;
/* Pad data */
if (!RSA_FormatBlock(&padded, &padded_len, len, RSA_BlockPrivate,
SilcInt mp_tmp2;
SilcInt mp_dst;
unsigned char *verify, *unpadded;
- unsigned int verify_len, len = key->bits / 8;
+ uint32 verify_len, len = key->bits / 8;
silc_mp_init_set_ui(&mp_tmp2, 0);
silc_mp_init_set_ui(&mp_dst, 0);
/*
* $Id$
* $Log$
- * Revision 1.1 2000/06/27 11:36:54 priikone
- * Initial revision
+ * Revision 1.2 2001/04/03 19:54:10 priikone
+ * updates. New data types.
+ *
+ * Revision 1.1.1.1 2000/06/27 11:36:54 priikone
+ * Importet from internal CVS/Added Log headers.
*
*
*/
SILC_CIPHER_API_ENCRYPT_CBC(rc5)
{
- unsigned int *in, *out, *tiv;
- unsigned int tmp[2];
+ uint32 *in, *out, *tiv;
+ uint32 tmp[2];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0] ^ tiv[0];
tmp[1] = in[1] ^ tiv[1];
SILC_CIPHER_API_DECRYPT_CBC(rc5)
{
- unsigned int *in, *out, *tiv;
- unsigned int tmp[2], tmp2[2];
+ uint32 *in, *out, *tiv;
+ uint32 tmp[2], tmp2[2];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0];
tmp[1] = in[1];
SILC_CIPHER_API_SET_KEY(rc6)
{
- rc6_set_key((RC6Context *)context, (unsigned int *)key, keylen);
+ rc6_set_key((RC6Context *)context, (uint32 *)key, keylen);
return 1;
}
SILC_CIPHER_API_ENCRYPT_CBC(rc6)
{
- unsigned int *in, *out, *tiv;
- unsigned int tmp[4];
+ uint32 *in, *out, *tiv;
+ uint32 tmp[4];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0] ^ tiv[0];
tmp[1] = in[1] ^ tiv[1];
SILC_CIPHER_API_DECRYPT_CBC(rc6)
{
- unsigned int *in, *out, *tiv;
- unsigned int tmp[4], tmp2[4];
+ uint32 *in, *out, *tiv;
+ uint32 tmp[4], tmp2[4];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0];
tmp[1] = in[1];
SILC_PKCS_API_INIT(rsa)
{
- unsigned int prime_bits = keylen / 2;
+ uint32 prime_bits = keylen / 2;
SilcInt p, q;
printf("Generating RSA Public and Private keys, might take a while...\n");
{
RsaKey *key = (RsaKey *)context;
unsigned char *e, *n, *ret;
- unsigned int e_len, n_len;
+ uint32 e_len, n_len;
unsigned char tmp[4];
e = silc_mp_mp2bin(&key->e, 0, &e_len);
{
RsaKey *key = (RsaKey *)context;
unsigned char *e, *n, *d, *ret;
- unsigned int e_len, n_len, d_len;
+ uint32 e_len, n_len, d_len;
unsigned char tmp[4];
e = silc_mp_mp2bin(&key->e, 0, &e_len);
{
RsaKey *key = (RsaKey *)context;
unsigned char tmp[4];
- unsigned int e_len, n_len;
+ uint32 e_len, n_len;
silc_mp_init(&key->e);
silc_mp_init(&key->n);
{
RsaKey *key = (RsaKey *)context;
unsigned char tmp[4];
- unsigned int e_len, n_len, d_len;
+ uint32 e_len, n_len, d_len;
silc_mp_init(&key->e);
silc_mp_init(&key->n);
to compute the modulus n has to be generated before calling this. They
are then sent as argument for the function. */
-void rsa_generate_keys(RsaKey *key, unsigned int bits,
+void rsa_generate_keys(RsaKey *key, uint32 bits,
SilcInt *p, SilcInt *q)
{
SilcInt phi, hlp;
SilcInt d; /* private exponent */
} RsaKey;
-void rsa_generate_keys(RsaKey *key, unsigned int bits,
+void rsa_generate_keys(RsaKey *key, uint32 bits,
SilcInt *p, SilcInt *q);
void rsa_clear_keys(RsaKey *key);
void rsa_en_de_crypt(SilcInt *cm, SilcInt *mc,
/* Hash a single 512-bit block. This is the core of the algorithm. */
-void SHA1Transform(unsigned long state[5], unsigned char buffer[64])
+void SHA1Transform(uint32 state[5], unsigned char buffer[64])
{
-unsigned long a, b, c, d, e;
+uint32 a, b, c, d, e;
typedef union {
unsigned char c[64];
- unsigned long l[16];
+ uint32 l[16];
} CHAR64LONG16;
CHAR64LONG16* block;
static unsigned char workspace[64];
/* Run your data through this. */
-void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len)
+void SHA1Update(SHA1_CTX* context, unsigned char* data, uint32 len)
{
-unsigned int i, j;
+uint32 i, j;
j = (context->count[0] >> 3) & 63;
if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
{
-unsigned long i, j;
+uint32 i, j;
unsigned char finalcount[8];
for (i = 0; i < 8; i++) {
/* Context declaration */
typedef struct {
- unsigned long state[5];
- unsigned long count[2];
+ uint32 state[5];
+ uint32 count[2];
unsigned char buffer[64];
} SHA1_CTX;
/* Function forward declerations */
-void SHA1Transform(unsigned long state[5], unsigned char buffer[64]);
+void SHA1Transform(uint32 state[5], unsigned char buffer[64]);
void SHA1Init(SHA1_CTX* context);
-void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len);
+void SHA1Update(SHA1_CTX* context, unsigned char* data, uint32 len);
void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
#endif
/* Encrypts */
int silc_cipher_encrypt(SilcCipher cipher, const unsigned char *src,
- unsigned char *dst, unsigned int len,
+ unsigned char *dst, uint32 len,
unsigned char *iv)
{
return cipher->cipher->encrypt(cipher->context, src, dst, len, iv);
/* Decrypts */
int silc_cipher_decrypt(SilcCipher cipher, const unsigned char *src,
- unsigned char *dst, unsigned int len,
+ unsigned char *dst, uint32 len,
unsigned char *iv)
{
return cipher->cipher->decrypt(cipher->context, src, dst, len, iv);
/* Sets the key for the cipher */
int silc_cipher_set_key(SilcCipher cipher, const unsigned char *key,
- unsigned int keylen)
+ uint32 keylen)
{
return cipher->cipher->set_key(cipher->context, key, keylen);
}
/* Returns the key length of the cipher. */
-unsigned int silc_cipher_get_key_len(SilcCipher cipher)
+uint32 silc_cipher_get_key_len(SilcCipher cipher)
{
return cipher->cipher->key_len;
}
/* Returns the block size of the cipher. */
-unsigned int silc_cipher_get_block_len(SilcCipher cipher)
+uint32 silc_cipher_get_block_len(SilcCipher cipher)
{
return cipher->cipher->block_len;
}
Logical name of the cipher.
- unsigned int block_len
+ uint32 block_len
Block size of the cipher.
- unsigned int key_len
+ uint32 key_len
Length of the key of the cipher (in bits).
*/
typedef struct {
char *name;
- unsigned int block_len;
+ uint32 block_len;
unsigned key_len;
- int (*set_key)(void *, const unsigned char *, unsigned int);
- int (*set_key_with_string)(void *, const unsigned char *, unsigned int);
+ int (*set_key)(void *, const unsigned char *, uint32);
+ int (*set_key_with_string)(void *, const unsigned char *, uint32);
int (*encrypt)(void *, const unsigned char *, unsigned char *,
- unsigned int, unsigned char *);
+ uint32, unsigned char *);
int (*decrypt)(void *, const unsigned char *, unsigned char *,
- unsigned int, unsigned char *);
- unsigned int (*context_len)();
+ uint32, unsigned char *);
+ uint32 (*context_len)();
} SilcCipherObject;
#define SILC_CIPHER_MAX_IV_SIZE 16
void (*set_iv)(struct SilcCipherStruct *, const unsigned char *);
void (*get_iv)(struct SilcCipherStruct *, unsigned char *);
- unsigned int (*get_key_len)(struct SilcCipherStruct *);
- unsigned int (*get_block_len)(struct SilcCipherStruct *);
+ uint32 (*get_key_len)(struct SilcCipherStruct *);
+ uint32 (*get_block_len)(struct SilcCipherStruct *);
} *SilcCipher;
/* List of all registered ciphers. */
#define SILC_CIPHER_API_SET_KEY(cipher) \
int silc_##cipher##_set_key(void *context, \
const unsigned char *key, \
- unsigned int keylen)
+ uint32 keylen)
#define SILC_CIPHER_API_SET_KEY_WITH_STRING(cipher) \
int silc_##cipher##_set_key_with_string(void *context, \
const unsigned char *string, \
- unsigned int stringlen)
+ uint32 stringlen)
#define SILC_CIPHER_API_ENCRYPT_CBC(cipher) \
int silc_##cipher##_encrypt_cbc(void *context, \
const unsigned char *src, \
unsigned char *dst, \
- unsigned int len, \
+ uint32 len, \
unsigned char *iv)
#define SILC_CIPHER_API_DECRYPT_CBC(cipher) \
int silc_##cipher##_decrypt_cbc(void *context, \
const unsigned char *src, \
unsigned char *dst, \
- unsigned int len, \
+ uint32 len, \
unsigned char *iv)
#define SILC_CIPHER_API_CONTEXT_LEN(cipher) \
-unsigned int silc_##cipher##_context_len()
+uint32 silc_##cipher##_context_len()
/* Prototypes */
int silc_cipher_register(SilcCipherObject *cipher);
int silc_cipher_is_supported(const unsigned char *name);
char *silc_cipher_get_supported();
int silc_cipher_encrypt(SilcCipher cipher, const unsigned char *src,
- unsigned char *dst, unsigned int len,
+ unsigned char *dst, uint32 len,
unsigned char *iv);
int silc_cipher_decrypt(SilcCipher cipher, const unsigned char *src,
- unsigned char *dst, unsigned int len,
+ unsigned char *dst, uint32 len,
unsigned char *iv);
int silc_cipher_set_key(SilcCipher cipher, const unsigned char *key,
- unsigned int keylen);
+ uint32 keylen);
void silc_cipher_set_iv(SilcCipher cipher, const unsigned char *iv);
void silc_cipher_get_iv(SilcCipher cipher, unsigned char *iv);
-unsigned int silc_cipher_get_key_len(SilcCipher cipher);
-unsigned int silc_cipher_get_block_len(SilcCipher cipher);
+uint32 silc_cipher_get_key_len(SilcCipher cipher);
+uint32 silc_cipher_get_block_len(SilcCipher cipher);
#endif
/* Same as above but returns the computed secret key as octet binary
string. */
int silc_dh_compute_key_data(SilcDH dh, unsigned char **z,
- unsigned int *z_len);
+ uint32 *z_len);
#endif
/* Returns the length of the hash digest. */
-unsigned int silc_hash_len(SilcHash hash)
+uint32 silc_hash_len(SilcHash hash)
{
return hash->hash->hash_len;
}
/* Creates the hash value and returns it to the return_hash argument. */
void silc_hash_make(SilcHash hash, const unsigned char *data,
- unsigned int len, unsigned char *return_hash)
+ uint32 len, unsigned char *return_hash)
{
hash->hash->init(hash->context);
hash->hash->update(hash->context, (unsigned char *)data, len);
caller. */
char *silc_hash_fingerprint(SilcHash hash, const unsigned char *data,
- unsigned int data_len)
+ uint32 data_len)
{
char fingerprint[64], *cp;
unsigned char h[32];
/* The default Silc hash object to represent any hash function in SILC. */
typedef struct {
char *name;
- unsigned int hash_len;
- unsigned int block_len;
+ uint32 hash_len;
+ uint32 block_len;
void (*init)(void *);
- void (*update)(void *, unsigned char *, unsigned int);
+ void (*update)(void *, unsigned char *, uint32);
void (*final)(void *, unsigned char *);
- void (*transform)(unsigned long *, unsigned char *);
- unsigned int (*context_len)();
+ void (*transform)(uint32 *, unsigned char *);
+ uint32 (*context_len)();
} SilcHashObject;
/* The main SILC hash structure. Use SilcHash instead of SilcHashStruct.
void *context;
void (*make_hash)(struct SilcHashStruct *, const unsigned char *,
- unsigned int, unsigned char *);
+ uint32, unsigned char *);
} *SilcHash;
extern struct SilcHashListStruct *silc_hash_list;
void silc_##hash##_init(void *context)
#define SILC_HASH_API_UPDATE(hash) \
void silc_##hash##_update(void *context, unsigned char *data, \
- unsigned int len)
+ uint32 len)
#define SILC_HASH_API_FINAL(hash) \
void silc_##hash##_final(void *context, unsigned char *digest)
#define SILC_HASH_API_TRANSFORM(hash) \
-void silc_##hash##_transform(unsigned long *state, \
+void silc_##hash##_transform(uint32 *state, \
unsigned char *buffer)
#define SILC_HASH_API_CONTEXT_LEN(hash) \
-unsigned int silc_##hash##_context_len()
+uint32 silc_##hash##_context_len()
/* Prototypes */
int silc_hash_register(SilcHashObject *hash);
int silc_hash_unregister(SilcHashObject *hash);
int silc_hash_alloc(const unsigned char *name, SilcHash *new_hash);
void silc_hash_free(SilcHash hash);
-unsigned int silc_hash_len(SilcHash hash);
+uint32 silc_hash_len(SilcHash hash);
int silc_hash_is_supported(const unsigned char *name);
char *silc_hash_get_supported();
void silc_hash_make(SilcHash hash, const unsigned char *data,
- unsigned int len, unsigned char *return_hash);
+ uint32 len, unsigned char *return_hash);
char *silc_hash_fingerprint(SilcHash hash, const unsigned char *data,
- unsigned int data_len);
+ uint32 data_len);
#endif
/* Returns the length of the MAC that the HMAC will produce. */
-unsigned int silc_hmac_len(SilcHmac hmac)
+uint32 silc_hmac_len(SilcHmac hmac)
{
return hmac->hmac->len;
}
/* Sets the HMAC key used in the HMAC creation */
void silc_hmac_set_key(SilcHmac hmac, const unsigned char *key,
- unsigned int key_len)
+ uint32 key_len)
{
if (hmac->key) {
memset(hmac->key, 0, hmac->key_len);
return_hash argument. */
void silc_hmac_make_internal(SilcHmac hmac, unsigned char *data,
- unsigned int data_len, unsigned char *key,
- unsigned int key_len, unsigned char *return_hash)
+ uint32 data_len, unsigned char *key,
+ uint32 key_len, unsigned char *return_hash)
{
SilcHash hash = hmac->hash;
unsigned char inner_pad[hash->hash->block_len + 1];
uses the internal key set with silc_hmac_set_key. */
void silc_hmac_make(SilcHmac hmac, unsigned char *data,
- unsigned int data_len, unsigned char *return_hash,
- unsigned int *return_len)
+ uint32 data_len, unsigned char *return_hash,
+ uint32 *return_len)
{
silc_hmac_make_internal(hmac, data, data_len, hmac->key,
hmac->key_len, return_hash);
key. The key is sent as argument to the function. */
void silc_hmac_make_with_key(SilcHmac hmac, unsigned char *data,
- unsigned int data_len,
- unsigned char *key, unsigned int key_len,
+ uint32 data_len,
+ unsigned char *key, uint32 key_len,
unsigned char *return_hash,
- unsigned int *return_len)
+ uint32 *return_len)
{
silc_hmac_make_internal(hmac, data, data_len, key, key_len, return_hash);
if (return_len)
routine allows these dangerous truncations. */
void silc_hmac_make_truncated(SilcHmac hmac, unsigned char *data,
- unsigned int data_len,
- unsigned int truncated_len,
+ uint32 data_len,
+ uint32 truncated_len,
unsigned char *return_hash)
{
unsigned char hvalue[hmac->hash->hash->hash_len];
Name of the HMAC.
- unsigned int len
+ uint32 len
Length of the MAC the HMAC is to produce (bytes).
must not be freed.
unsigned char *key
- unsigned int len
+ uint32 len
The key and its length used to make the HMAC. This is set
with silc_hmac_set_key function.
typedef struct {
char *name;
- unsigned int len;
+ uint32 len;
} SilcHmacObject;
struct SilcHmacStruct {
SilcHash hash;
char allocated_hash;
unsigned char *key;
- unsigned int key_len;
+ uint32 key_len;
};
/* Prototypes */
void silc_hmac_free(SilcHmac hmac);
int silc_hmac_is_supported(const char *name);
char *silc_hmac_get_supported();
-unsigned int silc_hmac_len(SilcHmac hmac);
+uint32 silc_hmac_len(SilcHmac hmac);
void silc_hmac_set_key(SilcHmac hmac, const unsigned char *key,
- unsigned int key_len);
+ uint32 key_len);
void silc_hmac_make(SilcHmac hmac, unsigned char *data,
- unsigned int data_len, unsigned char *return_hash,
- unsigned int *return_len);
+ uint32 data_len, unsigned char *return_hash,
+ uint32 *return_len);
void silc_hmac_make_with_key(SilcHmac hmac, unsigned char *data,
- unsigned int data_len,
- unsigned char *key, unsigned int key_len,
+ uint32 data_len,
+ unsigned char *key, uint32 key_len,
unsigned char *return_hash,
- unsigned int *return_len);
+ uint32 *return_len);
void silc_hmac_make_truncated(SilcHmac hmac,
unsigned char *data,
- unsigned int data_len,
- unsigned int truncated_len,
+ uint32 data_len,
+ uint32 truncated_len,
unsigned char *return_hash);
#endif
/* Returns the length of the key */
-unsigned int silc_pkcs_get_key_len(SilcPKCS self)
+uint32 silc_pkcs_get_key_len(SilcPKCS self)
{
return self->key_len;
}
/* Returns SILC style public key */
-unsigned char *silc_pkcs_get_public_key(SilcPKCS pkcs, unsigned int *len)
+unsigned char *silc_pkcs_get_public_key(SilcPKCS pkcs, uint32 *len)
{
return pkcs->pkcs->get_public_key(pkcs->context, len);
}
/* Returns SILC style private key */
-unsigned char *silc_pkcs_get_private_key(SilcPKCS pkcs, unsigned int *len)
+unsigned char *silc_pkcs_get_private_key(SilcPKCS pkcs, uint32 *len)
{
return pkcs->pkcs->get_private_key(pkcs->context, len);
}
/* Sets public key from data. */
int silc_pkcs_public_key_data_set(SilcPKCS pkcs, unsigned char *pk,
- unsigned int pk_len)
+ uint32 pk_len)
{
return pkcs->pkcs->set_public_key(pkcs->context, pk, pk_len);
}
/* Sets private key from data. */
int silc_pkcs_private_key_data_set(SilcPKCS pkcs, unsigned char *prv,
- unsigned int prv_len)
+ uint32 prv_len)
{
return pkcs->pkcs->set_private_key(pkcs->context, prv, prv_len);
}
/* Encrypts */
-int silc_pkcs_encrypt(SilcPKCS pkcs, unsigned char *src, unsigned int src_len,
- unsigned char *dst, unsigned int *dst_len)
+int silc_pkcs_encrypt(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
+ unsigned char *dst, uint32 *dst_len)
{
return pkcs->pkcs->encrypt(pkcs->context, src, src_len, dst, dst_len);
}
/* Decrypts */
-int silc_pkcs_decrypt(SilcPKCS pkcs, unsigned char *src, unsigned int src_len,
- unsigned char *dst, unsigned int *dst_len)
+int silc_pkcs_decrypt(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
+ unsigned char *dst, uint32 *dst_len)
{
return pkcs->pkcs->decrypt(pkcs->context, src, src_len, dst, dst_len);
}
/* Generates signature */
-int silc_pkcs_sign(SilcPKCS pkcs, unsigned char *src, unsigned int src_len,
- unsigned char *dst, unsigned int *dst_len)
+int silc_pkcs_sign(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
+ unsigned char *dst, uint32 *dst_len)
{
return pkcs->pkcs->sign(pkcs->context, src, src_len, dst, dst_len);
}
/* Verifies signature */
int silc_pkcs_verify(SilcPKCS pkcs, unsigned char *signature,
- unsigned int signature_len, unsigned char *data,
- unsigned int data_len)
+ uint32 signature_len, unsigned char *data,
+ uint32 data_len)
{
return pkcs->pkcs->verify(pkcs->context, signature, signature_len,
data, data_len);
/* Generates signature with hash. The hash is signed. */
int silc_pkcs_sign_with_hash(SilcPKCS pkcs, SilcHash hash,
- unsigned char *src, unsigned int src_len,
- unsigned char *dst, unsigned int *dst_len)
+ unsigned char *src, uint32 src_len,
+ unsigned char *dst, uint32 *dst_len)
{
unsigned char hashr[32];
- unsigned int hash_len;
+ uint32 hash_len;
int ret;
silc_hash_make(hash, src, src_len, hashr);
int silc_pkcs_verify_with_hash(SilcPKCS pkcs, SilcHash hash,
unsigned char *signature,
- unsigned int signature_len,
+ uint32 signature_len,
unsigned char *data,
- unsigned int data_len)
+ uint32 data_len)
{
unsigned char hashr[32];
- unsigned int hash_len;
+ uint32 hash_len;
int ret;
silc_hash_make(hash, data, data_len, hashr);
{
SilcBuffer buf;
char *identifier;
- unsigned int len, tlen = 0;
+ uint32 len, tlen = 0;
if (!username || !host)
return NULL;
SilcPublicKey silc_pkcs_public_key_alloc(char *name, char *identifier,
unsigned char *pk,
- unsigned int pk_len)
+ uint32 pk_len)
{
SilcPublicKey public_key;
duplicated. */
SilcPrivateKey silc_pkcs_private_key_alloc(char *name, unsigned char *prv,
- unsigned int prv_len)
+ uint32 prv_len)
{
SilcPrivateKey private_key;
data. */
unsigned char *
-silc_pkcs_public_key_encode(SilcPublicKey public_key, unsigned int *len)
+silc_pkcs_public_key_encode(SilcPublicKey public_key, uint32 *len)
{
SilcBuffer buf;
unsigned char *ret;
/* Encodes SILC style public key. Returns the encoded data. */
unsigned char *
-silc_pkcs_public_key_data_encode(unsigned char *pk, unsigned int pk_len,
+silc_pkcs_public_key_data_encode(unsigned char *pk, uint32 pk_len,
char *pkcs, char *identifier,
- unsigned int *len)
+ uint32 *len)
{
SilcBuffer buf;
unsigned char *ret;
- unsigned int totlen;
+ uint32 totlen;
totlen = 4 + 2 + strlen(pkcs) + 2 + strlen(identifier) + pk_len;
buf = silc_buffer_alloc(totlen);
/* Decodes SILC style public key. Returns TRUE if the decoding was
successful. Allocates new public key as well. */
-int silc_pkcs_public_key_decode(unsigned char *data, unsigned int data_len,
+int silc_pkcs_public_key_decode(unsigned char *data, uint32 data_len,
SilcPublicKey *public_key)
{
SilcBuffer buf;
SilcPKCS alg;
- unsigned short pkcs_len, identifier_len;
- unsigned int totlen, key_len;
+ uint16 pkcs_len, identifier_len;
+ uint32 totlen, key_len;
unsigned char *pkcs_name = NULL, *ident = NULL, *key_data = NULL;
int ret;
/* Encodes SILC private key from SilcPrivateKey. Returns the encoded data. */
unsigned char *
-silc_pkcs_private_key_encode(SilcPrivateKey private_key, unsigned int *len)
+silc_pkcs_private_key_encode(SilcPrivateKey private_key, uint32 *len)
{
SilcBuffer buf;
unsigned char *ret;
- unsigned int totlen;
+ uint32 totlen;
totlen = 2 + strlen(private_key->name) + private_key->prv_len;
buf = silc_buffer_alloc(totlen);
/* Encodes SILC private key. Returns the encoded data. */
unsigned char *
-silc_pkcs_private_key_data_encode(unsigned char *prv, unsigned int prv_len,
- char *pkcs, unsigned int *len)
+silc_pkcs_private_key_data_encode(unsigned char *prv, uint32 prv_len,
+ char *pkcs, uint32 *len)
{
SilcBuffer buf;
unsigned char *ret;
- unsigned int totlen;
+ uint32 totlen;
totlen = 2 + strlen(pkcs) + prv_len;
buf = silc_buffer_alloc(totlen);
/* Decodes SILC style public key. Returns TRUE if the decoding was
successful. Allocates new private key as well. */
-int silc_pkcs_private_key_decode(unsigned char *data, unsigned int data_len,
+int silc_pkcs_private_key_decode(unsigned char *data, uint32 data_len,
SilcPrivateKey *private_key)
{
SilcBuffer buf;
SilcPKCS alg;
- unsigned short pkcs_len;
- unsigned int key_len;
+ uint16 pkcs_len;
+ uint32 key_len;
unsigned char *pkcs_name = NULL, *key_data = NULL;
int ret;
static int silc_pkcs_save_public_key_internal(char *filename,
unsigned char *data,
- unsigned int data_len,
- unsigned int encoding)
+ uint32 data_len,
+ uint32 encoding)
{
SilcBuffer buf;
- unsigned int len;
+ uint32 len;
switch(encoding) {
case SILC_PKCS_FILE_BIN:
/* Saves public key into file */
int silc_pkcs_save_public_key(char *filename, SilcPublicKey public_key,
- unsigned int encoding)
+ uint32 encoding)
{
unsigned char *data;
- unsigned int data_len;
+ uint32 data_len;
data = silc_pkcs_public_key_encode(public_key, &data_len);
return silc_pkcs_save_public_key_internal(filename, data, data_len,
/* Saves public key into file */
int silc_pkcs_save_public_key_data(char *filename, unsigned char *data,
- unsigned int data_len,
- unsigned int encoding)
+ uint32 data_len,
+ uint32 encoding)
{
return silc_pkcs_save_public_key_internal(filename, data, data_len,
encoding);
static int silc_pkcs_save_private_key_internal(char *filename,
unsigned char *data,
- unsigned int data_len,
- unsigned int encoding)
+ uint32 data_len,
+ uint32 encoding)
{
SilcBuffer buf;
- unsigned int len;
+ uint32 len;
switch(encoding) {
case SILC_PKCS_FILE_BIN:
int silc_pkcs_save_private_key(char *filename, SilcPrivateKey private_key,
unsigned char *passphrase,
- unsigned int encoding)
+ uint32 encoding)
{
unsigned char *data;
- unsigned int data_len;
+ uint32 data_len;
data = silc_pkcs_private_key_encode(private_key, &data_len);
return silc_pkcs_save_private_key_internal(filename, data, data_len,
/* XXX The buffer should be encrypted if passphrase is provided. */
int silc_pkcs_save_private_key_data(char *filename, unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
unsigned char *passphrase,
- unsigned int encoding)
+ uint32 encoding)
{
return silc_pkcs_save_private_key_internal(filename, data, data_len,
encoding);
is loading was successful. */
int silc_pkcs_load_public_key(char *filename, SilcPublicKey *public_key,
- unsigned int encoding)
+ uint32 encoding)
{
unsigned char *cp, *old, *data, byte;
- unsigned int i, data_len, len;
+ uint32 i, data_len, len;
old = data = silc_file_read(filename, &data_len);
if (!data)
/* XXX Should support encrypted private key files */
int silc_pkcs_load_private_key(char *filename, SilcPrivateKey *private_key,
- unsigned int encoding)
+ uint32 encoding)
{
unsigned char *cp, *old, *data, byte;
- unsigned int i, data_len, len;
+ uint32 i, data_len, len;
old = data = silc_file_read(filename, &data_len);
if (!data)
char *name;
void *data_context;
- int (*init)(void *, unsigned int, SilcRng);
+ int (*init)(void *, uint32, SilcRng);
void (*clear_keys)(void *);
- unsigned char *(*get_public_key)(void *, unsigned int *);
- unsigned char *(*get_private_key)(void *, unsigned int *);
- int (*set_public_key)(void *, unsigned char *, unsigned int);
- int (*set_private_key)(void *, unsigned char *, unsigned int);
- unsigned int (*context_len)();
- unsigned int (*data_context_len)();
+ unsigned char *(*get_public_key)(void *, uint32 *);
+ unsigned char *(*get_private_key)(void *, uint32 *);
+ int (*set_public_key)(void *, unsigned char *, uint32);
+ int (*set_private_key)(void *, unsigned char *, uint32);
+ uint32 (*context_len)();
+ uint32 (*data_context_len)();
int (*set_arg)(void *, void *, int, SilcInt);
- int (*encrypt)(void *, unsigned char *, unsigned int,
- unsigned char *, unsigned int *);
- int (*decrypt)(void *, unsigned char *, unsigned int,
- unsigned char *, unsigned int *);
- int (*sign)(void *, unsigned char *, unsigned int,
- unsigned char *, unsigned int *);
- int (*verify)(void *, unsigned char *, unsigned int,
- unsigned char *, unsigned int);
+ int (*encrypt)(void *, unsigned char *, uint32,
+ unsigned char *, uint32 *);
+ int (*decrypt)(void *, unsigned char *, uint32,
+ unsigned char *, uint32 *);
+ int (*sign)(void *, unsigned char *, uint32,
+ unsigned char *, uint32 *);
+ int (*verify)(void *, unsigned char *, uint32,
+ unsigned char *, uint32);
} SilcPKCSObject;
/* The main SILC PKCS structure. Use SilcPKCS instead of SilcPKCSStruct.
typedef struct SilcPKCSStruct {
void *context;
SilcPKCSObject *pkcs;
- unsigned int key_len;
+ uint32 key_len;
- unsigned int (*get_key_len)(struct SilcPKCSStruct *);
+ uint32 (*get_key_len)(struct SilcPKCSStruct *);
} *SilcPKCS;
/* List of all PKCS in SILC. */
object. Public keys received from network must be in this format as
well. */
typedef struct {
- unsigned int len;
+ uint32 len;
char *name;
char *identifier;
unsigned char *pk;
- unsigned int pk_len;
+ uint32 pk_len;
} *SilcPublicKey;
/* SILC style private key object. Private key is read from file to this
typedef struct {
char *name;
unsigned char *prv;
- unsigned int prv_len;
+ uint32 prv_len;
} *SilcPrivateKey;
/* Public and private key file headers */
would look something like this:
#define SILC_PKCS_API_INIT(pkcs) \
- inline int silc_##pkcs##_init(void *context, unsigned int keylen, \
+ inline int silc_##pkcs##_init(void *context, uint32 keylen, \
void *p1, void *p2)
Now we wouldn't have to send the SilcRng object since the primes are
*/
#define SILC_PKCS_API_INIT(pkcs) \
-int silc_##pkcs##_init(void *context, unsigned int keylen, \
+int silc_##pkcs##_init(void *context, uint32 keylen, \
SilcRng rng)
#define SILC_PKCS_API_CLEAR_KEYS(pkcs) \
void silc_##pkcs##_clear_keys(void *context)
#define SILC_PKCS_API_GET_PUBLIC_KEY(pkcs) \
unsigned char *silc_##pkcs##_get_public_key(void *context, \
- unsigned int *ret_len)
+ uint32 *ret_len)
#define SILC_PKCS_API_GET_PRIVATE_KEY(pkcs) \
unsigned char *silc_##pkcs##_get_private_key(void *context, \
- unsigned int *ret_len)
+ uint32 *ret_len)
#define SILC_PKCS_API_SET_PUBLIC_KEY(pkcs) \
int silc_##pkcs##_set_public_key(void *context, unsigned char *key_data, \
- unsigned int key_len)
+ uint32 key_len)
#define SILC_PKCS_API_SET_PRIVATE_KEY(pkcs) \
int silc_##pkcs##_set_private_key(void *context, unsigned char *key_data, \
- unsigned int key_len)
+ uint32 key_len)
#define SILC_PKCS_API_CONTEXT_LEN(pkcs) \
-unsigned int silc_##pkcs##_context_len()
+uint32 silc_##pkcs##_context_len()
#define SILC_PKCS_API_DATA_CONTEXT_LEN(pkcs) \
-unsigned int silc_##pkcs##_data_context_len()
+uint32 silc_##pkcs##_data_context_len()
#define SILC_PKCS_API_SET_ARG(pkcs) \
int silc_##pkcs##_set_arg(void *context, \
void *data_context, \
#define SILC_PKCS_API_ENCRYPT(pkcs) \
int silc_##pkcs##_encrypt(void *context, \
unsigned char *src, \
- unsigned int src_len, \
+ uint32 src_len, \
unsigned char *dst, \
- unsigned int *dst_len)
+ uint32 *dst_len)
#define SILC_PKCS_API_DECRYPT(pkcs) \
int silc_##pkcs##_decrypt(void *context, \
unsigned char *src, \
- unsigned int src_len, \
+ uint32 src_len, \
unsigned char *dst, \
- unsigned int *dst_len)
+ uint32 *dst_len)
#define SILC_PKCS_API_SIGN(pkcs) \
int silc_##pkcs##_sign(void *context, \
unsigned char *src, \
- unsigned int src_len, \
+ uint32 src_len, \
unsigned char *dst, \
- unsigned int *dst_len)
+ uint32 *dst_len)
#define SILC_PKCS_API_VERIFY(pkcs) \
int silc_##pkcs##_verify(void *context, \
unsigned char *signature, \
- unsigned int signature_len, \
+ uint32 signature_len, \
unsigned char *data, \
- unsigned int data_len)
+ uint32 data_len)
/* Prototypes */
int silc_pkcs_alloc(const unsigned char *name, SilcPKCS *new_pkcs);
void silc_pkcs_free(SilcPKCS pkcs);
int silc_pkcs_is_supported(const unsigned char *name);
char *silc_pkcs_get_supported();
-unsigned int silc_pkcs_get_key_len(SilcPKCS self);
-unsigned char *silc_pkcs_get_public_key(SilcPKCS pkcs, unsigned int *len);
-unsigned char *silc_pkcs_get_private_key(SilcPKCS pkcs, unsigned int *len);
+uint32 silc_pkcs_get_key_len(SilcPKCS self);
+unsigned char *silc_pkcs_get_public_key(SilcPKCS pkcs, uint32 *len);
+unsigned char *silc_pkcs_get_private_key(SilcPKCS pkcs, uint32 *len);
int silc_pkcs_public_key_set(SilcPKCS pkcs, SilcPublicKey public_key);
int silc_pkcs_public_key_data_set(SilcPKCS pkcs, unsigned char *pk,
- unsigned int pk_len);
+ uint32 pk_len);
int silc_pkcs_private_key_set(SilcPKCS pkcs, SilcPrivateKey private_key);
int silc_pkcs_private_key_data_set(SilcPKCS pkcs, unsigned char *prv,
- unsigned int prv_len);
-int silc_pkcs_encrypt(SilcPKCS pkcs, unsigned char *src, unsigned int src_len,
- unsigned char *dst, unsigned int *dst_len);
-int silc_pkcs_decrypt(SilcPKCS pkcs, unsigned char *src, unsigned int src_len,
- unsigned char *dst, unsigned int *dst_len);
-int silc_pkcs_sign(SilcPKCS pkcs, unsigned char *src, unsigned int src_len,
- unsigned char *dst, unsigned int *dst_len);
+ uint32 prv_len);
+int silc_pkcs_encrypt(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
+ unsigned char *dst, uint32 *dst_len);
+int silc_pkcs_decrypt(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
+ unsigned char *dst, uint32 *dst_len);
+int silc_pkcs_sign(SilcPKCS pkcs, unsigned char *src, uint32 src_len,
+ unsigned char *dst, uint32 *dst_len);
int silc_pkcs_verify(SilcPKCS pkcs, unsigned char *signature,
- unsigned int signature_len, unsigned char *data,
- unsigned int data_len);
+ uint32 signature_len, unsigned char *data,
+ uint32 data_len);
int silc_pkcs_sign_with_hash(SilcPKCS pkcs, SilcHash hash,
- unsigned char *src, unsigned int src_len,
- unsigned char *dst, unsigned int *dst_len);
+ unsigned char *src, uint32 src_len,
+ unsigned char *dst, uint32 *dst_len);
int silc_pkcs_verify_with_hash(SilcPKCS pkcs, SilcHash hash,
unsigned char *signature,
- unsigned int signature_len,
+ uint32 signature_len,
unsigned char *data,
- unsigned int data_len);
+ uint32 data_len);
char *silc_pkcs_encode_identifier(char *username, char *host, char *realname,
char *email, char *org, char *country);
SilcPublicKey silc_pkcs_public_key_alloc(char *name, char *identifier,
unsigned char *pk,
- unsigned int pk_len);
+ uint32 pk_len);
void silc_pkcs_public_key_free(SilcPublicKey public_key);
SilcPrivateKey silc_pkcs_private_key_alloc(char *name, unsigned char *prv,
- unsigned int prv_len);
+ uint32 prv_len);
void silc_pkcs_private_key_free(SilcPrivateKey private_key);
unsigned char *
-silc_pkcs_public_key_encode(SilcPublicKey public_key, unsigned int *len);
+silc_pkcs_public_key_encode(SilcPublicKey public_key, uint32 *len);
unsigned char *
-silc_pkcs_public_key_data_encode(unsigned char *pk, unsigned int pk_len,
+silc_pkcs_public_key_data_encode(unsigned char *pk, uint32 pk_len,
char *pkcs, char *identifier,
- unsigned int *len);
-int silc_pkcs_public_key_decode(unsigned char *data, unsigned int data_len,
+ uint32 *len);
+int silc_pkcs_public_key_decode(unsigned char *data, uint32 data_len,
SilcPublicKey *public_key);
unsigned char *
-silc_pkcs_private_key_encode(SilcPrivateKey private_key, unsigned int *len);
+silc_pkcs_private_key_encode(SilcPrivateKey private_key, uint32 *len);
unsigned char *
-silc_pkcs_private_key_data_encode(unsigned char *prv, unsigned int prv_len,
- char *pkcs, unsigned int *len);
-int silc_pkcs_private_key_decode(unsigned char *data, unsigned int data_len,
+silc_pkcs_private_key_data_encode(unsigned char *prv, uint32 prv_len,
+ char *pkcs, uint32 *len);
+int silc_pkcs_private_key_decode(unsigned char *data, uint32 data_len,
SilcPrivateKey *private_key);
int silc_pkcs_save_public_key(char *filename, SilcPublicKey public_key,
- unsigned int encoding);
+ uint32 encoding);
int silc_pkcs_save_public_key_data(char *filename, unsigned char *data,
- unsigned int data_len,
- unsigned int encoding);
+ uint32 data_len,
+ uint32 encoding);
int silc_pkcs_save_private_key(char *filename, SilcPrivateKey private_key,
unsigned char *passphrase,
- unsigned int encoding);
+ uint32 encoding);
int silc_pkcs_save_private_key_data(char *filename, unsigned char *data,
- unsigned int data_len,
+ uint32 data_len,
unsigned char *passphrase,
- unsigned int encoding);
+ uint32 encoding);
int silc_pkcs_load_public_key(char *filename, SilcPublicKey *public_key,
- unsigned int encoding);
+ uint32 encoding);
int silc_pkcs_load_private_key(char *filename, SilcPrivateKey *private_key,
- unsigned int encoding);
+ uint32 encoding);
#endif
#undef SILC_RNG_DEBUG
/* #define SILC_RNG_DEBUG */
-static unsigned int silc_rng_get_position(SilcRng rng);
+static uint32 silc_rng_get_position(SilcRng rng);
static void silc_rng_stir_pool(SilcRng rng);
-static void silc_rng_xor(SilcRng rng, unsigned int val, unsigned int pos);
+static void silc_rng_xor(SilcRng rng, uint32 val, unsigned int pos);
static void silc_rng_add_noise(SilcRng rng, unsigned char *buffer,
- unsigned int len);
+ uint32 len);
static void silc_rng_exec_command(SilcRng rng, char *command);
static void silc_rng_get_hard_noise(SilcRng rng);
static void silc_rng_get_medium_noise(SilcRng rng);
from the same point of the pool. Short description of the fields
following.
- unsigned int low
- unsigned int pos
+ uint32 low
+ uint32 pos
The index for the random pool buffer. Lowest and current
positions.
*/
typedef struct SilcRngStateContext {
- unsigned int low;
- unsigned int pos;
+ uint32 low;
+ uint32 pos;
struct SilcRngStateContext *next;
} *SilcRngState;
pool. After adding the noise the pool is stirred. */
static void silc_rng_add_noise(SilcRng rng, unsigned char *buffer,
- unsigned int len)
+ uint32 len)
{
- unsigned int i, pos;
+ uint32 i, pos;
pos = silc_rng_get_position(rng);
/* XOR's data into the pool */
-static void silc_rng_xor(SilcRng rng, unsigned int val, unsigned int pos)
+static void silc_rng_xor(SilcRng rng, uint32 val, unsigned int pos)
{
assert(rng != NULL);
rng->pool[pos] ^= val + val;
static void silc_rng_stir_pool(SilcRng rng)
{
int i;
- unsigned long iv[5];
+ uint32 iv[5];
/* Get the IV */
memcpy(iv, &rng->pool[SILC_RNG_POOLSIZE - 256], sizeof(iv));
/* Returns next position where data is fetched from the pool or
put to the pool. */
-static unsigned int silc_rng_get_position(SilcRng rng)
+static uint32 silc_rng_get_position(SilcRng rng)
{
SilcRngState next;
- unsigned int pos;
+ uint32 pos;
next = rng->state->next;
/* Returns 16 bit random number */
-unsigned short silc_rng_get_rn16(SilcRng rng)
+uint16 silc_rng_get_rn16(SilcRng rng)
{
unsigned char rn[2];
- unsigned short num;
+ uint16 num;
rn[0] = silc_rng_get_byte(rng);
rn[1] = silc_rng_get_byte(rng);
/* Returns 32 bit random number */
-unsigned int silc_rng_get_rn32(SilcRng rng)
+uint32 silc_rng_get_rn32(SilcRng rng)
{
unsigned char rn[4];
- unsigned short num;
+ uint16 num;
rn[0] = silc_rng_get_byte(rng);
rn[1] = silc_rng_get_byte(rng);
/* Returns random number string. Returned string is in HEX format. */
-unsigned char *silc_rng_get_rn_string(SilcRng rng, unsigned int len)
+unsigned char *silc_rng_get_rn_string(SilcRng rng, uint32 len)
{
int i;
unsigned char *string;
/* Returns random number binary data. */
-unsigned char *silc_rng_get_rn_data(SilcRng rng, unsigned int len)
+unsigned char *silc_rng_get_rn_data(SilcRng rng, uint32 len)
{
int i;
unsigned char *data;
return global_rng ? silc_rng_get_byte(global_rng) : 0;
}
-unsigned short silc_rng_global_get_rn16()
+uint16 silc_rng_global_get_rn16()
{
return global_rng ? silc_rng_get_rn16(global_rng) : 0;
}
-unsigned int silc_rng_global_get_rn32()
+uint32 silc_rng_global_get_rn32()
{
return global_rng ? silc_rng_get_rn32(global_rng) : 0;
}
-unsigned char *silc_rng_global_get_rn_string(unsigned int len)
+unsigned char *silc_rng_global_get_rn_string(uint32 len)
{
return global_rng ? silc_rng_get_rn_string(global_rng, len) : NULL;
}
-unsigned char *silc_rng_global_get_rn_data(unsigned int len)
+unsigned char *silc_rng_global_get_rn_data(uint32 len)
{
return global_rng ? silc_rng_get_rn_data(global_rng, len) : NULL;
}
void silc_rng_free(SilcRng rng);
void silc_rng_init(SilcRng rng);
unsigned char silc_rng_get_byte(SilcRng rng);
-unsigned short silc_rng_get_rn16(SilcRng rng);
-unsigned int silc_rng_get_rn32(SilcRng rng);
-unsigned char *silc_rng_get_rn_string(SilcRng rng, unsigned int len);
-unsigned char *silc_rng_get_rn_data(SilcRng rng, unsigned int len);
+uint16 silc_rng_get_rn16(SilcRng rng);
+uint32 silc_rng_get_rn32(SilcRng rng);
+unsigned char *silc_rng_get_rn_string(SilcRng rng, uint32 len);
+unsigned char *silc_rng_get_rn_data(SilcRng rng, uint32 len);
int silc_rng_global_init(SilcRng rng);
int silc_rng_global_uninit();
unsigned char silc_rng_global_get_byte();
-unsigned short silc_rng_global_get_rn16();
-unsigned int silc_rng_global_get_rn32();
-unsigned char *silc_rng_global_get_rn_string(unsigned int len);
-unsigned char *silc_rng_global_get_rn_data(unsigned int len);
+uint16 silc_rng_global_get_rn16();
+uint32 silc_rng_global_get_rn32();
+unsigned char *silc_rng_global_get_rn_string(uint32 len);
+unsigned char *silc_rng_global_get_rn_data(uint32 len);
#endif
SILC_CIPHER_API_SET_KEY(twofish)
{
- twofish_set_key((TwofishContext *)context, (unsigned int *)key, keylen);
+ twofish_set_key((TwofishContext *)context, (uint32 *)key, keylen);
return 1;
}
SILC_CIPHER_API_ENCRYPT_CBC(twofish)
{
- unsigned int *in, *out, *tiv;
- unsigned int tmp[4];
+ uint32 *in, *out, *tiv;
+ uint32 tmp[4];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0] ^ tiv[0];
tmp[1] = in[1] ^ tiv[1];
SILC_CIPHER_API_DECRYPT_CBC(twofish)
{
- unsigned int *tiv, *in, *out;
- unsigned int tmp[4], tmp2[4];
+ uint32 *tiv, *in, *out;
+ uint32 tmp[4], tmp2[4];
int i;
- in = (unsigned int *)src;
- out = (unsigned int *)dst;
- tiv = (unsigned int *)iv;
+ in = (uint32 *)src;
+ out = (uint32 *)dst;
+ tiv = (uint32 *)iv;
tmp[0] = in[0];
tmp[1] = in[1];
must be free'd by the caller. If `len' is provided the destination
buffer is allocated that large. If zero then the size is approximated. */
-unsigned char *silc_mp_mp2bin(SilcInt *val, unsigned int len,
- unsigned int *ret_len)
+unsigned char *silc_mp_mp2bin(SilcInt *val, uint32 len,
+ uint32 *ret_len)
{
int i;
- unsigned int size;
+ uint32 size;
unsigned char *ret;
SilcInt tmp;
returned into `dst' and it's length to the `ret_len'. */
void silc_mp_mp2bin_noalloc(SilcInt *val, unsigned char *dst,
- unsigned int dst_len)
+ uint32 dst_len)
{
int i;
- unsigned int size = dst_len;
+ uint32 size = dst_len;
SilcInt tmp;
silc_mp_init_set(&tmp, val);
/* Decodes binary data into MP integer. The integer sent as argument
must be initialized. */
-void silc_mp_bin2mp(unsigned char *data, unsigned int len, SilcInt *ret)
+void silc_mp_bin2mp(unsigned char *data, uint32 len, SilcInt *ret)
{
int i;
#ifndef MPBIN_H
#define MPBIN_H
-unsigned char *silc_mp_mp2bin(SilcInt *val, unsigned int len,
- unsigned int *ret_len);
+unsigned char *silc_mp_mp2bin(SilcInt *val, uint32 len,
+ uint32 *ret_len);
void silc_mp_mp2bin_noalloc(SilcInt *val, unsigned char *dst,
- unsigned int dst_len);
-void silc_mp_bin2mp(unsigned char *data, unsigned int len, SilcInt *ret);
+ uint32 dst_len);
+void silc_mp_bin2mp(unsigned char *data, uint32 len, SilcInt *ret);
#endif
*/
-static unsigned int primetable[] =
+static uint32 primetable[] =
{
2, 3, 5, 7, 11, 13, 17, 19,
23, 29, 31, 37, 41, 43, 47, 53,
If argument verbose is TRUE this will display some status information
about the progress of generation. */
-int silc_math_gen_prime(SilcInt *prime, unsigned int bits, int verbose)
+int silc_math_gen_prime(SilcInt *prime, uint32 bits, int verbose)
{
unsigned char *numbuf;
- unsigned int i, b, k;
- unsigned int *spmods;
+ uint32 i, b, k;
+ uint32 *spmods;
SilcInt r, base, tmp, tmp2, oprime;
silc_mp_init(&r);
/* Init modulo table with the prime candidate and the primes
in the primetable. */
- spmods = silc_calloc(1, sizeof(primetable) * sizeof(unsigned int));
+ spmods = silc_calloc(1, sizeof(primetable) * sizeof(uint32));
for (i = 0; primetable[i] != 0; i++) {
silc_mp_mod_ui(&tmp, prime, primetable[i]);
spmods[i] = silc_mp_get_ui(&tmp);
#ifndef SILCPRIMEGEN_H
#define SILCPRIMEGEN_H
-int silc_math_gen_prime(SilcInt *prime, unsigned int bits, int verbose);
+int silc_math_gen_prime(SilcInt *prime, uint32 bits, int verbose);
int silc_math_prime_test(SilcInt *p);
void silc_math_primegen_init();
void silc_math_primegen_uninit();
{
SilcBuffer buf;
unsigned char *x_str;
- unsigned int x_len;
+ uint32 x_len;
int ret;
SILC_LOG_DEBUG(("Encoding KE Payload"));
SilcSKEStatus status = SILC_SKE_STATUS_ERROR;
SilcSKEKEPayload *payload;
unsigned char *x = NULL;
- unsigned short x_len;
- unsigned int tot_len = 0, len2;
+ uint16 x_len;
+ uint32 tot_len = 0, len2;
int ret;
SILC_LOG_DEBUG(("Decoding Key Exchange Payload"));
/* SILC Key Exchange Start Payload */
typedef struct {
unsigned char flags;
- unsigned short len;
+ uint16 len;
unsigned char *cookie;
- unsigned short cookie_len;
+ uint16 cookie_len;
unsigned char *version;
- unsigned short version_len;
+ uint16 version_len;
- unsigned short ke_grp_len;
+ uint16 ke_grp_len;
unsigned char *ke_grp_list;
- unsigned short pkcs_alg_len;
+ uint16 pkcs_alg_len;
unsigned char *pkcs_alg_list;
- unsigned short enc_alg_len;
+ uint16 enc_alg_len;
unsigned char *enc_alg_list;
- unsigned short hash_alg_len;
+ uint16 hash_alg_len;
unsigned char *hash_alg_list;
- unsigned short hmac_alg_len;
+ uint16 hmac_alg_len;
unsigned char *hmac_alg_list;
- unsigned short comp_alg_len;
+ uint16 comp_alg_len;
unsigned char *comp_alg_list;
} SilcSKEStartPayload;
/* SILC Key Exchange Payload */
typedef struct {
- unsigned short pk_len;
+ uint16 pk_len;
unsigned char *pk_data;
- unsigned short pk_type;
+ uint16 pk_type;
SilcInt x;
- unsigned short sign_len;
+ uint16 sign_len;
unsigned char *sign_data;
} SilcSKEKEPayload;
SilcBuffer payload_buf;
SilcInt *x, e;
SilcSKEKEPayload *payload;
- unsigned int pk_len;
+ uint32 pk_len;
SILC_LOG_DEBUG(("Start"));
/* Compute signature data if we are doing mutual authentication */
if (ske->start_payload->flags & SILC_SKE_SP_FLAG_MUTUAL) {
unsigned char hash[32], sign[1024];
- unsigned int hash_len, sign_len;
+ uint32 hash_len, sign_len;
SILC_LOG_DEBUG(("We are doing mutual authentication"));
SILC_LOG_DEBUG(("Computing HASH value"));
SilcPublicKey public_key = NULL;
SilcInt *KEY;
unsigned char hash[32];
- unsigned int hash_len;
+ uint32 hash_len;
SILC_LOG_DEBUG(("Start"));
if (ske->start_payload->flags & SILC_SKE_SP_FLAG_MUTUAL) {
SilcPublicKey public_key = NULL;
unsigned char hash[32];
- unsigned int hash_len;
+ uint32 hash_len;
SILC_LOG_DEBUG(("We are doing mutual authentication"));
SILC_LOG_DEBUG(("Verifying public key"));
SilcBuffer payload_buf;
SilcInt *KEY;
unsigned char hash[32], sign[1024], *pk;
- unsigned int hash_len, sign_len, pk_len;
+ uint32 hash_len, sign_len, pk_len;
SILC_LOG_DEBUG(("Start"));
of len bits. The rnd sent as argument must be initialized. */
SilcSKEStatus silc_ske_create_rnd(SilcSKE ske, SilcInt n,
- unsigned int len,
+ uint32 len,
SilcInt *rnd)
{
SilcSKEStatus status = SILC_SKE_STATUS_OK;
SilcSKEStatus silc_ske_make_hash(SilcSKE ske,
unsigned char *return_hash,
- unsigned int *return_hash_len,
+ uint32 *return_hash_len,
int initiator)
{
SilcSKEStatus status = SILC_SKE_STATUS_OK;
SilcBuffer buf;
unsigned char *e, *f, *KEY;
- unsigned int e_len, f_len, KEY_len;
+ uint32 e_len, f_len, KEY_len;
int ret;
SILC_LOG_DEBUG(("Start"));
SilcSKEStatus
silc_ske_process_key_material_data(unsigned char *data,
- unsigned int data_len,
- unsigned int req_iv_len,
- unsigned int req_enc_key_len,
- unsigned int req_hmac_key_len,
+ uint32 data_len,
+ uint32 req_iv_len,
+ uint32 req_enc_key_len,
+ uint32 req_hmac_key_len,
SilcHash hash,
SilcSKEKeyMaterial *key)
{
SilcBuffer buf;
unsigned char hashd[32];
- unsigned int hash_len = req_hmac_key_len;
- unsigned int enc_key_len = req_enc_key_len / 8;
+ uint32 hash_len = req_hmac_key_len;
+ uint32 enc_key_len = req_enc_key_len / 8;
SILC_LOG_DEBUG(("Start"));
the actual keys to be used in the SILC. */
SilcSKEStatus silc_ske_process_key_material(SilcSKE ske,
- unsigned int req_iv_len,
- unsigned int req_enc_key_len,
- unsigned int req_hmac_key_len,
+ uint32 req_iv_len,
+ uint32 req_enc_key_len,
+ uint32 req_hmac_key_len,
SilcSKEKeyMaterial *key)
{
SilcSKEStatus status;
SilcBuffer buf;
unsigned char *tmpbuf;
- int klen;
+ uint32 klen;
/* Encode KEY to binary data */
tmpbuf = silc_mp_mp2bin(ske->KEY, 0, &klen);
/* Callback function used to verify the received public key. */
typedef SilcSKEStatus (*SilcSKEVerifyCb)(SilcSKE ske,
unsigned char *pk_data,
- unsigned int pk_len,
+ uint32 pk_len,
SilcSKEPKType pk_type,
void *context);
typedef struct {
unsigned char *send_iv;
unsigned char *receive_iv;
- unsigned int iv_len;
+ uint32 iv_len;
unsigned char *send_enc_key;
unsigned char *receive_enc_key;
- unsigned int enc_key_len;
+ uint32 enc_key_len;
unsigned char *hmac_key;
- unsigned int hmac_key_len;
+ uint32 hmac_key_len;
} SilcSKEKeyMaterial;
/* Length of cookie in Start Payload */
/* If initiator, this is responders public key. If responder this
is our own public key. */
unsigned char *pk;
- unsigned int pk_len;
+ uint32 pk_len;
/* Random number x, 1 < x < q. This is the secret exponent
used in Diffie Hellman computations. */
/* The hash value HASH of the key exchange */
unsigned char *hash;
- unsigned int hash_len;
+ uint32 hash_len;
/* Random Number Generator. This is set by the caller and must
be free'd by the caller. */
SilcSKEStartPayload *payload,
SilcSKEStartPayload *remote_payload);
SilcSKEStatus silc_ske_create_rnd(SilcSKE ske, SilcInt n,
- unsigned int len,
+ uint32 len,
SilcInt *rnd);
SilcSKEStatus silc_ske_make_hash(SilcSKE ske,
unsigned char *return_hash,
- unsigned int *return_hash_len,
+ uint32 *return_hash_len,
int initiator);
SilcSKEStatus
silc_ske_process_key_material_data(unsigned char *data,
- unsigned int data_len,
- unsigned int req_iv_len,
- unsigned int req_enc_key_len,
- unsigned int req_hmac_key_len,
+ uint32 data_len,
+ uint32 req_iv_len,
+ uint32 req_enc_key_len,
+ uint32 req_hmac_key_len,
SilcHash hash,
SilcSKEKeyMaterial *key);
SilcSKEStatus silc_ske_process_key_material(SilcSKE ske,
- unsigned int req_iv_len,
- unsigned int req_enc_key_len,
- unsigned int req_hmac_key_len,
+ uint32 req_iv_len,
+ uint32 req_enc_key_len,
+ uint32 req_hmac_key_len,
SilcSKEKeyMaterial *key);
SilcSKEStatus silc_ske_check_version(SilcSKE ske,
unsigned char *version,
- unsigned int version_len);
+ uint32 version_len);
void silc_ske_free_key_material(SilcSKEKeyMaterial *key);
#endif
the allocated data area. Following short description of the fields
of the buffer.
- unsigned int truelen;
+ uint32 truelen;
True length of the buffer. This is set at the allocation of the
buffer and it should not be touched after that. This field should
be considered read-only.
- unsigned int len;
+ uint32 len;
Length of the currently valid data area. Tells the length of the
data at the buffer. This is set to zero at the allocation of the
*/
typedef struct SilcBufferStruct {
- unsigned int truelen;
- unsigned int len;
+ uint32 truelen;
+ uint32 len;
unsigned char *head;
unsigned char *data;
unsigned char *tail;
/* Inline functions */
extern inline
-SilcBuffer silc_buffer_alloc(unsigned int len)
+SilcBuffer silc_buffer_alloc(uint32 len)
{
SilcBuffer sb;
*/
extern inline
-unsigned char *silc_buffer_pull(SilcBuffer sb, unsigned int len)
+unsigned char *silc_buffer_pull(SilcBuffer sb, uint32 len)
{
unsigned char *old_data = sb->data;
*/
extern inline
-unsigned char *silc_buffer_push(SilcBuffer sb, unsigned int len)
+unsigned char *silc_buffer_push(SilcBuffer sb, uint32 len)
{
unsigned char *old_data = sb->data;
*/
extern inline
-unsigned char *silc_buffer_pull_tail(SilcBuffer sb, unsigned int len)
+unsigned char *silc_buffer_pull_tail(SilcBuffer sb, uint32 len)
{
unsigned char *old_tail = sb->tail;
*/
extern inline
-unsigned char *silc_buffer_push_tail(SilcBuffer sb, unsigned int len)
+unsigned char *silc_buffer_push_tail(SilcBuffer sb, uint32 len)
{
unsigned char *old_tail = sb->tail;
extern inline
unsigned char *silc_buffer_put_head(SilcBuffer sb,
unsigned char *data,
- unsigned int len)
+ uint32 len)
{
#ifdef SILC_DEBUG
assert((sb->data - sb->head) >= len);
extern inline
unsigned char *silc_buffer_put(SilcBuffer sb,
unsigned char *data,
- unsigned int len)
+ uint32 len)
{
#ifdef SILC_DEBUG
assert((sb->tail - sb->data) >= len);
extern inline
unsigned char *silc_buffer_put_tail(SilcBuffer sb,
unsigned char *data,
- unsigned int len)
+ uint32 len)
{
#ifdef SILC_DEBUG
assert((sb->end - sb->tail) >= len);
case SILC_BUFFER_PARAM_SI16_SHORT:
{
unsigned char xf[2];
- short x = (short)va_arg(ap, int);
+ int16 x = (int16)va_arg(ap, int);
HAS_SPACE(dst, 2);
SILC_PUT16_MSB(x, xf);
silc_buffer_put(dst, xf, 2);
case SILC_BUFFER_PARAM_UI16_SHORT:
{
unsigned char xf[2];
- unsigned short x = (unsigned short)va_arg(ap, int);
+ uint16 x = (uint16)va_arg(ap, int);
HAS_SPACE(dst, 2);
SILC_PUT16_MSB(x, xf);
silc_buffer_put(dst, xf, 2);
case SILC_BUFFER_PARAM_SI32_INT:
{
unsigned char xf[4];
- int x = va_arg(ap, int);
+ int32 x = va_arg(ap, int32);
HAS_SPACE(dst, 4);
SILC_PUT32_MSB(x, xf);
silc_buffer_put(dst, xf, 4);
case SILC_BUFFER_PARAM_UI32_INT:
{
unsigned char xf[4];
- unsigned int x = va_arg(ap, unsigned int);
+ uint32 x = va_arg(ap, uint32);
HAS_SPACE(dst, 4);
SILC_PUT32_MSB(x, xf);
silc_buffer_put(dst, xf, 4);
case SILC_BUFFER_PARAM_UI32_STRING_ALLOC:
{
unsigned char *x = va_arg(ap, unsigned char *);
- int tmp_len = strlen(x);
+ uint32 tmp_len = strlen(x);
HAS_SPACE(dst, tmp_len);
silc_buffer_put(dst, x, tmp_len);
silc_buffer_pull(dst, tmp_len);
case SILC_BUFFER_PARAM_UI_XNSTRING_ALLOC:
{
unsigned char *x = va_arg(ap, unsigned char *);
- unsigned int len = va_arg(ap, unsigned int);
+ uint32 len = va_arg(ap, uint32);
HAS_SPACE(dst, len);
silc_buffer_put(dst, x, len);
silc_buffer_pull(dst, len);
}
case SILC_BUFFER_PARAM_SI16_SHORT:
{
- short *x = va_arg(ap, short *);
+ int16 *x = va_arg(ap, int16 *);
HAS_SPACE(src, 2);
if (x)
SILC_GET16_MSB(*x, src->data);
}
case SILC_BUFFER_PARAM_UI16_SHORT:
{
- unsigned short *x = va_arg(ap, unsigned short *);
+ uint16 *x = va_arg(ap, uint16 *);
HAS_SPACE(src, 2);
if (x)
SILC_GET16_MSB(*x, src->data);
}
case SILC_BUFFER_PARAM_SI32_INT:
{
- int *x = va_arg(ap, int *);
+ int32 *x = va_arg(ap, int32 *);
HAS_SPACE(src, 4);
if (x)
SILC_GET32_MSB(*x, src->data);
}
case SILC_BUFFER_PARAM_UI32_INT:
{
- unsigned int *x = va_arg(ap, unsigned int *);
+ uint32 *x = va_arg(ap, uint32 *);
HAS_SPACE(src, 4);
if (x)
SILC_GET32_MSB(*x, src->data);
}
case SILC_BUFFER_PARAM_UI16_STRING:
{
- unsigned short len2;
+ uint16 len2;
unsigned char **x = va_arg(ap, unsigned char **);
HAS_SPACE(src, 2);
SILC_GET16_MSB(len2, src->data);
}
case SILC_BUFFER_PARAM_UI16_STRING_ALLOC:
{
- unsigned short len2;
+ uint16 len2;
unsigned char **x = va_arg(ap, unsigned char **);
HAS_SPACE(src, 2);
SILC_GET16_MSB(len2, src->data);
}
case SILC_BUFFER_PARAM_UI32_STRING:
{
- unsigned int len2;
+ uint32 len2;
unsigned char **x = va_arg(ap, unsigned char **);
HAS_SPACE(src, 4);
SILC_GET32_MSB(len2, src->data);
}
case SILC_BUFFER_PARAM_UI32_STRING_ALLOC:
{
- unsigned int len2;
+ uint32 len2;
unsigned char **x = va_arg(ap, unsigned char **);
HAS_SPACE(src, 4);
SILC_GET32_MSB(len2, src->data);
}
case SILC_BUFFER_PARAM_UI16_NSTRING:
{
- unsigned short len2;
+ uint16 len2;
unsigned char **x = va_arg(ap, unsigned char **);
- unsigned short *len = va_arg(ap, unsigned short *);
+ uint16 *len = va_arg(ap, unsigned short *);
HAS_SPACE(src, 2);
SILC_GET16_MSB(len2, src->data);
silc_buffer_pull(src, 2);
}
case SILC_BUFFER_PARAM_UI16_NSTRING_ALLOC:
{
- unsigned short len2;
+ uint16 len2;
unsigned char **x = va_arg(ap, unsigned char **);
- unsigned short *len = va_arg(ap, unsigned short *);
+ uint16 *len = va_arg(ap, uint16 *);
HAS_SPACE(src, 2);
SILC_GET16_MSB(len2, src->data);
silc_buffer_pull(src, 2);
}
case SILC_BUFFER_PARAM_UI32_NSTRING:
{
- unsigned int len2;
+ uint32 len2;
unsigned char **x = va_arg(ap, unsigned char **);
- unsigned int *len = va_arg(ap, unsigned int *);
+ uint32 *len = va_arg(ap, uint32 *);
HAS_SPACE(src, 4);
SILC_GET32_MSB(len2, src->data);
silc_buffer_pull(src, 4);
case SILC_BUFFER_PARAM_UI_XNSTRING:
{
unsigned char **x = va_arg(ap, unsigned char **);
- unsigned int len = va_arg(ap, unsigned int);
+ uint32 len = va_arg(ap, uint32);
HAS_SPACE(src, len);
if (len && x)
*x = src->data;
case SILC_BUFFER_PARAM_UI_XNSTRING_ALLOC:
{
unsigned char **x = va_arg(ap, unsigned char **);
- unsigned int len = va_arg(ap, unsigned int);
+ uint32 len = va_arg(ap, uint32);
HAS_SPACE(src, len);
if (len && x) {
*x = silc_calloc(len + 1, sizeof(unsigned char));
#define SILC_STR_SI_CHAR(x) SILC_BUFFER_PARAM_SI8_CHAR, (x)
#define SILC_STR_UI_CHAR(x) SILC_BUFFER_PARAM_UI8_CHAR, (x)
-/* Signed/unsigned short.
+/* Signed/uint16.
Formatting: SILC_STR_SI_SHORT(short)
- SILC_STR_UI_SHORT(unsigned short)
+ SILC_STR_UI_SHORT(uint16)
Unformatting: SILC_STR_SI_SHORT(short *)
- SILC_STR_UI_SHORT(unsigned short *)
+ SILC_STR_UI_SHORT(uint16 *)
*/
#define SILC_STR_SI_SHORT(x) SILC_BUFFER_PARAM_SI16_SHORT, (x)
#define SILC_STR_UI_SHORT(x) SILC_BUFFER_PARAM_UI16_SHORT, (x)
-/* Signed/unsigned int.
+/* Signed/uint32.
Formatting: SILC_STR_SI_INT(int)
- SILC_STR_UI_INT(unsigned int)
+ SILC_STR_UI_INT(uint32)
Unformatting: SILC_STR_SI_INT(int *)
- SILC_STR_UI_INT(unsigned int *)
+ SILC_STR_UI_INT(uint32 *)
*/
#define SILC_STR_SI_INT(x) SILC_BUFFER_PARAM_SI32_INT, (x)
/* Unsigned string. Second argument is the length of the string.
- Formatting: SILC_STR_UI32_NSTRING(unsigned char *, unsigned int)
- Unformatting: SILC_STR_UI32_NSTRING(unsigned char **, unsigned int *)
+ Formatting: SILC_STR_UI32_NSTRING(unsigned char *, uint32)
+ Unformatting: SILC_STR_UI32_NSTRING(unsigned char **, uint32 *)
Unformatting procedure will check for length of the string from the
buffer before trying to get the string out. Thus, one *must* format the
the string.
Formatting: This is equal to using *_NSTRING
- Unformatting: SILC_STR_UI_XNSTRING(unsigned char **, unsigned int)
+ Unformatting: SILC_STR_UI_XNSTRING(unsigned char **, uint32)
This type can be used to take arbitrary length string from the buffer
by sending the requested amount of bytes as argument. This differs
except that there is now more space at the end of buffer. */
extern inline
-SilcBuffer silc_buffer_realloc(SilcBuffer sb, unsigned int newsize)
+SilcBuffer silc_buffer_realloc(SilcBuffer sb, uint32 newsize)
{
SilcBuffer sb_new;
char *log_warning_file;
char *log_error_file;
char *log_fatal_file;
-unsigned int log_info_size;
-unsigned int log_warning_size;
-unsigned int log_error_size;
-unsigned int log_fatal_size;
+uint32 log_info_size;
+uint32 log_warning_size;
+uint32 log_error_size;
+uint32 log_fatal_size;
/* Log callbacks. If these are set by the application these are used
instead of the default functions in this file. */
/* Outputs the log message to what ever log file selected. */
-void silc_log_output(const char *filename, unsigned int maxsize,
+void silc_log_output(const char *filename, uint32 maxsize,
SilcLogType type, char *string)
{
FILE *fp;
void silc_log_output_hexdump(char *file, char *function,
int line, void *data_in,
- unsigned int len, char *string)
+ uint32 len, char *string)
{
int i, k;
int off, pos, count;
/* Sets log files */
-void silc_log_set_files(char *info, unsigned int info_size,
- char *warning, unsigned int warning_size,
- char *error, unsigned int error_size,
- char *fatal, unsigned int fatal_size)
+void silc_log_set_files(char *info, uint32 info_size,
+ char *warning, uint32 warning_size,
+ char *error, uint32 error_size,
+ char *fatal, uint32 fatal_size)
{
log_info_file = info;
log_warning_file = warning;
/* Debug hexdump function callback. */
typedef void (*SilcDebugHexdumpCb)(char *file, char *function,
int line, unsigned char *data,
- unsigned int data_len, char *message);
+ uint32 data_len, char *message);
/* Default log filenames */
#define SILC_LOG_FILE_INFO "silcd.log"
extern char *log_warning_file;
extern char *log_error_file;
extern char *log_fatal_file;
-extern unsigned int log_info_size;
-extern unsigned int log_warning_size;
-extern unsigned int log_error_size;
-extern unsigned int log_fatal_size;
+extern uint32 log_info_size;
+extern uint32 log_warning_size;
+extern uint32 log_error_size;
+extern uint32 log_fatal_size;
/* Log macros. */
#define SILC_LOG_INFO(fmt) (silc_log_output(log_info_file, \
/* Prototypes */
void silc_log_output_debug(char *file, char *function,
int line, char *string);
-void silc_log_output(const char *filename, unsigned int maxsize,
+void silc_log_output(const char *filename, uint32 maxsize,
SilcLogType type, char *string);
void silc_log_output_hexdump(char *file, char *function,
int line, void *data_in,
- unsigned int len, char *string);
-void silc_log_set_files(char *info, unsigned int info_size,
- char *warning, unsigned int warning_size,
- char *error, unsigned int error_size,
- char *fatal, unsigned int fatal_size);
+ uint32 len, char *string);
+void silc_log_set_files(char *info, uint32 info_size,
+ char *warning, uint32 warning_size,
+ char *error, uint32 error_size,
+ char *fatal, uint32 fatal_size);
void silc_log_set_callbacks(SilcLogCb info, SilcLogCb warning,
SilcLogCb error, SilcLogCb fatal);
void silc_log_reset_callbacks();
/* Return remote port by socket. */
-unsigned short silc_net_get_remote_port(int sock)
+uint16 silc_net_get_remote_port(int sock)
{
struct sockaddr_in remote;
int len;
/* Return local port by socket. */
-unsigned short silc_net_get_local_port(int sock)
+uint16 silc_net_get_local_port(int sock)
{
struct sockaddr_in local;
int len;
int silc_net_set_socket_opt(int sock, int level, int option, int on);
int silc_net_is_ip(const char *addr);
void silc_net_check_host_by_sock(int sock, char **hostname, char **ip);
-unsigned short silc_net_get_remote_port(int sock);
-unsigned short silc_net_get_local_port(int sock);
+uint16 silc_net_get_remote_port(int sock);
+uint16 silc_net_get_local_port(int sock);
char *silc_net_localhost();
#endif
call this directly if wanted. This can be called multiple times for
one file descriptor to set different iomasks. */
-void silc_schedule_set_listen_fd(int fd, unsigned int iomask)
+void silc_schedule_set_listen_fd(int fd, uint32 iomask)
{
assert(schedule.valid != FALSE);
assert(fd < schedule.fd_list.max_fd);
allowed. */
typedef struct {
int *fd;
- unsigned int last_fd;
- unsigned int max_fd;
+ uint32 last_fd;
+ uint32 max_fd;
} SilcScheduleFdList;
/*
int max_fd);
int silc_schedule_uninit();
void silc_schedule_stop();
-void silc_schedule_set_listen_fd(int fd, unsigned int iomask);
+void silc_schedule_set_listen_fd(int fd, uint32 iomask);
void silc_schedule_unset_listen_fd(int fd);
void silc_schedule();
int silc_schedule_one(int block);
/* Reads a file to a buffer. The allocated buffer is returned. Length of
the file read is returned to the return_len argument. */
-char *silc_file_read(const char *filename, int *return_len)
+char *silc_file_read(const char *filename, uint32 *return_len)
{
int fd;
char *buffer;
/* Writes a buffer to the file. */
-int silc_file_write(const char *filename, const char *buffer, int len)
+int silc_file_write(const char *filename, const char *buffer, uint32 len)
{
int fd;
set to the file. */
int silc_file_write_mode(const char *filename, const char *buffer,
- int len, int mode)
+ uint32 len, int mode)
{
int fd;
data string. Note: This is originally public domain code and is
still PD. */
-char *silc_encode_pem(unsigned char *data, unsigned int len)
+char *silc_encode_pem(unsigned char *data, uint32 len)
{
int i, j;
- unsigned int bits, c, char_count;
+ uint32 bits, c, char_count;
char *pem;
char_count = 0;
/* Same as above but puts newline ('\n') every 72 characters. */
-char *silc_encode_pem_file(unsigned char *data, unsigned int data_len)
+char *silc_encode_pem_file(unsigned char *data, uint32 data_len)
{
int i, j;
- unsigned int len, cols;
+ uint32 len, cols;
char *pem, *pem2;
pem = silc_encode_pem(data, data_len);
/* Decodes PEM into data. Returns the decoded data. Note: This is
originally public domain code and is still PD. */
-unsigned char *silc_decode_pem(unsigned char *pem, unsigned int pem_len,
- unsigned int *ret_len)
+unsigned char *silc_decode_pem(unsigned char *pem, uint32 pem_len,
+ uint32 *ret_len)
{
int i, j;
- unsigned int len, c, char_count, bits;
+ uint32 len, c, char_count, bits;
unsigned char *data;
static char ialpha[256], decoder[256];
does not know anything about these. */
int silc_parse_nickname(char *string, char **nickname, char **server,
- unsigned int *num)
+ uint32 *num)
{
- unsigned int tlen;
+ uint32 tlen;
char tmp[256];
if (!string)
void silc_parse_command_line(unsigned char *buffer,
unsigned char ***parsed,
- unsigned int **parsed_lens,
- unsigned int **parsed_types,
- unsigned int *parsed_num,
- unsigned int max_args)
+ uint32 **parsed_lens,
+ uint32 **parsed_types,
+ uint32 *parsed_num,
+ uint32 max_args)
{
int i, len = 0;
int argc = 0;
static char rid[256];
-char *silc_id_render(void *id, unsigned short type)
+char *silc_id_render(void *id, uint16 type)
{
char tmp[100];
unsigned char tmps[2];
#define SILCUTIL_H
/* Prototypes */
-char *silc_file_read(const char *filename, int *return_len);
-int silc_file_write(const char *filename, const char *buffer, int len);
+char *silc_file_read(const char *filename, uint32 *return_len);
+int silc_file_write(const char *filename, const char *buffer, uint32 len);
int silc_file_write_mode(const char *filename, const char *buffer,
- int len, int mode);
+ uint32 len, int mode);
int silc_gets(char *dest, int destlen, const char *src, int srclen, int begin);
int silc_check_line(char *buf);
char *silc_get_time();
char *silc_to_upper(char *string);
-char *silc_encode_pem(unsigned char *data, unsigned int len);
-char *silc_encode_pem_file(unsigned char *data, unsigned int data_len);
-unsigned char *silc_decode_pem(unsigned char *pem, unsigned int pem_len,
- unsigned int *ret_len);
+char *silc_encode_pem(unsigned char *data, uint32 len);
+char *silc_encode_pem_file(unsigned char *data, uint32 data_len);
+unsigned char *silc_decode_pem(unsigned char *pem, uint32 pem_len,
+ uint32 *ret_len);
int silc_parse_nickname(char *string, char **nickname, char **server,
- unsigned int *num);
+ uint32 *num);
void silc_parse_command_line(unsigned char *buffer,
unsigned char ***parsed,
- unsigned int **parsed_lens,
- unsigned int **parsed_types,
- unsigned int *parsed_num,
- unsigned int max_args);
+ uint32 **parsed_lens,
+ uint32 **parsed_types,
+ uint32 *parsed_num,
+ uint32 max_args);
char *silc_format(char *fmt, ...);
-char *silc_id_render(void *id, unsigned short type);
+char *silc_id_render(void *id, uint16 type);
int silc_string_compare(char *string1, char *string2);
char *silc_string_regexify(const char *string);
int silc_string_regex_match(const char *regex, const char *string);
projects / silc.git / commitdiff