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
|
// class sock implementation. the multiplex socket implementation has been token from the
// GNU C Library Examples and modified in order to fit in here ( POSIX threads etc. ).
#ifndef SOCK_CXX
#define SOCK_CXX
#include <unistd.h>
#include "sock.h"
#include "CHAT.h"
#include "CONF.h"
#include "MUTX.h"
#include "TOOL.h"
#include "chat.h"
#include "user.h"
using namespace std;
sock::sock()
{
this->b_run = true;
this->i_req = 0;
this->req_parser = new reqp();
this->thrd_pool = new pool();
}
void
sock::chat_stream( int i_sock, map_string &map_params )
{
user* p_user = CHAT::get().get_user( map_params["nick"] );
p_user->set_sock( i_sock );
string s_msg( "" );
pthread_mutex_lock ( &(p_user->mut_message) );
while( p_user->get_online() )
{
pthread_cond_wait( &(p_user->cond_message), &(p_user->mut_message) );
s_msg = p_user->get_mess( );
if ( 0 > send( i_sock, s_msg.c_str(), s_msg.size(), 0 ) )
p_user->set_online( false );
}
pthread_mutex_unlock( &(p_user->mut_message) );
// remove the user from its room.
string s_user( p_user->get_name() );
p_user->get_p_room()->del_elem( s_user );
// post the room that the user has left the chat.
p_user->get_p_room()->msg_post( new string( p_user->get_name().append( USERLEAV ) ) );
p_user->~user();
}
int
sock::make_socket( uint16_t i_port )
{
int sock;
struct sockaddr_in name;
// create the server socket.
sock = socket (PF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
cerr << "Sock: socket error" << endl;
if ( ++i_port > MAXPORT )
exit(-1);
cerr << SOCKERR << i_port << endl;
return make_socket( i_port );
}
// give the server socket a name.
name.sin_family = AF_INET;
name.sin_port = htons (i_port);
name.sin_addr.s_addr = htonl (INADDR_ANY);
int optval=1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&optval, sizeof(int));
if (bind (sock, (struct sockaddr *) &name, sizeof (name)) < 0)
{
cerr << "Sock: bind error" << endl;
if ( ++i_port > MAXPORT )
exit(-1);
cout << SOCKERR << i_port << endl;
return make_socket( i_port );
}
return sock;
}
int
sock::read_write( thrd* p_thrd, int i_sock )
{
char c_req[2048];
int i_bytes;
i_bytes = read (i_sock, c_req, 2048);
if (i_bytes < 0)
{
cerr << "Sock: read error " << endl;
}
else
{
// stores the request params.
map_string map_params;
// get the s_rep ( HTML response which will be send imediatly to the client
// and fill map_params with request values.
auto string s_temp=(string)c_req;
string s_rep = req_parser->parse( p_thrd, string( c_req ), map_params );
// send s_rep to the client.
send( i_sock, s_rep.c_str(), s_rep.size(), 0 );
// prove if this is a request for a chat stream!
if ( map_params["event"] == "stream" )
chat_stream( i_sock, map_params );
return 0;
}
return -1;
}
int
sock::start()
{
auto int i_port = TOOL::string2int( CONF::get().get_val( "SRVRPORT" ) );
int sock;
fd_set active_fd_set, read_fd_set;
int i;
struct sockaddr_in clientname;
size_t size;
#ifdef _VERBOSE
cout << SOCKCRT << "localhost:" << i_port << endl;
#endif
// create the server socket and set it up to accept connections.
sock = make_socket ( i_port );
if (listen (sock, 1) < 0)
{
cerr << "Sock: listen error" << endl;
exit( EXIT_FAILURE );
}
#ifdef _VERBOSE
cout << SOCKRDY << endl;
#endif
// initialize the set of active sockets.
FD_ZERO (&active_fd_set);
FD_SET (sock, &active_fd_set);
while( b_run )
{
// block until input arrives on one or more active sockets.
read_fd_set = active_fd_set;
if (select (FD_SETSIZE, &read_fd_set, NULL, NULL, NULL) < 0)
{
cerr << "Sock: select error" << endl;
exit( EXIT_FAILURE );
}
// service all the sockets with input pending.
for ( i = 0; i < FD_SETSIZE; i++ )
if ( FD_ISSET (i, &read_fd_set) )
{
if ( i == sock )
{
// connection request on original socket.
i_req++;
int new_sock;
size = sizeof (clientname);
new_sock = accept (sock,
(struct sockaddr *) &clientname,
&size);
if (new_sock < 0)
{
cerr << "Sock: accept error" << endl;
close ( new_sock );
}
#ifdef _VERBOSE
cout << CONNECT << i_req << " "
<< inet_ntoa( clientname.sin_addr )
<< ":"
<< ntohs ( clientname.sin_port )
<< endl;
#endif
FD_SET (new_sock, &active_fd_set);
}
else
{
thrd_pool->run( (void*) new thrd( i ) );
FD_CLR( i, &active_fd_set );
}
}
}
}
#endif
|
