Mercurial > geeqie
annotate src/remote.c @ 503:e5023cced4e5
Fix image overlay displayed only on second "I" press in layout view.
author | zas_ |
---|---|
date | Wed, 23 Apr 2008 23:47:53 +0000 |
parents | c7a2471e5c4e |
children | fc9c8a3e1a8b |
rev | line source |
---|---|
9 | 1 /* |
196 | 2 * Geeqie |
9 | 3 * (C) 2004 John Ellis |
475 | 4 * Copyright (C) 2008 The Geeqie Team |
9 | 5 * |
6 * Author: John Ellis | |
7 * | |
8 * This software is released under the GNU General Public License (GNU GPL). | |
9 * Please read the included file COPYING for more information. | |
10 * This software comes with no warranty of any kind, use at your own risk! | |
11 */ | |
12 | |
13 | |
281 | 14 #include "main.h" |
9 | 15 #include "remote.h" |
16 | |
17 | |
18 #include <sys/types.h> | |
19 #include <sys/socket.h> | |
20 #include <sys/un.h> | |
21 #include <signal.h> | |
22 #include <errno.h> | |
23 | |
24 | |
25 #define SERVER_MAX_CLIENTS 8 | |
26 | |
27 #define REMOTE_SERVER_BACKLOG 4 | |
28 | |
29 | |
30 #ifndef UNIX_PATH_MAX | |
31 #define UNIX_PATH_MAX 108 | |
32 #endif | |
33 | |
34 | |
35 typedef struct _RemoteClient RemoteClient; | |
36 struct _RemoteClient { | |
37 gint fd; | |
38 gint channel_id; | |
39 RemoteConnection *rc; | |
40 }; | |
41 | |
42 | |
43 static gboolean remote_server_client_cb(GIOChannel *source, GIOCondition condition, gpointer data) | |
44 { | |
45 RemoteClient *client = data; | |
46 RemoteConnection *rc; | |
47 | |
48 rc = client->rc; | |
49 | |
50 if (condition & G_IO_IN) | |
51 { | |
52 GList *queue = NULL; | |
53 GList *work; | |
54 gchar *buffer = NULL; | |
55 GError *error = NULL; | |
64
04ff0df3ad2f
Mon Aug 15 17:13:57 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
56 guint termpos; |
9 | 57 |
58 while (g_io_channel_read_line(source, &buffer, NULL, &termpos, &error) == G_IO_STATUS_NORMAL) | |
59 { | |
60 if (buffer) | |
61 { | |
62 buffer[termpos] = '\0'; | |
63 | |
64 if (strlen(buffer) > 0) | |
65 { | |
66 queue = g_list_append(queue, buffer); | |
67 } | |
68 else | |
69 { | |
70 g_free(buffer); | |
71 } | |
72 | |
73 buffer = NULL; | |
74 } | |
75 } | |
76 | |
77 if (error) | |
78 { | |
79 printf("error reading socket: %s\n", error->message); | |
80 g_error_free(error); | |
81 } | |
82 | |
83 work = queue; | |
84 while (work) | |
85 { | |
86 gchar *command = work->data; | |
87 work = work->next; | |
88 | |
89 if (rc->read_func) rc->read_func(rc, command, rc->read_data); | |
90 g_free(command); | |
91 } | |
92 | |
93 g_list_free(queue); | |
94 } | |
95 | |
96 if (condition & G_IO_HUP) | |
97 { | |
98 rc->clients = g_list_remove(rc->clients, client); | |
99 | |
495 | 100 DEBUG_1("HUP detected, closing client.\nclient count %d\n", g_list_length(rc->clients)); |
101 | |
9 | 102 g_source_remove(client->channel_id); |
103 close(client->fd); | |
104 g_free(client); | |
105 } | |
106 | |
107 return TRUE; | |
108 } | |
109 | |
110 static void remote_server_client_add(RemoteConnection *rc, int fd) | |
111 { | |
112 RemoteClient *client; | |
113 GIOChannel *channel; | |
114 | |
115 if (g_list_length(rc->clients) > SERVER_MAX_CLIENTS) | |
116 { | |
117 printf("maximum remote clients of %d exceeded, closing connection\n", SERVER_MAX_CLIENTS); | |
118 close(fd); | |
119 return; | |
120 } | |
121 | |
122 client = g_new0(RemoteClient, 1); | |
123 client->rc = rc; | |
124 client->fd = fd; | |
125 | |
126 channel = g_io_channel_unix_new(fd); | |
127 client->channel_id = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, G_IO_IN | G_IO_HUP, | |
128 remote_server_client_cb, client, NULL); | |
129 g_io_channel_unref(channel); | |
130 | |
131 rc->clients = g_list_append(rc->clients, client); | |
495 | 132 DEBUG_1("client count %d\n", g_list_length(rc->clients)); |
9 | 133 } |
134 | |
135 static void remote_server_clients_close(RemoteConnection *rc) | |
136 { | |
137 while (rc->clients) | |
138 { | |
139 RemoteClient *client = rc->clients->data; | |
140 | |
141 rc->clients = g_list_remove(rc->clients, client); | |
142 | |
143 g_source_remove(client->channel_id); | |
144 close(client->fd); | |
145 g_free(client); | |
146 } | |
147 } | |
148 | |
149 static gboolean remote_server_read_cb(GIOChannel *source, GIOCondition condition, gpointer data) | |
150 { | |
151 RemoteConnection *rc = data; | |
152 int fd; | |
64
04ff0df3ad2f
Mon Aug 15 17:13:57 2005 John Ellis <johne@verizon.net>
gqview
parents:
9
diff
changeset
|
153 unsigned int alen; |
9 | 154 |
155 fd = accept(rc->fd, NULL, &alen); | |
156 if (fd == -1) | |
157 { | |
158 printf("error accepting socket: %s\n", strerror(errno)); | |
159 return TRUE; | |
160 } | |
161 | |
162 remote_server_client_add(rc, fd); | |
163 | |
164 return TRUE; | |
165 } | |
166 | |
167 static gint remote_server_exists(const gchar *path) | |
168 { | |
169 RemoteConnection *rc; | |
170 | |
171 /* verify server up */ | |
172 rc = remote_client_open(path); | |
173 remote_close(rc); | |
174 | |
175 if (rc) return TRUE; | |
176 | |
177 /* unable to connect, remove socket file to free up address */ | |
178 unlink(path); | |
179 return FALSE; | |
180 } | |
181 | |
182 RemoteConnection *remote_server_open(const gchar *path) | |
183 { | |
184 RemoteConnection *rc; | |
185 struct sockaddr_un addr; | |
186 gint sun_path_len; | |
187 int fd; | |
188 GIOChannel *channel; | |
189 | |
190 if (remote_server_exists(path)) | |
191 { | |
192 printf("Address already in use: %s\n", path); | |
193 return NULL; | |
194 } | |
195 | |
196 fd = socket(PF_UNIX, SOCK_STREAM, 0); | |
197 if (fd == -1) return NULL; | |
198 | |
199 addr.sun_family = AF_UNIX; | |
200 sun_path_len = MIN(strlen(path) + 1, UNIX_PATH_MAX); | |
201 strncpy(addr.sun_path, path, sun_path_len); | |
202 if (bind(fd, &addr, sizeof(addr)) == -1 || | |
203 listen(fd, REMOTE_SERVER_BACKLOG) == -1) | |
204 { | |
205 printf("error subscribing to socket: %s\n", strerror(errno)); | |
206 close(fd); | |
207 return NULL; | |
208 } | |
209 | |
210 rc = g_new0(RemoteConnection, 1); | |
211 rc->server = TRUE; | |
212 rc->fd = fd; | |
213 rc->path = g_strdup(path); | |
214 | |
215 rc->read_func = NULL; | |
216 rc->read_data = NULL; | |
217 | |
218 rc->clients = NULL; | |
219 | |
220 channel = g_io_channel_unix_new(rc->fd); | |
221 rc->channel_id = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, G_IO_IN, | |
222 remote_server_read_cb, rc, NULL); | |
223 g_io_channel_unref(channel); | |
224 | |
225 return rc; | |
226 } | |
227 | |
228 void remote_server_subscribe(RemoteConnection *rc, RemoteReadFunc *func, gpointer data) | |
229 { | |
230 if (!rc || !rc->server) return; | |
231 | |
232 rc->read_func = func; | |
233 rc->read_data = data; | |
234 } | |
235 | |
236 | |
237 RemoteConnection *remote_client_open(const gchar *path) | |
238 { | |
239 RemoteConnection *rc; | |
240 struct stat st; | |
241 struct sockaddr_un addr; | |
242 gint sun_path_len; | |
243 int fd; | |
244 | |
245 if (stat(path, &st) != 0 || !S_ISSOCK(st.st_mode)) return NULL; | |
246 | |
247 fd = socket(PF_UNIX, SOCK_STREAM, 0); | |
248 if (fd == -1) return NULL; | |
249 | |
250 addr.sun_family = AF_UNIX; | |
251 sun_path_len = MIN(strlen(path) + 1, UNIX_PATH_MAX); | |
252 strncpy(addr.sun_path, path, sun_path_len); | |
253 if (connect(fd, &addr, sizeof(addr)) == -1) | |
442 | 254 { |
495 | 255 DEBUG_1("error connecting to socket: %s\n", strerror(errno)); |
442 | 256 close(fd); |
257 return NULL; | |
258 } | |
9 | 259 |
260 rc = g_new0(RemoteConnection, 1); | |
261 rc->server = FALSE; | |
262 rc->fd = fd; | |
263 rc->path = g_strdup(path); | |
264 | |
371
7997b6704fdb
this might fix the freezes on freebsd, solaris, etc.
nadvornik
parents:
281
diff
changeset
|
265 /* this might fix the freezes on freebsd, solaris, etc. - completely untested */ |
442 | 266 remote_client_send(rc, "\n"); |
371
7997b6704fdb
this might fix the freezes on freebsd, solaris, etc.
nadvornik
parents:
281
diff
changeset
|
267 |
9 | 268 return rc; |
269 } | |
270 | |
271 static sig_atomic_t sigpipe_occured = FALSE; | |
272 | |
273 static void sighandler_sigpipe(int sig) | |
274 { | |
275 sigpipe_occured = TRUE; | |
276 } | |
277 | |
278 gint remote_client_send(RemoteConnection *rc, const gchar *text) | |
279 { | |
280 struct sigaction new_action, old_action; | |
281 gint ret = FALSE; | |
282 | |
283 if (!rc || rc->server) return FALSE; | |
284 if (!text) return TRUE; | |
285 | |
286 sigpipe_occured = FALSE; | |
287 | |
288 new_action.sa_handler = sighandler_sigpipe; | |
289 sigemptyset (&new_action.sa_mask); | |
290 new_action.sa_flags = 0; | |
291 | |
292 /* setup our signal handler */ | |
293 sigaction (SIGPIPE, &new_action, &old_action); | |
294 | |
295 if (write(rc->fd, text, strlen(text)) == -1 || | |
296 write(rc->fd, "\n", 1) == -1) | |
297 { | |
298 if (sigpipe_occured) | |
299 { | |
300 printf("SIGPIPE writing to socket: %s\n", rc->path); | |
301 } | |
302 else | |
303 { | |
304 printf("error writing to socket: %s\n", strerror(errno)); | |
305 } | |
306 ret = FALSE;; | |
307 } | |
308 else | |
309 { | |
310 ret = TRUE; | |
311 } | |
312 | |
313 /* restore the original signal handler */ | |
314 sigaction (SIGPIPE, &old_action, NULL); | |
315 | |
316 return ret; | |
317 } | |
318 | |
319 void remote_close(RemoteConnection *rc) | |
320 { | |
321 if (!rc) return; | |
322 | |
323 if (rc->server) | |
324 { | |
325 remote_server_clients_close(rc); | |
326 | |
327 g_source_remove(rc->channel_id); | |
328 unlink(rc->path); | |
329 } | |
330 | |
331 close(rc->fd); | |
332 | |
333 g_free(rc->path); | |
334 g_free(rc); | |
335 } |