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
|
/* $Id: thread.c,v 1.1 2000-09-12 00:07:44 rjkaes Exp $
*
* Handles the creation/destruction of the various threads required for
* processing incoming connections.
*
* Copyright (C) 2000 Robert James Kaes (rjkaes@flarenet.com)
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2, or (at your option) any
* later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*/
#include "tinyproxy.h"
#include "log.h"
#include "reqs.h"
#include "sock.h"
#include "thread.h"
static int listenfd;
static socklen_t addrlen;
struct thread_s {
pthread_t tid;
enum { T_EMPTY, T_WAITING, T_CONNECTED } status;
};
static struct thread_s *thread_ptr;
static pthread_mutex_t mlock = PTHREAD_MUTEX_INITIALIZER;
struct thread_config_s {
unsigned int maxclients, maxrequestsperchild;
unsigned int maxspareservers, minspareservers, startservers;
} thread_config;
static unsigned int servers_waiting; /* servers waiting for a connection */
static pthread_mutex_t servers_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t servers_cond = PTHREAD_COND_INITIALIZER;
#define LOCK_SERVERS() pthread_mutex_lock(&servers_mutex)
#define UNLOCK_SERVERS() pthread_mutex_unlock(&servers_mutex)
/*
* Set the configuration values for the various thread related settings.
*/
int thread_configure(thread_config_t type, unsigned int val)
{
switch (type) {
case THREAD_MAXCLIENTS:
thread_config.maxclients = val;
break;
case THREAD_MAXSPARESERVERS:
thread_config.maxspareservers = val;
break;
case THREAD_MINSPARESERVERS:
thread_config.minspareservers = val;
break;
case THREAD_STARTSERVERS:
thread_config.startservers = val;
break;
case THREAD_MAXREQUESTSPERCHILD:
thread_config.maxrequestsperchild = val;
break;
default:
DEBUG2("Invalid type (%d)", type);
return -1;
}
return 0;
}
/*
* This is the main (per thread) loop.
*/
static void *thread_main(void *arg)
{
int connfd;
struct sockaddr *cliaddr;
socklen_t clilen;
struct thread_s *ptr;
ptr = (struct thread_s *)arg;
cliaddr = malloc(addrlen);
if (!cliaddr) {
log(LOG_ERR, "Could not allocate memory");
return NULL;
}
for ( ; ; ) {
clilen = addrlen;
pthread_mutex_lock(&mlock);
connfd = accept(listenfd, cliaddr, &clilen);
pthread_mutex_unlock(&mlock);
LOCK_SERVERS();
ptr->status = T_CONNECTED;
servers_waiting--;
UNLOCK_SERVERS();
handle_connection(connfd);
close(connfd);
LOCK_SERVERS();
ptr->status = T_WAITING;
servers_waiting++;
UNLOCK_SERVERS();
}
}
/*
* Create the initial pool of threads.
*/
int thread_pool_create(void)
{
unsigned int i;
if (thread_config.maxclients == 0) {
log(LOG_ERR, "You must set MaxClients to a value greater than 0");
return -1;
}
if (thread_config.startservers == 0) {
log(LOG_ERR, "You must set StartServers to a value greate than 0");
return -1;
}
thread_ptr = calloc(thread_config.maxclients, sizeof(struct thread_s));
if (!thread_ptr)
return -1;
if (thread_config.startservers > thread_config.maxclients) {
log(LOG_WARNING, "Can not start more than 'MaxClients' servers. Starting %d servers", thread_config.maxclients);
thread_config.startservers = thread_config.maxclients;
}
for (i = 0; i < thread_config.startservers; i++) {
thread_ptr[i].status = T_WAITING;
servers_waiting++;
pthread_create(&thread_ptr[i].tid, NULL, &thread_main, &thread_ptr[i]);
}
for (i = thread_config.startservers; i < thread_config.maxclients; i++) {
thread_ptr[i].status = T_EMPTY;
}
return 0;
}
/*
* Keep the proper number of servers running. This is the birth and death
* of the servers. It monitors this at least once a second.
*/
int thread_main_loop(void)
{
int i;
struct timeval tv;
struct timespec ts;
while (config.quit == FALSE) {
/* Wait for one of the threads to signal */
pthread_mutex_lock(&servers_mutex);
while (config.quit == FALSE
&& servers_waiting < thread_config.maxspareservers
&& servers_waiting > thread_config.minspareservers) {
if (gettimeofday(&tv, NULL) < 0) {
return -1;
}
ts.tv_sec = tv.tv_sec + 1;
ts.tv_nsec = tv.tv_usec * 1000;
pthread_cond_timedwait(&servers_cond, &servers_mutex, &ts);
}
if (config.quit == TRUE)
return 0;
/* If there are not enough spare servers, create more */
if (servers_waiting < thread_config.minspareservers) {
for (i = 0; i < thread_config.maxclients; i++) {
if (thread_ptr[i].status == T_EMPTY) {
pthread_create(&thread_ptr[i].tid, NULL, &thread_main, &thread_ptr[i]);
thread_ptr[i].status = T_WAITING;
servers_waiting++;
log(LOG_NOTICE, "Created a new thread.");
break;
}
}
} else if (servers_waiting > thread_config.maxspareservers) {
for (i = 0; i < thread_config.maxclients; i++) {
if (thread_ptr[i].status == T_WAITING) {
pthread_join(thread_ptr[i].tid, NULL);
servers_waiting--;
thread_ptr[i].status = T_EMPTY;
log(LOG_NOTICE, "Killed off a thread.");
break;
}
}
}
pthread_mutex_unlock(&servers_mutex);
}
return 0;
}
inline int thread_listening_sock(unsigned int port)
{
listenfd = listen_sock(port, &addrlen);
return listenfd;
}
inline void thread_close_sock(void)
{
close(listenfd);
}
|
