ad_user
/
f2b
2
2
Fork 0
Code Issues Pull Requests Releases Activity
Browse Source

* refactor f2b_csocket_*() : hide f2b_csock_t *handler

master
Alex 'AdUser' Z 4 years ago
parent
bee237f261
commit
4873582cc7
4 changed files with 50 additions and 59 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      src/csocket-test.c
  2. 76
      src/csocket.c
  3. 8
      src/csocket.h
  4. 18
      src/daemon.c

7
src/csocket-test.c
Unescape View File

@ -21,7 +21,6 @@ cmd_handler(const f2b_cmd_t *cmd, f2b_buf_t *res) {
int main(int argc, const char **argv) {
f2b_config_t config;
f2b_csock_t *csock = NULL;
if (argc < 2) {
puts("Usage: csocket-test <csocket.conf>");
@ -37,16 +36,16 @@ int main(int argc, const char **argv) {
return EXIT_FAILURE;
}
if ((csock = f2b_csocket_create(config.csocket)) == NULL) {
if (!f2b_csocket_create(config.csocket)) {
perror("f2b_csocket_create()");
exit(EXIT_FAILURE);
}
while (run) {
f2b_csocket_poll(csock, cmd_handler);
f2b_csocket_poll(cmd_handler);
sleep(1);
}
f2b_csocket_destroy(csock);
f2b_csocket_destroy();
return 0;
}

76
src/csocket.c
Unescape View File

@ -40,7 +40,7 @@ struct f2b_csock_t {
int nlisten;
int nclients;
char password[32];
};
} csock;
/* helpers */
@ -336,69 +336,64 @@ f2b_sock_destroy(f2b_sock_t *sock) {
/* control socket-related functions */
f2b_csock_t *
bool
f2b_csocket_create(f2b_config_section_t *config) {
f2b_csock_t *csock = NULL;
f2b_sock_t *sock = NULL;
bool need_pass = false;
if ((csock = calloc(1, sizeof(f2b_csock_t))) == NULL) {
f2b_log_msg(log_error, "can't allocate memory for csocket struct");
return NULL;
}
memset(&csock, 0x0, sizeof(csock));
for (f2b_config_param_t *p = config->param; p != NULL; p = p->next) {
if (strcmp(p->name, "listen") == 0) {
if (csock->nlisten >= CSOCKET_MAX_LISTEN) {
if (csock.nlisten >= CSOCKET_MAX_LISTEN) {
f2b_log_msg(log_error, "ignoring excess 'listen' directive: %s", p->value);
continue;
}
if ((sock = f2b_sock_create(p->value)) != NULL) {
csock->listen[csock->nlisten] = sock;
csock->nlisten++;
csock.listen[csock.nlisten] = sock;
csock.nlisten++;
if (strncmp(p->value, "inet:", 5) == 0)
need_pass = true;
}
}
if (strcmp(p->name, "password") == 0) {
strlcpy(csock->password, p->value, sizeof(csock->password));
strlcpy(csock.password, p->value, sizeof(csock.password));
}
}
if (csock->nlisten == 0) {
f2b_csocket_destroy(csock);
return NULL;
if (csock.nlisten == 0) {
f2b_csocket_destroy();
return false;
}
if (need_pass && strcmp(csock->password, "") == 0) {
snprintf(csock->password, sizeof(csock->password), "%lx+%ld", random(), time(NULL));
f2b_log_msg(log_info, "set random password for control socket: %s", csock->password);
if (need_pass && strcmp(csock.password, "") == 0) {
snprintf(csock.password, sizeof(csock.password), "%lx+%ld", random(), time(NULL));
f2b_log_msg(log_info, "set random password for control socket: %s", csock.password);
}
return csock;
return true;
}
void
f2b_csocket_destroy(f2b_csock_t *csock) {
f2b_csocket_destroy() {
f2b_sock_t *sock = NULL;
f2b_conn_t *conn = NULL;
assert(csock != NULL);
for (int i = 0; i < CSOCKET_MAX_LISTEN; i++) {
if ((sock = csock->listen[i]) == NULL)
if ((sock = csock.listen[i]) == NULL)
continue;
f2b_sock_destroy(csock->listen[i]);
csock->listen[i] = NULL;
f2b_sock_destroy(csock.listen[i]);
csock.listen[i] = NULL;
}
for (int i = 0; i < CSOCKET_MAX_CLIENTS; i++) {
if ((conn = csock->clients[i]) == NULL)
if ((conn = csock.clients[i]) == NULL)
continue;
f2b_conn_destroy(conn);
csock->clients[i] = NULL;
csock.clients[i] = NULL;
}
free(csock);
memset(&csock, 0x0, sizeof(csock));
return;
}
void
f2b_csocket_poll(f2b_csock_t *csock, void (*cb)(const f2b_cmd_t *cmd, f2b_buf_t *res)) {
f2b_csocket_poll(void (*cb)(const f2b_cmd_t *cmd, f2b_buf_t *res)) {
struct timeval tv = { .tv_sec = 0, .tv_usec = 0 };
fd_set rfds, wfds;
f2b_conn_t *conn = NULL;
@ -406,22 +401,21 @@ f2b_csocket_poll(f2b_csock_t *csock, void (*cb)(const f2b_cmd_t *cmd, f2b_buf_t
struct sockaddr_storage addr;
socklen_t addrlen;
assert(csock != NULL);
assert(cb != NULL);
/* loop / init */
FD_ZERO(&rfds);
FD_ZERO(&wfds);
for (int i = 0; i < csock->nlisten; i++) {
sock = csock->listen[i]->sock;
for (int i = 0; i < csock.nlisten; i++) {
sock = csock.listen[i]->sock;
FD_SET(sock, &rfds); /* watch for new connections */
nfds = max(nfds, sock);
}
/* watch for new data on established connections */
for (int cnum = 0; cnum < CSOCKET_MAX_CLIENTS; cnum++) {
if ((conn = csock->clients[cnum]) == NULL)
if ((conn = csock.clients[cnum]) == NULL)
continue;
FD_SET(conn->sock, &rfds);
if (conn->send.used)
@ -445,23 +439,23 @@ f2b_csocket_poll(f2b_csock_t *csock, void (*cb)(const f2b_cmd_t *cmd, f2b_buf_t
return; /* no new data */
/* new connection on listening socket? */
for (int i = 0; i < csock->nlisten; i++) {
if (!FD_ISSET(csock->listen[i]->sock, &rfds))
for (int i = 0; i < csock.nlisten; i++) {
if (!FD_ISSET(csock.listen[i]->sock, &rfds))
continue;
/* find free connection slot */
int cnum = 0;
for (int cnum = 0; cnum < CSOCKET_MAX_CLIENTS; cnum++) {
if (csock->clients[cnum] == NULL) break;
if (csock.clients[cnum] == NULL) break;
}
int sock = -1;
/* accept() new connection */
addrlen = sizeof(struct sockaddr_storage);
if ((sock = accept(csock->listen[i]->sock, (struct sockaddr *) &addr, &addrlen)) < 0) {
if ((sock = accept(csock.listen[i]->sock, (struct sockaddr *) &addr, &addrlen)) < 0) {
f2b_log_msg(log_error, "can't accept() new connection: %s", strerror(errno));
} else if (cnum < CSOCKET_MAX_CLIENTS) {
if ((conn = f2b_conn_create(RBUF_SIZE, WBUF_SIZE)) != NULL) {
conn->flags = csock->listen[i]->flags;
if (csock->listen[i]->flags & CSOCKET_CONN_TYPE_UNIX) {
conn->flags = csock.listen[i]->flags;
if (csock.listen[i]->flags & CSOCKET_CONN_TYPE_UNIX) {
struct ucred peer;
socklen_t peerlen = 0;
peerlen = sizeof(peer);
@ -480,9 +474,9 @@ f2b_csocket_poll(f2b_csock_t *csock, void (*cb)(const f2b_cmd_t *cmd, f2b_buf_t
f2b_log_msg(log_debug, "new remote connection from %s, socket %d", conn->peer, sock);
}
conn->sock = sock;
conn->password = csock->password;
conn->password = csock.password;
f2b_conn_update_challenge(conn);
csock->clients[cnum] = conn;
csock.clients[cnum] = conn;
} else {
f2b_log_msg(log_error, "can't create new connection");
}
@ -493,14 +487,14 @@ f2b_csocket_poll(f2b_csock_t *csock, void (*cb)(const f2b_cmd_t *cmd, f2b_buf_t
}
for (int cnum = 0; cnum < CSOCKET_MAX_CLIENTS; cnum++) {
if ((conn = csock->clients[cnum]) == NULL)
if ((conn = csock.clients[cnum]) == NULL)
continue;
retval = f2b_conn_process(conn, FD_ISSET(conn->sock, &rfds), cb);
if (retval < 0) {
f2b_log_msg(log_debug, "closing connection on socket %d", conn->sock);
shutdown(conn->sock, SHUT_RDWR);
f2b_conn_destroy(conn);
csock->clients[cnum] = NULL;
csock.clients[cnum] = NULL;
}
} /* foreach connection(s) */
return;

8
src/csocket.h
Unescape View File

@ -16,8 +16,6 @@
#define CSOCKET_CONN_TYPE_INET 0x02
#define CSOCKET_CONN_AUTH_OK 0x04
typedef struct f2b_csock_t f2b_csock_t;
/**
* @file
* This file contains control socket manage routines
@ -28,13 +26,13 @@ typedef struct f2b_csock_t f2b_csock_t;
* @param spec String with socket path/address specification
* @returns Allocated socket struct
*/
f2b_csock_t * f2b_csocket_create (f2b_config_section_t *config);
bool f2b_csocket_create (f2b_config_section_t *config);
/**
* @brief Destroy socket struct and free resources
* @param csock Socket struct
*/
void f2b_csocket_destroy(f2b_csock_t *csock);
void f2b_csocket_destroy();
/**
* @brief Poll control socket for new messages
@ -42,6 +40,6 @@ void f2b_csocket_destroy(f2b_csock_t *csock);
* @param cb Callback for handling message
* @returns -1 on error, 0 on no messages, and > 0 on some messages processed
*/
void f2b_csocket_poll(f2b_csock_t *csock, void (*cb)(const f2b_cmd_t *cmd, f2b_buf_t *res));
void f2b_csocket_poll(void (*cb)(const f2b_cmd_t *cmd, f2b_buf_t *res));
#endif /* F2B_CSOCKET_H_ */

18
src/daemon.c
Unescape View File

@ -63,21 +63,21 @@ void usage(int exitcode) {
}
static time_t started = 0;
static f2b_csock_t *csock = NULL;
#ifndef WITH_CSOCKET
/* add stubs to reduce #ifdef count */
f2b_csock_t *
bool
f2b_csocket_create (f2b_config_section_t *config) {
UNUSED(path);
f2b_log_msg(log_warn, "control socket support was disabled at compile-time");
return NULL;
}
void
f2b_csocket_destroy(f2b_csock_t *csock) {
UNUSED(csock); return;
f2b_csocket_destroy() {
return;
}
int f2b_csocket_poll(f2b_csock_t *csock, void (*cb)(const f2b_cmd_t *cmd, f2b_buf_t *res)) {
UNUSED(csock); UNUSED(cb); return 0;
int
f2b_csocket_poll(void (*cb)(const f2b_cmd_t *cmd, f2b_buf_t *res)) {
UNUSED(cb); return 0;
}
void
f2b_csocket_cmd_process(const f2b_cmd_t *cmd, f2b_buf_t *res) {
@ -337,7 +337,7 @@ int main(int argc, char *argv[]) {
}
if (config.csocket) {
csock = f2b_csocket_create(config.csocket);
f2b_csocket_create(config.csocket);
}
if (config.defaults)
@ -356,7 +356,7 @@ int main(int argc, char *argv[]) {
for (f2b_jail_t *jail = jails; jail != NULL; jail = jail->next) {
f2b_jail_process(jail);
}
f2b_csocket_poll(csock, f2b_csocket_cmd_process);
f2b_csocket_poll(f2b_csocket_cmd_process);
sleep(1);
if (state == logrotate && strcmp(appconfig.logdest, "file") == 0) {
state = run;
@ -378,7 +378,7 @@ int main(int argc, char *argv[]) {
}
}
f2b_csocket_destroy(csock);
f2b_csocket_destroy();
jails_stop(jails);
jails = NULL;

Write Preview
Loading…
Cancel
Save