source: trunk/instant_messenger/socket/BKP_20071105/BKP_20071026/BKP_20071019/BKP_20071018/BKP_20071009/BKP_20071008/server_bkp.c @ 151

Revision 151, 7.9 KB checked in by niltonneto, 16 years ago (diff)

Commit da nova versão do módulo, usando agente em C.
Vide Página do módulo do Trac:
http://www.expressolivre.org/dev/wiki/messenger

A versão anterior encontra-se na subpasta bkp (32/64).
Line 
1#include "server.h"
2
3int main(int argc, char ** argv)
4{
5        /* variables to parse arguments */
6        extern int optind,
7                           optopt;
8        extern char * optarg;
9
10        char * log_file;
11        int c           = (int)NULL,
12                errflg  = (int)NULL,
13                verbose = (int)NULL,
14                optval  = 1;
15
16        socklen_t optlen = sizeof(optval);
17
18        /* fd -> file descriptor */
19        int socket_server_fd    = (int)NULL,
20                socket_server_port      = (int)NULL,
21                socket_accept_fd        = (int)NULL,
22                sockaddr_in_size        = sizeof(struct sockaddr_in),
23                err                                     = (int)NULL;
24
25        /* Internet socket address stuct */
26        struct sockaddr_in server_addr,
27                                           accept_addr;
28
29        struct client * clients = (struct client *) NULL,
30                                  * current = (struct client *) NULL;
31
32        pthread_t threads;
33
34        /* clear screen */
35        system(__CLEAR_SCREEN__);
36
37        while ( (c = getopt(argc, argv, ":vp:")) != -1 )
38        {
39                switch ( c )
40                {
41                        case 'p':
42                                if ( socket_server_port = strtol(optarg, 0, 10) == 0 )
43                                {
44                                        fprintf(stderr, "Option -%c requires a valid port and '%s' isn't valid\n", optopt, optarg);
45                                        ++errflg;
46                                }
47                                break;
48                        case 'v':
49                                verbose = 1;
50                                break;
51                        case ':':
52                                /* -f or -o without operand */
53                                fprintf(stderr, "Option -%c requires an operand\n", optopt);
54                                ++errflg;
55                                break;
56                        case '?':
57                                fprintf(stderr, "Unrecognized option: -%c\n", optopt);
58                                ++errflg;
59                }
60        }
61        if ( errflg )
62        {
63                fprintf(stderr, "usage: . . . \n\n");
64                exit(2);
65        }
66
67        /* make a socket */
68        socket_server_fd = socket(AF_INET, SOCK_STREAM, 0);
69        if ( socket_server_fd == __SOCKET_ERROR__ )
70        {
71                printf("\nCould not make a socket\n");
72                return 0;
73        }
74
75        bzero((char *) &server_addr, sockaddr_in_size);
76        bzero((char *) &accept_addr, sockaddr_in_size);
77
78        if ( !socket_server_port )
79                socket_server_port = __DEFAULT_OPEN_PORT__;
80
81        /* fill address struct */
82        server_addr.sin_addr.s_addr     = INADDR_ANY;
83        server_addr.sin_port            = htons(socket_server_port);
84        server_addr.sin_family          = AF_INET;
85        bzero(&(server_addr.sin_zero), 8);
86
87        if ( __DEBUG__  || verbose )
88                printf("\nBinding to port %d...\n", socket_server_port);
89
90        /* bind to a port */
91        if ( bind(socket_server_fd, (struct sockaddr *)&(server_addr), sizeof(server_addr)) == __SOCKET_ERROR__ )
92        {
93                printf("\nCould not connect to host\n");
94                exit(1);
95        }
96
97        /* get port number */
98        getsockname(socket_server_fd, (struct sockaddr *)&(server_addr), (socklen_t *) &(sockaddr_in_size));
99        if ( __DEBUG__  || verbose )
100        {
101                printf("\nopened socket as fd (%d) on port (%d) for stream i/o\n", socket_server_fd, ntohs(server_addr.sin_port));
102
103                printf("Server\n\
104                                sin_family        = %d\n\
105                                sin_addr.s_addr   = %d\n\
106                                sin_port          = %d\n"
107                                , server_addr.sin_family
108                                , server_addr.sin_addr.s_addr
109                                , ntohs(server_addr.sin_port)
110                          );
111                printf("\nMaking a listen queue of %d elements", __QUEUE_SIZE__);
112        }
113
114        /* establish listen queue */
115        if ( listen(socket_server_fd, __QUEUE_SIZE__) == __SOCKET_ERROR__ )
116        {
117                printf("\nCould not listen\n");
118                return 0;
119        }
120
121        for ( ; ; )
122        {
123                if ( __DEBUG__  || verbose )
124                        puts("\nWaiting for a connection\n");
125
126                /* get the connected socket */
127                socket_accept_fd = accept(socket_server_fd, (struct sockaddr *) &(accept_addr), (socklen_t *) &(sockaddr_in_size));
128                fcntl(socket_accept_fd, F_SETFL, fcntl(socket_accept_fd, F_GETFL, 0) | O_NDELAY);
129
130                if ( socket_accept_fd > -1 )
131                {
132                        if ( clients == (struct client *) NULL )
133                                current = clients;
134                        else
135                                while ( (current = clients->next) != (struct client *) NULL );
136
137                        current                         = (struct client *) malloc(sizeof(struct client));
138                        current->next           = (struct client *) NULL;
139                        current->fd                     = socket_accept_fd;
140                        current->sockaddr       = accept_addr;
141                        current->last           = time(NULL);
142
143                        pthread_create(&(threads), NULL, handler, (void *) current);
144                }
145        }
146        pthread_exit(NULL);
147}
148
149int starttls(int * jabberfd, int * clientfd)
150{
151        int err;
152
153        SSL_CTX * ctx;
154        SSL * clientssl,
155                * jabberssl;
156
157        OpenSSL_add_all_algorithms();
158        SSL_library_init();
159        SSL_load_error_strings();
160
161
162        if ( !(ctx = SSL_CTX_new(TLSv1_server_method())) )
163        {
164                printf("Error creating the context.\n");
165                exit(0);
166        }
167
168        SSL_CTX_set_verify(ctx,SSL_VERIFY_NONE,NULL);
169       
170        /*
171        clientssl = SSL_new(ctx);
172
173        puts("#1");
174        SSL_set_fd(clientssl, *(clientfd));
175
176        puts("accept");
177        err = SSL_accept(clientssl);
178        // Check for error in connect.
179        if ( err < 1 )
180        {
181                puts("server");
182                SSL_CTX_free(ctx);
183                return 0;
184        }
185        */
186
187        jabberssl = SSL_new(ctx);
188
189        puts("#2");
190        SSL_set_fd(jabberssl, *(jabberfd));
191
192        puts("connect");
193        err = SSL_connect(jabberssl);
194        /* Check for error in connect. */
195        if ( err < 1 )
196        {
197                puts("client");
198                SSL_CTX_free(ctx);
199                return 0;
200        }
201
202        return 1;
203}
204
205void * handler(void * pClient)
206{
207    char buffer_client[__BUFFER_SIZE__],
208                 buffer_jabber[__BUFFER_SIZE__];
209    struct client * client = (struct client *) pClient;
210    int i = 0, err;
211        time_t last;
212
213        char ip[46];
214        unsigned short port;
215        inet_ntop(AF_INET, &(client->sockaddr.sin_addr), ip, sizeof (ip));
216        port = ntohs(client->sockaddr.sin_port);
217        printf("\nGot a connection from %s, port %hu\n", ip, port);
218        /*---------------------------------------------------*/
219
220        int jabber_fd           = (int)NULL,
221                jabber_port             = (int)NULL,
222                jabber_error    = (int)NULL;
223
224        struct sockaddr_in jabber_addr;
225
226        jabber_port = __DEFAULT_JABBER_PORT__;
227        jabber_fd = socket(AF_INET, SOCK_STREAM, 0);
228
229        fcntl(jabber_fd, F_SETFL, fcntl(jabber_fd, F_GETFL, 0) | O_NDELAY);
230
231        jabber_addr.sin_family = AF_INET;
232        inet_aton(__DEFAULT_JABBER_IP__, &jabber_addr.sin_addr);
233        //jabber_addr.sin_addr.s_addr = inet_addr(__DEFAULT_JABBER_IP__);
234        jabber_addr.sin_port = htons(jabber_port);
235
236        jabber_error = connect(jabber_fd, (struct sockaddr *) &(jabber_addr), sizeof(jabber_addr));
237
238        last = time(NULL);
239        int client_is_connected = -1;
240        int jabber_is_connected = -1;
241        int sockaddr_in_size    = sizeof(struct sockaddr_in);
242        while ( client_is_connected != 0 )
243        {
244                /* read from client */
245                puts("\tread - client");
246                bzero(buffer_client, __BUFFER_SIZE__);
247                if ( (client_is_connected = read(client->fd, buffer_client, __BUFFER_SIZE__)) != 0 && strlen(buffer_jabber) > 0 )
248                {
249                        puts("\twrite - client");
250                        printf("\t%s\n", buffer_jabber);
251                        /* write in the client */
252                        write(client->fd, buffer_jabber, strlen(buffer_jabber));
253                }
254
255                /* read from jabber service */
256                puts("\tread - jabber");
257                bzero(buffer_jabber, __BUFFER_SIZE__);
258                if ( (jabber_is_connected = read(jabber_fd, buffer_jabber, __BUFFER_SIZE__))  && strlen(buffer_client) > 0 )
259                {
260                                puts("\twrite - jabber");
261                                printf("\t%s\n", buffer_client);
262                                /* write in the jabber service */
263                                if ( !strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
264                                        write(jabber_fd, buffer_client, strlen(buffer_client));
265                }
266                if ( strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
267                {
268                        fcntl(jabber_fd, F_SETFL, fcntl(jabber_fd, F_GETFL, 0) | ~O_NDELAY);
269                        //starttls(&jabber_fd, &client->fd);
270                        int err;
271
272                        SSL_CTX * ctx;
273                        SSL * jabberssl;
274
275                        //OpenSSL_add_all_algorithms();
276
277                        SSL_library_init();
278                        SSL_load_error_strings();
279
280                        if ( !(ctx = SSL_CTX_new(TLSv1_server_method())) )
281                        {
282                                printf("Error creating the context.\n");
283                                exit(0);
284                        }
285
286                        SSL_CTX_set_verify(ctx,SSL_VERIFY_NONE,NULL);
287
288                        jabberssl = SSL_new(ctx);
289
290                        puts("#1");
291                        err=SSL_set_fd(jabberssl, jabber_fd);
292                        if ( err < 1 )
293                        {
294                                puts("shsfghdfgh");
295                                SSL_CTX_free(ctx);
296                        }
297
298                        puts("connect");
299                        err = SSL_connect(jabberssl);
300                        if ( err < 1 )
301                        {
302                                puts("client");
303                                err = SSL_get_error(jabberssl, err);
304                                printf("%d\n", err);
305                                char err_str[1024];
306                                ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
307                                printf("%s\n", err_str);
308                                SSL_CTX_free(ctx);
309                        }
310                }
311
312                if ( jabber_is_connected == 0 )
313                        client_is_connected = jabber_is_connected;
314
315                puts("end loop");
316                usleep(500000);
317        }
318
319    if ( close(jabber_fd) == __SOCKET_ERROR__ )
320    {
321        printf("\nCould not close jabber socket\n");
322        return 0;
323    }
324        /*---------------------------------------------------*/
325    if ( close(client->fd) == __SOCKET_ERROR__ )
326    {
327        printf("\nCould not close socket\n");
328        return 0;
329    }
330
331    fflush(stdin);
332    fflush(stdout);
333        free(client);
334    pthread_exit(NULL);
335}
Note: See TracBrowser for help on using the repository browser.