char buf[PATH_MAX];
char buf2[PATH_MAX];
+ask_filename:
+
/* Check stdin and stdout */
if(ask && tty) {
/* Ask for a file and/or directory name. */
#endif
/* The directory is a relative path or a filename. */
getcwd(directory, sizeof(directory));
- snprintf(buf2, sizeof(buf2), "%s" SLASH "%s", directory, filename);
+
+ if((size_t)snprintf(buf2, sizeof(buf2), "%s" SLASH "%s", directory, filename) >= sizeof(buf2)) {
+ fprintf(stderr, "Filename too long: %s" SLASH "%s\n", directory, filename);
+
+ if(ask && tty) {
+ goto ask_filename;
+ } else {
+ return NULL;
+ }
+ }
+
filename = buf2;
}
blen += result;
}
- if(newline - buffer >= len) {
+ if((size_t)(newline - buffer) >= len) {
return false;
}
return true;
}
-bool recvdata(int fd, char *data, size_t len) {
- if(len == -1) {
- len = blen;
- }
-
+static bool recvdata(int fd, char *data, size_t len) {
while(blen < len) {
int result = recv(fd, buffer + blen, sizeof(buffer) - blen, 0);
bool sendline(int fd, char *format, ...) {
static char buffer[4096];
char *p = buffer;
- int blen = 0;
+ int blen;
va_list ap;
va_start(ap, format);
buffer[sizeof(buffer) - 1] = 0;
va_end(ap);
- if(blen < 1 || blen >= sizeof(buffer)) {
+ if(blen < 1 || (size_t)blen >= sizeof(buffer)) {
return false;
}
return true;
}
-static void pcap(int fd, FILE *out, int snaplen) {
+static void pcap(int fd, FILE *out, uint32_t snaplen) {
sendline(fd, "%d %d %d", CONTROL, REQ_PCAP, snaplen);
char data[9018];
0xa1b2c3d4,
2, 4,
0, 0,
- snaplen ? : sizeof(data),
+ snaplen ? snaplen : sizeof(data),
1,
};
int n = sscanf(line, "%d %d %d", &code, &req, &len);
gettimeofday(&tv, NULL);
- if(n != 3 || code != CONTROL || req != REQ_PCAP || len < 0 || len > sizeof(data)) {
+ if(n != 3 || code != CONTROL || req != REQ_PCAP || len < 0 || (size_t)len > sizeof(data)) {
break;
}
int code, req, len;
int n = sscanf(line, "%d %d %d", &code, &req, &len);
- if(n != 3 || code != CONTROL || req != REQ_LOG || len < 0 || len > sizeof(data)) {
+ if(n != 3 || code != CONTROL || req != REQ_LOG || len < 0 || (size_t)len > sizeof(data)) {
break;
}
strncpy(sa.sun_path, unixsocketname, sizeof(sa.sun_path));
+ sa.sun_path[sizeof(sa.sun_path) - 1] = 0;
+
fd = socket(AF_UNIX, SOCK_STREAM, 0);
if(fd < 0) {
setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&one, sizeof(one));
#endif
+ sendline(fd, "%d ^%s %d", ID, controlcookie, TINC_CTL_VERSION_CURRENT);
+
char data[4096];
int version;
return false;
}
- sendline(fd, "%d ^%s %d", ID, controlcookie, TINC_CTL_VERSION_CURRENT);
-
if(!recvline(fd, line, sizeof(line)) || sscanf(line, "%d %d %d", &code, &version, &pid) != 3 || code != 4 || version != TINC_CTL_VERSION_CURRENT) {
if(verbose) {
fprintf(stderr, "Could not fully establish control socket connection\n");
}
static int cmd_stop(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
}
static int cmd_reload(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
}
char fname[PATH_MAX];
- snprintf(fname, sizeof(fname), "%s" SLASH "%s", dname, ent->d_name);
+
+ if((size_t)snprintf(fname, sizeof(fname), "%s" SLASH "%s", dname, ent->d_name) >= sizeof(fname)) {
+ fprintf(stderr, "Filename too long: %s" SLASH "%s\n", dname, ent->d_name);
+ continue;
+ }
+
FILE *f = fopen(fname, "r");
if(!f) {
}
static int cmd_purge(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
}
static int cmd_retry(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
}
static int cmd_top(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
#ifdef SIGINT
static void sigint_handler(int sig) {
+ (void)sig;
+
fprintf(stderr, "\n");
shutdown(fd, SHUT_RDWR);
}
}
static int cmd_pid(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
FILE *tf = NULL;
if(action >= -1) {
- snprintf(tmpfile, sizeof(tmpfile), "%s.config.tmp", filename);
+ if((size_t)snprintf(tmpfile, sizeof(tmpfile), "%s.config.tmp", filename) >= sizeof(tmpfile)) {
+ fprintf(stderr, "Filename too long: %s.config.tmp\n", filename);
+ return 1;
+ }
+
tf = fopen(tmpfile, "w");
if(!tf) {
return success;
}
-int check_port(char *name) {
+int check_port(const char *name) {
if(try_bind(655)) {
return 655;
}
#endif
static int cmd_generate_ed25519_keys(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
}
static int cmd_help(int argc, char *argv[]) {
+ (void)argc;
+ (void)argv;
+
usage(false);
return 0;
}
static int cmd_version(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
char *command;
#ifndef HAVE_MINGW
- xasprintf(&command, "\"%s\" \"%s\"", getenv("VISUAL") ? : getenv("EDITOR") ? : "vi", filename);
+ const char *editor = getenv("VISUAL");
+ if (!editor)
+ editor = getenv("EDITOR");
+ if (!editor)
+ editor = "vi";
+
+ xasprintf(&command, "\"%s\" \"%s\"", editor, filename);
#else
xasprintf(&command, "edit \"%s\"", filename);
#endif
}
static int cmd_export(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
}
static int cmd_export_all(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
}
static int cmd_import(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
fclose(out);
}
- snprintf(filename, sizeof(filename), "%s" SLASH "%s", hosts_dir, name);
+ if((size_t)snprintf(filename, sizeof(filename), "%s" SLASH "%s", hosts_dir, name) >= sizeof(filename)) {
+ fprintf(stderr, "Filename too long: %s" SLASH "%s\n", hosts_dir, name);
+ return 1;
+ }
if(!force && !access(filename, F_OK)) {
fprintf(stderr, "Host configuration file %s already exists, skipping.\n", filename);
}
static int cmd_exchange(int argc, char *argv[]) {
- return cmd_export(argc, argv) ? : cmd_import(argc, argv);
+ return cmd_export(argc, argv) ? 1 : cmd_import(argc, argv);
}
static int cmd_exchange_all(int argc, char *argv[]) {
- return cmd_export_all(argc, argv) ? : cmd_import(argc, argv);
+ return cmd_export_all(argc, argv) ? 1 : cmd_import(argc, argv);
}
static int switch_network(char *name) {
}
static int cmd_fsck(int argc, char *argv[]) {
+ (void)argv;
+
if(argc > 1) {
fprintf(stderr, "Too many arguments!\n");
return 1;
static void *readfile(FILE *in, size_t *len) {
size_t count = 0;
- size_t alloced = 4096;
- char *buf = xmalloc(alloced);
+ size_t bufsize = 4096;
+ char *buf = xmalloc(bufsize);
while(!feof(in)) {
- size_t read = fread(buf + count, 1, alloced - count, in);
+ size_t read = fread(buf + count, 1, bufsize - count, in);
if(!read) {
break;
count += read;
- if(count >= alloced) {
- alloced *= 2;
- buf = xrealloc(buf, alloced);
+ if(count >= bufsize) {
+ bufsize *= 2;
+ buf = xrealloc(buf, bufsize);
}
}
int (*function)(int argc, char *argv[]);
bool hidden;
} commands[] = {
- {"start", cmd_start},
- {"stop", cmd_stop},
- {"restart", cmd_restart},
- {"reload", cmd_reload},
- {"dump", cmd_dump},
- {"list", cmd_dump},
- {"purge", cmd_purge},
- {"debug", cmd_debug},
- {"retry", cmd_retry},
- {"connect", cmd_connect},
- {"disconnect", cmd_disconnect},
- {"top", cmd_top},
- {"pcap", cmd_pcap},
- {"log", cmd_log},
- {"pid", cmd_pid},
+ {"start", cmd_start, false},
+ {"stop", cmd_stop, false},
+ {"restart", cmd_restart, false},
+ {"reload", cmd_reload, false},
+ {"dump", cmd_dump, false},
+ {"list", cmd_dump, false},
+ {"purge", cmd_purge, false},
+ {"debug", cmd_debug, false},
+ {"retry", cmd_retry, false},
+ {"connect", cmd_connect, false},
+ {"disconnect", cmd_disconnect, false},
+ {"top", cmd_top, false},
+ {"pcap", cmd_pcap, false},
+ {"log", cmd_log, false},
+ {"pid", cmd_pid, false},
{"config", cmd_config, true},
- {"add", cmd_config},
- {"del", cmd_config},
- {"get", cmd_config},
- {"set", cmd_config},
- {"init", cmd_init},
- {"generate-keys", cmd_generate_keys},
+ {"add", cmd_config, false},
+ {"del", cmd_config, false},
+ {"get", cmd_config, false},
+ {"set", cmd_config, false},
+ {"init", cmd_init, false},
+ {"generate-keys", cmd_generate_keys, false},
#ifndef DISABLE_LEGACY
- {"generate-rsa-keys", cmd_generate_rsa_keys},
+ {"generate-rsa-keys", cmd_generate_rsa_keys, false},
#endif
- {"generate-ed25519-keys", cmd_generate_ed25519_keys},
- {"help", cmd_help},
- {"version", cmd_version},
- {"info", cmd_info},
- {"edit", cmd_edit},
- {"export", cmd_export},
- {"export-all", cmd_export_all},
- {"import", cmd_import},
- {"exchange", cmd_exchange},
- {"exchange-all", cmd_exchange_all},
- {"invite", cmd_invite},
- {"join", cmd_join},
- {"network", cmd_network},
- {"fsck", cmd_fsck},
- {"sign", cmd_sign},
- {"verify", cmd_verify},
- {NULL, NULL},
+ {"generate-ed25519-keys", cmd_generate_ed25519_keys, false},
+ {"help", cmd_help, false},
+ {"version", cmd_version, false},
+ {"info", cmd_info, false},
+ {"edit", cmd_edit, false},
+ {"export", cmd_export, false},
+ {"export-all", cmd_export_all, false},
+ {"import", cmd_import, false},
+ {"exchange", cmd_exchange, false},
+ {"exchange-all", cmd_exchange_all, false},
+ {"invite", cmd_invite, false},
+ {"join", cmd_join, false},
+ {"network", cmd_network, false},
+ {"fsck", cmd_fsck, false},
+ {"sign", cmd_sign, false},
+ {"verify", cmd_verify, false},
+ {NULL, NULL, false},
};
#ifdef HAVE_READLINE
}
static char *complete_nothing(const char *text, int state) {
+ (void)text;
+ (void)state;
return NULL;
}
static char **completion(const char *text, int start, int end) {
+ (void)end;
char **matches = NULL;
if(!start) {
free(line);
rl_basic_word_break_characters = "\t\n ";
line = readline(prompt);
-
- if(line) {
- copy = xstrdup(line);
- }
+ copy = line ? xstrdup(line) : NULL;
} else {
line = fgets(buf, sizeof(buf), stdin);
}
}
if(!strcasecmp(nargv[argc], "exit") || !strcasecmp(nargv[argc], "quit")) {
+#ifdef HAVE_READLINE
+ free(copy);
+#endif
free(nargv);
return result;
}
}
}
+#ifdef HAVE_READLINE
+ free(copy);
+#endif
free(nargv);
if(tty) {
static struct WSAData wsa_state;
if(WSAStartup(MAKEWORD(2, 2), &wsa_state)) {
- fprintf(stderr, "System call `%s' failed: %s", "WSAStartup", winerror(GetLastError()));
+ fprintf(stderr, "System call `%s' failed: %s\n", "WSAStartup", winerror(GetLastError()));
return false;
}