1 /* ovirt viewer console application
2 * Copyright (C) 2008 Red Hat Inc.
3 * Written by Mohammed Morsi <mmorsi@redhat.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 /* ovirt-viewer starts listening on network port to
21 * encapsulate vnc packets including the vm's name
22 * so as to be able to be proxied.
24 * This operation takes place in another thread
25 * which can be started/stopped by calling
26 * start_tunnel / stop_tunnel.
28 * An additional connection thread is created and maintained
29 * internally for each vm / vnc connection open in ovirt-viewer
30 * establishing a connection w/ the ovirt server.
33 #include <sys/types.h>
34 #include <sys/socket.h>
38 #include <netinet/in.h>
39 #include <arpa/inet.h>
50 // max length of a vm name
51 const int VM_NAME_MAX_LEN = 250;
53 // max length of vnc data
54 const int VNC_DATA_MAX_LEN = 800000;
56 // port which to connect to on ovirt server
57 const int OVIRT_SERVER_PORT = 5900;
59 /* Private thread functions */
60 static gpointer tunnel_thread(gpointer data);
61 static gpointer client_server_thread(gpointer data);
62 static gpointer server_client_thread(gpointer data);
64 /* Other private functions */
65 static void close_socket(gpointer _socket, gpointer data);
66 static void wait_for_thread(gpointer _thread, gpointer data);
68 /* tunnel and main threads */
69 static GThread *tunnel_gthread = NULL;
70 static GThread *main_gthread = NULL;
72 /* list of communication threads */
73 static GSList *communication_threads = NULL;
76 static GSList *sockets = NULL;
78 /* thread termination flag */
79 static gboolean run_tunnel = FALSE;
81 /* internal.h shared constructs */
86 /** public implementations **/
88 /* start tunnel thread */
94 DEBUG ("starting the tunnel thread");
96 assert (tunnel_gthread == NULL);
100 main_gthread = g_thread_self ();
102 tunnel_gthread = g_thread_create (tunnel_thread, NULL, TRUE, &error);
104 g_print ("%s\n", error->message);
105 g_error_free (error);
110 /* stop tunnel thread */
117 DEBUG ("stopping the tunnel thread");
119 assert (tunnel_gthread != NULL);
120 ASSERT_IS_MAIN_THREAD ();
124 g_slist_foreach(sockets, close_socket, NULL);
126 (void) g_thread_join (tunnel_gthread);
127 tunnel_gthread = NULL;
132 /** private implementations **/
134 /* the tunnel thread */
136 tunnel_thread (gpointer _data)
138 struct hostent *dns_serv;
140 //char vm_data[VM_NAME_MAX_LEN];
141 int local_server_socketfd, ovirt_server_socket, client_socketfd;
142 unsigned int local_server_len, client_len, ovirt_server_len;
144 struct sockaddr_in local_server_address;
145 struct sockaddr_in ovirt_server_address;
146 struct sockaddr_in client_address;
148 struct sockaddr_in local_server_address_lookup;
149 unsigned int local_server_address_lookup_len = sizeof(local_server_address_lookup);
151 GThread *client_server_gthread = NULL;
152 GThread *server_client_gthread = NULL;
154 int sockets_param[2];
157 DEBUG ("tunnel thread starting up");
159 // ovirt server address
160 dns_serv = gethostbyname(hostname);
161 if(dns_serv == NULL){
162 DEBUG("ovirt server lookup failed");
165 ovirt_server_address.sin_family = PF_INET;
166 ovirt_server_address.sin_addr.s_addr = ((struct in_addr*)(dns_serv->h_addr))->s_addr; //inet_addr(hostname);
167 ovirt_server_address.sin_port = htons(OVIRT_SERVER_PORT);
168 ovirt_server_len = sizeof(ovirt_server_address);
170 // create local net socket
171 local_server_socketfd = socket(PF_INET, SOCK_STREAM, 0);
172 c_socket = malloc(sizeof(int)); *c_socket = local_server_socketfd;
173 sockets = g_slist_prepend(sockets, c_socket);
175 // local server address
176 local_server_address.sin_family = PF_INET;
177 local_server_address.sin_addr.s_addr = inet_addr("127.0.0.1");
178 local_server_address.sin_port = 0;
179 local_server_len = sizeof(local_server_address);
181 // increment ports until one is available
182 if(bind(local_server_socketfd, (struct sockaddr*)&local_server_address, local_server_len) < 0){
183 DEBUG("tunnel bind failed");
187 getsockname(local_server_socketfd,
188 (struct sockaddr*) &local_server_address_lookup,
189 &local_server_address_lookup_len);
190 tunnel_port = (int)ntohs(local_server_address_lookup.sin_port);
191 DEBUG ("tunnel bound to local port %i", tunnel_port);
193 // increase client buffer size?
194 listen(local_server_socketfd, 5);
197 // accept a client connection
198 DEBUG("tunnel accepting");
199 client_len = sizeof(client_address);
200 client_socketfd = accept(local_server_socketfd, (struct sockaddr*)&client_address, &client_len);
201 if(client_socketfd < 0){
202 DEBUG("tunnel accept failed");
205 // TODO check accept return value for err
206 c_socket = malloc(sizeof(int)); *c_socket = client_socketfd;
207 sockets = g_slist_prepend(sockets, c_socket);
209 DEBUG ("client connected to tunnel");
211 // establish connection w/ ovirt server
212 ovirt_server_socket = socket(PF_INET, SOCK_STREAM, 0);
213 c_socket = malloc(sizeof(int)); *c_socket = ovirt_server_socket;
214 sockets = g_slist_prepend(sockets, c_socket);
215 DEBUG ("connecting to ovirt server %s on %i", hostname, OVIRT_SERVER_PORT);
216 if(connect(ovirt_server_socket, (struct sockaddr*)&ovirt_server_address, ovirt_server_len) < 0){
217 DEBUG ("could not connect to ovirt server");
221 DEBUG ("connected to ovirt server");
223 sockets_param[0] = ovirt_server_socket;
224 sockets_param[1] = client_socketfd;
226 // launch thread for client -> server traffic
227 client_server_gthread = g_thread_create (client_server_thread,
228 &sockets_param, TRUE, NULL);
230 // launch thread for server -> client traffic
231 server_client_gthread = g_thread_create (server_client_thread,
232 &sockets_param, TRUE, NULL);
234 communication_threads = g_slist_prepend(communication_threads, client_server_gthread);
235 communication_threads = g_slist_prepend(communication_threads, server_client_gthread);
237 // send target vm for this session
238 //strcpy(vm_data, vm_in_focus->description);
239 DEBUG ("sending vm %s", vm_in_focus->description);
240 write(ovirt_server_socket, vm_in_focus->description, strlen(vm_in_focus->description));
244 DEBUG("terminating tunnel thread");
246 // wait for connection threads to finish
247 g_slist_foreach(communication_threads, wait_for_thread, NULL);
249 DEBUG ("tunnel thread completed");
253 /* the tunnel thread */
255 client_server_thread (gpointer _data){
257 char vnc_data[VNC_DATA_MAX_LEN];
259 int ovirt_server_socket = ((int*)_data)[0],
260 client_socket = ((int*)_data)[1];
262 DEBUG ("client/server thread starting up");
265 VERBOSE( "accepting client data");
268 nbytes = read(client_socket, vnc_data, VNC_DATA_MAX_LEN);
270 DEBUG ( "error reading data from client" );
273 VERBOSE ("read %i bytes from client", nbytes);
275 // send network_data onto server
276 nbytes = write(ovirt_server_socket, vnc_data, nbytes);
278 DEBUG ( "error writing data to server" );
281 VERBOSE ("wrote %i bytes to server", nbytes);
284 DEBUG ("client/server thread completed");
288 /* the server thread */
290 server_client_thread (gpointer _data){
291 char vnc_data[VNC_DATA_MAX_LEN];
293 int ovirt_server_socket = ((int*)_data)[0],
294 client_socket = ((int*)_data)[1];
298 DEBUG ("server/client thread starting up");
302 nbytes = read(ovirt_server_socket, vnc_data, VNC_DATA_MAX_LEN);
304 DEBUG ( "error reading data from server" );
307 VERBOSE ("read %i bytes from server", nbytes);
309 // send network_data onto client
310 nbytes = write(client_socket, vnc_data, nbytes);
312 DEBUG ( "error writing data to client" );
315 VERBOSE ("wrote %i bytes to client", nbytes);
318 DEBUG ("server/client thread completed");
322 static void close_socket(gpointer _socket, gpointer data){
323 shutdown(*(int*) _socket, 2);
324 close(*(int*) _socket);
325 free((int*) _socket);
328 static void wait_for_thread(gpointer _thread, gpointer data){
329 g_thread_join((GThread*)_thread);