|
8
|
1 #include <stdio.h>
|
|
|
2 #include <strings.h>
|
|
|
3 #include <stdlib.h>
|
|
|
4 #include <sys/types.h>
|
|
|
5 #include <sys/socket.h>
|
|
|
6 #include <netinet/in.h>
|
|
|
7 #include <netdb.h>
|
|
|
8 #include <unistd.h>
|
|
|
9 #include <errno.h>
|
|
|
10
|
|
|
11 #include "vim.h"
|
|
|
12 #include "reditor.h"
|
|
|
13
|
|
|
14 /* Global variables of Vim */
|
|
|
15 #include "globals.h"
|
|
|
16
|
|
|
17 /* Wrapper for Vim */
|
|
|
18 static void e_msg_wrp(char *msg);
|
|
|
19 static void e_msg2_wrp(char *msg1, char *msg2);
|
|
|
20 static void puts_msg_wrpt(char *msg);
|
|
|
21 static void free_wrp(void *p);
|
|
|
22 static BUFTYPE* make_new_buf_wrp(char *name);
|
|
|
23 static void free_buf_wrp(BUFTYPE *buf);
|
|
|
24 static BUFTYPE* find_buf_by_name_wrp(char *name);
|
|
|
25 static void open_buffer_memline_wrp(BUFTYPE *buf);
|
|
|
26 static BUFTYPE* get_curbuf_wrp();
|
|
|
27 static BUFTYPE* set_curbuf_wrp(BUFTYPE *buf);
|
|
|
28 static char* get_memline_wrp(BUFTYPE *buf, long lnum);
|
|
|
29 static int append_memline_wrp(long lnum, char *text);
|
|
|
30 static int delete_memline_wrp(long lnum);
|
|
|
31 static int replace_memline_wrp(long lnum, char *text);
|
|
|
32 static void update_screen_now_wrp();
|
|
|
33 static void update_screen_later_wrp(BUFTYPE *buf);
|
|
|
34 static long get_bufmaxline_wrp(BUFTYPE* buf);
|
|
|
35 static char* getstr_input_wrp(char *msg);
|
|
|
36 static char *get_fullpath_wrp(BUFTYPE *buf);
|
|
|
37 static char *get_shortname_wrp(BUFTYPE *buf);
|
|
|
38 /* Wrapper END */
|
|
|
39
|
|
|
40
|
|
|
41 static rep_T* get_rep();
|
|
|
42
|
|
|
43 static int del_ignored_cmd(rep_cmdlist *cmdlist);
|
|
|
44 static int translate(rep_cmdlist *userlist, rep_cmdlist *tokenlist);
|
|
|
45 static void set_header_to_pkt(rep_cmdlist *cmdlist);
|
|
|
46 static int rep_get_listened_fd();
|
|
|
47 static int set_hostnamebysock(int sock, char *hostname, int maxlen);
|
|
|
48 static int rep_accept();
|
|
|
49 static int rep_connect(char *host);
|
|
|
50
|
|
|
51 static void* rep_alloc(int size);
|
|
|
52 static void rep_free(void *obj);
|
|
|
53
|
|
|
54 static BUFTYPE* get_buf_by_name(char *name);
|
|
|
55 static Session* init_session(Session *sn);
|
|
|
56 static Session* make_session(char *name, BUFTYPE *buf);
|
|
|
57 static void free_session(Session *sn);
|
|
|
58 static void free_session_list(Session *head);
|
|
|
59 static void register_session(Session *sn);
|
|
|
60 static Session* set_cursession(Session *sn);
|
|
|
61 static Session* find_session_by_buf(BUFTYPE *buf);
|
|
|
62 static Session* find_session_by_name(char *name);
|
|
|
63 static int set_session_info(char *dest_sinfo, char *sname, char *hostname, int port);
|
|
|
64 static char* get_fullpath(Session *session);
|
|
|
65 static char* get_shortname(Session *session);
|
|
|
66
|
|
|
67 static int make_local_slineup(Session *slineup,
|
|
|
68 char *hostname,
|
|
|
69 Session *my_sessions);
|
|
|
70 static int get_slineup_from_sm(char *servername,
|
|
|
71 Session *slineup,
|
|
|
72 char *hostname,
|
|
|
73 Session *my_sessions);
|
|
|
74 static char* get_sname_by_snum(int snum);
|
|
|
75 static int writen(int fd, char *textbuf, unsigned int len);
|
|
|
76
|
|
|
77 static char* make_packet(unsigned int cmd,
|
|
|
78 unsigned int sid,
|
|
|
79 unsigned int eid,
|
|
|
80 unsigned int seq,
|
|
|
81 unsigned int lnum,
|
|
|
82 char *text);
|
|
|
83 static char* make_open_packet(char *file_name);
|
|
|
84 static rep_cmd* make_cmd(unsigned int cmd,
|
|
|
85 unsigned int sid,
|
|
|
86 unsigned int eid,
|
|
|
87 unsigned int seq,
|
|
|
88 unsigned int lnum,
|
|
|
89 char *text);
|
|
|
90 static int free_cmd(rep_cmd *cmd);
|
|
|
91 static int free_cmdlist(rep_cmdlist *cmdlist);
|
|
|
92 static void add_cmd_to_list(rep_cmdlist *cmdlist, rep_cmd *cmd);
|
|
|
93 static int add_pkt_to_list(rep_cmdlist *cmdlist, char *pkt);
|
|
|
94
|
|
|
95 static void check_line_change(Session *sn, unsigned int lnum);
|
|
|
96
|
|
|
97 static unsigned int get_header(char *buf,int offset);
|
|
|
98 static int set_header(unsigned int num, char *pkt, int offset);
|
|
|
99
|
|
|
100 static int rep_exe_cmd(unsigned int cmd,
|
|
|
101 unsigned int sid,
|
|
|
102 unsigned int eid,
|
|
|
103 unsigned int seq,
|
|
|
104 unsigned int lnum,
|
|
|
105 unsigned int textsize,
|
|
|
106 char *text);
|
|
|
107 static int rep_exe_pkt(char *pkt);
|
|
|
108 static int rep_exe_pktlist(rep_cmdlist *cmdlist);
|
|
|
109 static int rep_exe_cmdlist(rep_cmdlist *cmdlist);
|
|
|
110
|
|
|
111 static int rep_recv_cmds(int fd, rep_cmdlist *smcmdlist,rep_cmdlist *txtcmdlist);
|
|
|
112 static int rep_send_cmds(int fd, rep_cmdlist *cmdlist);
|
|
|
113
|
|
|
114 static int session_fd_check(Session *sn, fd_set *rfds_p, fd_set *efds_p);
|
|
|
115 static int session_fd_set(Session *sn, fd_set *rfds_p, fd_set *efds_p, int max_fds);
|
|
|
116 static int append_newline_sep_text(Session *sn, char *text);
|
|
|
117
|
|
|
118 /* g_rep has an all information of Remote Editor */
|
|
|
119 rep_T g_rep;
|
|
|
120
|
|
|
121
|
|
|
122
|
|
|
123 /*
|
|
|
124 * Wrapper for vim
|
|
|
125 */
|
|
|
126
|
|
|
127 /* エラーメッセージ出力 */
|
|
|
128 static void
|
|
|
129 e_msg_wrp(msg)
|
|
|
130 char * msg;
|
|
|
131 {
|
|
|
132 EMSG(msg);
|
|
|
133 }
|
|
|
134
|
|
|
135 static void
|
|
|
136 e_msg2_wrp(msg1, msg2)
|
|
|
137 char * msg1;
|
|
|
138 char * msg2;
|
|
|
139 {
|
|
|
140 EMSG2(msg1,msg2);
|
|
|
141 }
|
|
|
142
|
|
|
143 /* 通常のメッセージを出力 */
|
|
|
144 static void
|
|
|
145 puts_msg_wrp(msg)
|
|
|
146 char * msg;
|
|
|
147 {
|
|
|
148 MSG_PUTS(msg);
|
|
|
149 }
|
|
|
150
|
|
|
151 static void
|
|
|
152 free_wrp(p)
|
|
|
153 void *p;
|
|
|
154 {
|
|
|
155 vim_free(p);
|
|
|
156 return;
|
|
|
157 }
|
|
|
158
|
|
|
159
|
|
|
160 /* 空の新しいバッファを取得 */
|
|
|
161 static BUFTYPE *
|
|
|
162 make_new_buf_wrp(name)
|
|
|
163 char * name;
|
|
|
164 {
|
|
|
165 return buflist_new((char_u*)name, NULL, 0, BLN_LISTED);
|
|
|
166 }
|
|
|
167
|
|
|
168 static void
|
|
|
169 free_buf_wrp(buf)
|
|
|
170 BUFTYPE *buf;
|
|
|
171 {
|
|
|
172 close_buffer(NULL, buf, DOBUF_DEL);
|
|
|
173 return;
|
|
|
174 }
|
|
|
175
|
|
|
176
|
|
|
177 /* 名前からバッファへのポインタを取得 */
|
|
|
178 static BUFTYPE *
|
|
|
179 find_buf_by_name_wrp(name)
|
|
|
180 char * name;
|
|
|
181 {
|
|
|
182 char *sfname = NULL; // sfname is used name's address
|
|
|
183 BUFTYPE *buf;
|
|
|
184 BUFTYPE *orgbuf;
|
|
|
185
|
|
|
186 /* make a full file name. name is changed to absolute path.
|
|
|
187 * name's address is assigned to sfname. */
|
|
|
188 fname_expand(buf, (char_u**)&name, (char_u**)&sfname);
|
|
|
189 buf = buflist_findname((char_u*)name);
|
|
|
190
|
|
|
191 free_wrp(name);
|
|
|
192 return buf;
|
|
|
193 }
|
|
|
194
|
|
|
195 static void
|
|
|
196 open_buffer_memline_wrp(buf)
|
|
|
197 BUFTYPE *buf;
|
|
|
198 {
|
|
|
199 BUFTYPE *oldbuf;
|
|
|
200 /*
|
|
|
201 oldbuf = set_curbuf_wrp(buf);
|
|
|
202 set_curbuf_wrp(oldbuf);
|
|
|
203 */
|
|
|
204 oldbuf = curbuf;
|
|
|
205 curbuf = buf;
|
|
|
206 open_buffer(FALSE, NULL);
|
|
|
207 curbuf = oldbuf;
|
|
|
208 return;
|
|
|
209 }
|
|
|
210
|
|
|
211
|
|
|
212 /* 現在編集中のバッファへのポインタを取得 */
|
|
|
213 extern BUFTYPE *curbuf;
|
|
|
214 static BUFTYPE *
|
|
|
215 get_curbuf_wrp()
|
|
|
216 {
|
|
|
217 return curbuf;
|
|
|
218 }
|
|
|
219
|
|
|
220 /* buf を編集対象にする。
|
|
|
221 *それまで編集対象だったバッファへのポインタを返す */
|
|
|
222 static BUFTYPE *
|
|
|
223 set_curbuf_wrp(buf)
|
|
|
224 BUFTYPE *buf;
|
|
|
225 {
|
|
|
226 BUFTYPE *cb;
|
|
|
227 if (buf == NULL)
|
|
|
228 return NULL;
|
|
|
229
|
|
|
230 cb = get_curbuf_wrp();
|
|
|
231 set_curbuf(buf,DOBUF_GOTO);
|
|
|
232
|
|
|
233 return cb;
|
|
|
234 }
|
|
|
235
|
|
|
236 /* 指定した行番号の行のテキスト(文字列)のポインタを取得 */
|
|
|
237 static char *
|
|
|
238 get_memline_wrp(buf, lnum)
|
|
|
239 BUFTYPE *buf; // buf is curbuf
|
|
|
240 long lnum;
|
|
|
241 {
|
|
|
242 // return ml_get(lnum);
|
|
|
243 return (char*)ml_get_buf(buf, lnum, FALSE);
|
|
|
244 }
|
|
|
245
|
|
|
246 /* 編集中のバッファの行の挿入 */
|
|
|
247 /* "text" does NOT need to be allocated */
|
|
|
248 static int
|
|
|
249 append_memline_wrp(lnum, text)
|
|
|
250 long lnum;
|
|
|
251 char *text;
|
|
|
252 {
|
|
|
253 int r;
|
|
|
254 int permit;
|
|
|
255 rep_T *rep;
|
|
|
256 rep = get_rep();
|
|
|
257 permit = rep->permit;
|
|
|
258 rep->permit = FALSE;
|
|
|
259
|
|
|
260 r = ml_append(lnum-1, (char_u*)text, strlen(text)+1, FALSE);
|
|
|
261 appended_lines_mark(lnum-1,1);
|
|
|
262
|
|
|
263 rep->permit = permit;
|
|
|
264 return r;
|
|
|
265 }
|
|
|
266
|
|
|
267 /* 編集中のバッファの行の削除 */
|
|
|
268 static int
|
|
|
269 delete_memline_wrp(lnum)
|
|
|
270 long lnum;
|
|
|
271 {
|
|
|
272 int r;
|
|
|
273 int permit;
|
|
|
274 rep_T *rep;
|
|
|
275 rep = get_rep();
|
|
|
276 permit = rep->permit;
|
|
|
277 rep->permit = FALSE;
|
|
|
278
|
|
|
279 r = ml_delete(lnum, FALSE);
|
|
|
280 deleted_lines_mark(lnum,1);
|
|
|
281
|
|
|
282 rep->permit = permit;
|
|
|
283 return r;
|
|
|
284 }
|
|
|
285
|
|
|
286 /* 編集中のバッファの行の置換 */
|
|
|
287 static int
|
|
|
288 replace_memline_wrp(lnum, text)
|
|
|
289 long lnum;
|
|
|
290 char * text;
|
|
|
291 {
|
|
|
292 int r;
|
|
|
293 int permit;
|
|
|
294 rep_T *rep;
|
|
|
295 rep = get_rep();
|
|
|
296 permit = rep->permit;
|
|
|
297 rep->permit = FALSE;
|
|
|
298
|
|
|
299 r = ml_replace(lnum, (char_u*)text, TRUE);
|
|
|
300
|
|
|
301 rep->permit = permit;
|
|
|
302 return r;
|
|
|
303 }
|
|
|
304
|
|
|
305 /* バッファの編集後の後処理 */
|
|
|
306 static void
|
|
|
307 update_screen_now_wrp()
|
|
|
308 {
|
|
|
309 check_cursor();
|
|
|
310 update_screen(CLEAR);
|
|
|
311 return;
|
|
|
312 }
|
|
|
313
|
|
|
314 static void
|
|
|
315 update_screen_later_wrp(buf)
|
|
|
316 BUFTYPE *buf;
|
|
|
317 {
|
|
|
318 check_cursor();
|
|
|
319 return redraw_buf_later(buf, CLEAR);
|
|
|
320 }
|
|
|
321
|
|
|
322 /* 編集中のバッファの行数を返す */
|
|
|
323 static long
|
|
|
324 get_bufmaxline_wrp(buf)
|
|
|
325 BUFTYPE *buf;
|
|
|
326 {
|
|
|
327 return buf->b_ml.ml_line_count;
|
|
|
328 }
|
|
|
329
|
|
|
330 /* XXX もう使わないので消す予定 */
|
|
|
331 /* ユーザに文字列を入力させる */
|
|
|
332 static char *
|
|
|
333 getstr_input_wrp(msg)
|
|
|
334 char *msg; // 入力時のメッセージ
|
|
|
335 {
|
|
|
336 char *cmdline;
|
|
|
337
|
|
|
338 /* 受け取る文字列は使用後 vim_free() する */
|
|
|
339 // cmdline = (char*)getcmdline_prompt('@', (char_u*)msg, 0);
|
|
|
340 cmdline = NULL;
|
|
|
341
|
|
|
342 return cmdline;
|
|
|
343 }
|
|
|
344
|
|
|
345 /* get full path of buffer */
|
|
|
346 static char *
|
|
|
347 get_fullpath_wrp(buf)
|
|
|
348 BUFTYPE *buf;
|
|
|
349 {
|
|
|
350 return (char*)buf->b_ffname;
|
|
|
351 }
|
|
|
352
|
|
|
353 /* get short name of buffer */
|
|
|
354 static char *
|
|
|
355 get_shortname_wrp(buf)
|
|
|
356 BUFTYPE *buf;
|
|
|
357 {
|
|
|
358 return (char*)buf->b_sfname;
|
|
|
359 }
|
|
|
360
|
|
|
361 /* Wrapper END */
|
|
|
362
|
|
|
363
|
|
|
364 static void
|
|
|
365 puts_sys_err()
|
|
|
366 {
|
|
|
367 char errmsg[50];
|
|
|
368
|
|
|
369 sprintf(errmsg, "rep>> %d:%s", errno, strerror(errno));
|
|
|
370 e_msg_wrp(errmsg);
|
|
|
371 return;
|
|
|
372 }
|
|
|
373
|
|
|
374
|
|
|
375 static rep_T*
|
|
|
376 get_rep()
|
|
|
377 {
|
|
|
378 return(&g_rep);
|
|
|
379 }
|
|
|
380
|
|
|
381 int
|
|
|
382 rep_permit()
|
|
|
383 {
|
|
|
384 return(g_rep.permit);
|
|
|
385 }
|
|
|
386
|
|
|
387 int
|
|
|
388 rep_session_permit()
|
|
|
389 {
|
|
|
390 return(g_rep.permit && g_rep.cursession && g_rep.cursession->permit);
|
|
|
391 }
|
|
|
392
|
|
|
393 void
|
|
|
394 rep_start_create_cmds()
|
|
|
395 {
|
|
|
396 if (g_rep.cursession) {
|
|
|
397 g_rep.cursession->permit = TRUE;
|
|
|
398 }
|
|
|
399 return;
|
|
|
400 }
|
|
|
401
|
|
|
402 void
|
|
|
403 rep_stop_create_cmds()
|
|
|
404 {
|
|
|
405 if (g_rep.cursession) {
|
|
|
406 g_rep.cursession->permit = FALSE;
|
|
|
407 }
|
|
|
408 return;
|
|
|
409 }
|
|
|
410
|
|
|
411
|
|
|
412 int
|
|
|
413 rep_init()
|
|
|
414 {
|
|
|
415 /*
|
|
|
416 * g_rep is global variable and it is zero cleared.
|
|
|
417 */
|
|
|
418
|
|
|
419 char def_hostname[] = "localhost";
|
|
|
420
|
|
|
421 // 現在編集対象のバッファはセッションに加える?
|
|
|
422 g_rep.shead = NULL; //make_session();
|
|
|
423 g_rep.slineup = NULL;
|
|
|
424
|
|
|
425 g_rep.cursession = NULL;
|
|
|
426 g_rep.servername = NULL;
|
|
|
427 g_rep.waiting_session_name = NULL;
|
|
|
428
|
|
|
429 g_rep.smfd = -1;
|
|
|
430
|
|
|
431 g_rep.eid = 0;
|
|
|
432 g_rep.seqno = 0;
|
|
|
433
|
|
|
434 g_rep.permit = FALSE;
|
|
|
435
|
|
|
436 if (gethostname(g_rep.hostname, sizeof(g_rep.hostname)) < 0) {
|
|
|
437 strncpy(g_rep.hostname, def_hostname, sizeof(def_hostname)+1);
|
|
|
438 }
|
|
|
439
|
|
|
440 return(TRUE);
|
|
|
441 }
|
|
|
442
|
|
|
443
|
|
|
444 /*
|
|
|
445 * cmdlistを辿り、statメンバが REP_IGNORE であるREPコマンドを削除する。
|
|
|
446 */
|
|
|
447 static int
|
|
|
448 del_ignored_cmd(cmdlist)
|
|
|
449 rep_cmdlist *cmdlist;
|
|
|
450 {
|
|
|
451 rep_cmd *curcmd;
|
|
|
452 rep_cmd *next;
|
|
|
453
|
|
|
454 for (;(cmdlist->head) && (cmdlist->head->stat == REP_IGNORE); cmdlist->head=next) {
|
|
|
455 next = cmdlist->head->next;
|
|
|
456 free_cmd(cmdlist->head);
|
|
|
457 }
|
|
|
458
|
|
|
459 if (cmdlist->head == NULL) return(TRUE);
|
|
|
460
|
|
|
461 for (curcmd=cmdlist->head; curcmd->next;) {
|
|
|
462 next = curcmd->next->next;
|
|
|
463 if (curcmd->next->stat == REP_IGNORE) {
|
|
|
464 free_cmd(curcmd->next);
|
|
|
465 curcmd->next = next;
|
|
|
466 cmdlist->num--;
|
|
|
467 } else {
|
|
|
468 curcmd = curcmd->next;
|
|
|
469 }
|
|
|
470 }
|
|
|
471 return(TRUE);
|
|
|
472 }
|
|
|
473
|
|
|
474
|
|
|
475 /***** translate(UserList, ToknList) *****
|
|
|
476 入力はトークンとユーザ入力からのREPコマンドのリストで、
|
|
|
477 それらを比較・変換して、二つのREPコマンドリストを生成する。
|
|
|
478
|
|
|
479 -------------
|
|
|
480 UserList ->| | -> UserList'
|
|
|
481 | translate |
|
|
|
482 ToknList ->| | -> ToknList'
|
|
|
483 -------------
|
|
|
484
|
|
|
485 Session ID が異なるときは、可換なので、何もしない。
|
|
|
486
|
|
|
487 ToknList + UserList' をトークンとして次のリモートエディタに渡し、
|
|
|
488 ToknList' は自分のバッファに反映させる。
|
|
|
489
|
|
|
490 比較時に行番号が重なったときの処理は以下の表。
|
|
|
491 なるべくテキストが残るようにしている。
|
|
|
492 x\y は、TOKEN を x, USER を y するという意味。
|
|
|
493 0 -- なにもしない
|
|
|
494 +1 -- 行番号を +1
|
|
|
495 i -- コマンド id を 'i' にする。
|
|
|
496 X -- コマンドを削除(無視に)する。
|
|
|
497
|
|
|
498 USER
|
|
|
499 | i | r | d
|
|
|
500 ---|--------------------
|
|
|
501 T i | 0\+1 | 0\+1 | 0\+1
|
|
|
502 O ---|--------------------
|
|
|
503 K r | +1\0 | 0\X | i\X
|
|
|
504 E ---|--------------------
|
|
|
505 N d | +1\0 | X\i | X\X
|
|
|
506
|
|
|
507 無視にされた(stat に REP_IGNORE が入っている)REPコマンドは、
|
|
|
508 全ての比較が終了したときにリストから削除される。
|
|
|
509 */
|
|
|
510 static int
|
|
|
511 translate(userlist, tokenlist) /* userのREPコマンドリスト, tokenのREPコマンドリスト */
|
|
|
512 rep_cmdlist *userlist;
|
|
|
513 rep_cmdlist *tokenlist;
|
|
|
514 {
|
|
|
515 rep_cmd *usercmd;
|
|
|
516 rep_cmd *tokencmd;
|
|
|
517 rep_cmd *unext;
|
|
|
518 rep_cmd *tnext;
|
|
|
519
|
|
|
520 rep_cmd *h_pricmd; // high priority command
|
|
|
521 rep_cmd *l_pricmd; // low priority command
|
|
|
522
|
|
|
523 for (usercmd=userlist->head; usercmd; usercmd=unext) {
|
|
|
524 unext = usercmd->next;
|
|
|
525
|
|
|
526 /* 削除される(予定)のREPコマンドの比較は無視 */
|
|
|
527 if (usercmd->stat == REP_IGNORE) continue;
|
|
|
528
|
|
|
529 for (tokencmd=tokenlist->head; tokencmd; tokencmd=tnext) {
|
|
|
530 tnext=tokencmd->next;
|
|
|
531
|
|
|
532 /* 削除される(予定)のREPコマンドの比較は無視 */
|
|
|
533 if (tokencmd->stat == REP_IGNORE) continue;
|
|
|
534 /* XXX 消してもいい？?*/
|
|
|
535 if ( tokencmd->cmd != REP_INSERT_CMD &&
|
|
|
536 tokencmd->cmd != REP_DELETE_LINE_CMD &&
|
|
|
537 tokencmd->cmd != REP_REPLACE_CMD) {
|
|
|
538 tokencmd->stat = REP_IGNORE;
|
|
|
539 continue;
|
|
|
540 }
|
|
|
541 if (usercmd->stat == REP_IGNORE) break;
|
|
|
542 if ( usercmd->cmd != REP_INSERT_CMD &&
|
|
|
543 usercmd->cmd != REP_DELETE_LINE_CMD &&
|
|
|
544 usercmd->cmd != REP_REPLACE_CMD) {
|
|
|
545 usercmd->stat = REP_IGNORE;
|
|
|
546 break;
|
|
|
547 }
|
|
|
548 if (usercmd->sid != tokencmd->sid) {
|
|
|
549 // session id が違う場合は何しない
|
|
|
550 continue;
|
|
|
551 }
|
|
|
552 if (usercmd->lnum < tokencmd->lnum) { /* UsersLineNumber < TokensLineNumber */
|
|
|
553 if (usercmd->cmd == REP_INSERT_CMD) {
|
|
|
554 tokencmd->lnum++;
|
|
|
555 } else if (usercmd->cmd == REP_DELETE_LINE_CMD) {
|
|
|
556 tokencmd->lnum--;
|
|
|
557 }
|
|
|
558 } else if (usercmd->lnum > tokencmd->lnum) { /* UsersLineNumber > TokensLineNumber */
|
|
|
559 if (tokencmd->cmd == REP_INSERT_CMD) {
|
|
|
560 usercmd->lnum++;
|
|
|
561 } else if (tokencmd->cmd == REP_DELETE_LINE_CMD) {
|
|
|
562 usercmd->lnum--;
|
|
|
563 }
|
|
|
564 } else if (usercmd->lnum == tokencmd->lnum) { /* UsersLineNumber == TokensLineNumber */
|
|
|
565
|
|
|
566 #if 0
|
|
|
567 /*
|
|
|
568 * 行番号が重なるとREPコマンドの競合が起こるので、
|
|
|
569 * どちらかが譲らないといけない。
|
|
|
570 * uid が小さい方を優先(h_pricmdに)し、
|
|
|
571 * uid が大きい方(l_pricmd)を変更する。
|
|
|
572 */
|
|
|
573
|
|
|
574 if (usercmd->eid < tokencmd->eid) {
|
|
|
575 h_pricmd = usercmd;
|
|
|
576 l_pricmd = tokencmd;
|
|
|
577 } else {
|
|
|
578 h_pricmd = tokencmd;
|
|
|
579 l_pricmd = usercmd;
|
|
|
580 }
|
|
|
581 #else
|
|
|
582 /*
|
|
|
583 無条件に、自分の方が優先
|
|
|
584 */
|
|
|
585 h_pricmd = usercmd;
|
|
|
586 l_pricmd = tokencmd;
|
|
|
587 #endif
|
|
|
588
|
|
|
589 if (h_pricmd->cmd == REP_INSERT_CMD) {
|
|
|
590 l_pricmd->lnum++;
|
|
|
591 } else if (h_pricmd->cmd == REP_REPLACE_CMD) {
|
|
|
592
|
|
|
593 if (l_pricmd->cmd == REP_INSERT_CMD) {
|
|
|
594 h_pricmd->lnum++;
|
|
|
595 } else if (l_pricmd->cmd == REP_REPLACE_CMD) {
|
|
|
596 /* h_pricmd が優先され,l_pricmd は削除(無視に)する */
|
|
|
597 l_pricmd->stat = REP_IGNORE;
|
|
|
598 } else if (l_pricmd->cmd == REP_DELETE_LINE_CMD) {
|
|
|
599 /*
|
|
|
600 * l_pricmd 側ではすでにdeleteされているので、
|
|
|
601 * h_pricmd を REP_REPLACE_CMD -> REP_INSERT_CMD へ変更。
|
|
|
602 */
|
|
|
603 h_pricmd->cmd = REP_INSERT_CMD;
|
|
|
604 l_pricmd->stat = REP_IGNORE;
|
|
|
605 }
|
|
|
606
|
|
|
607 } else if (h_pricmd->cmd == REP_DELETE_LINE_CMD) {
|
|
|
608
|
|
|
609 if (l_pricmd->cmd == REP_INSERT_CMD) {
|
|
|
610 h_pricmd->lnum++;
|
|
|
611 } else if (l_pricmd->cmd == REP_REPLACE_CMD) {
|
|
|
612 /*
|
|
|
613 * h_pricmd 側ではすでにdeleteされているので、
|
|
|
614 * l_pricmd 側を REP_REPLACE_CMD -> REP_INSERT_CMD へ変更。
|
|
|
615 */
|
|
|
616 l_pricmd->cmd = REP_INSERT_CMD;
|
|
|
617 h_pricmd->stat= REP_IGNORE;
|
|
|
618 } else if (l_pricmd->cmd == REP_DELETE_LINE_CMD) {
|
|
|
619 /*
|
|
|
620 * 相手と削除する行が重なるので、
|
|
|
621 * 両方のコマンドを無視にする。
|
|
|
622 * 相手先ではすでにこの行は削除されている。
|
|
|
623 */
|
|
|
624 h_pricmd->stat = REP_IGNORE;
|
|
|
625 l_pricmd->stat = REP_IGNORE;
|
|
|
626 break;
|
|
|
627 } else {
|
|
|
628 }
|
|
|
629 } else {
|
|
|
630 }
|
|
|
631 }
|
|
|
632 }
|
|
|
633 }
|
|
|
634
|
|
|
635 return(TRUE);
|
|
|
636 }
|
|
|
637
|
|
|
638
|
|
|
639 static void
|
|
|
640 set_header_to_pkt(cmdlist)
|
|
|
641 rep_cmdlist *cmdlist;
|
|
|
642 {
|
|
|
643 rep_cmd *curcmd;
|
|
|
644 for (curcmd=cmdlist->head; curcmd; curcmd=curcmd->next) {
|
|
|
645 set_header(curcmd->cmd, curcmd->pkt, REP_CMD_OFFSET);
|
|
|
646 set_header(curcmd->sid, curcmd->pkt, REP_SID_OFFSET);
|
|
|
647 set_header(curcmd->eid, curcmd->pkt, REP_EID_OFFSET);
|
|
|
648 set_header(curcmd->seq, curcmd->pkt, REP_SEQNUM_OFFSET);
|
|
|
649 set_header(curcmd->len, curcmd->pkt, REP_T_SIZE_OFFSET);
|
|
|
650 set_header(curcmd->lnum, curcmd->pkt, REP_LNUM_OFFSET);
|
|
|
651 }
|
|
|
652 return;
|
|
|
653 }
|
|
|
654
|
|
|
655 static int
|
|
|
656 rep_get_listened_fd()
|
|
|
657 {
|
|
|
658 int sock;
|
|
|
659 int value;
|
|
|
660 struct sockaddr_in addr;
|
|
|
661
|
|
|
662 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
|
|
|
663 e_msg_wrp("socket(): ERROR");
|
|
|
664 return(-1);
|
|
|
665 }
|
|
|
666
|
|
|
667 /* Allow other programs to bind to the socket */
|
|
|
668 value = 1;
|
|
|
669 if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(value)) < 0) {
|
|
|
670 e_msg_wrp("setsockopt() REUSEADDR failed");
|
|
|
671 exit(1);
|
|
|
672 }
|
|
|
673
|
|
|
674 bzero((char*)&addr, sizeof(addr));
|
|
|
675
|
|
|
676 addr.sin_family = AF_INET;
|
|
|
677 addr.sin_addr.s_addr = INADDR_ANY;
|
|
|
678 addr.sin_port = htons(REP_PORT);
|
|
|
679
|
|
|
680 if ((bind(sock, (struct sockaddr*)&addr, sizeof(addr))) == -1) {
|
|
|
681 e_msg_wrp("bind(): ERROR");
|
|
|
682 return(-1);
|
|
|
683 }
|
|
|
684
|
|
|
685 if ((listen(sock, SOCK_MAX)) < 0) {
|
|
|
686 e_msg_wrp("listen(): ERROR");
|
|
|
687 return(-1);
|
|
|
688 }
|
|
|
689
|
|
|
690 return(sock);
|
|
|
691 }
|
|
|
692
|
|
|
693 static int
|
|
|
694 set_hostnamebysock(sock,hostname,maxlen)
|
|
|
695 int sock;
|
|
|
696 char *hostname;
|
|
|
697 int maxlen;
|
|
|
698 {
|
|
|
699 int sinlen;
|
|
|
700 struct sockaddr_in sin;
|
|
|
701 struct hostent *host;
|
|
|
702 int namelen;
|
|
|
703
|
|
|
704 sinlen = sizeof sin;
|
|
|
705 if (getpeername(sock, (struct sockaddr *) &sin, (socklen_t *)&sinlen) < 0){
|
|
|
706 return(FALSE);
|
|
|
707 }
|
|
|
708
|
|
|
709 if ((host = gethostbyaddr((char *) &sin.sin_addr, sizeof(sin.sin_addr), AF_INET)) == NULL){
|
|
|
710 return(FALSE);
|
|
|
711 }
|
|
|
712
|
|
|
713 namelen = strlen(host->h_name);
|
|
|
714 if (namelen > maxlen) {
|
|
|
715 e_msg_wrp("host name is too long.");
|
|
|
716 return(FALSE);
|
|
|
717 }
|
|
|
718
|
|
|
719 strncpy(hostname,host->h_name,namelen);
|
|
|
720 hostname[namelen] = '\0';
|
|
|
721 return(TRUE);
|
|
|
722 }
|
|
|
723
|
|
|
724 static char default_host[] = "localhost";
|
|
|
725
|
|
|
726 static int
|
|
|
727 rep_connect(host)
|
|
|
728 char *host; /* "hostname:portnumber" */
|
|
|
729 {
|
|
|
730 int sock;
|
|
|
731 struct hostent *hp;
|
|
|
732 struct sockaddr_in sin;
|
|
|
733 char *tmp;
|
|
|
734 int port;
|
|
|
735
|
|
|
736 if (host == NULL || host == '\n') {
|
|
|
737 host = default_host;
|
|
|
738 port = REP_PORT;
|
|
|
739 } else {
|
|
|
740 if ((tmp = strchr(host, ':')) == NULL ) {
|
|
|
741 return(-1);
|
|
|
742 }
|
|
|
743 *tmp = '\0';
|
|
|
744 tmp++;
|
|
|
745 port = atol(tmp);
|
|
|
746 }
|
|
|
747
|
|
|
748 if ((hp = gethostbyname(host)) == NULL) {
|
|
|
749 e_msg_wrp("rep_open: gethostbyname: ERROR");
|
|
|
750 return(-1);
|
|
|
751 }
|
|
|
752
|
|
|
753 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
|
|
|
754 e_msg_wrp("rep_open: socket : ERROR");
|
|
|
755 return(-1);
|
|
|
756 }
|
|
|
757
|
|
|
758 bzero(&sin, sizeof(sin));
|
|
|
759 sin.sin_family = AF_INET;
|
|
|
760 sin.sin_port = htons(port);
|
|
|
761 bcopy(hp->h_addr, &sin.sin_addr, hp->h_length);
|
|
|
762
|
|
|
763 if (connect(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) {
|
|
|
764 e_msg_wrp("rep_open: connect: ERROR");
|
|
|
765 return(-1);
|
|
|
766 }
|
|
|
767
|
|
|
768 return(sock);
|
|
|
769 }
|
|
|
770
|
|
|
771
|
|
|
772 static BUFTYPE *
|
|
|
773 get_buf_by_name(name)
|
|
|
774 char *name;
|
|
|
775 {
|
|
|
776 BUFTYPE *buf;
|
|
|
777 if ((buf = find_buf_by_name_wrp(name)) == NULL) {
|
|
|
778 buf = make_new_buf_wrp(name);
|
|
|
779 }
|
|
|
780
|
|
|
781 if (buf && (buf->b_ml.ml_mfp == NULL)) {
|
|
|
782 open_buffer_memline_wrp(buf);
|
|
|
783 }
|
|
|
784
|
|
|
785 return buf;
|
|
|
786 }
|
|
|
787
|
|
|
788
|
|
|
789 /* About Session */
|
|
|
790
|
|
|
791 static Session *
|
|
|
792 init_session(sn)
|
|
|
793 Session *sn;
|
|
|
794 {
|
|
|
795 sn->next = NULL;
|
|
|
796 sn->buf = NULL;
|
|
|
797 sn->sname = NULL;
|
|
|
798 sn->new_cmdlist.head = NULL;
|
|
|
799 sn->new_cmdlist.num = 0;
|
|
|
800 sn->sent_cmdlist.head = NULL;
|
|
|
801 sn->sent_cmdlist.num = 0;
|
|
|
802 sn->sid = 0;
|
|
|
803 sn->permit = FALSE;
|
|
|
804 sn->prevline = -1;
|
|
|
805
|
|
|
806 return sn;
|
|
|
807 }
|
|
|
808
|
|
|
809 /*
|
|
|
810 * Make a new session.
|
|
|
811 * if buf is NULL, buffer is found or made new one.
|
|
|
812 */
|
|
|
813 static Session *
|
|
|
814 make_session(name, buf)
|
|
|
815 char *name;
|
|
|
816 BUFTYPE *buf;
|
|
|
817 {
|
|
|
818 Session *s;
|
|
|
819
|
|
|
820 char *sname;
|
|
|
821 int namelen = strlen(name)+1;
|
|
|
822
|
|
|
823 s = (Session*)rep_alloc(sizeof(Session));
|
|
|
824 if (s == NULL) {
|
|
|
825 return(NULL);
|
|
|
826 }
|
|
|
827
|
|
|
828 if ((sname = (char*)rep_alloc(namelen)) == NULL) {
|
|
|
829 return NULL;
|
|
|
830 }
|
|
|
831 strncpy(sname,name,namelen);
|
|
|
832
|
|
|
833 init_session(s);
|
|
|
834
|
|
|
835 if (buf == NULL) buf = get_buf_by_name(sname);
|
|
|
836 s->buf = buf;
|
|
|
837
|
|
|
838 s->sname = sname;
|
|
|
839
|
|
|
840 return s;
|
|
|
841 }
|
|
|
842
|
|
|
843 static void
|
|
|
844 free_session(sn)
|
|
|
845 Session *sn;
|
|
|
846 {
|
|
|
847
|
|
|
848 free_cmdlist(&sn->new_cmdlist);
|
|
|
849 free_cmdlist(&sn->sent_cmdlist);
|
|
|
850 free_buf_wrp(sn->buf);
|
|
|
851
|
|
|
852 if (sn->sname) rep_free(sn->sname);
|
|
|
853
|
|
|
854 init_session(sn);
|
|
|
855
|
|
|
856 rep_free(sn);
|
|
|
857 return;
|
|
|
858 }
|
|
|
859
|
|
|
860 static void
|
|
|
861 free_session_list(head)
|
|
|
862 Session *head;
|
|
|
863 {
|
|
|
864 Session *next;
|
|
|
865 for (; head; head=next) {
|
|
|
866 next = head->next;
|
|
|
867 head->next = NULL;
|
|
|
868 free_session(head);
|
|
|
869 }
|
|
|
870 return;
|
|
|
871 }
|
|
|
872
|
|
|
873 static void
|
|
|
874 register_session(sn)
|
|
|
875 Session *sn;
|
|
|
876 {
|
|
|
877 rep_T *rep;
|
|
|
878
|
|
|
879 rep = get_rep();
|
|
|
880
|
|
|
881 sn->next = rep->shead;
|
|
|
882 rep->shead = sn;
|
|
|
883
|
|
|
884 return;
|
|
|
885 }
|
|
|
886
|
|
|
887 static Session*
|
|
|
888 set_cursession(sn)
|
|
|
889 Session *sn;
|
|
|
890 {
|
|
|
891 BUFTYPE *oldbuf;
|
|
|
892 Session *oldsn;
|
|
|
893 rep_T *rep = get_rep();
|
|
|
894
|
|
|
895 if (sn) oldbuf = set_curbuf_wrp(sn->buf);
|
|
|
896 rep->cursession = sn;
|
|
|
897
|
|
|
898 oldsn = find_session_by_buf(oldbuf);
|
|
|
899 return oldsn;
|
|
|
900 }
|
|
|
901
|
|
|
902 static Session*
|
|
|
903 find_session_by_id(id)
|
|
|
904 unsigned int id;
|
|
|
905 {
|
|
|
906 Session *cursn = NULL;
|
|
|
907 rep_T *rep = get_rep();
|
|
|
908
|
|
|
909 if (rep->slineup && rep->slineup->sid == id) {
|
|
|
910 return rep->slineup;
|
|
|
911 }
|
|
|
912
|
|
|
913 for (cursn = rep->shead; cursn; cursn = cursn->next) {
|
|
|
914 if (cursn->sid == id) {
|
|
|
915 return cursn;
|
|
|
916 }
|
|
|
917 }
|
|
|
918
|
|
|
919 return NULL;
|
|
|
920 }
|
|
|
921
|
|
|
922 static Session*
|
|
|
923 find_session_by_buf(buf)
|
|
|
924 BUFTYPE *buf;
|
|
|
925 {
|
|
|
926 Session *cursn = NULL;
|
|
|
927 rep_T *rep = get_rep();
|
|
|
928
|
|
|
929 if (buf == NULL) return NULL;
|
|
|
930
|
|
|
931 if(rep->slineup->buf == buf)
|
|
|
932 return rep->slineup;
|
|
|
933 for (cursn = rep->shead; cursn; cursn = cursn->next) {
|
|
|
934 if (cursn->buf == buf) break;
|
|
|
935 }
|
|
|
936 return cursn;
|
|
|
937 }
|
|
|
938
|
|
|
939 static Session*
|
|
|
940 find_session_by_name(name)
|
|
|
941 char *name;
|
|
|
942 {
|
|
|
943 BUFTYPE *buf;
|
|
|
944 buf = find_buf_by_name_wrp(name);
|
|
|
945 return find_session_by_buf(buf);
|
|
|
946 }
|
|
|
947
|
|
|
948 int
|
|
|
949 rep_input_reg_session() // input own session(s)
|
|
|
950 {
|
|
|
951 char *sname;
|
|
|
952
|
|
|
953 while (1) {
|
|
|
954 // retrun value (sname) is allocated.
|
|
|
955 sname = getstr_input_wrp("Session to offer = ");
|
|
|
956 if (sname == NULL) return FALSE;
|
|
|
957 if (*sname=='\0') { // input pert is finished
|
|
|
958 free_wrp(sname);
|
|
|
959 break;
|
|
|
960 }
|
|
|
961 register_session(make_session(sname, NULL));
|
|
|
962
|
|
|
963 free_wrp(sname);
|
|
|
964 }
|
|
|
965
|
|
|
966 update_screen_now_wrp(); /* ウィンドウを再描画 */
|
|
|
967 return TRUE;
|
|
|
968 }
|
|
|
969
|
|
|
970
|
|
|
971 static int
|
|
|
972 set_session_info(dest_sinfo, sname, hostname, port)
|
|
|
973 char *dest_sinfo;
|
|
|
974 char *sname;
|
|
|
975 char *hostname;
|
|
|
976 int port;
|
|
|
977 {
|
|
|
978 int size;
|
|
|
979 size = sprintf(dest_sinfo, "%s:%d:%s",hostname, port, sname);
|
|
|
980 dest_sinfo[size] = '\0';
|
|
|
981 return 0;
|
|
|
982 }
|
|
|
983
|
|
|
984 static char*
|
|
|
985 get_fullpath(session)
|
|
|
986 Session *session;
|
|
|
987 {
|
|
|
988 BUFTYPE *buf;
|
|
|
989 if (session == NULL) {
|
|
|
990 buf = get_curbuf_wrp();
|
|
|
991 } else {
|
|
|
992 buf = session->buf;
|
|
|
993 }
|
|
|
994 return get_fullpath_wrp(buf);
|
|
|
995 }
|
|
|
996
|
|
|
997 static char*
|
|
|
998 get_shortname(session)
|
|
|
999 Session *session;
|
|
|
1000 {
|
|
|
1001 return get_shortname_wrp(session->buf);
|
|
|
1002 }
|
|
|
1003
|
|
|
1004
|
|
|
1005
|
|
|
1006 /* End Session */
|
|
|
1007
|
|
|
1008 #define SINFO_MAX 255
|
|
|
1009 /*
|
|
|
1010 * 自身が提供するセッションのみをセッションリストに書き出す
|
|
|
1011 * あらかじめセッションリストのバッファを編集対象のバッファに
|
|
|
1012 *指定しておく(set_curbuf_wrp(slineup)しておく)
|
|
|
1013 */
|
|
|
1014 static int
|
|
|
1015 make_local_slineup(slineup, hostname, my_sessions)
|
|
|
1016 Session *slineup;
|
|
|
1017 char *hostname;
|
|
|
1018 Session *my_sessions;
|
|
|
1019 {
|
|
|
1020 Session *s;
|
|
|
1021 BUFTYPE *oldcurbuf;
|
|
|
1022 char sinfo[SINFO_MAX];
|
|
|
1023
|
|
|
1024 if (my_sessions == NULL) return FALSE;
|
|
|
1025
|
|
|
1026 for (; my_sessions; my_sessions=my_sessions->next) {
|
|
|
1027 set_session_info(sinfo, my_sessions->sname, hostname, REP_PORT);
|
|
|
1028 /* 現在の編集対象のバッファ curbuf に対して書き込みを行なう */
|
|
|
1029 append_memline_wrp(1, sinfo);
|
|
|
1030 }
|
|
|
1031
|
|
|
1032 return TRUE;
|
|
|
1033 }
|
|
|
1034
|
|
|
1035
|
|
|
1036 /*
|
|
|
1037 * セッションマネージャからセッションリストを取得
|
|
|
1038 * あらかじめセッションリストのバッファを編集対象のバッファに
|
|
|
1039 *指定しておく(set_curbuf_wrp(buf)しておく)
|
|
|
1040 */
|
|
|
1041 static int
|
|
|
1042 get_slineup_from_sm(servername, slineup, hostname, my_sessions)
|
|
|
1043 char *servername;
|
|
|
1044 Session *slineup;
|
|
|
1045 char *hostname;
|
|
|
1046 Session *my_sessions; // linked list
|
|
|
1047 {
|
|
|
1048 return TRUE;
|
|
|
1049 }
|
|
|
1050
|
|
|
1051
|
|
|
1052 char *
|
|
|
1053 rep_input_param(msg, err_msg)
|
|
|
1054 char *msg;
|
|
|
1055 char *err_msg;
|
|
|
1056 {
|
|
|
1057 char *input_string;
|
|
|
1058
|
|
|
1059 if ((input_string = getstr_input_wrp(msg)) == NULL) {
|
|
|
1060 return NULL;
|
|
|
1061 }
|
|
|
1062
|
|
|
1063 if (*input_string == '\0') {
|
|
|
1064 if (err_msg) {
|
|
|
1065 puts_msg_wrp(err_msg);
|
|
|
1066 }
|
|
|
1067 free_wrp(input_string);
|
|
|
1068 return NULL;
|
|
|
1069 }
|
|
|
1070
|
|
|
1071 return input_string;
|
|
|
1072 }
|
|
|
1073
|
|
|
1074 int
|
|
|
1075 rep_join()
|
|
|
1076 {
|
|
|
1077 int sock;
|
|
|
1078 rep_T *rep;
|
|
|
1079
|
|
|
1080 rep_cmdlist cmdlist = {NULL,0};
|
|
|
1081
|
|
|
1082 rep = get_rep();
|
|
|
1083 /*
|
|
|
1084 if (server == NULL) {
|
|
|
1085 return FALSE;
|
|
|
1086 }
|
|
|
1087 */
|
|
|
1088 if ((sock = rep_connect(NULL)) < 0) {
|
|
|
1089 return FALSE;
|
|
|
1090 }
|
|
|
1091 if (rep->smfd > 0) {
|
|
|
1092 close(rep->smfd);
|
|
|
1093 }
|
|
|
1094
|
|
|
1095 rep->smfd = sock;
|
|
|
1096 rep->permit = TRUE;
|
|
|
1097
|
|
|
1098 add_cmd_to_list(&cmdlist, make_cmd(REP_JOIN_CMD, 0, rep->eid, rep->seqno++, 0, NULL));
|
|
|
1099 rep_send_cmds(sock, &cmdlist);
|
|
|
1100
|
|
|
1101 free_cmdlist(&cmdlist);
|
|
|
1102
|
|
|
1103 return TRUE;
|
|
|
1104
|
|
|
1105 }
|
|
|
1106
|
|
|
1107 int
|
|
|
1108 rep_select_command(session_no)
|
|
|
1109 char *session_no;
|
|
|
1110 {
|
|
|
1111 rep_T *rep = get_rep();
|
|
|
1112 rep_cmdlist cmdlist = {NULL, 0};
|
|
|
1113 int sid;
|
|
|
1114
|
|
|
1115
|
|
|
1116 if (rep->smfd < 0 || session_no == NULL) {
|
|
|
1117 return FALSE;
|
|
|
1118 }
|
|
|
1119
|
|
|
1120 if (rep->waiting_session_name) {
|
|
|
1121 rep_free(rep->waiting_session_name);
|
|
|
1122 }
|
|
|
1123 sid = atol(session_no);
|
|
|
1124 if ((rep->waiting_session_name = get_sname_by_snum(sid)) == NULL) {
|
|
|
1125 e_msg_wrp("Session Selection is false.");
|
|
|
1126 return FALSE;
|
|
|
1127 }
|
|
|
1128
|
|
|
1129 add_cmd_to_list(&cmdlist, make_cmd(REP_SELECT_CMD, sid, rep->eid, rep->seqno++, 0, session_no));
|
|
|
1130 rep_send_cmds(rep->smfd, &cmdlist);
|
|
|
1131
|
|
|
1132 free_cmdlist(&cmdlist);
|
|
|
1133
|
|
|
1134 return TRUE;
|
|
|
1135 }
|
|
|
1136
|
|
|
1137 int
|
|
|
1138 rep_put(sname)
|
|
|
1139 char *sname;
|
|
|
1140 {
|
|
|
1141 int sock;
|
|
|
1142 rep_T *rep = get_rep();
|
|
|
1143 rep_cmdlist cmdlist = {NULL, 0};
|
|
|
1144 int len;
|
|
|
1145 Session *sn;
|
|
|
1146
|
|
|
1147 if ((sock = rep_connect(NULL)) < 0) {
|
|
|
1148 return FALSE;
|
|
|
1149 }
|
|
|
1150 if (rep->smfd > 0) {
|
|
|
1151 close(rep->smfd);
|
|
|
1152 }
|
|
|
1153
|
|
|
1154 rep->smfd = sock;
|
|
|
1155 rep->permit = TRUE;
|
|
|
1156
|
|
|
1157 if (sname == NULL) {
|
|
|
1158 /* get current buffer name */
|
|
|
1159 if ((sname = get_fullpath(rep->cursession)) == NULL) {
|
|
|
1160 sname = NO_NAME; /* the buffer has not name */
|
|
|
1161 }
|
|
|
1162 }
|
|
|
1163
|
|
|
1164 /*
|
|
|
1165 if (find_session_by_name(sname) == NULL) {
|
|
|
1166 sn = make_session(sname, get_buf_by_name(sname));
|
|
|
1167 register_session(sn);
|
|
|
1168 }
|
|
|
1169 */
|
|
|
1170
|
|
|
1171
|
|
|
1172 if (rep->waiting_session_name) {
|
|
|
1173 rep_free(rep->waiting_session_name);
|
|
|
1174 }
|
|
|
1175 len = strlen(sname) +1;
|
|
|
1176 rep->waiting_session_name = (char *)rep_alloc(len);
|
|
|
1177 memcpy(rep->waiting_session_name, sname, len);
|
|
|
1178
|
|
|
1179 add_cmd_to_list(&cmdlist, make_cmd(REP_PUT_CMD, 0, rep->eid, rep->seqno++, 0, sname));
|
|
|
1180
|
|
|
1181 rep_send_cmds(rep->smfd, &cmdlist);
|
|
|
1182
|
|
|
1183 free_cmdlist(&cmdlist);
|
|
|
1184
|
|
|
1185 return TRUE;
|
|
|
1186 }
|
|
|
1187
|
|
|
1188
|
|
|
1189 int
|
|
|
1190 rep_remove()
|
|
|
1191 {
|
|
|
1192 rep_T *rep = get_rep();
|
|
|
1193 rep_cmd *cmd;
|
|
|
1194 rep_cmdlist cmdlist = {NULL, 0};
|
|
|
1195 Session *sn = rep->cursession;
|
|
|
1196
|
|
|
1197 if (rep->smfd < 0) { /* session does not exist */
|
|
|
1198 EMSG("Session does not exist.");
|
|
|
1199 return FALSE;
|
|
|
1200 }
|
|
|
1201
|
|
|
1202 cmd = make_cmd(REP_DEREGISTER_CMD, sn->sid, rep->eid, rep->seqno, 0, NULL);
|
|
|
1203 add_cmd_to_list(&cmdlist, cmd);
|
|
|
1204 rep_send_cmds(rep->smfd, &cmdlist);
|
|
|
1205 free_cmdlist(&cmdlist);
|
|
|
1206
|
|
|
1207 return TRUE;
|
|
|
1208 }
|
|
|
1209
|
|
|
1210 static int
|
|
|
1211 rep_make_slineup()
|
|
|
1212 {
|
|
|
1213 BUFTYPE buf;
|
|
|
1214 // BUFTYPE *oldcurbuf;
|
|
|
1215 Session *oldsn;
|
|
|
1216
|
|
|
1217 rep_T *rep;
|
|
|
1218 rep = get_rep();
|
|
|
1219
|
|
|
1220 if (rep->slineup) {
|
|
|
1221 free_session(rep->slineup);
|
|
|
1222 }
|
|
|
1223
|
|
|
1224 rep->slineup = make_session(SLINEUP_NAME, make_new_buf_wrp(SLINEUP_NAME));
|
|
|
1225
|
|
|
1226 oldsn = set_cursession(rep->slineup);
|
|
|
1227
|
|
|
1228 /* セッション一覧リストを作成 */
|
|
|
1229 if ((get_slineup_from_sm(rep->servername, rep->slineup, rep->hostname, rep->shead) == FALSE)) {
|
|
|
1230 make_local_slineup(rep->slineup, rep->hostname, rep->shead);
|
|
|
1231 }
|
|
|
1232
|
|
|
1233 update_screen_now_wrp(); /* ウィンドウを再描画 */
|
|
|
1234
|
|
|
1235 return TRUE;
|
|
|
1236 }
|
|
|
1237
|
|
|
1238
|
|
|
1239 static int
|
|
|
1240 enter_session(session_name)
|
|
|
1241 char *session_name;
|
|
|
1242 {
|
|
|
1243 return TRUE;
|
|
|
1244 }
|
|
|
1245
|
|
|
1246
|
|
|
1247 /* Session End */
|
|
|
1248
|
|
|
1249 static void *
|
|
|
1250 rep_alloc(size)
|
|
|
1251 int size; /* byte */
|
|
|
1252 {
|
|
|
1253 void *allocated;
|
|
|
1254 if ((allocated = malloc(size)) == NULL) {
|
|
|
1255 e_msg_wrp("no memory!");
|
|
|
1256 }
|
|
|
1257
|
|
|
1258 return allocated;
|
|
|
1259 }
|
|
|
1260
|
|
|
1261 static void
|
|
|
1262 rep_free(obj)
|
|
|
1263 void *obj;
|
|
|
1264 {
|
|
|
1265 if (obj) free(obj);
|
|
|
1266 return;
|
|
|
1267 }
|
|
|
1268
|
|
|
1269
|
|
|
1270 static int
|
|
|
1271 writen(sock, pkt, len)
|
|
|
1272 int sock;
|
|
|
1273 char *pkt;
|
|
|
1274 unsigned int len;
|
|
|
1275 {
|
|
|
1276 int offset;
|
|
|
1277 int written;
|
|
|
1278
|
|
|
1279 if (len == 0) return 0;
|
|
|
1280
|
|
|
1281 for (offset=0, written=0; offset<len; offset += written) {
|
|
|
1282 if ((written = write(sock, pkt + offset, len - offset)) < 0) {
|
|
|
1283 puts_sys_err();
|
|
|
1284 return written;
|
|
|
1285 }
|
|
|
1286 }
|
|
|
1287 return offset;
|
|
|
1288 }
|
|
|
1289
|
|
|
1290 static int
|
|
|
1291 readn(sock, pkt, len)
|
|
|
1292 int sock;
|
|
|
1293 char *pkt;
|
|
|
1294 unsigned int len;
|
|
|
1295 {
|
|
|
1296 unsigned int r;
|
|
|
1297 unsigned int offset;
|
|
|
1298
|
|
|
1299 if (len == 0) return 0;
|
|
|
1300
|
|
|
1301 for (offset=0, r=0; offset<len; offset += r) {
|
|
|
1302 if ((r = read(sock, pkt + offset, len - offset)) < 0) {
|
|
|
1303 puts_sys_err();
|
|
|
1304 return r;
|
|
|
1305 }
|
|
|
1306 }
|
|
|
1307 return offset;
|
|
|
1308 }
|
|
|
1309
|
|
|
1310
|
|
|
1311 static char*
|
|
|
1312 make_packet(cmd, sid, eid, seq, lnum, text)
|
|
|
1313 unsigned int cmd;
|
|
|
1314 unsigned int sid;
|
|
|
1315 unsigned int eid;
|
|
|
1316 unsigned int seq;
|
|
|
1317 unsigned int lnum;
|
|
|
1318 char * text;
|
|
|
1319 {
|
|
|
1320 char *packet;
|
|
|
1321 unsigned int len = 0;
|
|
|
1322
|
|
|
1323 if (text) len += strlen(text);// + 1; /* for include '\0' */
|
|
|
1324
|
|
|
1325 if ((packet = (char *)rep_alloc(REP_HEADER_SIZE+len)) == NULL) {
|
|
|
1326 return(NULL);
|
|
|
1327 }
|
|
|
1328
|
|
|
1329 set_header(cmd, packet, REP_CMD_OFFSET);
|
|
|
1330 set_header(sid, packet, REP_SID_OFFSET);
|
|
|
1331 set_header(eid, packet, REP_EID_OFFSET);
|
|
|
1332 set_header(seq, packet, REP_SEQNUM_OFFSET);
|
|
|
1333 set_header(lnum, packet, REP_LNUM_OFFSET);
|
|
|
1334 set_header(len, packet, REP_T_SIZE_OFFSET);
|
|
|
1335
|
|
|
1336 if (text) {
|
|
|
1337 memcpy(packet+REP_TEXT_OFFSET, text, len);
|
|
|
1338 }
|
|
|
1339
|
|
|
1340 return(packet);
|
|
|
1341 }
|
|
|
1342
|
|
|
1343
|
|
|
1344 static rep_cmd*
|
|
|
1345 make_cmd(cmd, sid, eid, seq, lnum, text)
|
|
|
1346 unsigned int cmd;
|
|
|
1347 unsigned int sid;
|
|
|
1348 unsigned int eid;
|
|
|
1349 unsigned int seq;
|
|
|
1350 unsigned int lnum;
|
|
|
1351 char *text;
|
|
|
1352 {
|
|
|
1353 rep_cmd *cmd_p;
|
|
|
1354 char *pkt;
|
|
|
1355 unsigned int length = 0;
|
|
|
1356
|
|
|
1357 pkt = make_packet(cmd, sid, eid, seq, lnum, text);
|
|
|
1358 if (pkt == NULL) {
|
|
|
1359 e_msg_wrp("make_cmd: no memory: ERROR");
|
|
|
1360 return(NULL);
|
|
|
1361 }
|
|
|
1362
|
|
|
1363 cmd_p = (rep_cmd*)rep_alloc(sizeof(rep_cmd));
|
|
|
1364 if (cmd_p == NULL) {
|
|
|
1365 e_msg_wrp("make_cmd: no memory: ERROR");
|
|
|
1366 return(NULL);
|
|
|
1367 }
|
|
|
1368
|
|
|
1369 if (text) {
|
|
|
1370 length = strlen(text); //+1; // include '\0'
|
|
|
1371 }
|
|
|
1372
|
|
|
1373 cmd_p->next = NULL;
|
|
|
1374
|
|
|
1375 cmd_p->cmd = cmd;
|
|
|
1376 cmd_p->sid = sid;
|
|
|
1377 cmd_p->eid = eid;
|
|
|
1378 cmd_p->seq = seq;
|
|
|
1379 cmd_p->len = length;
|
|
|
1380 cmd_p->lnum = lnum;
|
|
|
1381
|
|
|
1382 cmd_p->stat = REP_AVAIL;
|
|
|
1383 cmd_p->pkt = pkt;
|
|
|
1384
|
|
|
1385 return(cmd_p);
|
|
|
1386 }
|
|
|
1387
|
|
|
1388 static int
|
|
|
1389 free_cmd(cmd)
|
|
|
1390 rep_cmd *cmd;
|
|
|
1391 {
|
|
|
1392 if (cmd == NULL) return(FALSE);
|
|
|
1393
|
|
|
1394 if (cmd->pkt) {
|
|
|
1395 rep_free(cmd->pkt);
|
|
|
1396 cmd->pkt=NULL;
|
|
|
1397 }
|
|
|
1398 rep_free(cmd);
|
|
|
1399 cmd = 0;
|
|
|
1400 return(TRUE);
|
|
|
1401 }
|
|
|
1402
|
|
|
1403 static int
|
|
|
1404 free_cmdlist(cmdlist)
|
|
|
1405 rep_cmdlist *cmdlist;
|
|
|
1406 {
|
|
|
1407 rep_cmd *cur;
|
|
|
1408 rep_cmd *next;
|
|
|
1409
|
|
|
1410 if (cmdlist->head==NULL) return(FALSE);
|
|
|
1411 for (cur=cmdlist->head; cur; cur=next) {
|
|
|
1412 next=cur->next;
|
|
|
1413 free_cmd(cur);
|
|
|
1414 }
|
|
|
1415 cmdlist->head = NULL;
|
|
|
1416 cmdlist->num = 0;
|
|
|
1417 return(TRUE);
|
|
|
1418 }
|
|
|
1419
|
|
|
1420 static void
|
|
|
1421 add_cmd_to_list(cmdlist, cmd)
|
|
|
1422 rep_cmdlist *cmdlist;
|
|
|
1423 rep_cmd *cmd;
|
|
|
1424 {
|
|
|
1425 rep_cmd *p;
|
|
|
1426 int count = 0;
|
|
|
1427
|
|
|
1428 for (p=cmd; p; p=p->next) count++;
|
|
|
1429
|
|
|
1430 if (cmdlist->head) {
|
|
|
1431 for (p = cmdlist->head; p->next; p = p->next);
|
|
|
1432 p->next = cmd;
|
|
|
1433 } else {
|
|
|
1434 cmdlist->head = cmd;
|
|
|
1435 }
|
|
|
1436 cmdlist->num += count;
|
|
|
1437 return;
|
|
|
1438 }
|
|
|
1439
|
|
|
1440 static int
|
|
|
1441 add_pkt_to_list(cmdlist, pkt) /* pkt is allocated */
|
|
|
1442 rep_cmdlist *cmdlist;
|
|
|
1443 char *pkt;
|
|
|
1444 {
|
|
|
1445 rep_cmd *cmd_p;
|
|
|
1446
|
|
|
1447 if (pkt == NULL) return(FALSE);
|
|
|
1448
|
|
|
1449 cmd_p = (rep_cmd*)rep_alloc(sizeof(rep_cmd));
|
|
|
1450 if (cmd_p == NULL) {
|
|
|
1451 e_msg_wrp("add_pkt_to_list: no memory: ERROR");
|
|
|
1452 return(FALSE);
|
|
|
1453 }
|
|
|
1454
|
|
|
1455 cmd_p->next = NULL;
|
|
|
1456
|
|
|
1457 cmd_p->cmd = get_header(pkt, REP_CMD_OFFSET);
|
|
|
1458 cmd_p->sid = get_header(pkt, REP_SID_OFFSET);
|
|
|
1459 cmd_p->eid = get_header(pkt, REP_EID_OFFSET);
|
|
|
1460 cmd_p->seq = get_header(pkt, REP_SEQNUM_OFFSET);
|
|
|
1461 cmd_p->lnum = get_header(pkt, REP_LNUM_OFFSET);
|
|
|
1462
|
|
|
1463 cmd_p->stat = REP_AVAIL;
|
|
|
1464 cmd_p->len = strlen(pkt)+1 - REP_HEADER_SIZE;
|
|
|
1465 cmd_p->pkt = pkt;
|
|
|
1466
|
|
|
1467 add_cmd_to_list(cmdlist, cmd_p);
|
|
|
1468
|
|
|
1469 return(TRUE);
|
|
|
1470 }
|
|
|
1471
|
|
|
1472
|
|
|
1473 void
|
|
|
1474 rep_prevline_flush()
|
|
|
1475 {
|
|
|
1476 BUFTYPE *cbuf;
|
|
|
1477 Session *cursn;
|
|
|
1478 rep_cmd *cmd;
|
|
|
1479 rep_T *rep = get_rep();
|
|
|
1480 char *text;
|
|
|
1481
|
|
|
1482 cursn = rep->cursession;
|
|
|
1483
|
|
|
1484 if ((cursn == NULL) || (cursn->prevline == -1)) return;
|
|
|
1485
|
|
|
1486 // バッファが変更された場合には rep->cursession も合わす
|
|
|
1487 if ((cbuf = get_curbuf_wrp()) != cursn->buf) {
|
|
|
1488 cursn = find_session_by_buf(cbuf);
|
|
|
1489 if (cursn == NULL)
|
|
|
1490 return;
|
|
|
1491 rep->cursession = cursn;
|
|
|
1492 }
|
|
|
1493
|
|
|
1494 text = get_memline_wrp(cursn->buf, cursn->prevline);
|
|
|
1495
|
|
|
1496 cmd = make_cmd(REP_REPLACE_CMD, cursn->sid, rep->eid, rep->seqno++, cursn->prevline, text);
|
|
|
1497
|
|
|
1498 add_cmd_to_list(&(cursn->new_cmdlist), cmd);
|
|
|
1499
|
|
|
1500
|
|
|
1501
|
|
|
1502 if (cursn->sent_cmdlist.num == 0) { // 自トークンを送信してない場合
|
|
|
1503 rep_send_cur_cmdlist();
|
|
|
1504 }
|
|
|
1505
|
|
|
1506 cursn->prevline = -1;
|
|
|
1507 }
|
|
|
1508
|
|
|
1509
|
|
|
1510 static void
|
|
|
1511 check_line_change(sn, lnum)
|
|
|
1512 Session *sn;
|
|
|
1513 unsigned int lnum;
|
|
|
1514 {
|
|
|
1515 rep_cmd *cmd;
|
|
|
1516 rep_T *rep = get_rep();
|
|
|
1517
|
|
|
1518
|
|
|
1519 if (sn->prevline == lnum) {
|
|
|
1520 return;
|
|
|
1521 }
|
|
|
1522
|
|
|
1523 if (sn->prevline == -1) {
|
|
|
1524 sn->prevline = lnum;
|
|
|
1525 return;
|
|
|
1526 }
|
|
|
1527 cmd = make_cmd(REP_REPLACE_CMD, sn->sid, rep->eid, rep->seqno++, sn->prevline,
|
|
|
1528 get_memline_wrp(sn->buf, sn->prevline));
|
|
|
1529 add_cmd_to_list(&(sn->new_cmdlist), cmd);
|
|
|
1530
|
|
|
1531 sn->prevline = lnum;
|
|
|
1532 return;
|
|
|
1533 }
|
|
|
1534
|
|
|
1535 int
|
|
|
1536 rep_register(lnum, lnume, xtra)
|
|
|
1537 unsigned int lnum;
|
|
|
1538 unsigned int lnume;
|
|
|
1539 int xtra;
|
|
|
1540 {
|
|
|
1541 int i;
|
|
|
1542 BUFTYPE *cbuf;
|
|
|
1543 Session *cursn;
|
|
|
1544 rep_cmd *cmd;
|
|
|
1545 rep_T *rep = get_rep();
|
|
|
1546
|
|
|
1547 if ((cursn = rep->cursession) == NULL) return FALSE;
|
|
|
1548
|
|
|
1549 // バッファが変更された場合には rep->cursession も合わす
|
|
|
1550 if ((cbuf = get_curbuf_wrp()) != cursn->buf) {
|
|
|
1551 cursn = find_session_by_buf(cbuf);
|
|
|
1552 if (cursn == NULL)
|
|
|
1553 return FALSE;
|
|
|
1554 rep->cursession = cursn;
|
|
|
1555 }
|
|
|
1556
|
|
|
1557 if (xtra == 0) {
|
|
|
1558 for (i = 0; lnume-lnum > i; i++) {
|
|
|
1559 check_line_change(cursn,lnum+i);
|
|
|
1560 }
|
|
|
1561 } else if (xtra > 0) {
|
|
|
1562 if (lnum != lnume) { /* 行の途中から改行 */
|
|
|
1563 cmd = make_cmd( REP_REPLACE_CMD, cursn->sid, rep->eid, rep->seqno++, lnum,
|
|
|
1564 get_memline_wrp(cursn->buf, lnum));
|
|
|
1565 add_cmd_to_list(&(cursn->new_cmdlist), cmd);
|
|
|
1566 lnum++;
|
|
|
1567 }
|
|
|
1568 for (i = 0; xtra > 0; i++, xtra--) {
|
|
|
1569 cmd = make_cmd( REP_INSERT_CMD, cursn->sid, rep->eid, rep->seqno++, lnum+i,
|
|
|
1570 get_memline_wrp(cursn->buf, lnum+i));
|
|
|
1571 add_cmd_to_list(&(cursn->new_cmdlist), cmd);
|
|
|
1572 }
|
|
|
1573 } else { /* xtra < 0 */
|
|
|
1574 xtra = -xtra;
|
|
|
1575 for (; xtra > 0; xtra--) {
|
|
|
1576 cmd = make_cmd(REP_DELETE_LINE_CMD, cursn->sid, rep->eid, rep->seqno++, lnum,
|
|
|
1577 NULL);
|
|
|
1578 add_cmd_to_list(&(cursn->new_cmdlist), cmd);
|
|
|
1579 }
|
|
|
1580 }
|
|
|
1581
|
|
|
1582 if (cursn->sent_cmdlist.num == 0) {
|
|
|
1583 rep_send_cur_cmdlist();
|
|
|
1584 }
|
|
|
1585
|
|
|
1586 return(lnume - lnum);
|
|
|
1587 }
|
|
|
1588
|
|
|
1589
|
|
|
1590 static int
|
|
|
1591 set_header(data, pkt, offset)
|
|
|
1592 unsigned int data;
|
|
|
1593 char *pkt;
|
|
|
1594 int offset;
|
|
|
1595 {
|
|
|
1596 int *ipkt;
|
|
|
1597 int ndata = htonl(data);
|
|
|
1598
|
|
|
1599 ipkt = (int*)pkt;
|
|
|
1600 ipkt[offset/4] = ndata;
|
|
|
1601
|
|
|
1602 return(TRUE);
|
|
|
1603 }
|
|
|
1604
|
|
|
1605 static unsigned int
|
|
|
1606 get_header(pkt, offset)
|
|
|
1607 char *pkt;
|
|
|
1608 int offset;
|
|
|
1609 {
|
|
|
1610 int *ipkt;
|
|
|
1611 int data;
|
|
|
1612 unsigned int header;
|
|
|
1613
|
|
|
1614 ipkt = (int *)pkt;
|
|
|
1615 data = ipkt[offset/4];
|
|
|
1616 header = (unsigned int)ntohl(data);
|
|
|
1617
|
|
|
1618 return(header);
|
|
|
1619 }
|
|
|
1620
|
|
|
1621
|
|
|
1622 static int
|
|
|
1623 rep_exe_cmd(cmd, sid, eid, seq, lnum, textsize, text)
|
|
|
1624 unsigned int cmd;
|
|
|
1625 unsigned int sid;
|
|
|
1626 unsigned int eid;
|
|
|
1627 unsigned int seq;
|
|
|
1628 unsigned int lnum;
|
|
|
1629 unsigned int textsize;
|
|
|
1630 char *text;
|
|
|
1631 {
|
|
|
1632 char h_name[50];
|
|
|
1633 rep_cmdlist tmplist = {NULL, 0};
|
|
|
1634 rep_cmd *repcmd;
|
|
|
1635 BUFTYPE *buf;
|
|
|
1636 rep_T *rep = get_rep();
|
|
|
1637 Session *session;
|
|
|
1638
|
|
|
1639 unsigned int buflenmax;
|
|
|
1640
|
|
|
1641 session = find_session_by_id(sid);
|
|
|
1642
|
|
|
1643 /*XXX 無理矢理 */
|
|
|
1644 if (textsize == 0) {
|
|
|
1645 text = NULL;
|
|
|
1646 }
|
|
|
1647
|
|
|
1648 switch (cmd) {
|
|
|
1649 case REP_JOIN_ACK:
|
|
|
1650 /* show session lineup */
|
|
|
1651 if (rep->slineup) {
|
|
|
1652 free_session(rep->slineup);
|
|
|
1653 }
|
|
|
1654 rep->slineup = make_session(SLINEUP_NAME, make_new_buf_wrp(SLINEUP_NAME));
|
|
|
1655 append_newline_sep_text(rep->slineup, text);
|
|
|
1656 set_cursession(rep->slineup);
|
|
|
1657 update_screen_now_wrp();
|
|
|
1658
|
|
|
1659 if (rep->eid == 0) {
|
|
|
1660 rep->eid = eid;
|
|
|
1661 }
|
|
|
1662 break;
|
|
|
1663 case REP_SELECT_ACK:
|
|
|
1664 // text is error message. means occur ERROR in session manager
|
|
|
1665 if (text) {
|
|
|
1666 e_msg_wrp(text);
|
|
|
1667 return FALSE;
|
|
|
1668 }
|
|
|
1669
|
|
|
1670 // DON'T wait session from session manager
|
|
|
1671 if (! rep->waiting_session_name) {
|
|
|
1672 return FALSE;
|
|
|
1673 }
|
|
|
1674
|
|
|
1675 session = make_session(rep->waiting_session_name,
|
|
|
1676 make_new_buf_wrp(rep->waiting_session_name));
|
|
|
1677 session->sid = sid;
|
|
|
1678 register_session(session);
|
|
|
1679
|
|
|
1680 rep_free(rep->waiting_session_name);
|
|
|
1681 rep->waiting_session_name = NULL;
|
|
|
1682
|
|
|
1683 set_cursession(session);
|
|
|
1684
|
|
|
1685 rep_start_create_cmds();
|
|
|
1686
|
|
|
1687 /* get window size */
|
|
|
1688 /* send read command */
|
|
|
1689 break;
|
|
|
1690 case REP_REGISTER_ACK:
|
|
|
1691 case REP_PUT_ACK:
|
|
|
1692 /* Enter Session */
|
|
|
1693
|
|
|
1694 if (text) { // text is error message.
|
|
|
1695 e_msg_wrp(text);
|
|
|
1696 return FALSE;
|
|
|
1697 }
|
|
|
1698
|
|
|
1699 /* Use wating_session_name for assign session id */
|
|
|
1700 if ((session = find_session_by_name(rep->waiting_session_name)) == NULL) {
|
|
|
1701 if (rep->waiting_session_name) {
|
|
|
1702 rep_free(rep->waiting_session_name);
|
|
|
1703 rep->waiting_session_name = NULL;
|
|
|
1704 }
|
|
|
1705 return FALSE;
|
|
|
1706 }
|
|
|
1707 session->sid = sid;
|
|
|
1708
|
|
|
1709 /* set session to cursession */
|
|
|
1710 set_cursession(session);
|
|
|
1711 rep_start_create_cmds();
|
|
|
1712
|
|
|
1713 break;
|
|
|
1714 case REP_DEREGISTER_CMD:
|
|
|
1715 case REP_DEREGISTER_ACK:
|
|
|
1716 case REP_QUIT_CMD:
|
|
|
1717 case REP_QUIT_ACK:
|
|
|
1718 case REP_GET_CMD:
|
|
|
1719 case REP_GET_ACK:
|
|
|
1720 break;
|
|
|
1721 case REP_OPEN_CMD:
|
|
|
1722 /* REP_OPEN_CMD is handled in list part. (may be upper function) */
|
|
|
1723 break;
|
|
|
1724
|
|
|
1725 /* connection commands */
|
|
|
1726
|
|
|
1727 case REP_OPEN_ACK:
|
|
|
1728 case REP_CLOSE_CMD:
|
|
|
1729 break;
|
|
|
1730 case REP_CLOSE_ACK:
|
|
|
1731 break;
|
|
|
1732 case REP_READ_CMD:
|
|
|
1733 break;
|
|
|
1734 case REP_READ_ACK:
|
|
|
1735 break;
|
|
|
1736 case REP_READ_FIN:
|
|
|
1737 break;
|
|
|
1738 /* buffer edit commands */
|
|
|
1739 /* session's buffer is set to current buffer */
|
|
|
1740 case REP_INSERT_CMD:
|
|
|
1741 append_memline_wrp(lnum, text);
|
|
|
1742 break;
|
|
|
1743 case REP_DELETE_LINE_CMD:
|
|
|
1744 delete_memline_wrp(lnum);
|
|
|
1745 break;
|
|
|
1746 case REP_REPLACE_CMD:
|
|
|
1747 if (lnum > get_bufmaxline_wrp(session->buf)) {
|
|
|
1748 append_memline_wrp(lnum, text);
|
|
|
1749 }
|
|
|
1750 replace_memline_wrp(lnum, text); /* text was allocated */
|
|
|
1751 break;
|
|
|
1752 default:
|
|
|
1753 break;
|
|
|
1754 }
|
|
|
1755
|
|
|
1756 free_cmdlist(&(tmplist));
|
|
|
1757
|
|
|
1758 return(TRUE);
|
|
|
1759 }
|
|
|
1760
|
|
|
1761
|
|
|
1762 static int
|
|
|
1763 rep_exe_pkt(pkt)
|
|
|
1764 char *pkt;
|
|
|
1765 {
|
|
|
1766 unsigned int cmd;
|
|
|
1767 unsigned int sid;
|
|
|
1768 unsigned int eid;
|
|
|
1769 unsigned int seq;
|
|
|
1770 unsigned int lnum;
|
|
|
1771 unsigned int len;
|
|
|
1772 char *text;
|
|
|
1773
|
|
|
1774 cmd = get_header(pkt, REP_CMD_OFFSET);
|
|
|
1775 sid = get_header(pkt, REP_SID_OFFSET);
|
|
|
1776 eid = get_header(pkt, REP_EID_OFFSET);
|
|
|
1777 seq = get_header(pkt, REP_SEQNUM_OFFSET);
|
|
|
1778 lnum = get_header(pkt, REP_LNUM_OFFSET);
|
|
|
1779 len = get_header(pkt, REP_T_SIZE_OFFSET);
|
|
|
1780 text = pkt + REP_TEXT_OFFSET;
|
|
|
1781
|
|
|
1782 rep_exe_cmd(cmd, sid, eid, seq, lnum, len, text);
|
|
|
1783
|
|
|
1784 return(TRUE);
|
|
|
1785 }
|
|
|
1786
|
|
|
1787 /* execute command list based cmd packet */
|
|
|
1788 static int
|
|
|
1789 rep_exe_pktlist(cmdlist)
|
|
|
1790 rep_cmdlist *cmdlist;
|
|
|
1791 {
|
|
|
1792 rep_cmd *repcmd;
|
|
|
1793 BUFTYPE *orgbuf;
|
|
|
1794 char *sname;
|
|
|
1795
|
|
|
1796 if ((cmdlist == NULL) || (cmdlist->head == NULL)) {
|
|
|
1797 return(FALSE);
|
|
|
1798 }
|
|
|
1799
|
|
|
1800 for (repcmd = cmdlist->head; repcmd; repcmd = repcmd->next) {
|
|
|
1801 if (repcmd->stat == REP_AVAIL) {
|
|
|
1802 rep_exe_pkt(repcmd->pkt);
|
|
|
1803 }
|
|
|
1804 }
|
|
|
1805
|
|
|
1806 return(TRUE);
|
|
|
1807 }
|
|
|
1808
|
|
|
1809
|
|
|
1810 /* execute command list based cmd structure */
|
|
|
1811 /* sn must be already exists */
|
|
|
1812 static int
|
|
|
1813 rep_exe_cmdlist(cmdlist)
|
|
|
1814 rep_cmdlist *cmdlist;
|
|
|
1815 {
|
|
|
1816 rep_cmd *cmd;
|
|
|
1817 BUFTYPE *orgbuf;
|
|
|
1818 unsigned short uid;
|
|
|
1819
|
|
|
1820 if ((cmdlist == NULL) || (cmdlist->head == NULL)) {
|
|
|
1821 return(FALSE);
|
|
|
1822 }
|
|
|
1823
|
|
|
1824 for (cmd = cmdlist->head; cmd; cmd = cmd->next) {
|
|
|
1825 if (cmd->stat == REP_AVAIL) {
|
|
|
1826 rep_exe_cmd(cmd->cmd, cmd->sid, cmd->eid, cmd->seq,
|
|
|
1827 cmd->lnum, cmd->len, cmd->pkt + REP_TEXT_OFFSET);
|
|
|
1828 }
|
|
|
1829 }
|
|
|
1830
|
|
|
1831 return(TRUE);
|
|
|
1832 }
|
|
|
1833
|
|
|
1834
|
|
|
1835
|
|
|
1836
|
|
|
1837 static int
|
|
|
1838 rep_recv_cmds(fd, smcmdlist, txtcmdlist)
|
|
|
1839 int fd;
|
|
|
1840 rep_cmdlist *smcmdlist;
|
|
|
1841 rep_cmdlist *txtcmdlist;
|
|
|
1842 {
|
|
|
1843 unsigned int cmd;
|
|
|
1844 unsigned int sid;
|
|
|
1845 unsigned int eid;
|
|
|
1846 unsigned int seq;
|
|
|
1847 unsigned int lnum;
|
|
|
1848 unsigned int textsize;
|
|
|
1849
|
|
|
1850 char header[REP_HEADER_SIZE];
|
|
|
1851
|
|
|
1852 char *text = NULL;
|
|
|
1853 int retval;
|
|
|
1854
|
|
|
1855 if (fd < 0) {
|
|
|
1856 return(FALSE);
|
|
|
1857 }
|
|
|
1858
|
|
|
1859 /* 一定時間読み取るようにしたい */
|
|
|
1860
|
|
|
1861 /* read header part */
|
|
|
1862 if (readn(fd, header, REP_HEADER_SIZE) < 0) {
|
|
|
1863 puts_sys_err();
|
|
|
1864 return(FALSE);
|
|
|
1865 }
|
|
|
1866
|
|
|
1867 cmd = get_header(header, REP_CMD_OFFSET);
|
|
|
1868 sid = get_header(header, REP_SID_OFFSET);
|
|
|
1869 eid = get_header(header, REP_EID_OFFSET);
|
|
|
1870 seq = get_header(header, REP_SEQNUM_OFFSET);
|
|
|
1871 lnum = get_header(header, REP_LNUM_OFFSET);
|
|
|
1872 textsize = get_header(header, REP_T_SIZE_OFFSET);
|
|
|
1873
|
|
|
1874 if (textsize > 0) {
|
|
|
1875 if ((text = (char*)rep_alloc(textsize)) == NULL) {
|
|
|
1876 return(FALSE);
|
|
|
1877 }
|
|
|
1878 /* read text part */
|
|
|
1879 if (readn(fd, text, textsize) < 0) {
|
|
|
1880 puts_sys_err();
|
|
|
1881 rep_free(text);
|
|
|
1882 return(FALSE);
|
|
|
1883 }
|
|
|
1884 }
|
|
|
1885
|
|
|
1886 if (cmd == REP_INSERT_CMD ||
|
|
|
1887 cmd == REP_DELETE_LINE_CMD ||
|
|
|
1888 cmd == REP_REPLACE_CMD) {
|
|
|
1889 add_cmd_to_list(txtcmdlist, make_cmd(cmd, sid, eid, seq, lnum, text));
|
|
|
1890 } else {
|
|
|
1891 add_cmd_to_list(smcmdlist, make_cmd(cmd, sid, eid, seq, lnum, text));
|
|
|
1892 }
|
|
|
1893 return(TRUE);
|
|
|
1894 }
|
|
|
1895
|
|
|
1896 void
|
|
|
1897 rep_send_cur_cmdlist()
|
|
|
1898 {
|
|
|
1899 rep_T *rep_p = get_rep();
|
|
|
1900
|
|
|
1901 rep_send_cmds(rep_p->smfd,&(rep_p->cursession->new_cmdlist));
|
|
|
1902
|
|
|
1903 free_cmdlist(&rep_p->cursession->sent_cmdlist);
|
|
|
1904
|
|
|
1905 rep_p->cursession->sent_cmdlist.head = rep_p->cursession->new_cmdlist.head;
|
|
|
1906 rep_p->cursession->sent_cmdlist.num = rep_p->cursession->new_cmdlist.num;
|
|
|
1907
|
|
|
1908 rep_p->cursession->new_cmdlist.head = NULL;
|
|
|
1909 rep_p->cursession->new_cmdlist.num = 0;
|
|
|
1910
|
|
|
1911 return;
|
|
|
1912 }
|
|
|
1913
|
|
|
1914 static int
|
|
|
1915 rep_send_cmds(fd,cmdlist)
|
|
|
1916 int fd;
|
|
|
1917 rep_cmdlist *cmdlist;
|
|
|
1918 {
|
|
|
1919 rep_cmd *cur;
|
|
|
1920 unsigned int nlen;
|
|
|
1921
|
|
|
1922 if ((fd<0) || (cmdlist == NULL)) {
|
|
|
1923 return(FALSE);
|
|
|
1924 }
|
|
|
1925
|
|
|
1926 if ((cmdlist->head == NULL) || (cmdlist->num == 0)) {
|
|
|
1927 return(TRUE);
|
|
|
1928 }
|
|
|
1929
|
|
|
1930 for (cur = cmdlist->head; cur; cur = cur->next) {
|
|
|
1931 if (writen(fd, cur->pkt, cur->len+REP_HEADER_SIZE) < 0) {
|
|
|
1932 return(FALSE);
|
|
|
1933 }
|
|
|
1934 }
|
|
|
1935 return(TRUE);
|
|
|
1936 }
|
|
|
1937
|
|
|
1938 /*
|
|
|
1939 static int
|
|
|
1940 session_fd_check(sn, rfds_p, efds_p)
|
|
|
1941 Session *sn;
|
|
|
1942 fd_set *rfds_p;
|
|
|
1943 fd_set *efds_p;
|
|
|
1944 {
|
|
|
1945 rep_cmdlist smcmdlist = {NULL,0};
|
|
|
1946 rep_cmdlist txtcmdlist = {NULL,0};
|
|
|
1947
|
|
|
1948 if (sn == NULL) return FALSE;
|
|
|
1949
|
|
|
1950 if (sn->smfd > 0) {
|
|
|
1951 if (FD_ISSET(sn->smfd, efds_p)) {
|
|
|
1952 if (sn->rfd != sn->sfd) close(sn->rfd);
|
|
|
1953 sn->rfd = -1;
|
|
|
1954 // 再接続処理をしたい
|
|
|
1955 return FALSE;
|
|
|
1956 } else if (FD_ISSET(sn->rfd, rfds_p)) {
|
|
|
1957 if (rep_recv_cmds(sn->rfd, &(smcmdlist), &(txtcmdlist)) == FALSE) {
|
|
|
1958 if (sn->rfd != sn->sfd) close(sn->rfd);
|
|
|
1959 sn->rfd = -1;
|
|
|
1960 return(FALSE);
|
|
|
1961 }
|
|
|
1962
|
|
|
1963 if ((cmdlist.head) && (cmdlist.head->uid == 99)) { // 単方向コマンド
|
|
|
1964 rep_exe_cmdlist(sn, sn->rfd, &(cmdlist));
|
|
|
1965 free_cmdlist(&(cmdlist));
|
|
|
1966 } else if ((cmdlist.head) && (cmdlist.head->uid == sn->uid)) { // 自分のコマンド
|
|
|
1967 free_cmdlist(&cmdlist);
|
|
|
1968
|
|
|
1969 if (rep_send_cmds(sn->sfd, &(sn->new_cmdlist)) == FALSE) {
|
|
|
1970 if (sn->rfd != sn->sfd) close(sn->sfd);
|
|
|
1971 sn->sfd = -1;
|
|
|
1972 return FALSE;
|
|
|
1973 }
|
|
|
1974
|
|
|
1975 sn->sent_cmdlist.head = sn->new_cmdlist.head;
|
|
|
1976 sn->sent_cmdlist.num = sn->new_cmdlist.num;
|
|
|
1977 sn->new_cmdlist.head = NULL;
|
|
|
1978 sn->new_cmdlist.num = 0;
|
|
|
1979
|
|
|
1980 } else { // リングに流すコマンド
|
|
|
1981 // 受け取ったトークンとユーザからのREPコマンドを比較・マージする
|
|
|
1982 // 既に送信した REPコマンド列 と比較
|
|
|
1983 translate(&(sn->sent_cmdlist), &(cmdlist));
|
|
|
1984 del_ignored_cmd(&(cmdlist));
|
|
|
1985 set_header_to_pkt(&(cmdlist));
|
|
|
1986
|
|
|
1987 if (rep_send_cmds(sn->sfd, &(cmdlist)) == FALSE) {
|
|
|
1988 if (sn->rfd != sn->sfd) close(sn->sfd);
|
|
|
1989 sn->sfd = -1;
|
|
|
1990 free_cmdlist(&(cmdlist));
|
|
|
1991 return FALSE;
|
|
|
1992 }
|
|
|
1993
|
|
|
1994 // 新規に追加された REPコマンド列 との比較
|
|
|
1995 translate(&(sn->new_cmdlist), &(cmdlist));
|
|
|
1996 del_ignored_cmd(&(cmdlist));
|
|
|
1997 set_header_to_pkt(&(sn->new_cmdlist));
|
|
|
1998
|
|
|
1999 // 変換したトークンREPコマンドを自分のバッファに反映する。
|
|
|
2000 //各パケットにはその変換は反映されていない.
|
|
|
2001 rep_exe_cmdlist(sn, sn->rfd, &(cmdlist));
|
|
|
2002
|
|
|
2003 free_cmdlist(&(cmdlist));
|
|
|
2004 }
|
|
|
2005 }
|
|
|
2006 }
|
|
|
2007 if (sn->sfd > 0) {
|
|
|
2008 if (FD_ISSET(sn->sfd, efds_p)) {
|
|
|
2009 if (sn->rfd != sn->sfd) close(sn->sfd);
|
|
|
2010 sn->sfd = -1;
|
|
|
2011 // 再接続処理をしたい
|
|
|
2012 return FALSE;
|
|
|
2013 } else if (FD_ISSET(sn->sfd, rfds_p)) { // from send client
|
|
|
2014 if (rep_recv_cmds(sn->sfd, &cmdlist) == FALSE) {
|
|
|
2015 if (sn->rfd != sn->sfd) close(sn->sfd);
|
|
|
2016 sn->sfd = -1;
|
|
|
2017 return(FALSE);
|
|
|
2018 }
|
|
|
2019 rep_exe_cmdlist(sn, sn->sfd, &cmdlist);
|
|
|
2020 free_cmdlist(&cmdlist);
|
|
|
2021 }
|
|
|
2022 }
|
|
|
2023 }
|
|
|
2024
|
|
|
2025 */
|
|
|
2026
|
|
|
2027 int
|
|
|
2028 rep_fd_check(fd, rfds_p, efds_p)
|
|
|
2029 int fd; // input from keyboard or something...
|
|
|
2030 fd_set *rfds_p; // readable fds
|
|
|
2031 fd_set *efds_p; // include a error fd
|
|
|
2032 {
|
|
|
2033 int newfd;
|
|
|
2034 rep_T *rep_p;
|
|
|
2035 rep_cmdlist smcmdlist = {NULL,0};
|
|
|
2036 rep_cmdlist txtcmdlist = {NULL,0};
|
|
|
2037
|
|
|
2038 Session *sn;
|
|
|
2039
|
|
|
2040 /* input from keyboard is most important.
|
|
|
2041 * reditor has nothing to do */
|
|
|
2042 if (FD_ISSET(fd, rfds_p) || FD_ISSET(fd, efds_p)) {
|
|
|
2043 return(TRUE);
|
|
|
2044 }
|
|
|
2045
|
|
|
2046 rep_p = get_rep();
|
|
|
2047
|
|
|
2048 if ((rep_p->smfd > 0) && (FD_ISSET(rep_p->smfd, rfds_p))) {
|
|
|
2049 /* we don't need this?
|
|
|
2050 // 受け取ったトークンとユーザからのREPコマンドを比較・マージする
|
|
|
2051 // 既に送信した REPコマンド列 と比較
|
|
|
2052 translate(&(sn->sent_cmdlist), &(cmdlist));
|
|
|
2053 del_ignored_cmd(&(cmdlist));
|
|
|
2054 set_header_to_pkt(&(cmdlist));
|
|
|
2055 */
|
|
|
2056
|
|
|
2057 if (rep_recv_cmds(rep_p->smfd, &(smcmdlist), &(txtcmdlist)) == FALSE) {
|
|
|
2058 close(rep_p->smfd);
|
|
|
2059 rep_p->smfd = -1;
|
|
|
2060 return FALSE;
|
|
|
2061 }
|
|
|
2062 /* Session ごとに行う↓*/
|
|
|
2063 for(sn = rep_p->shead; sn ; sn = sn->next) {
|
|
|
2064 translate( &sn->new_cmdlist , &txtcmdlist);
|
|
|
2065 }
|
|
|
2066 del_ignored_cmd(&txtcmdlist);
|
|
|
2067 rep_exe_pktlist(&txtcmdlist);
|
|
|
2068
|
|
|
2069 if (rep_send_cmds(rep_p->smfd, &(txtcmdlist)) == FALSE) {
|
|
|
2070 close(sn->smfd);
|
|
|
2071 sn->smfd = -1;
|
|
|
2072 free_cmdlist(&(txtcmdlist));
|
|
|
2073 return FALSE;
|
|
|
2074 }
|
|
|
2075 free_cmdlist(&(txtcmdlist));
|
|
|
2076
|
|
|
2077 rep_exe_pktlist( &smcmdlist);
|
|
|
2078 free_cmdlist(&(smcmdlist));
|
|
|
2079
|
|
|
2080 return TRUE;
|
|
|
2081 }
|
|
|
2082 rep_exe_pktlist( &smcmdlist);
|
|
|
2083 free_cmdlist(&(smcmdlist));
|
|
|
2084
|
|
|
2085 /*
|
|
|
2086 session_fd_check(rep_p->slineup, rfds_p, efds_p);
|
|
|
2087
|
|
|
2088 for (sn=rep_p->shead; sn; sn=sn->next) {
|
|
|
2089 session_fd_check(sn, rfds_p, efds_p);
|
|
|
2090 }
|
|
|
2091 */
|
|
|
2092
|
|
|
2093 }
|
|
|
2094
|
|
|
2095 /*
|
|
|
2096 static int
|
|
|
2097 session_fd_set(sn, rfds_p, efds_p, max_fds)
|
|
|
2098 Session *sn;
|
|
|
2099 fd_set *rfds_p;
|
|
|
2100 fd_set *efds_p;
|
|
|
2101 int max_fds;
|
|
|
2102 {
|
|
|
2103 if (sn == NULL) return max_fds;
|
|
|
2104
|
|
|
2105 if (sn->rfd > 0) {
|
|
|
2106 FD_SET(sn->rfd, rfds_p);
|
|
|
2107 FD_SET(sn->rfd, efds_p);
|
|
|
2108 if (max_fds < sn->rfd) {
|
|
|
2109 max_fds = sn->rfd;
|
|
|
2110 }
|
|
|
2111 }
|
|
|
2112 if (sn->sfd > 0) {
|
|
|
2113 FD_SET(sn->sfd, rfds_p);
|
|
|
2114 FD_SET(sn->sfd, efds_p);
|
|
|
2115 if (max_fds < sn->sfd) {
|
|
|
2116 max_fds = sn->sfd;
|
|
|
2117 }
|
|
|
2118 }
|
|
|
2119 return max_fds;
|
|
|
2120 }
|
|
|
2121 */
|
|
|
2122
|
|
|
2123
|
|
|
2124 int
|
|
|
2125 rep_fd_set(rfds_p, efds_p, max_fds)
|
|
|
2126 fd_set *rfds_p;
|
|
|
2127 fd_set *efds_p;
|
|
|
2128 int max_fds;
|
|
|
2129 {
|
|
|
2130 rep_T *rep_p;
|
|
|
2131 Session *sn;
|
|
|
2132 int i;
|
|
|
2133
|
|
|
2134 rep_p = get_rep();
|
|
|
2135
|
|
|
2136 if (rep_p->smfd > 0) {
|
|
|
2137 FD_SET(rep_p->smfd,rfds_p);
|
|
|
2138 FD_SET(rep_p->smfd,efds_p);
|
|
|
2139 if(max_fds < rep_p->smfd){
|
|
|
2140 max_fds = rep_p->smfd;
|
|
|
2141 }
|
|
|
2142 }
|
|
|
2143
|
|
|
2144 /*
|
|
|
2145 max_fds = session_fd_set(rep_p->slineup, rfds_p, efds_p, max_fds);
|
|
|
2146
|
|
|
2147 for (sn=rep_p->shead; sn; sn=sn->next) {
|
|
|
2148 max_fds = session_fd_set(sn, rfds_p, efds_p, max_fds);
|
|
|
2149 }
|
|
|
2150 */
|
|
|
2151
|
|
|
2152 return(max_fds);
|
|
|
2153 }
|
|
|
2154
|
|
|
2155
|
|
|
2156
|
|
|
2157 /*
|
|
|
2158 * read などで待つ場合に、この関数で REP 関連のデータをチェックする
|
|
|
2159 * 指定した fd ( read で読みこむ) から入力があるとぬける。
|
|
|
2160 */
|
|
|
2161 int
|
|
|
2162 rep_select(fd)
|
|
|
2163 int fd;
|
|
|
2164 {
|
|
|
2165 fd_set rfds_p;
|
|
|
2166 fd_set efds_p;
|
|
|
2167 int sk;
|
|
|
2168 int max_fds = MAX_FDS;
|
|
|
2169
|
|
|
2170 struct timeval tv;
|
|
|
2171
|
|
|
2172 if (fd < 0) return(FALSE);
|
|
|
2173
|
|
|
2174 while (1) {
|
|
|
2175 /* select の中で modify されてるので、初期化 */
|
|
|
2176 tv.tv_sec = 0;
|
|
|
2177 tv.tv_usec = 100000;
|
|
|
2178 FD_ZERO(&rfds_p);
|
|
|
2179 FD_ZERO(&efds_p);
|
|
|
2180
|
|
|
2181 FD_SET(fd,&rfds_p);
|
|
|
2182
|
|
|
2183 max_fds = rep_fd_set(&rfds_p, &efds_p, max_fds);
|
|
|
2184
|
|
|
2185 if ((sk = select(max_fds+1, &rfds_p, NULL, &efds_p, &tv)) < 0) {
|
|
|
2186 e_msg_wrp("rep_select(): ERROR");
|
|
|
2187 return(FALSE);
|
|
|
2188 }
|
|
|
2189
|
|
|
2190 rep_fd_check(fd, &rfds_p, &efds_p);
|
|
|
2191 return(TRUE);
|
|
|
2192 }
|
|
|
2193 }
|
|
|
2194
|
|
|
2195 void
|
|
|
2196 rep_end()
|
|
|
2197 {
|
|
|
2198 rep_T *rep_p;
|
|
|
2199 rep_p = get_rep();
|
|
|
2200
|
|
|
2201 if (rep_p->shead) free_session_list(rep_p->shead); // cursession is freed
|
|
|
2202 if (rep_p->slineup) free_session(rep_p->slineup);
|
|
|
2203 if (rep_p->servername) free_wrp(rep_p->servername);
|
|
|
2204 if (rep_p->smfd > 0) close(rep_p->smfd);
|
|
|
2205
|
|
|
2206 set_curbuf_wrp(rep_p->scratch_buf);
|
|
|
2207
|
|
|
2208 rep_init();
|
|
|
2209 }
|
|
|
2210
|
|
|
2211
|
|
|
2212 /* append newline separated text to session buf */
|
|
|
2213 static int
|
|
|
2214 append_newline_sep_text(sn, text)
|
|
|
2215 Session *sn;
|
|
|
2216 char *text;
|
|
|
2217 {
|
|
|
2218 char *str;
|
|
|
2219 char *cur;
|
|
|
2220 // BUFTYPE *oldbuf;
|
|
|
2221 Session *oldsn;
|
|
|
2222
|
|
|
2223 /*
|
|
|
2224 *"append_memline()" is available "curbuf" only
|
|
|
2225 * thus, we must set buffer to "curbuf"
|
|
|
2226 */
|
|
|
2227 oldsn = set_cursession(sn);
|
|
|
2228
|
|
|
2229 for (str = cur = text; cur && *cur ; str = cur) {
|
|
|
2230 cur = strchr(str, '\n');
|
|
|
2231 if (cur) {
|
|
|
2232 *cur = '\0';
|
|
|
2233 cur++;
|
|
|
2234 }
|
|
|
2235
|
|
|
2236 append_memline_wrp(1, str);
|
|
|
2237 }
|
|
|
2238
|
|
|
2239 set_cursession(oldsn);
|
|
|
2240
|
|
|
2241 return TRUE;
|
|
|
2242 }
|
|
|
2243
|
|
|
2244 /* return value (file name) is allocated */
|
|
|
2245 static char *
|
|
|
2246 get_sname_by_snum(snum)
|
|
|
2247 int snum;
|
|
|
2248 {
|
|
|
2249 char *tmp, *text, *sname;
|
|
|
2250 int i, len;
|
|
|
2251 int maxlnum;
|
|
|
2252 rep_T *rep = get_rep();
|
|
|
2253
|
|
|
2254 maxlnum = get_bufmaxline_wrp(rep->slineup->buf);
|
|
|
2255
|
|
|
2256 for (i = 1; i <= maxlnum; i++) {
|
|
|
2257 // text is "filename:hostname:sessionnumber"
|
|
|
2258 text = get_memline_wrp(rep->slineup->buf, i);
|
|
|
2259
|
|
|
2260
|
|
|
2261 // get ':' separated last parameter (session number)
|
|
|
2262 if ((tmp = strrchr(text, ':')) == NULL) {
|
|
|
2263 return NULL;
|
|
|
2264 }
|
|
|
2265 tmp++;
|
|
|
2266
|
|
|
2267 if (snum == atol(tmp)) {
|
|
|
2268 // get ':' separated first parameter (filename)
|
|
|
2269 tmp = strchr(text, ':');
|
|
|
2270 len = tmp - text;
|
|
|
2271 if ((sname = (char *)rep_alloc(len+1)) == NULL){
|
|
|
2272 e_msg_wrp("no memory!");
|
|
|
2273 return NULL;
|
|
|
2274 }
|
|
|
2275 memcpy(sname, text, len);
|
|
|
2276 sname[len] = '\0';
|
|
|
2277 return sname;
|
|
|
2278 }
|
|
|
2279 }
|
|
|
2280
|
|
|
2281 return NULL;
|
|
|
2282
|
|
|
2283 }
|
