silcutil.c
- Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
+ Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2000 Pekka Riikonen
+ Copyright (C) 1997 - 2007 Pekka Riikonen
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
+ the Free Software Foundation; version 2 of the License.
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* 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.
- *
- *
- */
-
-#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)
-{
- int fd;
- char *buffer;
- int filelen;
-
- fd = open(filename, O_RDONLY);
- if (fd < 0) {
- SILC_LOG_ERROR(("Cannot open file %s: %s", filename, strerror(errno)));
- return NULL;
- }
-
- filelen = lseek(fd, (off_t)0L, SEEK_END);
- if (filelen < 0)
- return NULL;
- if (lseek(fd, (off_t)0L, SEEK_SET) < 0)
- return NULL;
-
- if (filelen < 0) {
- SILC_LOG_ERROR(("Cannot open file %s: %s", filename, strerror(errno)));
- return NULL;
- }
-
- buffer = silc_calloc(filelen + 1, sizeof(char));
-
- if ((read(fd, buffer, filelen)) == -1) {
- memset(buffer, 0, sizeof(buffer));
- close(fd);
- SILC_LOG_ERROR(("Cannot read from file %s: %s", filename,
- strerror(errno)));
- return NULL;
- }
-
- close(fd);
- buffer[filelen] = EOF;
-
- *return_len = filelen;
- return buffer;
-}
-
-/* Writes a buffer to the file. */
-
-int silc_file_write(const char *filename, const char *buffer, int len)
-{
- int fd;
-
- if ((fd = creat(filename, 0644)) == -1) {
- SILC_LOG_ERROR(("Cannot open file %s for writing: %s", strerror(errno)));
- return -1;
- }
-
- if ((write(fd, buffer, len)) == -1) {
- SILC_LOG_ERROR(("Cannot write to file %s: %s", strerror(errno)));
- return -1;
- }
-
- close(fd);
-
- return 0;
-}
-
-/* Writes a buffer to the file. If the file is created specific mode is
- set to the file. */
-
-int silc_file_write_mode(const char *filename, const char *buffer,
- int len, int mode)
-{
- int fd;
-
- if ((fd = creat(filename, mode)) == -1) {
- SILC_LOG_ERROR(("Cannot open file %s for writing: %s", strerror(errno)));
- return -1;
- }
-
- if ((write(fd, buffer, len)) == -1) {
- SILC_LOG_ERROR(("Cannot write to file %s: %s", strerror(errno)));
- return -1;
- }
+/* $Id$ */
- close(fd);
-
- return 0;
-}
+#include "silc.h"
/* Gets line from a buffer. Stops reading when a newline or EOF occurs.
This doesn't remove the newline sign from the destination buffer. The
{
static int start = 0;
int i;
-
+
memset(dest, 0, destlen);
-
+
if (begin != start)
start = 0;
-
+
i = 0;
for ( ; start <= srclen; i++, start++) {
if (i > destlen)
return -1;
-
+
dest[i] = src[start];
-
- if (dest[i] == EOF)
+
+ if (dest[i] == EOF)
return EOF;
-
- if (dest[i] == '\n')
+
+ if (dest[i] == '\n')
break;
}
start++;
-
+
return start;
}
were found. This is used to check for bad lines when reading data from
for example a configuration file. */
-int silc_check_line(char *buf)
+int silc_check_line(char *buf)
{
/* Illegal characters in line */
if (strchr(buf, '#')) return -1;
if (strchr(buf, '\a')) return -1;
if (strchr(buf, '\b')) return -1;
if (strchr(buf, '\f')) return -1;
-
+
/* Empty line */
if (buf[0] == '\n')
return -1;
-
+
return 0;
}
-/* Returns current time as string. */
+/* Converts string to capital characters. */
-char *silc_get_time()
+SilcBool silc_to_upper(const char *string, char *dest, SilcUInt32 dest_size)
{
- time_t curtime;
- char *return_time;
+ int i;
+
+ if (strlen(string) > dest_size)
+ return FALSE;
- curtime = time(NULL);
- return_time = ctime(&curtime);
- return_time[strlen(return_time) - 1] = '\0';
+ for (i = 0; i < strlen(string); i++)
+ dest[i] = (char)toupper((int)string[i]);
- return return_time;
+ return TRUE;
}
-/* Converts string to capital characters */
+/* Converts string to lower letter characters. */
-char *silc_to_upper(char *string)
+SilcBool silc_to_lower(const char *string, char *dest, SilcUInt32 dest_size)
{
int i;
- char *ret = silc_calloc(strlen(string) + 1, sizeof(char));
+
+ if (strlen(string) > dest_size)
+ return FALSE;
for (i = 0; i < strlen(string); i++)
- ret[i] = toupper(string[i]);
+ dest[i] = (char)tolower((int)string[i]);
- return ret;
+ return TRUE;
}
-/* Compares two strings. Strings may include wildcards * and ?.
- Returns TRUE if strings match. */
+/* Parse userfqdn string which is in user@fqdn format. */
-int silc_string_compare(char *string1, char *string2)
+int silc_parse_userfqdn(const char *string,
+ char *user, SilcUInt32 user_size,
+ char *fqdn, SilcUInt32 fqdn_size)
{
- int i;
- int slen1 = strlen(string1);
- int slen2 = strlen(string2);
- char *tmpstr1, *tmpstr2;
+ SilcUInt32 tlen;
- if (!string1 || !string2)
- return FALSE;
+ if (!user && !fqdn)
+ return 0;
- /* See if they are same already */
- if (!strncmp(string1, string2, strlen(string2)))
- return TRUE;
+ memset(user, 0, user_size);
+ memset(fqdn, 0, fqdn_size);
- 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 (!string)
+ return 0;
+
+ if (string[0] == '@') {
+ if (user)
+ silc_strncat(user, user_size, string, strlen(string));
+
+ return 1;
}
-
- /* 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;
+
+ if (strchr(string, '@')) {
+ tlen = strcspn(string, "@");
+
+ if (user)
+ silc_strncat(user, user_size, string, tlen);
+
+ if (fqdn)
+ silc_strncat(fqdn, fqdn_size, string + tlen + 1,
+ strlen(string) - tlen - 1);
+
+ return 2;
}
-
- memset(tmpstr1, 0, slen1);
- memset(tmpstr2, 0, slen2);
- silc_free(tmpstr1);
- silc_free(tmpstr2);
- return FALSE;
-}
-unsigned char pem_enc[64] =
-"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+ if (user)
+ silc_strncat(user, user_size, string, strlen(string));
+
+ return 1;
+}
-/* Encodes data into PEM encoding. Returns NULL terminated PEM encoded
- data string. Note: This is originally public domain code and is
- still PD. */
+/* Parses command line. At most `max_args' is taken. Rest of the line
+ will be allocated as the last argument if there are more than `max_args'
+ arguments in the line. Note that the command name is counted as one
+ argument and is saved. */
-char *silc_encode_pem(unsigned char *data, unsigned int len)
+void silc_parse_command_line(unsigned char *buffer,
+ unsigned char ***parsed,
+ SilcUInt32 **parsed_lens,
+ SilcUInt32 **parsed_types,
+ SilcUInt32 *parsed_num,
+ SilcUInt32 max_args)
{
- int i, j;
- unsigned int bits, c, char_count;
- char *pem;
-
- char_count = 0;
- bits = 0;
- j = 0;
-
- pem = silc_calloc(((len * 8 + 5) / 6) + 5, sizeof(*pem));
-
- for (i = 0; i < len; i++) {
- c = data[i];
- bits += c;
- char_count++;
-
- if (char_count == 3) {
- pem[j++] = pem_enc[bits >> 18];
- pem[j++] = pem_enc[(bits >> 12) & 0x3f];
- pem[j++] = pem_enc[(bits >> 6) & 0x3f];
- pem[j++] = pem_enc[bits & 0x3f];
- bits = 0;
- char_count = 0;
- } else {
- bits <<= 8;
- }
- }
+ 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, " ");
+ tmp = silc_calloc(strlen(cp) + 1, sizeof(*tmp));
+ if (!tmp)
+ return;
+ silc_to_upper(cp, tmp, strlen(cp));
+ (*parsed)[0] = silc_calloc(len + 1, sizeof(char));
+ memcpy((*parsed)[0], tmp, len);
+ silc_free(tmp);
+ (*parsed_lens)[0] = len;
+ cp += len;
+ while (*cp == ' ')
+ cp++;
+ argc++;
+
+ /* Parse arguments */
+ if (strchr(cp, ' ') || strlen(cp) != 0) {
+ for (i = 1; i < max_args; i++) {
+
+ if (i != max_args - 1)
+ 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,
+ sizeof(**parsed_lens) * (argc + 1));
+ (*parsed)[argc] = silc_calloc(len + 1, sizeof(char));
+ memcpy((*parsed)[argc], cp, len);
+ (*parsed_lens)[argc] = len;
+ argc++;
- if (char_count != 0) {
- bits <<= 16 - (8 * char_count);
- pem[j++] = pem_enc[bits >> 18];
- pem[j++] = pem_enc[(bits >> 12) & 0x3f];
-
- if (char_count == 1) {
- pem[j++] = '=';
- pem[j] = '=';
- } else {
- pem[j++] = pem_enc[(bits >> 6) & 0x3f];
- pem[j] = '=';
+ cp += len;
+ if (strlen(cp) == 0)
+ break;
+ else
+ while (*cp == ' ')
+ cp++;
}
}
- return pem;
+ /* Save argument types. Protocol defines all argument types but
+ this implementation makes sure that they are always in correct
+ order hence this simple code. */
+ *parsed_types = silc_calloc(argc, sizeof(**parsed_types));
+ for (i = 0; i < argc; i++)
+ (*parsed_types)[i] = i;
+
+ *parsed_num = argc;
}
-/* Same as above but puts newline ('\n') every 72 characters. */
+/* Formats arguments to a string and returns it after allocating memory
+ for it. It must be remembered to free it later. */
-char *silc_encode_pem_file(unsigned char *data, unsigned int data_len)
+char *silc_format(char *fmt, ...)
{
- int i, j;
- unsigned int len, cols;
- char *pem, *pem2;
+ va_list args;
+ char buf[8192];
- pem = silc_encode_pem(data, data_len);
- len = strlen(pem);
+ memset(buf, 0, sizeof(buf));
+ va_start(args, fmt);
+ silc_vsnprintf(buf, sizeof(buf) - 1, fmt, args);
+ va_end(args);
- pem2 = silc_calloc(len + (len / 72) + 1, sizeof(*pem2));
+ return strdup(buf);
+}
- for (i = 0, j = 0, cols = 1; i < len; i++, cols++) {
- if (cols == 72) {
- pem2[i] = '\n';
- cols = 0;
- len++;
- continue;
- }
+/* 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. */
- pem2[i] = pem[j++];
+SilcUInt32 silc_hash_string(void *key, void *user_context)
+{
+ char *s = (char *)key;
+ SilcUInt32 h = 0, g;
+
+ while (*s != '\0') {
+ h = (h << 4) + tolower((int)*s);
+ if ((g = h & 0xf0000000)) {
+ h = h ^ (g >> 24);
+ h = h ^ g;
+ }
+ s++;
}
- return pem2;
+ return h;
}
-/* Decodes PEM into data. Returns the decoded data. Note: This is
- originally public domain code and is still PD. */
+/* Hash UTF-8 string */
-unsigned char *silc_decode_pem(unsigned char *pem, unsigned int pem_len,
- unsigned int *ret_len)
+SilcUInt32 silc_hash_utf8_string(void *key, void *user_context)
{
- int i, j;
- unsigned int len, c, char_count, bits;
- unsigned char *data;
- static char ialpha[256], decoder[256];
-
- for (i = 64 - 1; i >= 0; i--) {
- ialpha[pem_enc[i]] = 1;
- decoder[pem_enc[i]] = i;
+ unsigned char *s = (unsigned char *)key;
+ SilcUInt32 h = 0, g;
+
+ while (*s != '\0') {
+ h = (h << 4) + *s;
+ if ((g = h & 0xf0000000)) {
+ h = h ^ (g >> 24);
+ h = h ^ g;
+ }
+ s++;
}
- char_count = 0;
- bits = 0;
- j = 0;
+ return h;
+}
- if (!pem_len)
- len = strlen(pem);
- else
- len = pem_len;
+/* Basic hash function to hash integers. May be used with the SilcHashTable. */
- data = silc_calloc(((len * 6) / 8), sizeof(*data));
+SilcUInt32 silc_hash_uint(void *key, void *user_context)
+{
+ return SILC_PTR_TO_32(key);
+}
- for (i = 0; i < len; i++) {
- c = pem[i];
+/* Basic hash funtion to hash pointers. May be used with the SilcHashTable. */
- if (c == '=')
- break;
+SilcUInt32 silc_hash_ptr(void *key, void *user_context)
+{
+ return SILC_PTR_TO_32(key);
+}
+
+/* Hash a ID. The `user_context' is the ID type. */
- if (c > 127 || !ialpha[c])
- continue;
+SilcUInt32 silc_hash_id(void *key, void *user_context)
+{
+ SilcIdType id_type = (SilcIdType)SILC_PTR_TO_32(user_context);
+ SilcUInt32 h = 0;
+ int i;
- bits += decoder[c];
- char_count++;
+ switch (id_type) {
+ case SILC_ID_CLIENT:
+ {
+ SilcClientID *id = (SilcClientID *)key;
- if (char_count == 4) {
- data[j++] = bits >> 16;
- data[j++] = (bits >> 8) & 0xff;
- data[j++] = bits & 0xff;
- bits = 0;
- char_count = 0;
- } else {
- bits <<= 6;
+ /* 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. */
+ return silc_hash_client_id_hash(id->hash, NULL);
}
- }
+ break;
+ case SILC_ID_SERVER:
+ {
+ SilcServerID *id = (SilcServerID *)key;
- switch(char_count) {
- case 1:
- silc_free(data);
- return NULL;
+ h = id->port * id->rnd;
+ for (i = 0; i < id->ip.data_len; i++)
+ h ^= id->ip.data[i];
+
+ return h;
+ }
break;
- case 2:
- data[j++] = bits >> 10;
+ 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;
- case 3:
- data[j++] = bits >> 16;
- data[j++] = (bits >> 8) & 0xff;
+ default:
break;
}
- if (ret_len)
- *ret_len = j;
+ return h;
+}
+
+/* Hash Client ID's hash. */
+
+SilcUInt32 silc_hash_client_id_hash(void *key, void *user_context)
+{
+ int i;
+ unsigned char *hash = key;
+ SilcUInt32 h = 0, g;
+
+ for (i = 0; i < CLIENTID_HASH_LEN; i++) {
+ h = (h << 4) + hash[i];
+ if ((g = h & 0xf0000000)) {
+ h = h ^ (g >> 24);
+ h = h ^ g;
+ }
+ }
+
+ return h;
+}
+
+/* Hash binary data. The `user_context' is the data length. */
+
+SilcUInt32 silc_hash_data(void *key, void *user_context)
+{
+ SilcUInt32 len = SILC_PTR_TO_32(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 data;
+ return h;
}
-/* Parse nickname string. The format may be <num>!<nickname>@<server> to
- support multiple same nicknames. The <num> 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. */
+/* Hash public key of any type. */
-int silc_parse_nickname(char *string, char **nickname, char **server,
- unsigned int *num)
+SilcUInt32 silc_hash_public_key(void *key, void *user_context)
{
- unsigned int tlen;
- char tmp[256];
+ SilcPublicKey public_key = key;
+ unsigned char *pk;
+ SilcUInt32 pk_len;
+ SilcUInt32 hash = 0;
- if (!string)
+ pk = silc_pkcs_public_key_encode(public_key, &pk_len);
+ if (!pk)
+ return hash;
+
+ hash = silc_hash_data(pk, SILC_32_TO_PTR(pk_len));
+ silc_free(pk);
+
+ return hash;
+}
+
+/* Compares two strings. It may be used as SilcHashTable comparison
+ function. */
+
+SilcBool 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. */
+
+SilcBool silc_hash_id_compare(void *key1, void *key2, void *user_context)
+{
+ SilcIdType id_type = (SilcIdType)SILC_PTR_TO_32(user_context);
+ return (id_type == SILC_ID_CLIENT ?
+ SILC_ID_COMPARE_HASH((SilcClientID *)key1, (SilcClientID *)key2) :
+ SILC_ID_COMPARE_TYPE(key1, key2, id_type));
+}
+
+/* Compares two ID's. Compares full IDs. */
+
+SilcBool silc_hash_id_compare_full(void *key1, void *key2, void *user_context)
+{
+ SilcIdType id_type = (SilcIdType)SILC_PTR_TO_32(user_context);
+ return SILC_ID_COMPARE_TYPE(key1, key2, id_type);
+}
+
+/* Compare two Client ID's entirely and not just the hash from the ID. */
+
+SilcBool 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. */
+
+SilcBool silc_hash_data_compare(void *key1, void *key2, void *user_context)
+{
+ SilcUInt32 len = SILC_PTR_TO_32(user_context);
+ return !memcmp(key1, key2, len);
+}
+
+/* Compares UTF-8 string. */
+
+SilcBool silc_hash_utf8_compare(void *key1, void *key2, void *user_context)
+{
+ int l1 = strlen((char *)key1);
+ int l2 = strlen((char *)key2);
+ if (l1 != l2)
return FALSE;
+ return !memcmp(key1, key2, l2);
+}
- if (strchr(string, '!')) {
- tlen = strcspn(string, "!");
- memset(tmp, 0, sizeof(tmp));
- memcpy(tmp, string, tlen);
+/* Compares two SILC Public keys. It may be used as SilcHashTable
+ comparison function. */
- if (num)
- *num = atoi(tmp);
+SilcBool silc_hash_public_key_compare(void *key1, void *key2,
+ void *user_context)
+{
+ return silc_pkcs_public_key_compare(key1, key2);
+}
- if (tlen >= strlen(string))
- return FALSE;
+/* Creates fingerprint from data, usually used with SHA1 digests */
- string += tlen + 1;
+char *silc_fingerprint(const unsigned char *data, SilcUInt32 data_len)
+{
+ char fingerprint[64], *cp;
+ int i;
+
+ memset(fingerprint, 0, sizeof(fingerprint));
+ cp = fingerprint;
+ for (i = 0; i < data_len; i++) {
+ silc_snprintf(cp, sizeof(fingerprint), "%02X", data[i]);
+ cp += 2;
+
+ if ((i + 1) % 2 == 0)
+ silc_snprintf(cp++, sizeof(fingerprint), " ");
+
+ if ((i + 1) % 10 == 0)
+ silc_snprintf(cp++, sizeof(fingerprint), " ");
}
+ i--;
+ if ((i + 1) % 2 == 0)
+ cp[-2] = 0;
+ if ((i + 1) % 10 == 0)
+ cp[-1] = 0;
- if (strchr(string, '@')) {
- tlen = strcspn(string, "@");
-
- if (nickname) {
- *nickname = silc_calloc(tlen + 1, sizeof(char));
- memcpy(*nickname, string, tlen);
- }
-
- if (server) {
- *server = silc_calloc(strlen(string) - tlen, sizeof(char));
- memcpy(*server, string + tlen + 1, strlen(string) - tlen - 1);
- }
- } else {
- if (nickname)
- *nickname = strdup(string);
+ return strdup(fingerprint);
+}
+
+/* Return TRUE if the `data' is ASCII string. */
+
+SilcBool silc_string_is_ascii(const unsigned char *data, SilcUInt32 data_len)
+{
+ int i;
+
+ for (i = 0; i < data_len; i++) {
+ if (!isascii(data[i]))
+ return FALSE;
}
return TRUE;
}
-/* Parses command line. At most `max_args' is taken. Rest of the line
- will be allocated as the last argument if there are more than `max_args'
- arguments in the line. Note that the command name is counted as one
- argument and is saved. */
+/* Displays input prompt on command line and takes input data from user */
-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)
+char *silc_get_input(const char *prompt, SilcBool echo_off)
{
- int i, len = 0;
- int argc = 0;
- const char *cp = buffer;
+#ifdef SILC_UNIX
+ int fd;
+ char input[2048];
+
+ if (echo_off) {
+ char *ret = NULL;
+#ifdef HAVE_TERMIOS_H
+ struct termios to;
+ struct termios to_old;
+
+ fd = open("/dev/tty", O_RDONLY);
+ if (fd < 0) {
+ fprintf(stderr, "silc: %s\n", strerror(errno));
+ return NULL;
+ }
- *parsed = silc_calloc(1, sizeof(**parsed));
- *parsed_lens = silc_calloc(1, sizeof(**parsed_lens));
+ signal(SIGINT, SIG_IGN);
- /* Get the command first */
- len = strcspn(cp, " ");
- (*parsed)[0] = silc_to_upper((char *)cp);
- (*parsed_lens)[0] = len;
- cp += len + 1;
- argc++;
+ /* Get terminal info */
+ tcgetattr(fd, &to);
+ to_old = to;
- /* Parse arguments */
- if (strchr(cp, ' ') || strlen(cp) != 0) {
- for (i = 1; i < max_args; i++) {
+ /* Echo OFF, and assure we can prompt and get input */
+ to.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
+ to.c_lflag |= ICANON;
+ to.c_cc[VMIN] = 255;
+ tcsetattr(fd, TCSANOW, &to);
- if (i != max_args - 1)
- len = strcspn(cp, " ");
- else
- len = strlen(cp);
-
- *parsed = silc_realloc(*parsed, sizeof(**parsed) * (argc + 1));
- *parsed_lens = silc_realloc(*parsed_lens,
- sizeof(**parsed_lens) * (argc + 1));
- (*parsed)[argc] = silc_calloc(len + 1, sizeof(char));
- memcpy((*parsed)[argc], cp, len);
- (*parsed_lens)[argc] = len;
- argc++;
+ memset(input, 0, sizeof(input));
- cp += len;
- if (strlen(cp) == 0)
- break;
- else
- cp++;
+ printf("%s", prompt);
+ fflush(stdout);
+
+ if ((read(fd, input, sizeof(input))) < 0) {
+ fprintf(stderr, "silc: %s\n", strerror(errno));
+ tcsetattr(fd, TCSANOW, &to_old);
+ return NULL;
}
- }
- /* Save argument types. Protocol defines all argument types but
- this implementation makes sure that they are always in correct
- order hence this simple code. */
- *parsed_types = silc_calloc(argc, sizeof(**parsed_types));
- for (i = 0; i < argc; i++)
- (*parsed_types)[i] = i;
+ if (strlen(input) <= 1) {
+ tcsetattr(fd, TCSANOW, &to_old);
+ return NULL;
+ }
- *parsed_num = argc;
+ if (strchr(input, '\n'))
+ *strchr(input, '\n') = '\0';
+
+ /* Restore old terminfo */
+ tcsetattr(fd, TCSANOW, &to_old);
+ signal(SIGINT, SIG_DFL);
+
+ ret = silc_memdup(input, strlen(input));
+ memset(input, 0, sizeof(input));
+#endif /* HAVE_TERMIOS_H */
+ return ret;
+ } else {
+ fd = open("/dev/tty", O_RDONLY);
+ if (fd < 0) {
+ fprintf(stderr, "silc: %s\n", strerror(errno));
+ return NULL;
+ }
+
+ memset(input, 0, sizeof(input));
+
+ printf("%s", prompt);
+ fflush(stdout);
+
+ if ((read(fd, input, sizeof(input))) < 0) {
+ fprintf(stderr, "silc: %s\n", strerror(errno));
+ return NULL;
+ }
+
+ if (strlen(input) <= 1)
+ return NULL;
+
+ if (strchr(input, '\n'))
+ *strchr(input, '\n') = '\0';
+
+ return strdup(input);
+ }
+#else
+ return NULL;
+#endif /* SILC_UNIX */
}