X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Fsilcutil.c;h=d571b8a62a4dd328b3a1b901a8ac00f59f8e2934;hb=017dec75a98209fbef49eb496c2269b0c49e736d;hp=39b9ab1ad92eb7a79c5f297f8a70324833a9fad4;hpb=318d79b391bf6288e3e28c840217a7097f3d0392;p=silc.git diff --git a/lib/silcutil/silcutil.c b/lib/silcutil/silcutil.c index 39b9ab1a..d571b8a6 100644 --- a/lib/silcutil/silcutil.c +++ b/lib/silcutil/silcutil.c @@ -21,35 +21,14 @@ * These are general utility functions that doesn't belong to any specific * group of routines. */ -/* - * $Id$ - * $Log$ - * Revision 1.1 2000/09/13 17:45:16 priikone - * Splitted SILC core library. Core library includes now only - * SILC protocol specific stuff. New utility library includes the - * old stuff from core library that is more generic purpose stuff. - * - * Revision 1.4 2000/07/19 07:04:04 priikone - * Minor bug fix in silc_encode_pem - * - * Revision 1.3 2000/07/10 05:34:40 priikone - * Added PEM encoding/decoding functions. - * - * Revision 1.2 2000/07/05 06:06:12 priikone - * Added file saving with specific mode. - * - * Revision 1.1.1.1 2000/06/27 11:36:55 priikone - * Imported from internal CVS/Added Log headers. - * - * - */ +/* $Id$ */ #include "silcincludes.h" /* 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; @@ -62,13 +41,18 @@ char *silc_file_read(const char *filename, int *return_len) } 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; } @@ -84,24 +68,28 @@ char *silc_file_read(const char *filename, int *return_len) close(fd); buffer[filelen] = EOF; - - *return_len = filelen; + + if (return_len) + *return_len = filelen; + return 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))); + close(fd); return -1; } @@ -114,17 +102,19 @@ int silc_file_write(const char *filename, const char *buffer, int len) 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; } @@ -214,92 +204,17 @@ char *silc_to_upper(char *string) 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; @@ -344,10 +259,10 @@ char *silc_encode_pem(unsigned char *data, unsigned int len) /* 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); @@ -366,17 +281,18 @@ char *silc_encode_pem_file(unsigned char *data, unsigned int 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]; @@ -439,49 +355,30 @@ unsigned char *silc_decode_pem(unsigned char *pem, unsigned int pem_len, return data; } -/* Parse nickname string. The format may be !@ to - support multiple same nicknames. The is the final unifier if same - nickname is on same server. Note, this is only local format and server - does not know anything about these. */ +/* Parse userfqdn string which is in user@fqdn format */ -int silc_parse_nickname(char *string, char **nickname, char **server, - unsigned int *num) +bool silc_parse_userfqdn(const char *string, char **left, char **right) { - unsigned int tlen; - char tmp[256]; + uint32 tlen; if (!string) return FALSE; - if (strchr(string, '!')) { - tlen = strcspn(string, "!"); - memset(tmp, 0, sizeof(tmp)); - memcpy(tmp, string, tlen); - - if (num) - *num = atoi(tmp); - - if (tlen >= strlen(string)) - return FALSE; - - string += tlen + 1; - } - if (strchr(string, '@')) { tlen = strcspn(string, "@"); - if (nickname) { - *nickname = silc_calloc(tlen + 1, sizeof(char)); - memcpy(*nickname, string, tlen); + if (left) { + *left = silc_calloc(tlen + 1, sizeof(char)); + memcpy(*left, string, tlen); } - if (server) { - *server = silc_calloc(strlen(string) - tlen, sizeof(char)); - memcpy(*server, string + tlen + 1, strlen(string) - tlen - 1); + if (right) { + *right = silc_calloc((strlen(string) - tlen) + 1, sizeof(char)); + memcpy(*right, string + tlen + 1, strlen(string) - tlen - 1); } } else { - if (nickname) - *nickname = strdup(string); + if (left) + *left = strdup(string); } return TRUE; @@ -494,23 +391,29 @@ int silc_parse_nickname(char *string, char **nickname, char **server, 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; const char *cp = buffer; + char *tmp; *parsed = silc_calloc(1, sizeof(**parsed)); *parsed_lens = silc_calloc(1, sizeof(**parsed_lens)); /* Get the command first */ len = strcspn(cp, " "); - (*parsed)[0] = silc_to_upper((char *)cp); + tmp = silc_to_upper((char *)cp); + (*parsed)[0] = silc_calloc(len + 1, sizeof(char)); + memcpy((*parsed)[0], tmp, len); + silc_free(tmp); (*parsed_lens)[0] = len; - cp += len + 1; + cp += len; + while (*cp == ' ') + cp++; argc++; /* Parse arguments */ @@ -521,6 +424,10 @@ void silc_parse_command_line(unsigned char *buffer, len = strcspn(cp, " "); else len = strlen(cp); + while (len && cp[len - 1] == ' ') + len--; + if (!len) + break; *parsed = silc_realloc(*parsed, sizeof(**parsed) * (argc + 1)); *parsed_lens = silc_realloc(*parsed_lens, @@ -534,7 +441,8 @@ void silc_parse_command_line(unsigned char *buffer, if (strlen(cp) == 0) break; else - cp++; + while (*cp == ' ') + cp++; } } @@ -547,3 +455,399 @@ void silc_parse_command_line(unsigned char *buffer, *parsed_num = argc; } + +/* Formats arguments to a string and returns it after allocating memory + for it. It must be remembered to free it later. */ + +char *silc_format(char *fmt, ...) +{ + va_list args; + static char buf[8192]; + + memset(buf, 0, sizeof(buf)); + va_start(args, fmt); + vsnprintf(buf, sizeof(buf) - 1, fmt, args); + va_end(args); + + 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; +} + +/* 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); +}