← Back to branch summary

~ubuntu-branches/ubuntu/trusty/keepalived/trusty

« back to all changes in this revision

Viewing changes to genhash/layer4.c

  • Committer: Bazaar Package Importer
  • Author(s): Alexander Wirt
  • Date: 2005-04-29 23:22:40 UTC
  • mfrom: (1.1.1 upstream) (2.1.1 hoary)
  • Revision ID: james.westby@ubuntu.com-20050429232240-a8m3jtpi3cvuyyy2
Tags: 1.1.11-3
Added a warning about sarge kernels to README.Debian and 
the package description 

Show diffs side-by-side

added added

removed removed

Lines of Context:
genhash/layer4.c
19
19
 *              as published by the Free Software Foundation; either version
20
20
 *              2 of the License, or (at your option) any later version.
21
21
 *
22
 
 * Copyright (C) 2001-2004 Alexandre Cassen, <acassen@linux-vs.org>
 
22
 * Copyright (C) 2001-2005 Alexandre Cassen, <acassen@linux-vs.org>
23
23
 */
24
24
 
25
25
#include "layer4.h"
75
75
}
76
76
 
77
77
enum connect_result
78
 
tcp_socket_state(int fd, thread * thread, uint32_t addr_ip, uint16_t addr_port,
 
78
tcp_socket_state(int fd, thread * thread_obj, uint32_t addr_ip, uint16_t addr_port,
79
79
                 int (*func) (struct _thread *))
80
80
{
81
81
        int status;
84
84
        TIMEVAL timer_min;
85
85
 
86
86
        /* Handle connection timeout */
87
 
        if (thread->type == THREAD_WRITE_TIMEOUT) {
 
87
        if (thread_obj->type == THREAD_WRITE_TIMEOUT) {
88
88
                DBG("TCP connection timeout to [%s:%d].\n",
89
89
                    inet_ntop2(addr_ip), ntohs(addr_port));
90
 
                close(thread->u.fd);
 
90
                close(thread_obj->u.fd);
91
91
                return connect_timeout;
92
92
        }
93
93
 
94
94
        /* Check file descriptor */
95
95
        slen = sizeof (status);
96
96
        if (getsockopt
97
 
            (thread->u.fd, SOL_SOCKET, SO_ERROR, (void *) &status, &slen) < 0)
 
97
            (thread_obj->u.fd, SOL_SOCKET, SO_ERROR, (void *) &status, &slen) < 0)
98
98
                ret = errno;
99
99
 
100
100
        /* Connection failed !!! */
101
101
        if (ret) {
102
102
                DBG("TCP connection failed to [%s:%d].\n",
103
103
                    inet_ntop2(addr_ip), ntohs(addr_port));
104
 
                close(thread->u.fd);
 
104
                close(thread_obj->u.fd);
105
105
                return connect_error;
106
106
        }
107
107
 
114
114
                DBG("TCP connection to [%s:%d] still IN_PROGRESS.\n",
115
115
                    inet_ntop2(addr_ip), ntohs(addr_port));
116
116
 
117
 
                timer_min = timer_sub_now(thread->sands);
118
 
                thread_add_write(thread->master, func, THREAD_ARG(thread)
119
 
                                 , thread->u.fd, TIMER_LONG(timer_min));
 
117
                timer_min = timer_sub_now(thread_obj->sands);
 
118
                thread_add_write(thread_obj->master, func, THREAD_ARG(thread_obj)
 
119
                                 , thread_obj->u.fd, TIMER_LONG(timer_min));
120
120
                return connect_in_progress;
121
121
        }
122
122
 
124
124
}
125
125
 
126
126
void
127
 
tcp_connection_state(int fd, enum connect_result status, thread * thread,
 
127
tcp_connection_state(int fd, enum connect_result status, thread * thread_obj,
128
128
                     int (*func) (struct _thread *)
129
129
                     , long timeout)
130
130
{
134
134
                break;
135
135
 
136
136
        case connect_success:
137
 
                thread_add_write(thread->master, func, THREAD_ARG(thread),
 
137
                thread_add_write(thread_obj->master, func, THREAD_ARG(thread_obj),
138
138
                                 fd, timeout);
139
139
                break;
140
140
 
141
141
                /* Checking non-blocking connect, we wait until socket is writable */
142
142
        case connect_in_progress:
143
 
                thread_add_write(thread->master, func, THREAD_ARG(thread),
 
143
                thread_add_write(thread_obj->master, func, THREAD_ARG(thread_obj),
144
144
                                 fd, timeout);
145
145
                break;
146
146
 
150
150
}
151
151
 
152
152
int
153
 
tcp_check_thread(thread * thread)
 
153
tcp_check_thread(thread * thread_obj)
154
154
{
155
 
        SOCK *sock = THREAD_ARG(thread);
 
155
        SOCK *sock_obj = THREAD_ARG(thread_obj);
156
156
        int ret = 1;
157
157
 
158
 
        sock->status =
159
 
            tcp_socket_state(thread->u.fd, thread, req->addr_ip, req->addr_port,
 
158
        sock_obj->status =
 
159
            tcp_socket_state(thread_obj->u.fd, thread_obj, req->addr_ip, req->addr_port,
160
160
                             tcp_check_thread);
161
 
        switch (sock->status) {
 
161
        switch (sock_obj->status) {
162
162
        case connect_error:
163
163
                DBG("Error connecting server [%s:%d].\n",
164
164
                    inet_ntop2(req->addr_ip), ntohs(req->addr_port));
165
 
                thread_add_terminate_event(thread->master);
 
165
                thread_add_terminate_event(thread_obj->master);
166
166
                return -1;
167
167
                break;
168
168
 
169
169
        case connect_timeout:
170
170
                DBG("Timeout connecting server [%s:%d].\n",
171
171
                    inet_ntop2(req->addr_ip), ntohs(req->addr_port));
172
 
                thread_add_terminate_event(thread->master);
 
172
                thread_add_terminate_event(thread_obj->master);
173
173
                return -1;
174
174
                break;
175
175
 
176
176
        case connect_success:{
177
177
                        if (req->ssl)
178
 
                                ret = ssl_connect(thread);
 
178
                                ret = ssl_connect(thread_obj);
179
179
 
180
180
                        if (ret) {
181
181
                                /* Remote WEB server is connected.
182
182
                                 * Unlock eventual locked socket.
183
183
                                 */
184
 
                                sock->lock = 0;
185
 
                                thread_add_event(thread->master,
186
 
                                                 http_request_thread, sock, 0);
 
184
                                sock_obj->lock = 0;
 
185
                                thread_add_event(thread_obj->master,
 
186
                                                 http_request_thread, sock_obj, 0);
187
187
                        } else {
188
188
                                DBG("Connection trouble to: [%s:%d].\n",
189
189
                                    inet_ntop2(req->addr_ip),
190
190
                                    ntohs(req->addr_port));
191
191
                                if (req->ssl)
192
192
                                        ssl_printerr(SSL_get_error
193
 
                                                     (sock->ssl, ret));
194
 
                                sock->status = connect_error;
 
193
                                                     (sock_obj->ssl, ret));
 
194
                                sock_obj->status = connect_error;
195
195
                                return -1;
196
196
                        }
197
197
                }
202
202
}
203
203
 
204
204
int
205
 
tcp_connect_thread(thread * thread)
 
205
tcp_connect_thread(thread * thread_obj)
206
206
{
207
 
        SOCK *sock = THREAD_ARG(thread);
 
207
        SOCK *sock_obj = THREAD_ARG(thread_obj);
208
208
 
209
 
        if ((sock->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
 
209
        if ((sock_obj->fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
210
210
                DBG("WEB connection fail to create socket.\n");
211
211
                return 0;
212
212
        }
213
213
 
214
 
        sock->status = tcp_connect(sock->fd, req->addr_ip, req->addr_port);
 
214
        sock->status = tcp_connect(sock_obj->fd, req->addr_ip, req->addr_port);
215
215
 
216
216
        /* handle tcp connection status & register check worker thread */
217
 
        tcp_connection_state(sock->fd, sock->status, thread, tcp_check_thread,
 
217
        tcp_connection_state(sock_obj->fd, sock_obj->status, thread_obj, tcp_check_thread,
218
218
                             HTTP_CNX_TIMEOUT);
219
219
        return 0;
220
220
}