X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/putty/blobdiff_plain/c5e438ecf3f6d7b8caab10e43a452f3555149309..8c1616628c6d488feff6ebec2c268aa30e337773:/unix/uxstore.c diff --git a/unix/uxstore.c b/unix/uxstore.c index 9047988b..b04d557c 100644 --- a/unix/uxstore.c +++ b/unix/uxstore.c @@ -5,15 +5,128 @@ #include #include +#include +#include +#include #include #include #include +#include #include #include #include "putty.h" #include "storage.h" #include "tree234.h" +enum { + INDEX_DIR, INDEX_HOSTKEYS, INDEX_RANDSEED, + INDEX_SESSIONDIR, INDEX_SESSION, +}; + +static const char hex[16] = "0123456789ABCDEF"; + +static char *mungestr(const char *in) +{ + char *out, *ret; + + if (!in) + in = "Default Settings"; + + ret = out = snewn(3*strlen(in)+1, char); + + while (*in) { + /* + * There are remarkably few punctuation characters that + * aren't shell-special in some way or likely to be used as + * separators in some file format or another! Hence we use + * opt-in for safe characters rather than opt-out for + * specific unsafe ones... + */ + if (*in!='+' && *in!='-' && *in!='.' && *in!='@' && *in!='_' && + !(*in >= '0' && *in <= '9') && + !(*in >= 'A' && *in <= 'Z') && + !(*in >= 'a' && *in <= 'z')) { + *out++ = '%'; + *out++ = hex[((unsigned char) *in) >> 4]; + *out++ = hex[((unsigned char) *in) & 15]; + } else + *out++ = *in; + in++; + } + *out = '\0'; + return ret; +} + +static char *unmungestr(const char *in) +{ + char *out, *ret; + out = ret = snewn(strlen(in)+1, char); + while (*in) { + if (*in == '%' && in[1] && in[2]) { + int i, j; + + i = in[1] - '0'; + i -= (i > 9 ? 7 : 0); + j = in[2] - '0'; + j -= (j > 9 ? 7 : 0); + + *out++ = (i << 4) + j; + in += 3; + } else { + *out++ = *in++; + } + } + *out = '\0'; + return ret; +} + +static void make_filename(char *filename, int index, const char *subname) +{ + char *home; + int len; + home = getenv("HOME"); + strncpy(filename, home, FILENAME_MAX); + len = strlen(filename); + if (index == INDEX_SESSION) { + char *munged = mungestr(subname); + char *fn = dupprintf("/.putty/sessions/%s", munged); + strncpy(filename + len, fn, FILENAME_MAX - len); + sfree(fn); + sfree(munged); + } else { + strncpy(filename + len, + index == INDEX_DIR ? "/.putty" : + index == INDEX_SESSIONDIR ? "/.putty/sessions" : + index == INDEX_HOSTKEYS ? "/.putty/sshhostkeys" : + index == INDEX_RANDSEED ? "/.putty/randomseed" : + "/.putty/ERROR", FILENAME_MAX - len); + } + filename[FILENAME_MAX-1] = '\0'; +} + +/* + * Read an entire line of text from a file. Return a buffer + * malloced to be as big as necessary (caller must free). + */ +static char *fgetline(FILE *fp) +{ + char *ret = snewn(512, char); + int size = 512, len = 0; + while (fgets(ret + len, size - len, fp)) { + len += strlen(ret + len); + if (ret[len-1] == '\n') + break; /* got a newline, we're done */ + size = len + 512; + ret = sresize(ret, size, char); + } + if (len == 0) { /* first fgets returned NULL */ + sfree(ret); + return NULL; + } + ret[len] = '\0'; + return ret; +} + /* * For the moment, the only existing Unix utility is pterm and that * has no GUI configuration at all, so our write routines need do @@ -21,21 +134,51 @@ * file somewhere or other. */ -void *open_settings_w(char *sessionname) +void *open_settings_w(const char *sessionname, char **errmsg) { - return NULL; + char filename[FILENAME_MAX]; + FILE *fp; + + *errmsg = NULL; + + /* + * Start by making sure the .putty directory and its sessions + * subdir actually exist. Ignore error returns from mkdir since + * they're perfectly likely to be `already exists', and any + * other error will trip us up later on so there's no real need + * to catch it now. + */ + make_filename(filename, INDEX_DIR, sessionname); + mkdir(filename, 0700); + make_filename(filename, INDEX_SESSIONDIR, sessionname); + mkdir(filename, 0700); + + make_filename(filename, INDEX_SESSION, sessionname); + fp = fopen(filename, "w"); + if (!fp) { + *errmsg = dupprintf("Unable to create %s: %s", + filename, strerror(errno)); + return NULL; /* can't open */ + } + return fp; } -void write_setting_s(void *handle, char *key, char *value) +void write_setting_s(void *handle, const char *key, const char *value) { + FILE *fp = (FILE *)handle; + fprintf(fp, "%s=%s\n", key, value); } -void write_setting_i(void *handle, char *key, int value) +void write_setting_i(void *handle, const char *key, int value) { + FILE *fp = (FILE *)handle; + fprintf(fp, "%s=%d\n", key, value); } void close_settings_w(void *handle) { + FILE *fp = (FILE *)handle; + fclose(fp); } /* @@ -47,24 +190,24 @@ void close_settings_w(void *handle) * immediately work out. */ -struct xrm_string { - char *key; - char *value; +struct keyval { + const char *key; + const char *value; }; static tree234 *xrmtree = NULL; -int xrmcmp(void *av, void *bv) +int keycmp(void *av, void *bv) { - struct xrm_string *a = (struct xrm_string *)av; - struct xrm_string *b = (struct xrm_string *)bv; + struct keyval *a = (struct keyval *)av; + struct keyval *b = (struct keyval *)bv; return strcmp(a->key, b->key); } void provide_xrm_string(char *string) { - char *p, *q; - struct xrm_string *xrms, *ret; + char *p, *q, *key; + struct keyval *xrms, *ret; p = q = strchr(string, ':'); if (!q) { @@ -75,16 +218,17 @@ void provide_xrm_string(char *string) q++; while (p > string && p[-1] != '.' && p[-1] != '*') p--; - xrms = smalloc(sizeof(struct xrm_string)); - xrms->key = smalloc(q-p); - memcpy(xrms->key, p, q-p); - xrms->key[q-p-1] = '\0'; - while (*q && isspace(*q)) + xrms = snew(struct keyval); + key = snewn(q-p, char); + memcpy(key, p, q-p); + key[q-p-1] = '\0'; + xrms->key = key; + while (*q && isspace((unsigned char)*q)) q++; xrms->value = dupstr(q); if (!xrmtree) - xrmtree = newtree234(xrmcmp); + xrmtree = newtree234(keycmp); ret = add234(xrmtree, xrms); if (ret) { @@ -94,9 +238,9 @@ void provide_xrm_string(char *string) } } -char *get_setting(char *key) +const char *get_setting(const char *key) { - struct xrm_string tmp, *ret; + struct keyval tmp, *ret; tmp.key = key; if (xrmtree) { ret = find234(xrmtree, &tmp, NULL); @@ -106,15 +250,56 @@ char *get_setting(char *key) return x_get_default(key); } -void *open_settings_r(char *sessionname) +void *open_settings_r(const char *sessionname) { - static int thing_to_return_an_arbitrary_non_null_pointer_to; - return &thing_to_return_an_arbitrary_non_null_pointer_to; + char filename[FILENAME_MAX]; + FILE *fp; + char *line; + tree234 *ret; + + make_filename(filename, INDEX_SESSION, sessionname); + fp = fopen(filename, "r"); + if (!fp) + return NULL; /* can't open */ + + ret = newtree234(keycmp); + + while ( (line = fgetline(fp)) ) { + char *value = strchr(line, '='); + struct keyval *kv; + + if (!value) + continue; + *value++ = '\0'; + value[strcspn(value, "\r\n")] = '\0'; /* trim trailing NL */ + + kv = snew(struct keyval); + kv->key = dupstr(line); + kv->value = dupstr(value); + add234(ret, kv); + + sfree(line); + } + + fclose(fp); + + return ret; } -char *read_setting_s(void *handle, char *key, char *buffer, int buflen) +char *read_setting_s(void *handle, const char *key, char *buffer, int buflen) { - char *val = get_setting(key); + tree234 *tree = (tree234 *)handle; + const char *val; + struct keyval tmp, *kv; + + tmp.key = key; + if (tree != NULL && + (kv = find234(tree, &tmp, NULL)) != NULL) { + val = kv->value; + assert(val != NULL); + } else + val = get_setting(key); + if (!val) return NULL; else { @@ -124,76 +309,116 @@ char *read_setting_s(void *handle, char *key, char *buffer, int buflen) } } -int read_setting_i(void *handle, char *key, int defvalue) +int read_setting_i(void *handle, const char *key, int defvalue) { - char *val = get_setting(key); + tree234 *tree = (tree234 *)handle; + const char *val; + struct keyval tmp, *kv; + + tmp.key = key; + if (tree != NULL && + (kv = find234(tree, &tmp, NULL)) != NULL) { + val = kv->value; + assert(val != NULL); + } else + val = get_setting(key); + if (!val) return defvalue; else return atoi(val); } -void close_settings_r(void *handle) +int read_setting_fontspec(void *handle, const char *name, FontSpec *result) { + return !!read_setting_s(handle, name, result->name, sizeof(result->name)); } - -void del_settings(char *sessionname) +int read_setting_filename(void *handle, const char *name, Filename *result) { + return !!read_setting_s(handle, name, result->path, sizeof(result->path)); } -void *enum_settings_start(void) +void write_setting_fontspec(void *handle, const char *name, FontSpec result) { - return NULL; + write_setting_s(handle, name, result.name); +} +void write_setting_filename(void *handle, const char *name, Filename result) +{ + write_setting_s(handle, name, result.path); } -char *enum_settings_next(void *handle, char *buffer, int buflen) +void close_settings_r(void *handle) { - return NULL; + tree234 *tree = (tree234 *)handle; + struct keyval *kv; + + if (!tree) + return; + + while ( (kv = index234(tree, 0)) != NULL) { + del234(tree, kv); + sfree((char *)kv->key); + sfree((char *)kv->value); + sfree(kv); + } + + freetree234(tree); } -void enum_settings_finish(void *handle) +void del_settings(const char *sessionname) { + char filename[FILENAME_MAX]; + make_filename(filename, INDEX_SESSION, sessionname); + unlink(filename); } -enum { - INDEX_DIR, INDEX_HOSTKEYS -}; +void *enum_settings_start(void) +{ + DIR *dp; + char filename[FILENAME_MAX]; -static void make_filename(char *filename, int index) + make_filename(filename, INDEX_SESSIONDIR, NULL); + dp = opendir(filename); + + return dp; +} + +char *enum_settings_next(void *handle, char *buffer, int buflen) { - char *home; + DIR *dp = (DIR *)handle; + struct dirent *de; + struct stat st; + char fullpath[FILENAME_MAX]; int len; - home = getenv("HOME"); - strncpy(filename, home, FILENAME_MAX); - len = strlen(filename); - strncpy(filename + len, - index == INDEX_DIR ? "/.putty" : - index == INDEX_HOSTKEYS ? "/.putty/sshhostkeys" : - "/.putty/ERROR", FILENAME_MAX - len); - filename[FILENAME_MAX-1] = '\0'; + char *unmunged; + + make_filename(fullpath, INDEX_SESSIONDIR, NULL); + len = strlen(fullpath); + + while ( (de = readdir(dp)) != NULL ) { + if (len < FILENAME_MAX) { + fullpath[len] = '/'; + strncpy(fullpath+len+1, de->d_name, FILENAME_MAX-(len+1)); + fullpath[FILENAME_MAX-1] = '\0'; + } + + if (stat(fullpath, &st) < 0 || !S_ISREG(st.st_mode)) + continue; /* try another one */ + + unmunged = unmungestr(de->d_name); + strncpy(buffer, unmunged, buflen); + buffer[buflen-1] = '\0'; + sfree(unmunged); + return buffer; + } + + return NULL; } -/* - * Read an entire line of text from a file. Return a buffer - * malloced to be as big as necessary (caller must free). - */ -static char *fgetline(FILE *fp) +void enum_settings_finish(void *handle) { - char *ret = smalloc(512); - int size = 512, len = 0; - while (fgets(ret + len, size - len, fp)) { - len += strlen(ret + len); - if (ret[len-1] == '\n') - break; /* got a newline, we're done */ - size = len + 512; - ret = srealloc(ret, size); - } - if (len == 0) { /* first fgets returned NULL */ - sfree(ret); - return NULL; - } - ret[len] = '\0'; - return ret; + DIR *dp = (DIR *)handle; + closedir(dp); } /* @@ -205,14 +430,15 @@ static char *fgetline(FILE *fp) * * rsa@22:foovax.example.org 0x23,0x293487364395345345....2343 */ -int verify_host_key(char *hostname, int port, char *keytype, char *key) +int verify_host_key(const char *hostname, int port, + const char *keytype, const char *key) { FILE *fp; char filename[FILENAME_MAX]; char *line; int ret; - make_filename(filename, INDEX_HOSTKEYS); + make_filename(filename, INDEX_HOSTKEYS, NULL); fp = fopen(filename, "r"); if (!fp) return 1; /* key does not exist */ @@ -271,18 +497,19 @@ int verify_host_key(char *hostname, int port, char *keytype, char *key) return ret; } -void store_host_key(char *hostname, int port, char *keytype, char *key) +void store_host_key(const char *hostname, int port, + const char *keytype, const char *key) { FILE *fp; int fd; char filename[FILENAME_MAX]; - make_filename(filename, INDEX_HOSTKEYS); + make_filename(filename, INDEX_HOSTKEYS, NULL); fd = open(filename, O_CREAT | O_APPEND | O_RDWR, 0600); if (fd < 0) { char dir[FILENAME_MAX]; - make_filename(dir, INDEX_DIR); + make_filename(dir, INDEX_DIR, NULL); mkdir(dir, 0700); fd = open(filename, O_CREAT | O_APPEND | O_RDWR, 0600); } @@ -297,10 +524,48 @@ void store_host_key(char *hostname, int port, char *keytype, char *key) void read_random_seed(noise_consumer_t consumer) { + int fd; + char fname[FILENAME_MAX]; + + make_filename(fname, INDEX_RANDSEED, NULL); + fd = open(fname, O_RDONLY); + if (fd) { + char buf[512]; + int ret; + while ( (ret = read(fd, buf, sizeof(buf))) > 0) + consumer(buf, ret); + close(fd); + } } void write_random_seed(void *data, int len) { + int fd; + char fname[FILENAME_MAX]; + + make_filename(fname, INDEX_RANDSEED, NULL); + /* + * Don't truncate the random seed file if it already exists; if + * something goes wrong half way through writing it, it would + * be better to leave the old data there than to leave it empty. + */ + fd = open(fname, O_CREAT | O_WRONLY, 0600); + if (fd < 0) { + char dir[FILENAME_MAX]; + + make_filename(dir, INDEX_DIR, NULL); + mkdir(dir, 0700); + fd = open(fname, O_CREAT | O_WRONLY, 0600); + } + + while (len > 0) { + int ret = write(fd, data, len); + if (ret <= 0) break; + len -= ret; + data = (char *)data + len; + } + + close(fd); } void cleanup_all(void)