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
227
|
#include "uwsgi.h"
extern struct uwsgi_server uwsgi;
/*
on connection retrieve the uid,gid and pid of the connecting process, in addition to up to 3
file descriptors (emperor pipe, emperor pipe_config, on_demand socket dup()'ed to 0)
if authorized, double fork, get the pid of the second child and exit()
its parent (this will force the Emperor to became its subreaper).
from now on, we can consider the new child as a full-featured vassal
*/
#define VASSAL_HAS_CONFIG 0x02
#define VASSAL_HAS_ON_DEMAND 0x04
static void parse_argv_hook(uint16_t item, char *value, uint16_t vlen, void *data) {
struct uwsgi_string_list **usl = (struct uwsgi_string_list **) data;
uwsgi_string_new_list(usl, uwsgi_concat2n(value, vlen, "", 0));
}
void uwsgi_fork_server(char *socket) {
// map fd 0 to /dev/null to avoid mess
uwsgi_remap_fd(0, "/dev/null");
int fd = bind_to_unix(socket, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
if (fd < 0) exit(1);
// automatically receive credentials (TODO make something useful with them, like checking the pid is from the Emperor)
if (uwsgi_socket_passcred(fd)) exit(1);
// initialize the event queue
int eq = event_queue_init();
if (uwsgi.has_emperor) {
event_queue_add_fd_read(eq, uwsgi.emperor_fd);
}
event_queue_add_fd_read(eq, fd);
// now start waiting for connections
for(;;) {
int interesting_fd = -1;
int rlen = event_queue_wait(eq, -1, &interesting_fd);
if (rlen <= 0) continue;
if (uwsgi.has_emperor && interesting_fd == uwsgi.emperor_fd) {
char byte;
ssize_t rlen = read(uwsgi.emperor_fd, &byte, 1);
if (rlen > 0) {
uwsgi_log_verbose("received message %d from emperor\n", byte);
}
exit(0);
}
if (interesting_fd != fd) continue;
struct sockaddr_un client_src;
socklen_t client_src_len = 0;
int client_fd = accept(fd, (struct sockaddr *) &client_src, &client_src_len);
if (client_fd < 0) {
uwsgi_error("uwsgi_fork_server()/accept()");
continue;
}
char hbuf[4];
pid_t ppid = -1;
uid_t uid = -1;
gid_t gid = -1;
int fds_count = 8;
size_t remains = 4;
// we can receive up to 8 fds (generally from 1 to 3)
int fds[8];
// we only read 4 bytes header
ssize_t len = uwsgi_recv_cred_and_fds(client_fd, hbuf, remains, &ppid, &uid, &gid, fds, &fds_count);
uwsgi_log_verbose("[uwsgi-fork-server] connection from pid: %d uid: %d gid:%d fds:%d\n", ppid, uid, gid, fds_count);
if (len <= 0 || fds_count < 1) {
uwsgi_error("uwsgi_fork_server()/recvmsg()");
goto end;
}
remains -= len;
if (uwsgi_read_nb(client_fd, hbuf + (4-remains), remains, uwsgi.socket_timeout)) {
uwsgi_error("uwsgi_fork_server()/uwsgi_read_nb()");
goto end;
}
struct uwsgi_header *uh = (struct uwsgi_header *) hbuf;
// this memory area must be freed in the right place !!!
char *body_argv = uwsgi_malloc(uh->_pktsize);
if (uwsgi_read_nb(client_fd, body_argv, uh->_pktsize, uwsgi.socket_timeout)) {
free(body_argv);
uwsgi_error("uwsgi_fork_server()/uwsgi_read_nb()");
goto end;
}
pid_t pid = fork();
if (pid < 0) {
free(body_argv);
int i;
for(i=0;i<fds_count;i++) close(fds[i]);
// error on fork()
uwsgi_error("uwsgi_fork_server()/fork()");
goto end;
}
else if (pid > 0) {
free(body_argv);
// close inherited descriptors
int i;
for(i=0;i<fds_count;i++) close(fds[i]);
// wait for child death...
waitpid(pid, NULL, 0);
goto end;
}
else {
// close Emperor channels
// we do not close others file descriptor as lot
// of funny tricks could be accomplished with them
if (uwsgi.has_emperor) {
close(uwsgi.emperor_fd);
if (uwsgi.emperor_fd_config > -1) close(uwsgi.emperor_fd_config);
}
// set EMPEROR_FD and FD_CONFIG env vars
char *uef = uwsgi_num2str(fds[0]);
if (setenv("UWSGI_EMPEROR_FD", uef, 1)) {
uwsgi_error("uwsgi_fork_server()/setenv()");
exit(1);
}
free(uef);
int pipe_config = -1;
int on_demand = -1;
if (uh->modifier2 & VASSAL_HAS_CONFIG && fds_count > 1) {
pipe_config = fds[1];
char *uef = uwsgi_num2str(pipe_config);
if (setenv("UWSGI_EMPEROR_FD_CONFIG", uef, 1)) {
uwsgi_error("uwsgi_fork_server()/setenv()");
exit(1);
}
free(uef);
}
if (uh->modifier2 & VASSAL_HAS_ON_DEMAND && fds_count > 1) {
if (pipe_config > -1) {
if (fds_count > 2) {
on_demand = fds[2];
}
}
else {
on_demand = fds[1];
}
}
// dup the on_demand socket to 0 and close it
if (on_demand > -1) {
if (dup2(on_demand, 0) < 0) {
uwsgi_error("uwsgi_fork_server()/dup2()");
exit(1);
}
close(on_demand);
}
// now fork again and die
pid_t new_pid = fork();
if (new_pid < 0) {
uwsgi_error("uwsgi_fork_server()/fork()");
exit(1);
}
else if (new_pid > 0) {
exit(0);
}
else {
// send the pid to the client_fd and close it
struct uwsgi_buffer *ub = uwsgi_buffer_new(uwsgi.page_size);
// leave space for header
ub->pos = 4;
if (uwsgi_buffer_append_keynum(ub, "pid", 3, getpid())) exit(1);
// fix uwsgi header
if (uwsgi_buffer_set_uh(ub, 35, 0)) goto end;
// send_pid()
if (uwsgi_write_nb(client_fd, ub->buf, ub->pos, uwsgi.socket_timeout)) exit(1);
close(client_fd);
uwsgi_log("double fork() and reparenting successful (new pid: %d)\n", getpid());
uwsgi_buffer_destroy(ub);
// now parse the uwsgi packet array and build the argv
struct uwsgi_string_list *usl = NULL, *usl_argv = NULL;
uwsgi_hooked_parse_array(body_argv, uh->_pktsize, parse_argv_hook, &usl_argv);
free(body_argv);
// build new argc/argv
uwsgi.new_argc = 0;
size_t procname_len = 1;
uwsgi_foreach(usl, usl_argv) {
uwsgi.new_argc++;
procname_len += usl->len + 1;
}
char *new_procname = uwsgi_calloc(procname_len);
uwsgi.new_argv = uwsgi_calloc(sizeof(char *) * (uwsgi.new_argc + 1));
int counter = 0;
uwsgi_foreach(usl, usl_argv) {
uwsgi.new_argv[counter] = usl->value;
strcat(new_procname, usl->value);
strcat(new_procname, " ");
counter++;
}
// fix process name
uwsgi_set_processname(new_procname);
free(new_procname);
// this is the only step required to have a consistent environment
uwsgi.fork_socket = NULL;
// this avoids the process to re-exec itself
uwsgi.exit_on_reload = 1;
// fixup the Emperor communication
uwsgi_check_emperor();
// continue with uWSGI startup
return;
}
}
end:
close(client_fd);
}
}
|
