int silc_idlist_get_clients_by_nickname(SilcIDList id_list, char *nickname,
char *server,
SilcClientEntry **clients,
SilcUInt32 *clients_count)
{
SilcList list;
SilcIDCacheEntry id_cache = NULL;
SILC_LOG_DEBUG(("Start"));
if (!silc_idcache_find_by_name(id_list->clients, nickname, &list))
return FALSE;
*clients = silc_realloc(*clients,
(silc_list_count(list) + *clients_count) *
sizeof(**clients));
silc_list_start(list);
while ((id_cache = silc_list_get(list)))
(*clients)[(*clients_count)++] = id_cache->context;
SILC_LOG_DEBUG(("Found total %d clients", *clients_count));
return TRUE;
}
void silc_sftp_name_add(SilcSFTPName name, const char *short_name,
const char *long_name, SilcSFTPAttributes attrs)
{
name->filename = silc_realloc(name->filename, sizeof(*name->filename) *
(name->count + 1));
name->long_filename = silc_realloc(name->long_filename,
sizeof(*name->long_filename) *
(name->count + 1));
name->attrs = silc_realloc(name->attrs, sizeof(*name->attrs) *
(name->count + 1));
if (!name->filename || !name->long_filename || !name->attrs)
return;
name->filename[name->count] = strdup(short_name);
name->long_filename[name->count] = strdup(long_name);
name->attrs[name->count] = attrs;
name->count++;
}
int silc_idlist_get_clients_by_hash(SilcIDList id_list,
char *nickname, char *server,
SilcHash md5hash,
SilcClientEntry **clients,
SilcUInt32 *clients_count)
{
SilcList list;
SilcIDCacheEntry id_cache = NULL;
unsigned char hash[SILC_HASH_MAXLEN];
SilcClientID client_id;
SilcClientEntry client_entry;
SILC_LOG_DEBUG(("Start"));
silc_hash_make(md5hash, nickname, strlen(nickname), hash);
/* As the Client ID is hashed in the ID cache by hashing only the hash
from the Client ID, we can do a lookup with only the hash not the
other parts of the ID and get all the clients with that hash, ie.
with that nickname, as the hash is from the nickname. */
memset(&client_id, 0, sizeof(client_id));
memcpy(&client_id.hash, hash, sizeof(client_id.hash));
if (!silc_idcache_find_by_id(id_list->clients, &client_id, &list))
return FALSE;
/* If server is specified, narrow the search with it. */
if (server) {
silc_list_start(list);
while ((id_cache = silc_list_get(list))) {
client_entry = id_cache->context;
if (!client_entry->servername)
continue;
if (!silc_utf8_strcasecmp(client_entry->servername, server))
silc_list_del(list, id_cache);
}
}
if (!silc_list_count(list))
return FALSE;
*clients = silc_realloc(*clients,
(silc_list_count(list) + *clients_count) *
sizeof(**clients));
silc_list_start(list);
while ((id_cache = silc_list_get(list)))
(*clients)[(*clients_count)++] = id_cache->context;
SILC_LOG_DEBUG(("Found total %d clients", *clients_count));
return TRUE;
}
unsigned char *silc_attribute_get_verify_data(SilcDList attrs,
SilcBool server_verification,
SilcUInt32 *data_len)
{
SilcAttributePayload attr;
SilcBufferStruct buffer;
unsigned char *data = NULL;
SilcUInt32 len = 0;
silc_dlist_start(attrs);
while ((attr = silc_dlist_get(attrs)) != SILC_LIST_END) {
switch (attr->attribute) {
case SILC_ATTRIBUTE_SERVER_DIGITAL_SIGNATURE:
/* Server signature is never part of the verification data */
break;
case SILC_ATTRIBUTE_USER_DIGITAL_SIGNATURE:
/* For user signature verification this is not part of the data */
if (!server_verification)
break;
/* Fallback, for server signature verification, user digital signature
is part of verification data. */
default:
/* All other data is part of the verification data */
data = silc_realloc(data, sizeof(*data) * (4 + attr->data_len + len));
if (!data)
return NULL;
silc_buffer_set(&buffer, data + len, 4 + attr->data_len);
silc_buffer_format(&buffer,
SILC_STR_UI_CHAR(attr->attribute),
SILC_STR_UI_CHAR(attr->flags),
SILC_STR_UI_SHORT(attr->data_len),
SILC_STR_UI_XNSTRING(attr->data, attr->data_len),
SILC_STR_END);
len += 4 + attr->data_len;
break;
}
}
if (data_len)
*data_len = len;
return data;
}
void *silc_srealloc(SilcStack stack, SilcUInt32 old_size,
void *ptr, SilcUInt32 size)
{
void *new_ptr;
if (!stack)
return silc_realloc(ptr, size);
new_ptr = silc_stack_realloc(stack, old_size, ptr, size);
if (!new_ptr) {
new_ptr = silc_smalloc(stack, size);
if (!new_ptr)
return NULL;
memcpy(new_ptr, ptr, old_size > size ? size : old_size);
}
return new_ptr;
}
SilcBool silc_vcard_decode(const unsigned char *data, SilcUInt32 data_len,
SilcVCard vcard)
{
unsigned char *val;
SilcBool has_begin = FALSE, has_end = FALSE;
int len, i, off = 0;
val = (unsigned char *)data;
while (val) {
len = 0;
for (i = (val - data); i < data_len; i++) {
if (data[i] == '\0' || data[i] == '\n') {
len = i - (val - data);
break;
}
}
if (!len || len > data_len - (val - data))
break;
/* Check for mandatory header and footer */
if (!strncasecmp(val, VCARD_HEADER, strlen(VCARD_HEADER))) {
has_begin = TRUE;
goto next;
}
if (!strncasecmp(val, VCARD_FOOTER, strlen(VCARD_FOOTER))) {
has_end = TRUE;
goto next;
}
/* Get single fields */
VCARD_FIELD(val, "FN:", vcard->full_name);
VCARD_FIELD(val, "NICKNAME:", vcard->nickname);
VCARD_FIELD(val, "BDAY:", vcard->bday);
VCARD_FIELD(val, "TITLE:", vcard->title);
VCARD_FIELD(val, "ROLE:", vcard->role);
VCARD_FIELD(val, "CATEGORIES:", vcard->categories);
VCARD_FIELD(val, "CLASS:", vcard->catclass);
VCARD_FIELD(val, "URL:", vcard->url);
VCARD_FIELD(val, "LABEL;", vcard->label);
VCARD_FIELD(val, "NOTE:", vcard->note);
VCARD_FIELD(val, "REV:", vcard->rev);
/* Get multi-column fields */
if (!strncasecmp(val, "N:", 2)) {
if (vcard->family_name)
break;
if (len - 2) {
off = 2;
for (i = off; i < len; i++)
if (val[i] == ';') {
VCARD_TOKEN(vcard->family_name);
VCARD_TOKEN(vcard->first_name);
VCARD_TOKEN(vcard->middle_names);
VCARD_TOKEN(vcard->prefix);
}
if (!vcard->family_name && !vcard->first_name) {
VCARD_LASTTOKEN(vcard->family_name);
off += (len - off);
}
if (!vcard->first_name) {
VCARD_LASTTOKEN(vcard->first_name);
} else {
VCARD_LASTTOKEN(vcard->suffix);
}
}
goto next;
}
if (!strncasecmp(val, "ORG:", 4)) {
if (vcard->org_name)
continue;
if (len - 4) {
off = 4;
for (i = off; i < len; i++) {
if (val[i] == ';') {
VCARD_TOKEN(vcard->org_name);
break;
}
}
/* It's possible to have ORG without last ';', so check for it */
if (!vcard->org_name) {
VCARD_LASTTOKEN(vcard->org_name);
} else {
VCARD_LASTTOKEN(vcard->org_unit);
}
}
goto next;
}
if (!strncasecmp(val, "ADR;", 4)) {
vcard->addrs = silc_realloc(vcard->addrs, sizeof(*vcard->addrs) *
(vcard->num_addrs + 1));
memset(&vcard->addrs[vcard->num_addrs], 0, sizeof(*vcard->addrs));
if (len - 4) {
off = 4;
for (i = off; i < len; i++)
if (val[i] == ';') {
VCARD_TYPETOKEN(vcard->addrs[vcard->num_addrs].type);
VCARD_TOKEN(vcard->addrs[vcard->num_addrs].pbox);
VCARD_TOKEN(vcard->addrs[vcard->num_addrs].ext_addr);
VCARD_TOKEN(vcard->addrs[vcard->num_addrs].street_addr);
VCARD_TOKEN(vcard->addrs[vcard->num_addrs].city);
VCARD_TOKEN(vcard->addrs[vcard->num_addrs].state);
VCARD_TOKEN(vcard->addrs[vcard->num_addrs].code);
}
VCARD_LASTTOKEN(vcard->addrs[vcard->num_addrs].country);
}
vcard->num_addrs++;
goto next;
}
if (!strncasecmp(val, "TEL;", 4)) {
vcard->tels = silc_realloc(vcard->tels, sizeof(*vcard->tels) *
(vcard->num_tels + 1));
memset(&vcard->tels[vcard->num_tels], 0, sizeof(*vcard->tels));
if (len - 4) {
off = 4;
for (i = off; i < len; i++)
if (val[i] == ':') {
i++;
VCARD_TYPETOKEN(vcard->tels[vcard->num_tels].type);
break;
}
VCARD_LASTTOKEN(vcard->tels[vcard->num_tels].telnum);
}
vcard->num_tels++;
goto next;
}
if (!strncasecmp(val, "EMAIL;", 6)) {
vcard->emails = silc_realloc(vcard->emails, sizeof(*vcard->emails) *
(vcard->num_emails + 1));
memset(&vcard->emails[vcard->num_emails], 0, sizeof(*vcard->emails));
if (len - 6) {
off = 6;
for (i = off; i < len; i++)
if (val[i] == ':') {
i++;
VCARD_TYPETOKEN(vcard->emails[vcard->num_emails].type);
break;
}
VCARD_LASTTOKEN(vcard->emails[vcard->num_emails].address);
}
vcard->num_emails++;
goto next;
}
next:
val = strchr(val, '\n');
if (!val)
break;
val++;
if (!val || !(*val))
break;
}
if (!has_begin || !has_end || !vcard->full_name) {
silc_vcard_free(vcard);
return FALSE;
}
return TRUE;
}
SilcStringprepStatus
silc_stringprep(const unsigned char *bin, SilcUInt32 bin_len,
SilcStringEncoding bin_encoding,
const char *profile_name,
SilcStringprepFlags flags,
unsigned char **out, SilcUInt32 *out_len,
SilcStringEncoding out_encoding)
{
Stringprep_profile_flags f = 0;
const Stringprep_profile *profile;
unsigned char *utf8s;
SilcUInt32 utf8s_len;
int ret;
SILC_LOG_DEBUG(("Preparing string"));
if (!bin || !bin_len || !profile_name)
return SILC_STRINGPREP_ERR;
/* Convert string to UTF-8 */
utf8s_len = silc_utf8_encoded_len(bin, bin_len, bin_encoding);
if (!utf8s_len)
return SILC_STRINGPREP_ERR_ENCODING;
utf8s = silc_calloc(utf8s_len + 1, sizeof(*utf8s));
if (!utf8s)
return SILC_STRINGPREP_ERR_OUT_OF_MEMORY;
silc_utf8_encode(bin, bin_len, bin_encoding, utf8s, utf8s_len);
/* Check profile. */
if (!strcmp(profile_name, SILC_IDENTIFIER_PREP))
profile = stringprep_silc_identifier_prep;
else if (!strcmp(profile_name, SILC_IDENTIFIER_CH_PREP))
profile = stringprep_silc_identifier_ch_prep;
else if (!strcmp(profile_name, SILC_IDENTIFIERC_PREP))
profile = stringprep_silc_identifierc_prep;
else if (!strcmp(profile_name, SILC_CASEFOLD_PREP))
profile = stringprep_silc_casefold_prep;
else
return SILC_STRINGPREP_ERR_UNSUP_PROFILE;
/* Translate flags */
if (!(flags & SILC_STRINGPREP_ALLOW_UNASSIGNED))
f |= STRINGPREP_NO_UNASSIGNED;
/* Prepare */
ret = stringprep((char *)utf8s, utf8s_len, f, profile);
SILC_LOG_DEBUG(("stringprep() return %d", ret));
/* Since the stringprep() doesn't allocate returned buffer, and
stringprep_profile() doesn't do it correctly, we can't know how
much space we must have for the conversion. Allocate more if it
fails, and try again. */
if (ret == STRINGPREP_TOO_SMALL_BUFFER) {
utf8s = silc_realloc(utf8s, sizeof(*utf8s) * ((utf8s_len * 2) + 1));
if (!utf8s)
return SILC_STRINGPREP_ERR_OUT_OF_MEMORY;
memset(utf8s + utf8s_len + 1, 0, utf8s_len);
ret = stringprep((char *)utf8s, utf8s_len * 2, f, profile);
SILC_LOG_DEBUG(("stringprep() return %d", ret));
}
switch (ret) {
case STRINGPREP_OK:
ret = SILC_STRINGPREP_OK;
break;
case STRINGPREP_CONTAINS_UNASSIGNED:
ret = SILC_STRINGPREP_ERR_UNASSIGNED;
break;
case STRINGPREP_CONTAINS_PROHIBITED:
ret = SILC_STRINGPREP_ERR_PROHIBITED;
break;
case STRINGPREP_BIDI_BOTH_L_AND_RAL:
ret = SILC_STRINGPREP_ERR_BIDI_RAL_WITH_L;
break;
case STRINGPREP_BIDI_LEADTRAIL_NOT_RAL:
ret = SILC_STRINGPREP_ERR_BIDI_RAL;
break;
case STRINGPREP_BIDI_CONTAINS_PROHIBITED:
ret = SILC_STRINGPREP_ERR_BIDI_PROHIBITED;
break;
case STRINGPREP_UNKNOWN_PROFILE:
ret = SILC_STRINGPREP_ERR_UNSUP_PROFILE;
break;
case STRINGPREP_MALLOC_ERROR:
ret = SILC_STRINGPREP_ERR_OUT_OF_MEMORY;
break;
default:
ret = SILC_STRINGPREP_ERR;
break;
}
/* Convert to desired output character encoding */
if (ret == SILC_STRINGPREP_OK) {
if (out && out_len) {
if (out_encoding != SILC_STRING_UTF8) {
*out_len = silc_utf8_decoded_len(utf8s, strlen(utf8s), out_encoding);
if (*out_len) {
*out = silc_calloc(*out_len + 1, sizeof(**out));
if (*out) {
silc_utf8_decode(utf8s, strlen(utf8s), out_encoding, *out,
*out_len);
} else {
ret = SILC_STRINGPREP_ERR_OUT_OF_MEMORY;
}
} else {
ret = SILC_STRINGPREP_ERR_ENCODING;
}
} else {
*out_len = strlen(utf8s);
*out = silc_memdup(utf8s, *out_len);
}
}
}
silc_free(utf8s);
return (SilcStringprepStatus)ret;
}
