/* 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;
}
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
}
}
}
/* Inspects the `string' for wildcards and returns regex string that can
- be used by the GNU regex library. This has a lot overhead but luckily
- this is used only for short strings. */
+ 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;
- /* If there is no wildcards then we don't need to regexify the string. */
- if (!strchr(string, '*') && !strchr(string, '?'))
- return strdup(string);
-
len = strlen(string);
- count = 0;
-
+ count = 4;
for (i = 0; i < len; i++)
if (string[i] == '*' || string[i] == '?')
count++;
- regex = silc_calloc(len + count + 4, sizeof(*regex));
+ regex = silc_calloc(len + count, sizeof(*regex));
count = 0;
regex[count] = '(';
if (string[i] == '*' || string[i] == '?') {
regex[count] = '.';
count++;
+ } else if (string[i] == ',') {
+ regex[count] = '|';
+ count++;
+ continue;
}
regex[count] = string[i];
len2 = strlen(string2);
tmp = silc_calloc(2 + len1 + len2, sizeof(*tmp));
- memcpy(tmp, string1, len1 - 2);
- memcpy(tmp, "|", 1);
- memcpy(tmp, string2 + 1, len2 - 1);
+ strncat(tmp, string1, len1 - 2);
+ strncat(tmp, "|", 1);
+ strncat(tmp, string2 + 1, len2 - 1);
return tmp;
}
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;
+
+ 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;
+}
projects / silc.git / blobdiff