X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcutil%2Fsilcutil.c;h=d571b8a62a4dd328b3a1b901a8ac00f59f8e2934;hb=017dec75a98209fbef49eb496c2269b0c49e736d;hp=ba4b9cc7bcbd39226373bb6d0a492d55714143cb;hpb=0bf38ae7a8125a1586d617f5f835329d1f924721;p=silc.git diff --git a/lib/silcutil/silcutil.c b/lib/silcutil/silcutil.c index ba4b9cc7..d571b8a6 100644 --- a/lib/silcutil/silcutil.c +++ b/lib/silcutil/silcutil.c @@ -28,7 +28,7 @@ /* 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; @@ -41,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; } @@ -72,17 +77,19 @@ char *silc_file_read(const char *filename, int *return_len) /* 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; } @@ -95,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; } @@ -202,10 +211,10 @@ static unsigned char pem_enc[64] = 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; @@ -250,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); @@ -272,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]; @@ -345,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) + 1, 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; @@ -400,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 */ @@ -427,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, @@ -440,7 +441,8 @@ void silc_parse_command_line(unsigned char *buffer, if (strlen(cp) == 0) break; else - cp++; + while (*cp == ' ') + cp++; } } @@ -474,7 +476,7 @@ char *silc_format(char *fmt, ...) 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]; @@ -484,7 +486,15 @@ char *silc_id_render(void *id, unsigned short type) 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); @@ -497,7 +507,15 @@ char *silc_id_render(void *id, unsigned short type) 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); @@ -511,7 +529,15 @@ char *silc_id_render(void *id, unsigned short type) 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); @@ -553,7 +579,7 @@ int silc_string_compare(char *string1, char *string2) 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] == '*') @@ -574,11 +600,6 @@ int silc_string_compare(char *string1, char *string2) if (!(slen1 < slen2)) tmpstr2[i] = '?'; } -#if 0 - } else { - if (strncmp(tmpstr1, tmpstr2, i)) - strncpy(tmpstr2, string2, slen2); -#endif } } @@ -601,96 +622,232 @@ int silc_string_compare(char *string1, char *string2) 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. */ +/* 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. */ -char *silc_string_regexify(const char *string) +uint32 silc_hash_string(void *key, void *user_context) { - int i, len, count; - char *regex; + 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; +} - len = strlen(string); - count = 4; - for (i = 0; i < len; i++) - if (string[i] == '*' || string[i] == '?') - count++; +/* Basic hash function to hash integers. May be used with the SilcHashTable. */ + +uint32 silc_hash_uint(void *key, void *user_context) +{ + return *(uint32 *)key; +} - regex = silc_calloc(len + count, sizeof(*regex)); +/* Basic hash funtion to hash pointers. May be used with the SilcHashTable. */ - count = 0; - regex[count] = '('; - count++; +uint32 silc_hash_ptr(void *key, void *user_context) +{ + return (uint32)key; +} - for (i = 0; i < len; i++) { - if (string[i] == '*' || string[i] == '?') { - regex[count] = '.'; - count++; - } else if (string[i] == ',') { - regex[count] = '|'; - count++; - continue; - } +/* Hash a ID. The `user_context' is the ID type. */ - regex[count] = string[i]; - count++; +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; } - regex[count - 1] = ')'; - regex[count] = '$'; + 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 regex; + return h; } -/* 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'. */ +/* Compares two strings. May be used as SilcHashTable comparison function. */ -char *silc_string_regex_combine(const char *string1, const char *string2) +bool silc_hash_string_compare(void *key1, void *key2, void *user_context) { - char *tmp; - int len1, len2; + return !strcasecmp((char *)key1, (char *)key2); +} - len1 = strlen(string1); - len2 = strlen(string2); +/* 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)); +} - tmp = silc_calloc(2 + len1 + len2, sizeof(*tmp)); - strncat(tmp, string1, len1 - 2); - strncat(tmp, "|", 1); - strncat(tmp, string2 + 1, len2 - 1); +/* Compare two Client ID's entirely and not just the hash from the ID. */ - return tmp; +bool silc_hash_client_id_compare(void *key1, void *key2, void *user_context) +{ + return SILC_ID_COMPARE_TYPE(key1, key2, SILC_ID_CLIENT); } -/* Matches the two strings and returns TRUE if the strings match. */ +/* Compares binary data. May be used as SilcHashTable comparison function. */ -int silc_string_regex_match(const char *regex, const char *string) +bool silc_hash_data_compare(void *key1, void *key2, void *user_context) { - regex_t preg; - int ret = FALSE; - - if (regcomp(&preg, regex, REG_NOSUB | REG_EXTENDED) < 0) - return FALSE; + uint32 len = (uint32)user_context; + return !memcmp(key1, key2, len); +} - if (regexec(&preg, string, 0, NULL, 0) == 0) - ret = TRUE; +/* Parses mode mask and returns the mode as string. */ - regfree(&preg); +char *silc_client_chmode(uint32 mode, const char *cipher, const char *hmac) +{ + char string[100]; - return ret; + 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); } -/* Do regex match to the two strings `string1' and `string2'. If the - `string2' matches the `string1' this returns TRUE. */ +/* Parses channel user mode and returns it as special mode character. */ -int silc_string_match(const char *string1, const char *string2) +char *silc_client_chumode_char(uint32 mode) { - char *s1; - int ret = FALSE; + char string[4]; - s1 = silc_string_regexify(string1); - ret = silc_string_regex_match(s1, string2); - silc_free(s1); + if (!mode) + return NULL; - return ret; + 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); }