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

Revision 151, 10.6 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    char buffer_client[__BUFFER_SIZE__],
144                 buffer_jabber[__BUFFER_SIZE__];
145    struct client * client = current;//(struct client *) pClient;
146    int i = 0, err;
147        time_t last;
148
149        char ip[46];
150        unsigned short port;
151        inet_ntop(AF_INET, &(client->sockaddr.sin_addr), ip, sizeof (ip));
152        port = ntohs(client->sockaddr.sin_port);
153        printf("\nGot a connection from %s, port %hu\n", ip, port);
154        /*---------------------------------------------------*/
155
156        int jabber_fd           = (int)NULL,
157                jabber_port             = (int)NULL,
158                jabber_error    = (int)NULL;
159
160        struct sockaddr_in jabber_addr;
161
162        jabber_port = __DEFAULT_JABBER_PORT__;
163        jabber_fd = socket(AF_INET, SOCK_STREAM, 0);
164
165        fcntl(jabber_fd, F_SETFL, fcntl(jabber_fd, F_GETFL, 0) | O_NDELAY);
166
167        jabber_addr.sin_family = AF_INET;
168        inet_aton(__DEFAULT_JABBER_IP__, &jabber_addr.sin_addr);
169        //jabber_addr.sin_addr.s_addr = inet_addr(__DEFAULT_JABBER_IP__);
170        jabber_addr.sin_port = htons(jabber_port);
171
172        jabber_error = connect(jabber_fd, (struct sockaddr *) &(jabber_addr), sizeof(jabber_addr));
173
174        last = time(NULL);
175        int client_is_connected = -1;
176        int jabber_is_connected = -1;
177        int sockaddr_in_size    = sizeof(struct sockaddr_in);
178        while ( client_is_connected != 0 )
179        {
180                /* read from client */
181                puts("\tread - client");
182                bzero(buffer_client, __BUFFER_SIZE__);
183                if ( (client_is_connected = read(client->fd, buffer_client, __BUFFER_SIZE__)) != 0 && strlen(buffer_jabber) > 0 )
184                {
185                        puts("\twrite - client");
186                        printf("\t%s\n", buffer_jabber);
187                        /* write in the client */
188                        write(client->fd, buffer_jabber, strlen(buffer_jabber));
189                }
190
191                /* read from jabber service */
192                puts("\tread - jabber");
193                bzero(buffer_jabber, __BUFFER_SIZE__);
194                if ( (jabber_is_connected = read(jabber_fd, buffer_jabber, __BUFFER_SIZE__))  && strlen(buffer_client) > 0 )
195                {
196                                puts("\twrite - jabber");
197                                printf("\t%s\n", buffer_client);
198                                /* write in the jabber service */
199                                if ( !strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
200                                        write(jabber_fd, buffer_client, strlen(buffer_client));
201                }
202                if ( strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
203                {
204                        fcntl(jabber_fd, F_SETFL, fcntl(jabber_fd, F_GETFL, 0) | ~O_NDELAY);
205                        //starttls(&jabber_fd, &client->fd);
206                        int err;
207
208                        SSL_CTX * ctx;
209                        SSL * jabberssl;
210
211                        //OpenSSL_add_all_algorithms();
212
213                        SSL_library_init();
214                        SSL_load_error_strings();
215
216                        if ( !(ctx = SSL_CTX_new(TLSv1_server_method())) )
217                        {
218                                printf("Error creating the context.\n");
219                                exit(0);
220                        }
221
222                        SSL_CTX_set_verify(ctx,SSL_VERIFY_NONE,NULL);
223
224                        jabberssl = SSL_new(ctx);
225
226                        puts("#1");
227                        err=SSL_set_fd(jabberssl, jabber_fd);
228                        if ( err < 1 )
229                        {
230                                puts("shsfghdfgh");
231                                SSL_CTX_free(ctx);
232                        }
233
234                        puts("connect");
235                        err = SSL_connect(jabberssl);
236                        if ( err < 1 )
237                        {
238                                puts("client");
239                                err = SSL_get_error(jabberssl, err);
240                                printf("%d\n", err);
241                                char err_str[1024];
242                                ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
243                                printf("%s\n", err_str);
244                                SSL_CTX_free(ctx);
245                        }
246                }
247
248                if ( jabber_is_connected == 0 )
249                        client_is_connected = jabber_is_connected;
250
251                puts("end loop");
252                usleep(500000);
253        }
254
255    if ( close(jabber_fd) == __SOCKET_ERROR__ )
256    {
257        printf("\nCould not close jabber socket\n");
258        return 0;
259    }
260        /*---------------------------------------------------*/
261    if ( close(client->fd) == __SOCKET_ERROR__ )
262    {
263        printf("\nCould not close socket\n");
264        return 0;
265    }
266
267    fflush(stdin);
268    fflush(stdout);
269        free(client);
270                        //pthread_create(&(threads), NULL, handler, (void *) current);
271                }
272        }
273        pthread_exit(NULL);
274}
275
276void * handler(void * pClient)
277{
278    char buffer_client[__BUFFER_SIZE__],
279                 buffer_jabber[__BUFFER_SIZE__];
280    struct client * client = (struct client *) pClient;
281    int i = 0, err;
282        time_t last;
283
284        char ip[46];
285        unsigned short port;
286        inet_ntop(AF_INET, &(client->sockaddr.sin_addr), ip, sizeof (ip));
287        port = ntohs(client->sockaddr.sin_port);
288        printf("\nGot a connection from %s, port %hu\n", ip, port);
289        /*---------------------------------------------------*/
290
291        int jabber_fd           = (int)NULL,
292                jabber_port             = (int)NULL,
293                jabber_error    = (int)NULL;
294
295        struct sockaddr_in jabber_addr;
296
297        jabber_port = __DEFAULT_JABBER_PORT__;
298        jabber_fd = socket(AF_INET, SOCK_STREAM, 0);
299
300        fcntl(jabber_fd, F_SETFL, fcntl(jabber_fd, F_GETFL, 0) | O_NDELAY);
301
302        jabber_addr.sin_family = AF_INET;
303        inet_aton(__DEFAULT_JABBER_IP__, &jabber_addr.sin_addr);
304        //jabber_addr.sin_addr.s_addr = inet_addr(__DEFAULT_JABBER_IP__);
305        jabber_addr.sin_port = htons(jabber_port);
306
307        jabber_error = connect(jabber_fd, (struct sockaddr *) &(jabber_addr), sizeof(jabber_addr));
308
309        last = time(NULL);
310        int client_is_connected = -1;
311        int jabber_is_connected = -1;
312        int sockaddr_in_size    = sizeof(struct sockaddr_in);
313        while ( client_is_connected != 0 )
314        {
315                /* read from client */
316                puts("\tread - client");
317                bzero(buffer_client, __BUFFER_SIZE__);
318                if ( (client_is_connected = read(client->fd, buffer_client, __BUFFER_SIZE__)) != 0 && strlen(buffer_jabber) > 0 )
319                {
320                        puts("\twrite - client");
321                        printf("\t%s\n", buffer_jabber);
322                        /* write in the client */
323                        write(client->fd, buffer_jabber, strlen(buffer_jabber));
324                }
325
326                /* read from jabber service */
327                puts("\tread - jabber");
328                bzero(buffer_jabber, __BUFFER_SIZE__);
329                if ( (jabber_is_connected = read(jabber_fd, buffer_jabber, __BUFFER_SIZE__))  && strlen(buffer_client) > 0 )
330                {
331                                puts("\twrite - jabber");
332                                printf("\t%s\n", buffer_client);
333                                /* write in the jabber service */
334                                if ( !strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
335                                        write(jabber_fd, buffer_client, strlen(buffer_client));
336                }
337                if ( strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
338                {
339                        fcntl(jabber_fd, F_SETFL, fcntl(jabber_fd, F_GETFL, 0) | ~O_NDELAY);
340                        //starttls(&jabber_fd, &client->fd);
341                        int err;
342
343                        SSL_CTX * ctx;
344                        SSL * jabberssl;
345
346                        //OpenSSL_add_all_algorithms();
347
348                        SSL_library_init();
349                        SSL_load_error_strings();
350
351                        if ( !(ctx = SSL_CTX_new(TLSv1_server_method())) )
352                        {
353                                printf("Error creating the context.\n");
354                                exit(0);
355                        }
356
357                        SSL_CTX_set_verify(ctx,SSL_VERIFY_NONE,NULL);
358
359                        jabberssl = SSL_new(ctx);
360
361                        puts("#1");
362                        err=SSL_set_fd(jabberssl, jabber_fd);
363                        if ( err < 1 )
364                        {
365                                puts("shsfghdfgh");
366                                SSL_CTX_free(ctx);
367                        }
368
369                        puts("connect");
370                        err = SSL_connect(jabberssl);
371                        if ( err < 1 )
372                        {
373                                puts("client");
374                                err = SSL_get_error(jabberssl, err);
375                                printf("%d\n", err);
376                                char err_str[1024];
377                                ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
378                                printf("%s\n", err_str);
379                                SSL_CTX_free(ctx);
380                        }
381                }
382
383                if ( jabber_is_connected == 0 )
384                        client_is_connected = jabber_is_connected;
385
386                puts("end loop");
387                usleep(500000);
388        }
389
390    if ( close(jabber_fd) == __SOCKET_ERROR__ )
391    {
392        printf("\nCould not close jabber socket\n");
393        return 0;
394    }
395        /*---------------------------------------------------*/
396    if ( close(client->fd) == __SOCKET_ERROR__ )
397    {
398        printf("\nCould not close socket\n");
399        return 0;
400    }
401
402    fflush(stdin);
403    fflush(stdout);
404        free(client);
405    pthread_exit(NULL);
406}
Note: See TracBrowser for help on using the repository browser.