/* 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;
}
filelen = lseek(fd, (off_t)0L, SEEK_END);
- if (filelen < 0)
+ if (filelen < 0) {
+ close(fd);
return NULL;
- if (lseek(fd, (off_t)0L, SEEK_SET) < 0)
+ }
+ if (lseek(fd, (off_t)0L, SEEK_SET) < 0) {
+ close(fd);
return NULL;
+ }
if (filelen < 0) {
SILC_LOG_ERROR(("Cannot open file %s: %s", filename, strerror(errno)));
+ close(fd);
return NULL;
}
/* 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;
if ((fd = creat(filename, 0644)) == -1) {
- SILC_LOG_ERROR(("Cannot open file %s for writing: %s", strerror(errno)));
+ SILC_LOG_ERROR(("Cannot open file %s for writing: %s", filename,
+ strerror(errno)));
return -1;
}
if ((write(fd, buffer, len)) == -1) {
- SILC_LOG_ERROR(("Cannot write to file %s: %s", strerror(errno)));
+ SILC_LOG_ERROR(("Cannot write to file %s: %s", filename, strerror(errno)));
+ close(fd);
return -1;
}
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;
if ((fd = creat(filename, mode)) == -1) {
- SILC_LOG_ERROR(("Cannot open file %s for writing: %s", strerror(errno)));
+ SILC_LOG_ERROR(("Cannot open file %s for writing: %s", filename,
+ strerror(errno)));
return -1;
}
if ((write(fd, buffer, len)) == -1) {
- SILC_LOG_ERROR(("Cannot write to file %s: %s", strerror(errno)));
+ SILC_LOG_ERROR(("Cannot write to file %s: %s", filename, strerror(errno)));
+ close(fd);
return -1;
}
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);
pem2[i] = pem[j++];
}
+ silc_free(pem);
return pem2;
}
/* 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];
case SILC_ID_SERVER:
{
SilcServerID *server_id = (SilcServerID *)id;
- strcat(rid, inet_ntoa(server_id->ip));
+ struct in_addr ipv4;
+
+ if (server_id->ip.data_len > 4) {
+
+ } else {
+ SILC_GET32_MSB(ipv4.s_addr, server_id->ip.data);
+ strcat(rid, inet_ntoa(ipv4));
+ }
+
memset(tmp, 0, sizeof(tmp));
snprintf(tmp, sizeof(tmp), ",%d,", ntohs(server_id->port));
strcat(rid, tmp);
case SILC_ID_CLIENT:
{
SilcClientID *client_id = (SilcClientID *)id;
- strcat(rid, inet_ntoa(client_id->ip));
+ struct in_addr ipv4;
+
+ if (client_id->ip.data_len > 4) {
+
+ } else {
+ SILC_GET32_MSB(ipv4.s_addr, client_id->ip.data);
+ strcat(rid, inet_ntoa(ipv4));
+ }
+
memset(tmp, 0, sizeof(tmp));
snprintf(tmp, sizeof(tmp), ",%02x,", client_id->rnd);
strcat(rid, tmp);
case SILC_ID_CHANNEL:
{
SilcChannelID *channel_id = (SilcChannelID *)id;
- strcat(rid, inet_ntoa(channel_id->ip));
+ struct in_addr ipv4;
+
+ if (channel_id->ip.data_len > 4) {
+
+ } else {
+ SILC_GET32_MSB(ipv4.s_addr, channel_id->ip.data);
+ strcat(rid, inet_ntoa(ipv4));
+ }
+
memset(tmp, 0, sizeof(tmp));
snprintf(tmp, sizeof(tmp), ",%d,", ntohs(channel_id->port));
strcat(rid, tmp);
tmpstr2 = silc_calloc(slen2 + 1, sizeof(char));
memcpy(tmpstr2, string2, slen2);
- for (i = 0; i < slen2; i++) {
+ for (i = 0; i < slen1; i++) {
/* * wildcard. Only one * wildcard is possible. */
if (tmpstr1[i] == '*')
if (!(slen1 < slen2))
tmpstr2[i] = '?';
}
-#if 0
- } else {
- if (strncmp(tmpstr1, tmpstr2, i))
- strncpy(tmpstr2, string2, slen2);
-#endif
}
}
return ret;
}
+
+/* Returns the username of the user. If the global variable LOGNAME
+ does not exists we will get the name from the password file. */
+
+char *silc_get_username()
+{
+ char *logname = NULL;
+
+ if (!getenv("LOGNAME")) {
+ fprintf(stderr, "Error: environment variable $LOGNAME not set\n");
+ return NULL;
+ }
+
+ logname = strdup(getenv("LOGNAME"));
+ if (!logname) {
+ logname = getlogin();
+ if (!logname) {
+ struct passwd *pw;
+
+ pw = getpwuid(getuid());
+ if (!pw) {
+ fprintf(stderr, "silc_get_username: %s\n", strerror(errno));
+ return NULL;
+ }
+
+ logname = strdup(pw->pw_name);
+ }
+ }
+
+ return logname;
+}
+
+/* Returns the real name of ther user. */
+
+char *silc_get_real_name()
+{
+ char *realname = NULL;
+ struct passwd *pw;
+
+ pw = getpwuid(getuid());
+ if (!pw) {
+ fprintf(stderr, "silc_get_username: %s\n", strerror(errno));
+ return NULL;
+ }
+
+ if (strchr(pw->pw_gecos, ','))
+ *strchr(pw->pw_gecos, ',') = 0;
+
+ realname = strdup(pw->pw_gecos);
+
+ return realname;
+}
+
+/* Basic has function to hash strings. May be used with the SilcHashTable.
+ Note that this lowers the characters of the string (with tolower()) so
+ this is used usually with nicknames, channel and server names to provide
+ case insensitive keys. */
+
+uint32 silc_hash_string(void *key, void *user_context)
+{
+ char *s = (char *)key;
+ uint32 h = 0, g;
+
+ while (*s != '\0') {
+ h = (h << 4) + tolower(*s);
+ if ((g = h & 0xf0000000)) {
+ h = h ^ (g >> 24);
+ h = h ^ g;
+ }
+ s++;
+ }
+
+ return h;
+}
+
+/* Basic hash function to hash integers. May be used with the SilcHashTable. */
+
+uint32 silc_hash_uint(void *key, void *user_context)
+{
+ return *(uint32 *)key;
+}
+
+/* Basic hash funtion to hash pointers. May be used with the SilcHashTable. */
+
+uint32 silc_hash_ptr(void *key, void *user_context)
+{
+ return (uint32)key;
+}
+
+/* Hash a ID. The `user_context' is the ID type. */
+
+uint32 silc_hash_id(void *key, void *user_context)
+{
+ SilcIdType id_type = (SilcIdType)(uint32)user_context;
+ uint32 h = 0;
+ int i;
+
+ switch (id_type) {
+ case SILC_ID_CLIENT:
+ {
+ SilcClientID *id = (SilcClientID *)key;
+ uint32 g;
+
+ /* The client ID is hashed by hashing the hash of the ID
+ (which is a truncated MD5 hash of the nickname) so that we
+ can access the entry from the cache with both Client ID but
+ with just a hash from the ID as well. */
+
+ for (i = 0; i < sizeof(id->hash); i++) {
+ h = (h << 4) + id->hash[i];
+ if ((g = h & 0xf0000000)) {
+ h = h ^ (g >> 24);
+ h = h ^ g;
+ }
+ }
+
+ return h;
+ }
+ break;
+ case SILC_ID_SERVER:
+ {
+ SilcServerID *id = (SilcServerID *)key;
+
+ h = id->port * id->rnd;
+ for (i = 0; i < id->ip.data_len; i++)
+ h ^= id->ip.data[i];
+
+ return h;
+ }
+ break;
+ case SILC_ID_CHANNEL:
+ {
+ SilcChannelID *id = (SilcChannelID *)key;
+
+ h = id->port * id->rnd;
+ for (i = 0; i < id->ip.data_len; i++)
+ h ^= id->ip.data[i];
+
+ return h;
+ }
+ break;
+ default:
+ break;
+ }
+
+ return h;
+}
+
+/* Hash binary data. The `user_context' is the data length. */
+
+uint32 silc_hash_data(void *key, void *user_context)
+{
+ uint32 len = (uint32)user_context, h = 0;
+ unsigned char *data = (unsigned char *)key;
+ int i;
+
+ h = (data[0] * data[len - 1] + 1) * len;
+ for (i = 0; i < len; i++)
+ h ^= data[i];
+
+ return h;
+}
+
+/* Compares two strings. May be used as SilcHashTable comparison function. */
+
+bool silc_hash_string_compare(void *key1, void *key2, void *user_context)
+{
+ return !strcasecmp((char *)key1, (char *)key2);
+}
+
+/* Compares two ID's. May be used as SilcHashTable comparison function.
+ The Client ID's compares only the hash of the Client ID not any other
+ part of the Client ID. Other ID's are fully compared. */
+
+bool silc_hash_id_compare(void *key1, void *key2, void *user_context)
+{
+ SilcIdType id_type = (SilcIdType)(uint32)user_context;
+ return (id_type == SILC_ID_CLIENT ?
+ SILC_ID_COMPARE_HASH((SilcClientID *)key1, (SilcClientID *)key2) :
+ SILC_ID_COMPARE_TYPE(key1, key2, id_type));
+}
+
+/* Compare two Client ID's entirely and not just the hash from the ID. */
+
+bool silc_hash_client_id_compare(void *key1, void *key2, void *user_context)
+{
+ return SILC_ID_COMPARE_TYPE(key1, key2, SILC_ID_CLIENT);
+}
+
+/* Compares binary data. May be used as SilcHashTable comparison function. */
+
+bool silc_hash_data_compare(void *key1, void *key2, void *user_context)
+{
+ uint32 len = (uint32)user_context;
+ return !memcmp(key1, key2, len);
+}
+
+/* Parses mode mask and returns the mode as string. */
+
+char *silc_client_chmode(uint32 mode, const char *cipher, const char *hmac)
+{
+ char string[100];
+
+ if (!mode)
+ return NULL;
+
+ memset(string, 0, sizeof(string));
+
+ if (mode & SILC_CHANNEL_MODE_PRIVATE)
+ strncat(string, "p", 1);
+
+ if (mode & SILC_CHANNEL_MODE_SECRET)
+ strncat(string, "s", 1);
+
+ if (mode & SILC_CHANNEL_MODE_PRIVKEY)
+ strncat(string, "k", 1);
+
+ if (mode & SILC_CHANNEL_MODE_INVITE)
+ strncat(string, "i", 1);
+
+ if (mode & SILC_CHANNEL_MODE_TOPIC)
+ strncat(string, "t", 1);
+
+ if (mode & SILC_CHANNEL_MODE_ULIMIT)
+ strncat(string, "l", 1);
+
+ if (mode & SILC_CHANNEL_MODE_PASSPHRASE)
+ strncat(string, "a", 1);
+
+ if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)
+ strncat(string, "f", 1);
+
+ if (mode & SILC_CHANNEL_MODE_CIPHER)
+ strncat(string, cipher, strlen(cipher));
+
+ if (mode & SILC_CHANNEL_MODE_HMAC)
+ strncat(string, hmac, strlen(hmac));
+
+ /* Rest of mode is ignored */
+
+ return strdup(string);
+}
+
+/* Parses channel user mode mask and returns te mode as string */
+
+char *silc_client_chumode(uint32 mode)
+{
+ char string[4];
+
+ if (!mode)
+ return NULL;
+
+ memset(string, 0, sizeof(string));
+
+ if (mode & SILC_CHANNEL_UMODE_CHANFO)
+ strncat(string, "f", 1);
+
+ if (mode & SILC_CHANNEL_UMODE_CHANOP)
+ strncat(string, "o", 1);
+
+ return strdup(string);
+}
+
+/* Parses channel user mode and returns it as special mode character. */
+
+char *silc_client_chumode_char(uint32 mode)
+{
+ char string[4];
+
+ if (!mode)
+ return NULL;
+
+ memset(string, 0, sizeof(string));
+
+ if (mode & SILC_CHANNEL_UMODE_CHANFO)
+ strncat(string, "*", 1);
+
+ if (mode & SILC_CHANNEL_UMODE_CHANOP)
+ strncat(string, "@", 1);
+
+ return strdup(string);
+}
projects / runtime.git / blobdiff