summaryrefslogtreecommitdiff
path: root/pullreqd.c
blob: 5e403a9ca89bc2ff2dff1340631913fff1dbcb10 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
#include <arpa/inet.h>
#include <errno.h>
#include <netdb.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/un.h>
#include <syslog.h>
#include <unistd.h>
#include "config.h"
#include "macros.h"

#define UNIX_PATH_MAX 108

pid_t fork_proc() {
	/* Fork off the parent. */
	pid_t pid = fork();

	/* The process id is non zero, so it must be the parent process. */
	if (pid) {
		/* Exit with EXIT_FAILURE if the parent's pid is
		 * negative, otherwise exit with EXIT_SUCCESS.
		 */
		exit((pid < 0) ? EXIT_FAILURE : EXIT_SUCCESS);
	}
	return pid;
}

void child_handler(int sig_num) {
	signal(SIGCHLD, child_handler);
}

void hangup_handler(int sig_num) {
	signal(SIGHUP, hangup_handler);
}

void init_daemon(int change_dir, char *path) {
	/* Fork the parent. */
	pid_t pid = fork_proc();

	/* Exit if the child process isn't the session leader. */
	if (setsid() < 0) {
		exit(EXIT_FAILURE);
	}

	/* Catch, ignore, and/or handle signals. */
	signal(SIGCHLD, child_handler);
	signal(SIGHUP, hangup_handler);

	/* Fork again. */
	pid = fork_proc();

	/* Set new file permissions. */
	umask(0);

	/* If change_dir is true, change the working directory to path, or
	 * the root directory if path isn't set.
	 */
	if (change_dir) {
		chdir((!path) ? "/" : path);
	}

	/* Close any open file descriptors. */
	for (int i = sysconf(_SC_OPEN_MAX); i >= 0; close(i--));

	/* Open the logfile. */
	openlog("pullreqd", LOG_PID, LOG_DAEMON);
}

int init_config(char *config_file, config **cfg) {
	log(LOG_INFO, "Reading config file %s.", config_file);

	*cfg = parse_config(config_file);

	/* Did the config file parser succeed? */
	if (*cfg != NULL) {
		log(LOG_INFO, "Successfully read %s.", config_file);
	} else {
		log(LOG_ERR, "Error reading %s.", config_file);
	}

	return (*cfg != NULL);
}

int init_socket(config *cfg) {
	union sock_addr {
		struct sockaddr sa;
		struct sockaddr_un sa_un;
		struct sockaddr_in sa_in;
	} sock_addr;
	/* Size of the socket address we're using. */
	size_t sockaddr_size = 0;
	/* Set socket type to unix socket, if socket-type was set to unix, otherwise set it to network socket. */
	const int sock_type = (strcasecmp(cfg->sock_type, "unix") == 0) ? AF_UNIX : AF_INET;

	if (sock_type == AF_UNIX) {
		size_t path_length = strlen(cfg->sock);
		/* Is the path too long? */
		if (path_length >= UNIX_PATH_MAX) {
			log(LOG_ERR, "The socket path is too long, and exceeded %i characters.", UNIX_PATH_MAX);
			return -1;
		}

		sockaddr_size = sizeof(sock_addr.sa_un);
		sock_addr.sa_un.sun_family = sock_type;
		memcpy(sock_addr.sa_un.sun_path, cfg->sock, path_length+1);
	} else {
		struct addrinfo hints, *ainfo_root, *ainfo;

		memset(&hints, 0, sizeof(hints));

		hints.ai_family = AF_UNSPEC;
		hints.ai_socktype = SOCK_SEQPACKET;
		/*hints.ai_protocol = IPPROTO_SCTP;*/
		hints.ai_flags = AI_PASSIVE;

		const int gai_ret = getaddrinfo(cfg->sock, cfg->port, &hints, &ainfo_root);
		/* Did getaddrinfo fail? */
		if (gai_ret) {
			log_reason(LOG_ERR, "getaddrinfo() failed for hostname %s.", cfg->sock, gai_strerror(gai_ret));
			return -1;
		}

		/* TODO: Create sockets for all resolved addresses, instead of just the first. */
		sockaddr_size = ainfo_root->ai_addrlen;
		sock_addr.sa = *ainfo_root->ai_addr;

		freeaddrinfo(ainfo_root);
	}

	/* Create a new listen socket. */
	const int fd = socket(sock_addr.sa.sa_family, SOCK_SEQPACKET, 0);

	/* Did we fail to create the listen socket? */
	if (fd < 0) {
		log_reason(LOG_ERR, "Failed to create listen socket.", strerror(errno));
		return -1;
	}


	/* Did we fail to bind the listen socket? */
	if (bind(fd, &sock_addr.sa, sockaddr_size) < 0) {
		log_reason(LOG_ERR, "Failed to bind listen socket.", strerror(errno));
		return -1;
	}

	int one = 1;

	/* Did we fail to enable SO_REUSEADDR? */
	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) {
		log_reason(LOG_ERR, "Failed to enable SO_REUSEADDR.", strerror(errno));
		return -1;
	}

	/* Did we fail to listen to the socket? */
	if (listen(fd, 20) < 0) {
		log_reason(LOG_ERR, "Failed to listen to socket.", strerror(errno));
		return -1;
	}

	log(LOG_INFO, "Successfully created socket descriptor %i for address %s.", fd, cfg->sock);
	return fd;
}

int main_loop(config *cfg, int listen_socket) {
	int done = 0;

	for (; !done;) {
		break;
	}

	return 0;
}

void cleanup(config *cfg, int listen_socket) {
	if (listen_socket > 0) {
		close(listen_socket);
		/* Is this a unix domain socket? */
		if (strcasecmp(cfg->sock_type, "unix") == 0) {
			unlink(cfg->sock);
		}
	}

	if (cfg) {
		cleanup_config(cfg);
	}
}

int main(int argc, char **argv) {
	config *cfg;
	char *config_file = "test.conf";
	int config_read = 0;
	int listen_socket = -1;
	int exit_status = EXIT_FAILURE;

	init_daemon(1, "/");
	log(LOG_NOTICE, "pullreqd started.");

	/* Read the config file. */
	config_read = init_config(config_file, &cfg);

	/* Did we successfully read the config file? */
	if (config_read) {
		/* Create the Listen socket. */
		listen_socket = init_socket(cfg);
	}

	/* Did we successfully read the config file, and create the listen socket? */
	if (config_read && listen_socket >= 0) {
		exit_status = main_loop(cfg, listen_socket);
	}

	cleanup(cfg, listen_socket);

	log(LOG_NOTICE, "pullreqd stopped.");

	closelog();

	return exit_status;
}