/* 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;
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)));
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)));
return -1;
}
return ret;
}
-/* Compares two strings. Strings may include wildcards * and ?.
- Returns TRUE if strings match. */
-
-int silc_string_compare(char *string1, char *string2)
-{
- int i;
- int slen1 = strlen(string1);
- int slen2 = strlen(string2);
- char *tmpstr1, *tmpstr2;
-
- if (!string1 || !string2)
- return FALSE;
-
- /* See if they are same already */
- if (!strncmp(string1, string2, strlen(string2)))
- return TRUE;
-
- if (slen2 < slen1)
- if (!strchr(string1, '*'))
- return FALSE;
-
- /* Take copies of the original strings as we will change them */
- tmpstr1 = silc_calloc(slen1 + 1, sizeof(char));
- memcpy(tmpstr1, string1, slen1);
- tmpstr2 = silc_calloc(slen2 + 1, sizeof(char));
- memcpy(tmpstr2, string2, slen2);
-
- for (i = 0; i < slen2; i++) {
-
- /* * wildcard. Only one * wildcard is possible. */
- if (tmpstr1[i] == '*')
- if (!strncmp(tmpstr1, tmpstr2, i)) {
- memset(tmpstr2, 0, slen2);
- strncpy(tmpstr2, tmpstr1, i);
- break;
- }
-
- /* ? wildcard */
- if (tmpstr1[i] == '?') {
- if (!strncmp(tmpstr1, tmpstr2, i)) {
- if (!(slen1 < i + 1))
- if (tmpstr1[i + 1] != '?' &&
- tmpstr1[i + 1] != tmpstr2[i + 1])
- continue;
-
- if (!(slen1 < slen2))
- tmpstr2[i] = '?';
- }
-#if 0
- } else {
- if (strncmp(tmpstr1, tmpstr2, i))
- strncpy(tmpstr2, string2, slen2);
-#endif
- }
- }
-
- /* if using *, remove it */
- if (strchr(tmpstr1, '*'))
- *strchr(tmpstr1, '*') = 0;
-
- if (!strcmp(tmpstr1, tmpstr2)) {
- memset(tmpstr1, 0, slen1);
- memset(tmpstr2, 0, slen2);
- silc_free(tmpstr1);
- silc_free(tmpstr2);
- return TRUE;
- }
-
- memset(tmpstr1, 0, slen1);
- memset(tmpstr2, 0, slen2);
- silc_free(tmpstr1);
- silc_free(tmpstr2);
- return FALSE;
-}
-
-unsigned char pem_enc[64] =
+static unsigned char pem_enc[64] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/* Encodes data into PEM encoding. Returns NULL terminated PEM encoded
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)
}
if (server) {
- *server = silc_calloc(strlen(string) - tlen, sizeof(char));
+ *server = silc_calloc((strlen(string) - tlen) + 1, sizeof(char));
memcpy(*server, string + tlen + 1, strlen(string) - tlen - 1);
}
} else {
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;
return strdup(buf);
}
+
+/* Renders ID to suitable to print for example to log file. */
+
+static char rid[256];
+
+char *silc_id_render(void *id, uint16 type)
+{
+ char tmp[100];
+ unsigned char tmps[2];
+
+ memset(rid, 0, sizeof(rid));
+ switch(type) {
+ case SILC_ID_SERVER:
+ {
+ SilcServerID *server_id = (SilcServerID *)id;
+ 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);
+ SILC_PUT16_MSB(server_id->rnd, tmps);
+ memset(tmp, 0, sizeof(tmp));
+ snprintf(tmp, sizeof(tmp), "[%02x %02x]", tmps[0], tmps[1]);
+ strcat(rid, tmp);
+ }
+ break;
+ case SILC_ID_CLIENT:
+ {
+ SilcClientID *client_id = (SilcClientID *)id;
+ 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);
+ memset(tmp, 0, sizeof(tmp));
+ snprintf(tmp, sizeof(tmp), "[%02x %02x %02x %02x...]",
+ client_id->hash[0], client_id->hash[1],
+ client_id->hash[2], client_id->hash[3]);
+ strcat(rid, tmp);
+ }
+ break;
+ case SILC_ID_CHANNEL:
+ {
+ SilcChannelID *channel_id = (SilcChannelID *)id;
+ 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);
+ SILC_PUT16_MSB(channel_id->rnd, tmps);
+ memset(tmp, 0, sizeof(tmp));
+ snprintf(tmp, sizeof(tmp), "[%02x %02x]", tmps[0], tmps[1]);
+ strcat(rid, tmp);
+ }
+ break;
+ }
+
+ return rid;
+}
+
+/* Compares two strings. Strings may include wildcards * and ?.
+ Returns TRUE if strings match. */
+
+int silc_string_compare(char *string1, char *string2)
+{
+ int i;
+ int slen1 = strlen(string1);
+ int slen2 = strlen(string2);
+ char *tmpstr1, *tmpstr2;
+
+ if (!string1 || !string2)
+ return FALSE;
+
+ /* See if they are same already */
+ if (!strncmp(string1, string2, strlen(string2)))
+ return TRUE;
+
+ if (slen2 < slen1)
+ if (!strchr(string1, '*'))
+ return FALSE;
+
+ /* Take copies of the original strings as we will change them */
+ tmpstr1 = silc_calloc(slen1 + 1, sizeof(char));
+ memcpy(tmpstr1, string1, slen1);
+ tmpstr2 = silc_calloc(slen2 + 1, sizeof(char));
+ memcpy(tmpstr2, string2, slen2);
+
+ for (i = 0; i < slen1; i++) {
+
+ /* * wildcard. Only one * wildcard is possible. */
+ if (tmpstr1[i] == '*')
+ if (!strncmp(tmpstr1, tmpstr2, i)) {
+ memset(tmpstr2, 0, slen2);
+ strncpy(tmpstr2, tmpstr1, i);
+ break;
+ }
+
+ /* ? wildcard */
+ if (tmpstr1[i] == '?') {
+ if (!strncmp(tmpstr1, tmpstr2, i)) {
+ if (!(slen1 < i + 1))
+ if (tmpstr1[i + 1] != '?' &&
+ tmpstr1[i + 1] != tmpstr2[i + 1])
+ continue;
+
+ if (!(slen1 < slen2))
+ tmpstr2[i] = '?';
+ }
+ }
+ }
+
+ /* if using *, remove it */
+ if (strchr(tmpstr1, '*'))
+ *strchr(tmpstr1, '*') = 0;
+
+ if (!strcmp(tmpstr1, tmpstr2)) {
+ memset(tmpstr1, 0, slen1);
+ memset(tmpstr2, 0, slen2);
+ silc_free(tmpstr1);
+ silc_free(tmpstr2);
+ return TRUE;
+ }
+
+ memset(tmpstr1, 0, slen1);
+ memset(tmpstr2, 0, slen2);
+ silc_free(tmpstr1);
+ silc_free(tmpstr2);
+ return FALSE;
+}
+
+/* Inspects the `string' for wildcards and returns regex string that can
+ be used by the GNU regex library. A comma (`,') in the `string' means
+ that the string is list. */
+
+char *silc_string_regexify(const char *string)
+{
+ int i, len, count;
+ char *regex;
+
+ len = strlen(string);
+ count = 4;
+ for (i = 0; i < len; i++)
+ if (string[i] == '*' || string[i] == '?')
+ count++;
+
+ regex = silc_calloc(len + count, sizeof(*regex));
+
+ count = 0;
+ regex[count] = '(';
+ count++;
+
+ for (i = 0; i < len; i++) {
+ if (string[i] == '*' || string[i] == '?') {
+ regex[count] = '.';
+ count++;
+ } else if (string[i] == ',') {
+ regex[count] = '|';
+ count++;
+ continue;
+ }
+
+ regex[count] = string[i];
+ count++;
+ }
+
+ regex[count - 1] = ')';
+ regex[count] = '$';
+
+ return regex;
+}
+
+/* Combines two regex strings into one regex string so that they can be
+ used as one by the GNU regex library. The `string2' is combine into
+ the `string1'. */
+
+char *silc_string_regex_combine(const char *string1, const char *string2)
+{
+ char *tmp;
+ int len1, len2;
+
+ len1 = strlen(string1);
+ len2 = strlen(string2);
+
+ tmp = silc_calloc(2 + len1 + len2, sizeof(*tmp));
+ strncat(tmp, string1, len1 - 2);
+ strncat(tmp, "|", 1);
+ strncat(tmp, string2 + 1, len2 - 1);
+
+ return tmp;
+}
+
+/* Matches the two strings and returns TRUE if the strings match. */
+
+int silc_string_regex_match(const char *regex, const char *string)
+{
+ regex_t preg;
+ int ret = FALSE;
+
+ if (regcomp(&preg, regex, REG_NOSUB | REG_EXTENDED) < 0)
+ return FALSE;
+
+ if (regexec(&preg, string, 0, NULL, 0) == 0)
+ ret = TRUE;
+
+ regfree(&preg);
+
+ return ret;
+}
+
+/* Do regex match to the two strings `string1' and `string2'. If the
+ `string2' matches the `string1' this returns TRUE. */
+
+int silc_string_match(const char *string1, const char *string2)
+{
+ char *s1;
+ int ret = FALSE;
+
+ s1 = silc_string_regexify(string1);
+ ret = silc_string_regex_match(s1, string2);
+ silc_free(s1);
+
+ 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. */
+
+uint32 silc_hash_string(void *key)
+{
+ char *s = (char *)key;
+ uint32 h = 0, g;
+
+ while (*s != '\0') {
+ h = (h << 4) + toupper(*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)
+{
+ return *(uint32 *)key;
+}
+
+/* Basic hash funtion to hash pointers. May be used with the SilcHashTable. */
+
+uint32 silc_hash_ptr(void *key)
+{
+ return (uint32)key;
+}
+
+/* Hash a Server ID. */
+
+uint32 silc_hash_server_id(void *key)
+{
+ SilcServerID *id = (SilcServerID *)key;
+ int i;
+ uint32 h;
+
+ h = id->port * id->rnd;
+ for (i = 0; i < id->ip.data_len; i++)
+ h ^= id->ip.data[i];
+
+ return h;
+}
+
+/* Hash a Client ID. */
+
+uint32 silc_hash_client_id(void *key)
+{
+ SilcClientID *id = (SilcClientID *)key;
+ int i;
+ uint32 h;
+
+ h = id->rnd;
+ for (i = 0; i < sizeof(id->hash); i++)
+ h ^= id->hash[i];
+ for (i = 0; i < id->ip.data_len; i++)
+ h ^= id->ip.data[i];
+
+ return h;
+}
+
+/* Hash a Channel ID. */
+
+uint32 silc_hash_channel_id(void *key)
+{
+ SilcChannelID *id = (SilcChannelID *)key;
+ int i;
+ uint32 h;
+
+ h = id->port * id->rnd;
+ for (i = 0; i < id->ip.data_len; i++)
+ h ^= id->ip.data[i];
+
+ return h;
+}
projects / silc.git / blobdiff