1 | /*************************************************************************** |
2 | * _ _ ____ _ |
3 | * Project ___| | | | _ \| | |
4 | * / __| | | | |_) | | |
5 | * | (__| |_| | _ <| |___ |
6 | * \___|\___/|_| \_\_____| |
7 | * |
8 | * Copyright (C) 1998 - 2022, Daniel Stenberg, <[email protected]>, et al. |
9 | * |
10 | * This software is licensed as described in the file COPYING, which |
11 | * you should have received as part of this distribution. The terms |
12 | * are also available at https://curl.se/docs/copyright.html. |
13 | * |
14 | * You may opt to use, copy, modify, merge, publish, distribute and/or sell |
15 | * copies of the Software, and permit persons to whom the Software is |
16 | * furnished to do so, under the terms of the COPYING file. |
17 | * |
18 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
19 | * KIND, either express or implied. |
20 | * |
21 | * SPDX-License-Identifier: curl |
22 | * |
23 | ***************************************************************************/ |
24 | |
25 | #include "curl_setup.h" |
26 | |
27 | #ifndef CURL_DISABLE_TELNET |
28 | |
29 | #ifdef HAVE_NETINET_IN_H |
30 | #include <netinet/in.h> |
31 | #endif |
32 | #ifdef HAVE_NETDB_H |
33 | #include <netdb.h> |
34 | #endif |
35 | #ifdef HAVE_ARPA_INET_H |
36 | #include <arpa/inet.h> |
37 | #endif |
38 | #ifdef HAVE_NET_IF_H |
39 | #include <net/if.h> |
40 | #endif |
41 | #ifdef HAVE_SYS_IOCTL_H |
42 | #include <sys/ioctl.h> |
43 | #endif |
44 | |
45 | #ifdef HAVE_SYS_PARAM_H |
46 | #include <sys/param.h> |
47 | #endif |
48 | |
49 | #include "urldata.h" |
50 | #include <curl/curl.h> |
51 | #include "transfer.h" |
52 | #include "sendf.h" |
53 | #include "telnet.h" |
54 | #include "connect.h" |
55 | #include "progress.h" |
56 | #include "system_win32.h" |
57 | #include "arpa_telnet.h" |
58 | #include "select.h" |
59 | #include "strcase.h" |
60 | #include "warnless.h" |
61 | |
62 | /* The last 3 #include files should be in this order */ |
63 | #include "curl_printf.h" |
64 | #include "curl_memory.h" |
65 | #include "memdebug.h" |
66 | |
67 | #define SUBBUFSIZE 512 |
68 | |
69 | #define CURL_SB_CLEAR(x) x->subpointer = x->subbuffer |
70 | #define CURL_SB_TERM(x) \ |
71 | do { \ |
72 | x->subend = x->subpointer; \ |
73 | CURL_SB_CLEAR(x); \ |
74 | } while(0) |
75 | #define CURL_SB_ACCUM(x,c) \ |
76 | do { \ |
77 | if(x->subpointer < (x->subbuffer + sizeof(x->subbuffer))) \ |
78 | *x->subpointer++ = (c); \ |
79 | } while(0) |
80 | |
81 | #define CURL_SB_GET(x) ((*x->subpointer++)&0xff) |
82 | #define CURL_SB_LEN(x) (x->subend - x->subpointer) |
83 | |
84 | /* For posterity: |
85 | #define CURL_SB_PEEK(x) ((*x->subpointer)&0xff) |
86 | #define CURL_SB_EOF(x) (x->subpointer >= x->subend) */ |
87 | |
88 | #ifdef CURL_DISABLE_VERBOSE_STRINGS |
89 | #define printoption(a,b,c,d) Curl_nop_stmt |
90 | #endif |
91 | |
92 | static |
93 | CURLcode telrcv(struct Curl_easy *data, |
94 | const unsigned char *inbuf, /* Data received from socket */ |
95 | ssize_t count); /* Number of bytes received */ |
96 | |
97 | #ifndef CURL_DISABLE_VERBOSE_STRINGS |
98 | static void printoption(struct Curl_easy *data, |
99 | const char *direction, |
100 | int cmd, int option); |
101 | #endif |
102 | |
103 | static void negotiate(struct Curl_easy *data); |
104 | static void send_negotiation(struct Curl_easy *data, int cmd, int option); |
105 | static void set_local_option(struct Curl_easy *data, |
106 | int option, int newstate); |
107 | static void set_remote_option(struct Curl_easy *data, |
108 | int option, int newstate); |
109 | |
110 | static void printsub(struct Curl_easy *data, |
111 | int direction, unsigned char *pointer, |
112 | size_t length); |
113 | static void suboption(struct Curl_easy *data); |
114 | static void sendsuboption(struct Curl_easy *data, int option); |
115 | |
116 | static CURLcode telnet_do(struct Curl_easy *data, bool *done); |
117 | static CURLcode telnet_done(struct Curl_easy *data, |
118 | CURLcode, bool premature); |
119 | static CURLcode send_telnet_data(struct Curl_easy *data, |
120 | char *buffer, ssize_t nread); |
121 | |
122 | /* For negotiation compliant to RFC 1143 */ |
123 | #define CURL_NO 0 |
124 | #define CURL_YES 1 |
125 | #define CURL_WANTYES 2 |
126 | #define CURL_WANTNO 3 |
127 | |
128 | #define CURL_EMPTY 0 |
129 | #define CURL_OPPOSITE 1 |
130 | |
131 | /* |
132 | * Telnet receiver states for fsm |
133 | */ |
134 | typedef enum |
135 | { |
136 | CURL_TS_DATA = 0, |
137 | CURL_TS_IAC, |
138 | CURL_TS_WILL, |
139 | CURL_TS_WONT, |
140 | CURL_TS_DO, |
141 | CURL_TS_DONT, |
142 | CURL_TS_CR, |
143 | CURL_TS_SB, /* sub-option collection */ |
144 | CURL_TS_SE /* looking for sub-option end */ |
145 | } TelnetReceive; |
146 | |
147 | struct TELNET { |
148 | int please_negotiate; |
149 | int already_negotiated; |
150 | int us[256]; |
151 | int usq[256]; |
152 | int us_preferred[256]; |
153 | int him[256]; |
154 | int himq[256]; |
155 | int him_preferred[256]; |
156 | int subnegotiation[256]; |
157 | char subopt_ttype[32]; /* Set with suboption TTYPE */ |
158 | char subopt_xdisploc[128]; /* Set with suboption XDISPLOC */ |
159 | unsigned short subopt_wsx; /* Set with suboption NAWS */ |
160 | unsigned short subopt_wsy; /* Set with suboption NAWS */ |
161 | TelnetReceive telrcv_state; |
162 | struct curl_slist *telnet_vars; /* Environment variables */ |
163 | |
164 | /* suboptions */ |
165 | unsigned char subbuffer[SUBBUFSIZE]; |
166 | unsigned char *subpointer, *subend; /* buffer for sub-options */ |
167 | }; |
168 | |
169 | |
170 | /* |
171 | * TELNET protocol handler. |
172 | */ |
173 | |
174 | const struct Curl_handler Curl_handler_telnet = { |
175 | "TELNET" , /* scheme */ |
176 | ZERO_NULL, /* setup_connection */ |
177 | telnet_do, /* do_it */ |
178 | telnet_done, /* done */ |
179 | ZERO_NULL, /* do_more */ |
180 | ZERO_NULL, /* connect_it */ |
181 | ZERO_NULL, /* connecting */ |
182 | ZERO_NULL, /* doing */ |
183 | ZERO_NULL, /* proto_getsock */ |
184 | ZERO_NULL, /* doing_getsock */ |
185 | ZERO_NULL, /* domore_getsock */ |
186 | ZERO_NULL, /* perform_getsock */ |
187 | ZERO_NULL, /* disconnect */ |
188 | ZERO_NULL, /* readwrite */ |
189 | ZERO_NULL, /* connection_check */ |
190 | ZERO_NULL, /* attach connection */ |
191 | PORT_TELNET, /* defport */ |
192 | CURLPROTO_TELNET, /* protocol */ |
193 | CURLPROTO_TELNET, /* family */ |
194 | PROTOPT_NONE | PROTOPT_NOURLQUERY /* flags */ |
195 | }; |
196 | |
197 | |
198 | static |
199 | CURLcode init_telnet(struct Curl_easy *data) |
200 | { |
201 | struct TELNET *tn; |
202 | |
203 | tn = calloc(1, sizeof(struct TELNET)); |
204 | if(!tn) |
205 | return CURLE_OUT_OF_MEMORY; |
206 | |
207 | data->req.p.telnet = tn; /* make us known */ |
208 | |
209 | tn->telrcv_state = CURL_TS_DATA; |
210 | |
211 | /* Init suboptions */ |
212 | CURL_SB_CLEAR(tn); |
213 | |
214 | /* Set the options we want by default */ |
215 | tn->us_preferred[CURL_TELOPT_SGA] = CURL_YES; |
216 | tn->him_preferred[CURL_TELOPT_SGA] = CURL_YES; |
217 | |
218 | /* To be compliant with previous releases of libcurl |
219 | we enable this option by default. This behavior |
220 | can be changed thanks to the "BINARY" option in |
221 | CURLOPT_TELNETOPTIONS |
222 | */ |
223 | tn->us_preferred[CURL_TELOPT_BINARY] = CURL_YES; |
224 | tn->him_preferred[CURL_TELOPT_BINARY] = CURL_YES; |
225 | |
226 | /* We must allow the server to echo what we sent |
227 | but it is not necessary to request the server |
228 | to do so (it might forces the server to close |
229 | the connection). Hence, we ignore ECHO in the |
230 | negotiate function |
231 | */ |
232 | tn->him_preferred[CURL_TELOPT_ECHO] = CURL_YES; |
233 | |
234 | /* Set the subnegotiation fields to send information |
235 | just after negotiation passed (do/will) |
236 | |
237 | Default values are (0,0) initialized by calloc. |
238 | According to the RFC1013 it is valid: |
239 | A value equal to zero is acceptable for the width (or height), |
240 | and means that no character width (or height) is being sent. |
241 | In this case, the width (or height) that will be assumed by the |
242 | Telnet server is operating system specific (it will probably be |
243 | based upon the terminal type information that may have been sent |
244 | using the TERMINAL TYPE Telnet option). */ |
245 | tn->subnegotiation[CURL_TELOPT_NAWS] = CURL_YES; |
246 | return CURLE_OK; |
247 | } |
248 | |
249 | static void negotiate(struct Curl_easy *data) |
250 | { |
251 | int i; |
252 | struct TELNET *tn = data->req.p.telnet; |
253 | |
254 | for(i = 0; i < CURL_NTELOPTS; i++) { |
255 | if(i == CURL_TELOPT_ECHO) |
256 | continue; |
257 | |
258 | if(tn->us_preferred[i] == CURL_YES) |
259 | set_local_option(data, i, CURL_YES); |
260 | |
261 | if(tn->him_preferred[i] == CURL_YES) |
262 | set_remote_option(data, i, CURL_YES); |
263 | } |
264 | } |
265 | |
266 | #ifndef CURL_DISABLE_VERBOSE_STRINGS |
267 | static void printoption(struct Curl_easy *data, |
268 | const char *direction, int cmd, int option) |
269 | { |
270 | if(data->set.verbose) { |
271 | if(cmd == CURL_IAC) { |
272 | if(CURL_TELCMD_OK(option)) |
273 | infof(data, "%s IAC %s" , direction, CURL_TELCMD(option)); |
274 | else |
275 | infof(data, "%s IAC %d" , direction, option); |
276 | } |
277 | else { |
278 | const char *fmt = (cmd == CURL_WILL) ? "WILL" : |
279 | (cmd == CURL_WONT) ? "WONT" : |
280 | (cmd == CURL_DO) ? "DO" : |
281 | (cmd == CURL_DONT) ? "DONT" : 0; |
282 | if(fmt) { |
283 | const char *opt; |
284 | if(CURL_TELOPT_OK(option)) |
285 | opt = CURL_TELOPT(option); |
286 | else if(option == CURL_TELOPT_EXOPL) |
287 | opt = "EXOPL" ; |
288 | else |
289 | opt = NULL; |
290 | |
291 | if(opt) |
292 | infof(data, "%s %s %s" , direction, fmt, opt); |
293 | else |
294 | infof(data, "%s %s %d" , direction, fmt, option); |
295 | } |
296 | else |
297 | infof(data, "%s %d %d" , direction, cmd, option); |
298 | } |
299 | } |
300 | } |
301 | #endif |
302 | |
303 | static void send_negotiation(struct Curl_easy *data, int cmd, int option) |
304 | { |
305 | unsigned char buf[3]; |
306 | ssize_t bytes_written; |
307 | struct connectdata *conn = data->conn; |
308 | |
309 | buf[0] = CURL_IAC; |
310 | buf[1] = (unsigned char)cmd; |
311 | buf[2] = (unsigned char)option; |
312 | |
313 | bytes_written = swrite(conn->sock[FIRSTSOCKET], buf, 3); |
314 | if(bytes_written < 0) { |
315 | int err = SOCKERRNO; |
316 | failf(data,"Sending data failed (%d)" ,err); |
317 | } |
318 | |
319 | printoption(data, "SENT" , cmd, option); |
320 | } |
321 | |
322 | static |
323 | void set_remote_option(struct Curl_easy *data, int option, int newstate) |
324 | { |
325 | struct TELNET *tn = data->req.p.telnet; |
326 | if(newstate == CURL_YES) { |
327 | switch(tn->him[option]) { |
328 | case CURL_NO: |
329 | tn->him[option] = CURL_WANTYES; |
330 | send_negotiation(data, CURL_DO, option); |
331 | break; |
332 | |
333 | case CURL_YES: |
334 | /* Already enabled */ |
335 | break; |
336 | |
337 | case CURL_WANTNO: |
338 | switch(tn->himq[option]) { |
339 | case CURL_EMPTY: |
340 | /* Already negotiating for CURL_YES, queue the request */ |
341 | tn->himq[option] = CURL_OPPOSITE; |
342 | break; |
343 | case CURL_OPPOSITE: |
344 | /* Error: already queued an enable request */ |
345 | break; |
346 | } |
347 | break; |
348 | |
349 | case CURL_WANTYES: |
350 | switch(tn->himq[option]) { |
351 | case CURL_EMPTY: |
352 | /* Error: already negotiating for enable */ |
353 | break; |
354 | case CURL_OPPOSITE: |
355 | tn->himq[option] = CURL_EMPTY; |
356 | break; |
357 | } |
358 | break; |
359 | } |
360 | } |
361 | else { /* NO */ |
362 | switch(tn->him[option]) { |
363 | case CURL_NO: |
364 | /* Already disabled */ |
365 | break; |
366 | |
367 | case CURL_YES: |
368 | tn->him[option] = CURL_WANTNO; |
369 | send_negotiation(data, CURL_DONT, option); |
370 | break; |
371 | |
372 | case CURL_WANTNO: |
373 | switch(tn->himq[option]) { |
374 | case CURL_EMPTY: |
375 | /* Already negotiating for NO */ |
376 | break; |
377 | case CURL_OPPOSITE: |
378 | tn->himq[option] = CURL_EMPTY; |
379 | break; |
380 | } |
381 | break; |
382 | |
383 | case CURL_WANTYES: |
384 | switch(tn->himq[option]) { |
385 | case CURL_EMPTY: |
386 | tn->himq[option] = CURL_OPPOSITE; |
387 | break; |
388 | case CURL_OPPOSITE: |
389 | break; |
390 | } |
391 | break; |
392 | } |
393 | } |
394 | } |
395 | |
396 | static |
397 | void rec_will(struct Curl_easy *data, int option) |
398 | { |
399 | struct TELNET *tn = data->req.p.telnet; |
400 | switch(tn->him[option]) { |
401 | case CURL_NO: |
402 | if(tn->him_preferred[option] == CURL_YES) { |
403 | tn->him[option] = CURL_YES; |
404 | send_negotiation(data, CURL_DO, option); |
405 | } |
406 | else |
407 | send_negotiation(data, CURL_DONT, option); |
408 | |
409 | break; |
410 | |
411 | case CURL_YES: |
412 | /* Already enabled */ |
413 | break; |
414 | |
415 | case CURL_WANTNO: |
416 | switch(tn->himq[option]) { |
417 | case CURL_EMPTY: |
418 | /* Error: DONT answered by WILL */ |
419 | tn->him[option] = CURL_NO; |
420 | break; |
421 | case CURL_OPPOSITE: |
422 | /* Error: DONT answered by WILL */ |
423 | tn->him[option] = CURL_YES; |
424 | tn->himq[option] = CURL_EMPTY; |
425 | break; |
426 | } |
427 | break; |
428 | |
429 | case CURL_WANTYES: |
430 | switch(tn->himq[option]) { |
431 | case CURL_EMPTY: |
432 | tn->him[option] = CURL_YES; |
433 | break; |
434 | case CURL_OPPOSITE: |
435 | tn->him[option] = CURL_WANTNO; |
436 | tn->himq[option] = CURL_EMPTY; |
437 | send_negotiation(data, CURL_DONT, option); |
438 | break; |
439 | } |
440 | break; |
441 | } |
442 | } |
443 | |
444 | static |
445 | void rec_wont(struct Curl_easy *data, int option) |
446 | { |
447 | struct TELNET *tn = data->req.p.telnet; |
448 | switch(tn->him[option]) { |
449 | case CURL_NO: |
450 | /* Already disabled */ |
451 | break; |
452 | |
453 | case CURL_YES: |
454 | tn->him[option] = CURL_NO; |
455 | send_negotiation(data, CURL_DONT, option); |
456 | break; |
457 | |
458 | case CURL_WANTNO: |
459 | switch(tn->himq[option]) { |
460 | case CURL_EMPTY: |
461 | tn->him[option] = CURL_NO; |
462 | break; |
463 | |
464 | case CURL_OPPOSITE: |
465 | tn->him[option] = CURL_WANTYES; |
466 | tn->himq[option] = CURL_EMPTY; |
467 | send_negotiation(data, CURL_DO, option); |
468 | break; |
469 | } |
470 | break; |
471 | |
472 | case CURL_WANTYES: |
473 | switch(tn->himq[option]) { |
474 | case CURL_EMPTY: |
475 | tn->him[option] = CURL_NO; |
476 | break; |
477 | case CURL_OPPOSITE: |
478 | tn->him[option] = CURL_NO; |
479 | tn->himq[option] = CURL_EMPTY; |
480 | break; |
481 | } |
482 | break; |
483 | } |
484 | } |
485 | |
486 | static void |
487 | set_local_option(struct Curl_easy *data, int option, int newstate) |
488 | { |
489 | struct TELNET *tn = data->req.p.telnet; |
490 | if(newstate == CURL_YES) { |
491 | switch(tn->us[option]) { |
492 | case CURL_NO: |
493 | tn->us[option] = CURL_WANTYES; |
494 | send_negotiation(data, CURL_WILL, option); |
495 | break; |
496 | |
497 | case CURL_YES: |
498 | /* Already enabled */ |
499 | break; |
500 | |
501 | case CURL_WANTNO: |
502 | switch(tn->usq[option]) { |
503 | case CURL_EMPTY: |
504 | /* Already negotiating for CURL_YES, queue the request */ |
505 | tn->usq[option] = CURL_OPPOSITE; |
506 | break; |
507 | case CURL_OPPOSITE: |
508 | /* Error: already queued an enable request */ |
509 | break; |
510 | } |
511 | break; |
512 | |
513 | case CURL_WANTYES: |
514 | switch(tn->usq[option]) { |
515 | case CURL_EMPTY: |
516 | /* Error: already negotiating for enable */ |
517 | break; |
518 | case CURL_OPPOSITE: |
519 | tn->usq[option] = CURL_EMPTY; |
520 | break; |
521 | } |
522 | break; |
523 | } |
524 | } |
525 | else { /* NO */ |
526 | switch(tn->us[option]) { |
527 | case CURL_NO: |
528 | /* Already disabled */ |
529 | break; |
530 | |
531 | case CURL_YES: |
532 | tn->us[option] = CURL_WANTNO; |
533 | send_negotiation(data, CURL_WONT, option); |
534 | break; |
535 | |
536 | case CURL_WANTNO: |
537 | switch(tn->usq[option]) { |
538 | case CURL_EMPTY: |
539 | /* Already negotiating for NO */ |
540 | break; |
541 | case CURL_OPPOSITE: |
542 | tn->usq[option] = CURL_EMPTY; |
543 | break; |
544 | } |
545 | break; |
546 | |
547 | case CURL_WANTYES: |
548 | switch(tn->usq[option]) { |
549 | case CURL_EMPTY: |
550 | tn->usq[option] = CURL_OPPOSITE; |
551 | break; |
552 | case CURL_OPPOSITE: |
553 | break; |
554 | } |
555 | break; |
556 | } |
557 | } |
558 | } |
559 | |
560 | static |
561 | void rec_do(struct Curl_easy *data, int option) |
562 | { |
563 | struct TELNET *tn = data->req.p.telnet; |
564 | switch(tn->us[option]) { |
565 | case CURL_NO: |
566 | if(tn->us_preferred[option] == CURL_YES) { |
567 | tn->us[option] = CURL_YES; |
568 | send_negotiation(data, CURL_WILL, option); |
569 | if(tn->subnegotiation[option] == CURL_YES) |
570 | /* transmission of data option */ |
571 | sendsuboption(data, option); |
572 | } |
573 | else if(tn->subnegotiation[option] == CURL_YES) { |
574 | /* send information to achieve this option*/ |
575 | tn->us[option] = CURL_YES; |
576 | send_negotiation(data, CURL_WILL, option); |
577 | sendsuboption(data, option); |
578 | } |
579 | else |
580 | send_negotiation(data, CURL_WONT, option); |
581 | break; |
582 | |
583 | case CURL_YES: |
584 | /* Already enabled */ |
585 | break; |
586 | |
587 | case CURL_WANTNO: |
588 | switch(tn->usq[option]) { |
589 | case CURL_EMPTY: |
590 | /* Error: DONT answered by WILL */ |
591 | tn->us[option] = CURL_NO; |
592 | break; |
593 | case CURL_OPPOSITE: |
594 | /* Error: DONT answered by WILL */ |
595 | tn->us[option] = CURL_YES; |
596 | tn->usq[option] = CURL_EMPTY; |
597 | break; |
598 | } |
599 | break; |
600 | |
601 | case CURL_WANTYES: |
602 | switch(tn->usq[option]) { |
603 | case CURL_EMPTY: |
604 | tn->us[option] = CURL_YES; |
605 | if(tn->subnegotiation[option] == CURL_YES) { |
606 | /* transmission of data option */ |
607 | sendsuboption(data, option); |
608 | } |
609 | break; |
610 | case CURL_OPPOSITE: |
611 | tn->us[option] = CURL_WANTNO; |
612 | tn->himq[option] = CURL_EMPTY; |
613 | send_negotiation(data, CURL_WONT, option); |
614 | break; |
615 | } |
616 | break; |
617 | } |
618 | } |
619 | |
620 | static |
621 | void rec_dont(struct Curl_easy *data, int option) |
622 | { |
623 | struct TELNET *tn = data->req.p.telnet; |
624 | switch(tn->us[option]) { |
625 | case CURL_NO: |
626 | /* Already disabled */ |
627 | break; |
628 | |
629 | case CURL_YES: |
630 | tn->us[option] = CURL_NO; |
631 | send_negotiation(data, CURL_WONT, option); |
632 | break; |
633 | |
634 | case CURL_WANTNO: |
635 | switch(tn->usq[option]) { |
636 | case CURL_EMPTY: |
637 | tn->us[option] = CURL_NO; |
638 | break; |
639 | |
640 | case CURL_OPPOSITE: |
641 | tn->us[option] = CURL_WANTYES; |
642 | tn->usq[option] = CURL_EMPTY; |
643 | send_negotiation(data, CURL_WILL, option); |
644 | break; |
645 | } |
646 | break; |
647 | |
648 | case CURL_WANTYES: |
649 | switch(tn->usq[option]) { |
650 | case CURL_EMPTY: |
651 | tn->us[option] = CURL_NO; |
652 | break; |
653 | case CURL_OPPOSITE: |
654 | tn->us[option] = CURL_NO; |
655 | tn->usq[option] = CURL_EMPTY; |
656 | break; |
657 | } |
658 | break; |
659 | } |
660 | } |
661 | |
662 | |
663 | static void printsub(struct Curl_easy *data, |
664 | int direction, /* '<' or '>' */ |
665 | unsigned char *pointer, /* where suboption data is */ |
666 | size_t length) /* length of suboption data */ |
667 | { |
668 | if(data->set.verbose) { |
669 | unsigned int i = 0; |
670 | if(direction) { |
671 | infof(data, "%s IAC SB " , (direction == '<')? "RCVD" :"SENT" ); |
672 | if(length >= 3) { |
673 | int j; |
674 | |
675 | i = pointer[length-2]; |
676 | j = pointer[length-1]; |
677 | |
678 | if(i != CURL_IAC || j != CURL_SE) { |
679 | infof(data, "(terminated by " ); |
680 | if(CURL_TELOPT_OK(i)) |
681 | infof(data, "%s " , CURL_TELOPT(i)); |
682 | else if(CURL_TELCMD_OK(i)) |
683 | infof(data, "%s " , CURL_TELCMD(i)); |
684 | else |
685 | infof(data, "%u " , i); |
686 | if(CURL_TELOPT_OK(j)) |
687 | infof(data, "%s" , CURL_TELOPT(j)); |
688 | else if(CURL_TELCMD_OK(j)) |
689 | infof(data, "%s" , CURL_TELCMD(j)); |
690 | else |
691 | infof(data, "%d" , j); |
692 | infof(data, ", not IAC SE) " ); |
693 | } |
694 | } |
695 | length -= 2; |
696 | } |
697 | if(length < 1) { |
698 | infof(data, "(Empty suboption?)" ); |
699 | return; |
700 | } |
701 | |
702 | if(CURL_TELOPT_OK(pointer[0])) { |
703 | switch(pointer[0]) { |
704 | case CURL_TELOPT_TTYPE: |
705 | case CURL_TELOPT_XDISPLOC: |
706 | case CURL_TELOPT_NEW_ENVIRON: |
707 | case CURL_TELOPT_NAWS: |
708 | infof(data, "%s" , CURL_TELOPT(pointer[0])); |
709 | break; |
710 | default: |
711 | infof(data, "%s (unsupported)" , CURL_TELOPT(pointer[0])); |
712 | break; |
713 | } |
714 | } |
715 | else |
716 | infof(data, "%d (unknown)" , pointer[i]); |
717 | |
718 | switch(pointer[0]) { |
719 | case CURL_TELOPT_NAWS: |
720 | if(length > 4) |
721 | infof(data, "Width: %d ; Height: %d" , (pointer[1]<<8) | pointer[2], |
722 | (pointer[3]<<8) | pointer[4]); |
723 | break; |
724 | default: |
725 | switch(pointer[1]) { |
726 | case CURL_TELQUAL_IS: |
727 | infof(data, " IS" ); |
728 | break; |
729 | case CURL_TELQUAL_SEND: |
730 | infof(data, " SEND" ); |
731 | break; |
732 | case CURL_TELQUAL_INFO: |
733 | infof(data, " INFO/REPLY" ); |
734 | break; |
735 | case CURL_TELQUAL_NAME: |
736 | infof(data, " NAME" ); |
737 | break; |
738 | } |
739 | |
740 | switch(pointer[0]) { |
741 | case CURL_TELOPT_TTYPE: |
742 | case CURL_TELOPT_XDISPLOC: |
743 | pointer[length] = 0; |
744 | infof(data, " \"%s\"" , &pointer[2]); |
745 | break; |
746 | case CURL_TELOPT_NEW_ENVIRON: |
747 | if(pointer[1] == CURL_TELQUAL_IS) { |
748 | infof(data, " " ); |
749 | for(i = 3; i < length; i++) { |
750 | switch(pointer[i]) { |
751 | case CURL_NEW_ENV_VAR: |
752 | infof(data, ", " ); |
753 | break; |
754 | case CURL_NEW_ENV_VALUE: |
755 | infof(data, " = " ); |
756 | break; |
757 | default: |
758 | infof(data, "%c" , pointer[i]); |
759 | break; |
760 | } |
761 | } |
762 | } |
763 | break; |
764 | default: |
765 | for(i = 2; i < length; i++) |
766 | infof(data, " %.2x" , pointer[i]); |
767 | break; |
768 | } |
769 | } |
770 | } |
771 | } |
772 | |
773 | static CURLcode check_telnet_options(struct Curl_easy *data) |
774 | { |
775 | struct curl_slist *head; |
776 | struct curl_slist *beg; |
777 | char option_keyword[128] = "" ; |
778 | char option_arg[256] = "" ; |
779 | struct TELNET *tn = data->req.p.telnet; |
780 | struct connectdata *conn = data->conn; |
781 | CURLcode result = CURLE_OK; |
782 | int binary_option; |
783 | |
784 | /* Add the user name as an environment variable if it |
785 | was given on the command line */ |
786 | if(data->state.aptr.user) { |
787 | msnprintf(option_arg, sizeof(option_arg), "USER,%s" , conn->user); |
788 | beg = curl_slist_append(tn->telnet_vars, option_arg); |
789 | if(!beg) { |
790 | curl_slist_free_all(tn->telnet_vars); |
791 | tn->telnet_vars = NULL; |
792 | return CURLE_OUT_OF_MEMORY; |
793 | } |
794 | tn->telnet_vars = beg; |
795 | tn->us_preferred[CURL_TELOPT_NEW_ENVIRON] = CURL_YES; |
796 | } |
797 | |
798 | for(head = data->set.telnet_options; head; head = head->next) { |
799 | if(sscanf(head->data, "%127[^= ]%*[ =]%255s" , |
800 | option_keyword, option_arg) == 2) { |
801 | |
802 | /* Terminal type */ |
803 | if(strcasecompare(option_keyword, "TTYPE" )) { |
804 | strncpy(tn->subopt_ttype, option_arg, 31); |
805 | tn->subopt_ttype[31] = 0; /* String termination */ |
806 | tn->us_preferred[CURL_TELOPT_TTYPE] = CURL_YES; |
807 | continue; |
808 | } |
809 | |
810 | /* Display variable */ |
811 | if(strcasecompare(option_keyword, "XDISPLOC" )) { |
812 | strncpy(tn->subopt_xdisploc, option_arg, 127); |
813 | tn->subopt_xdisploc[127] = 0; /* String termination */ |
814 | tn->us_preferred[CURL_TELOPT_XDISPLOC] = CURL_YES; |
815 | continue; |
816 | } |
817 | |
818 | /* Environment variable */ |
819 | if(strcasecompare(option_keyword, "NEW_ENV" )) { |
820 | beg = curl_slist_append(tn->telnet_vars, option_arg); |
821 | if(!beg) { |
822 | result = CURLE_OUT_OF_MEMORY; |
823 | break; |
824 | } |
825 | tn->telnet_vars = beg; |
826 | tn->us_preferred[CURL_TELOPT_NEW_ENVIRON] = CURL_YES; |
827 | continue; |
828 | } |
829 | |
830 | /* Window Size */ |
831 | if(strcasecompare(option_keyword, "WS" )) { |
832 | if(sscanf(option_arg, "%hu%*[xX]%hu" , |
833 | &tn->subopt_wsx, &tn->subopt_wsy) == 2) |
834 | tn->us_preferred[CURL_TELOPT_NAWS] = CURL_YES; |
835 | else { |
836 | failf(data, "Syntax error in telnet option: %s" , head->data); |
837 | result = CURLE_SETOPT_OPTION_SYNTAX; |
838 | break; |
839 | } |
840 | continue; |
841 | } |
842 | |
843 | /* To take care or not of the 8th bit in data exchange */ |
844 | if(strcasecompare(option_keyword, "BINARY" )) { |
845 | binary_option = atoi(option_arg); |
846 | if(binary_option != 1) { |
847 | tn->us_preferred[CURL_TELOPT_BINARY] = CURL_NO; |
848 | tn->him_preferred[CURL_TELOPT_BINARY] = CURL_NO; |
849 | } |
850 | continue; |
851 | } |
852 | |
853 | failf(data, "Unknown telnet option %s" , head->data); |
854 | result = CURLE_UNKNOWN_OPTION; |
855 | break; |
856 | } |
857 | failf(data, "Syntax error in telnet option: %s" , head->data); |
858 | result = CURLE_SETOPT_OPTION_SYNTAX; |
859 | break; |
860 | } |
861 | |
862 | if(result) { |
863 | curl_slist_free_all(tn->telnet_vars); |
864 | tn->telnet_vars = NULL; |
865 | } |
866 | |
867 | return result; |
868 | } |
869 | |
870 | /* |
871 | * suboption() |
872 | * |
873 | * Look at the sub-option buffer, and try to be helpful to the other |
874 | * side. |
875 | */ |
876 | |
877 | static void suboption(struct Curl_easy *data) |
878 | { |
879 | struct curl_slist *v; |
880 | unsigned char temp[2048]; |
881 | ssize_t bytes_written; |
882 | size_t len; |
883 | int err; |
884 | char varname[128] = "" ; |
885 | char varval[128] = "" ; |
886 | struct TELNET *tn = data->req.p.telnet; |
887 | struct connectdata *conn = data->conn; |
888 | |
889 | printsub(data, '<', (unsigned char *)tn->subbuffer, CURL_SB_LEN(tn) + 2); |
890 | switch(CURL_SB_GET(tn)) { |
891 | case CURL_TELOPT_TTYPE: |
892 | len = strlen(tn->subopt_ttype) + 4 + 2; |
893 | msnprintf((char *)temp, sizeof(temp), |
894 | "%c%c%c%c%s%c%c" , CURL_IAC, CURL_SB, CURL_TELOPT_TTYPE, |
895 | CURL_TELQUAL_IS, tn->subopt_ttype, CURL_IAC, CURL_SE); |
896 | bytes_written = swrite(conn->sock[FIRSTSOCKET], temp, len); |
897 | if(bytes_written < 0) { |
898 | err = SOCKERRNO; |
899 | failf(data,"Sending data failed (%d)" ,err); |
900 | } |
901 | printsub(data, '>', &temp[2], len-2); |
902 | break; |
903 | case CURL_TELOPT_XDISPLOC: |
904 | len = strlen(tn->subopt_xdisploc) + 4 + 2; |
905 | msnprintf((char *)temp, sizeof(temp), |
906 | "%c%c%c%c%s%c%c" , CURL_IAC, CURL_SB, CURL_TELOPT_XDISPLOC, |
907 | CURL_TELQUAL_IS, tn->subopt_xdisploc, CURL_IAC, CURL_SE); |
908 | bytes_written = swrite(conn->sock[FIRSTSOCKET], temp, len); |
909 | if(bytes_written < 0) { |
910 | err = SOCKERRNO; |
911 | failf(data,"Sending data failed (%d)" ,err); |
912 | } |
913 | printsub(data, '>', &temp[2], len-2); |
914 | break; |
915 | case CURL_TELOPT_NEW_ENVIRON: |
916 | msnprintf((char *)temp, sizeof(temp), |
917 | "%c%c%c%c" , CURL_IAC, CURL_SB, CURL_TELOPT_NEW_ENVIRON, |
918 | CURL_TELQUAL_IS); |
919 | len = 4; |
920 | |
921 | for(v = tn->telnet_vars; v; v = v->next) { |
922 | size_t tmplen = (strlen(v->data) + 1); |
923 | /* Add the variable only if it fits */ |
924 | if(len + tmplen < (int)sizeof(temp)-6) { |
925 | int rv; |
926 | char sep[2] = "" ; |
927 | varval[0] = 0; |
928 | rv = sscanf(v->data, "%127[^,]%1[,]%127s" , varname, sep, varval); |
929 | if(rv == 1) |
930 | len += msnprintf((char *)&temp[len], sizeof(temp) - len, |
931 | "%c%s" , CURL_NEW_ENV_VAR, varname); |
932 | else if(rv >= 2) |
933 | len += msnprintf((char *)&temp[len], sizeof(temp) - len, |
934 | "%c%s%c%s" , CURL_NEW_ENV_VAR, varname, |
935 | CURL_NEW_ENV_VALUE, varval); |
936 | } |
937 | } |
938 | msnprintf((char *)&temp[len], sizeof(temp) - len, |
939 | "%c%c" , CURL_IAC, CURL_SE); |
940 | len += 2; |
941 | bytes_written = swrite(conn->sock[FIRSTSOCKET], temp, len); |
942 | if(bytes_written < 0) { |
943 | err = SOCKERRNO; |
944 | failf(data,"Sending data failed (%d)" ,err); |
945 | } |
946 | printsub(data, '>', &temp[2], len-2); |
947 | break; |
948 | } |
949 | return; |
950 | } |
951 | |
952 | |
953 | /* |
954 | * sendsuboption() |
955 | * |
956 | * Send suboption information to the server side. |
957 | */ |
958 | |
959 | static void sendsuboption(struct Curl_easy *data, int option) |
960 | { |
961 | ssize_t bytes_written; |
962 | int err; |
963 | unsigned short x, y; |
964 | unsigned char *uc1, *uc2; |
965 | struct TELNET *tn = data->req.p.telnet; |
966 | struct connectdata *conn = data->conn; |
967 | |
968 | switch(option) { |
969 | case CURL_TELOPT_NAWS: |
970 | /* We prepare data to be sent */ |
971 | CURL_SB_CLEAR(tn); |
972 | CURL_SB_ACCUM(tn, CURL_IAC); |
973 | CURL_SB_ACCUM(tn, CURL_SB); |
974 | CURL_SB_ACCUM(tn, CURL_TELOPT_NAWS); |
975 | /* We must deal either with little or big endian processors */ |
976 | /* Window size must be sent according to the 'network order' */ |
977 | x = htons(tn->subopt_wsx); |
978 | y = htons(tn->subopt_wsy); |
979 | uc1 = (unsigned char *)&x; |
980 | uc2 = (unsigned char *)&y; |
981 | CURL_SB_ACCUM(tn, uc1[0]); |
982 | CURL_SB_ACCUM(tn, uc1[1]); |
983 | CURL_SB_ACCUM(tn, uc2[0]); |
984 | CURL_SB_ACCUM(tn, uc2[1]); |
985 | |
986 | CURL_SB_ACCUM(tn, CURL_IAC); |
987 | CURL_SB_ACCUM(tn, CURL_SE); |
988 | CURL_SB_TERM(tn); |
989 | /* data suboption is now ready */ |
990 | |
991 | printsub(data, '>', (unsigned char *)tn->subbuffer + 2, |
992 | CURL_SB_LEN(tn)-2); |
993 | |
994 | /* we send the header of the suboption... */ |
995 | bytes_written = swrite(conn->sock[FIRSTSOCKET], tn->subbuffer, 3); |
996 | if(bytes_written < 0) { |
997 | err = SOCKERRNO; |
998 | failf(data, "Sending data failed (%d)" , err); |
999 | } |
1000 | /* ... then the window size with the send_telnet_data() function |
1001 | to deal with 0xFF cases ... */ |
1002 | send_telnet_data(data, (char *)tn->subbuffer + 3, 4); |
1003 | /* ... and the footer */ |
1004 | bytes_written = swrite(conn->sock[FIRSTSOCKET], tn->subbuffer + 7, 2); |
1005 | if(bytes_written < 0) { |
1006 | err = SOCKERRNO; |
1007 | failf(data, "Sending data failed (%d)" , err); |
1008 | } |
1009 | break; |
1010 | } |
1011 | } |
1012 | |
1013 | |
1014 | static |
1015 | CURLcode telrcv(struct Curl_easy *data, |
1016 | const unsigned char *inbuf, /* Data received from socket */ |
1017 | ssize_t count) /* Number of bytes received */ |
1018 | { |
1019 | unsigned char c; |
1020 | CURLcode result; |
1021 | int in = 0; |
1022 | int startwrite = -1; |
1023 | struct TELNET *tn = data->req.p.telnet; |
1024 | |
1025 | #define startskipping() \ |
1026 | if(startwrite >= 0) { \ |
1027 | result = Curl_client_write(data, \ |
1028 | CLIENTWRITE_BODY, \ |
1029 | (char *)&inbuf[startwrite], \ |
1030 | in-startwrite); \ |
1031 | if(result) \ |
1032 | return result; \ |
1033 | } \ |
1034 | startwrite = -1 |
1035 | |
1036 | #define writebyte() \ |
1037 | if(startwrite < 0) \ |
1038 | startwrite = in |
1039 | |
1040 | #define bufferflush() startskipping() |
1041 | |
1042 | while(count--) { |
1043 | c = inbuf[in]; |
1044 | |
1045 | switch(tn->telrcv_state) { |
1046 | case CURL_TS_CR: |
1047 | tn->telrcv_state = CURL_TS_DATA; |
1048 | if(c == '\0') { |
1049 | startskipping(); |
1050 | break; /* Ignore \0 after CR */ |
1051 | } |
1052 | writebyte(); |
1053 | break; |
1054 | |
1055 | case CURL_TS_DATA: |
1056 | if(c == CURL_IAC) { |
1057 | tn->telrcv_state = CURL_TS_IAC; |
1058 | startskipping(); |
1059 | break; |
1060 | } |
1061 | else if(c == '\r') |
1062 | tn->telrcv_state = CURL_TS_CR; |
1063 | writebyte(); |
1064 | break; |
1065 | |
1066 | case CURL_TS_IAC: |
1067 | process_iac: |
1068 | DEBUGASSERT(startwrite < 0); |
1069 | switch(c) { |
1070 | case CURL_WILL: |
1071 | tn->telrcv_state = CURL_TS_WILL; |
1072 | break; |
1073 | case CURL_WONT: |
1074 | tn->telrcv_state = CURL_TS_WONT; |
1075 | break; |
1076 | case CURL_DO: |
1077 | tn->telrcv_state = CURL_TS_DO; |
1078 | break; |
1079 | case CURL_DONT: |
1080 | tn->telrcv_state = CURL_TS_DONT; |
1081 | break; |
1082 | case CURL_SB: |
1083 | CURL_SB_CLEAR(tn); |
1084 | tn->telrcv_state = CURL_TS_SB; |
1085 | break; |
1086 | case CURL_IAC: |
1087 | tn->telrcv_state = CURL_TS_DATA; |
1088 | writebyte(); |
1089 | break; |
1090 | case CURL_DM: |
1091 | case CURL_NOP: |
1092 | case CURL_GA: |
1093 | default: |
1094 | tn->telrcv_state = CURL_TS_DATA; |
1095 | printoption(data, "RCVD" , CURL_IAC, c); |
1096 | break; |
1097 | } |
1098 | break; |
1099 | |
1100 | case CURL_TS_WILL: |
1101 | printoption(data, "RCVD" , CURL_WILL, c); |
1102 | tn->please_negotiate = 1; |
1103 | rec_will(data, c); |
1104 | tn->telrcv_state = CURL_TS_DATA; |
1105 | break; |
1106 | |
1107 | case CURL_TS_WONT: |
1108 | printoption(data, "RCVD" , CURL_WONT, c); |
1109 | tn->please_negotiate = 1; |
1110 | rec_wont(data, c); |
1111 | tn->telrcv_state = CURL_TS_DATA; |
1112 | break; |
1113 | |
1114 | case CURL_TS_DO: |
1115 | printoption(data, "RCVD" , CURL_DO, c); |
1116 | tn->please_negotiate = 1; |
1117 | rec_do(data, c); |
1118 | tn->telrcv_state = CURL_TS_DATA; |
1119 | break; |
1120 | |
1121 | case CURL_TS_DONT: |
1122 | printoption(data, "RCVD" , CURL_DONT, c); |
1123 | tn->please_negotiate = 1; |
1124 | rec_dont(data, c); |
1125 | tn->telrcv_state = CURL_TS_DATA; |
1126 | break; |
1127 | |
1128 | case CURL_TS_SB: |
1129 | if(c == CURL_IAC) |
1130 | tn->telrcv_state = CURL_TS_SE; |
1131 | else |
1132 | CURL_SB_ACCUM(tn, c); |
1133 | break; |
1134 | |
1135 | case CURL_TS_SE: |
1136 | if(c != CURL_SE) { |
1137 | if(c != CURL_IAC) { |
1138 | /* |
1139 | * This is an error. We only expect to get "IAC IAC" or "IAC SE". |
1140 | * Several things may have happened. An IAC was not doubled, the |
1141 | * IAC SE was left off, or another option got inserted into the |
1142 | * suboption are all possibilities. If we assume that the IAC was |
1143 | * not doubled, and really the IAC SE was left off, we could get |
1144 | * into an infinite loop here. So, instead, we terminate the |
1145 | * suboption, and process the partial suboption if we can. |
1146 | */ |
1147 | CURL_SB_ACCUM(tn, CURL_IAC); |
1148 | CURL_SB_ACCUM(tn, c); |
1149 | tn->subpointer -= 2; |
1150 | CURL_SB_TERM(tn); |
1151 | |
1152 | printoption(data, "In SUBOPTION processing, RCVD" , CURL_IAC, c); |
1153 | suboption(data); /* handle sub-option */ |
1154 | tn->telrcv_state = CURL_TS_IAC; |
1155 | goto process_iac; |
1156 | } |
1157 | CURL_SB_ACCUM(tn, c); |
1158 | tn->telrcv_state = CURL_TS_SB; |
1159 | } |
1160 | else { |
1161 | CURL_SB_ACCUM(tn, CURL_IAC); |
1162 | CURL_SB_ACCUM(tn, CURL_SE); |
1163 | tn->subpointer -= 2; |
1164 | CURL_SB_TERM(tn); |
1165 | suboption(data); /* handle sub-option */ |
1166 | tn->telrcv_state = CURL_TS_DATA; |
1167 | } |
1168 | break; |
1169 | } |
1170 | ++in; |
1171 | } |
1172 | bufferflush(); |
1173 | return CURLE_OK; |
1174 | } |
1175 | |
1176 | /* Escape and send a telnet data block */ |
1177 | static CURLcode send_telnet_data(struct Curl_easy *data, |
1178 | char *buffer, ssize_t nread) |
1179 | { |
1180 | ssize_t escapes, i, outlen; |
1181 | unsigned char *outbuf = NULL; |
1182 | CURLcode result = CURLE_OK; |
1183 | ssize_t bytes_written, total_written; |
1184 | struct connectdata *conn = data->conn; |
1185 | |
1186 | /* Determine size of new buffer after escaping */ |
1187 | escapes = 0; |
1188 | for(i = 0; i < nread; i++) |
1189 | if((unsigned char)buffer[i] == CURL_IAC) |
1190 | escapes++; |
1191 | outlen = nread + escapes; |
1192 | |
1193 | if(outlen == nread) |
1194 | outbuf = (unsigned char *)buffer; |
1195 | else { |
1196 | ssize_t j; |
1197 | outbuf = malloc(nread + escapes + 1); |
1198 | if(!outbuf) |
1199 | return CURLE_OUT_OF_MEMORY; |
1200 | |
1201 | j = 0; |
1202 | for(i = 0; i < nread; i++) { |
1203 | outbuf[j++] = buffer[i]; |
1204 | if((unsigned char)buffer[i] == CURL_IAC) |
1205 | outbuf[j++] = CURL_IAC; |
1206 | } |
1207 | outbuf[j] = '\0'; |
1208 | } |
1209 | |
1210 | total_written = 0; |
1211 | while(!result && total_written < outlen) { |
1212 | /* Make sure socket is writable to avoid EWOULDBLOCK condition */ |
1213 | struct pollfd pfd[1]; |
1214 | pfd[0].fd = conn->sock[FIRSTSOCKET]; |
1215 | pfd[0].events = POLLOUT; |
1216 | switch(Curl_poll(pfd, 1, -1)) { |
1217 | case -1: /* error, abort writing */ |
1218 | case 0: /* timeout (will never happen) */ |
1219 | result = CURLE_SEND_ERROR; |
1220 | break; |
1221 | default: /* write! */ |
1222 | bytes_written = 0; |
1223 | result = Curl_write(data, conn->sock[FIRSTSOCKET], |
1224 | outbuf + total_written, |
1225 | outlen - total_written, |
1226 | &bytes_written); |
1227 | total_written += bytes_written; |
1228 | break; |
1229 | } |
1230 | } |
1231 | |
1232 | /* Free malloc copy if escaped */ |
1233 | if(outbuf != (unsigned char *)buffer) |
1234 | free(outbuf); |
1235 | |
1236 | return result; |
1237 | } |
1238 | |
1239 | static CURLcode telnet_done(struct Curl_easy *data, |
1240 | CURLcode status, bool premature) |
1241 | { |
1242 | struct TELNET *tn = data->req.p.telnet; |
1243 | (void)status; /* unused */ |
1244 | (void)premature; /* not used */ |
1245 | |
1246 | if(!tn) |
1247 | return CURLE_OK; |
1248 | |
1249 | curl_slist_free_all(tn->telnet_vars); |
1250 | tn->telnet_vars = NULL; |
1251 | |
1252 | Curl_safefree(data->req.p.telnet); |
1253 | |
1254 | return CURLE_OK; |
1255 | } |
1256 | |
1257 | static CURLcode telnet_do(struct Curl_easy *data, bool *done) |
1258 | { |
1259 | CURLcode result; |
1260 | struct connectdata *conn = data->conn; |
1261 | curl_socket_t sockfd = conn->sock[FIRSTSOCKET]; |
1262 | #ifdef USE_WINSOCK |
1263 | WSAEVENT event_handle; |
1264 | WSANETWORKEVENTS events; |
1265 | HANDLE stdin_handle; |
1266 | HANDLE objs[2]; |
1267 | DWORD obj_count; |
1268 | DWORD wait_timeout; |
1269 | DWORD readfile_read; |
1270 | int err; |
1271 | #else |
1272 | timediff_t interval_ms; |
1273 | struct pollfd pfd[2]; |
1274 | int poll_cnt; |
1275 | curl_off_t total_dl = 0; |
1276 | curl_off_t total_ul = 0; |
1277 | #endif |
1278 | ssize_t nread; |
1279 | struct curltime now; |
1280 | bool keepon = TRUE; |
1281 | char *buf = data->state.buffer; |
1282 | struct TELNET *tn; |
1283 | |
1284 | *done = TRUE; /* unconditionally */ |
1285 | |
1286 | result = init_telnet(data); |
1287 | if(result) |
1288 | return result; |
1289 | |
1290 | tn = data->req.p.telnet; |
1291 | |
1292 | result = check_telnet_options(data); |
1293 | if(result) |
1294 | return result; |
1295 | |
1296 | #ifdef USE_WINSOCK |
1297 | /* We want to wait for both stdin and the socket. Since |
1298 | ** the select() function in winsock only works on sockets |
1299 | ** we have to use the WaitForMultipleObjects() call. |
1300 | */ |
1301 | |
1302 | /* First, create a sockets event object */ |
1303 | event_handle = WSACreateEvent(); |
1304 | if(event_handle == WSA_INVALID_EVENT) { |
1305 | failf(data, "WSACreateEvent failed (%d)" , SOCKERRNO); |
1306 | return CURLE_FAILED_INIT; |
1307 | } |
1308 | |
1309 | /* Tell winsock what events we want to listen to */ |
1310 | if(WSAEventSelect(sockfd, event_handle, FD_READ|FD_CLOSE) == SOCKET_ERROR) { |
1311 | WSACloseEvent(event_handle); |
1312 | return CURLE_OK; |
1313 | } |
1314 | |
1315 | /* The get the Windows file handle for stdin */ |
1316 | stdin_handle = GetStdHandle(STD_INPUT_HANDLE); |
1317 | |
1318 | /* Create the list of objects to wait for */ |
1319 | objs[0] = event_handle; |
1320 | objs[1] = stdin_handle; |
1321 | |
1322 | /* If stdin_handle is a pipe, use PeekNamedPipe() method to check it, |
1323 | else use the old WaitForMultipleObjects() way */ |
1324 | if(GetFileType(stdin_handle) == FILE_TYPE_PIPE || |
1325 | data->set.is_fread_set) { |
1326 | /* Don't wait for stdin_handle, just wait for event_handle */ |
1327 | obj_count = 1; |
1328 | /* Check stdin_handle per 100 milliseconds */ |
1329 | wait_timeout = 100; |
1330 | } |
1331 | else { |
1332 | obj_count = 2; |
1333 | wait_timeout = 1000; |
1334 | } |
1335 | |
1336 | /* Keep on listening and act on events */ |
1337 | while(keepon) { |
1338 | const DWORD buf_size = (DWORD)data->set.buffer_size; |
1339 | DWORD waitret = WaitForMultipleObjects(obj_count, objs, |
1340 | FALSE, wait_timeout); |
1341 | switch(waitret) { |
1342 | |
1343 | case WAIT_TIMEOUT: |
1344 | { |
1345 | for(;;) { |
1346 | if(data->set.is_fread_set) { |
1347 | size_t n; |
1348 | /* read from user-supplied method */ |
1349 | n = data->state.fread_func(buf, 1, buf_size, data->state.in); |
1350 | if(n == CURL_READFUNC_ABORT) { |
1351 | keepon = FALSE; |
1352 | result = CURLE_READ_ERROR; |
1353 | break; |
1354 | } |
1355 | |
1356 | if(n == CURL_READFUNC_PAUSE) |
1357 | break; |
1358 | |
1359 | if(n == 0) /* no bytes */ |
1360 | break; |
1361 | |
1362 | /* fall through with number of bytes read */ |
1363 | readfile_read = (DWORD)n; |
1364 | } |
1365 | else { |
1366 | /* read from stdin */ |
1367 | if(!PeekNamedPipe(stdin_handle, NULL, 0, NULL, |
1368 | &readfile_read, NULL)) { |
1369 | keepon = FALSE; |
1370 | result = CURLE_READ_ERROR; |
1371 | break; |
1372 | } |
1373 | |
1374 | if(!readfile_read) |
1375 | break; |
1376 | |
1377 | if(!ReadFile(stdin_handle, buf, buf_size, |
1378 | &readfile_read, NULL)) { |
1379 | keepon = FALSE; |
1380 | result = CURLE_READ_ERROR; |
1381 | break; |
1382 | } |
1383 | } |
1384 | |
1385 | result = send_telnet_data(data, buf, readfile_read); |
1386 | if(result) { |
1387 | keepon = FALSE; |
1388 | break; |
1389 | } |
1390 | } |
1391 | } |
1392 | break; |
1393 | |
1394 | case WAIT_OBJECT_0 + 1: |
1395 | { |
1396 | if(!ReadFile(stdin_handle, buf, buf_size, |
1397 | &readfile_read, NULL)) { |
1398 | keepon = FALSE; |
1399 | result = CURLE_READ_ERROR; |
1400 | break; |
1401 | } |
1402 | |
1403 | result = send_telnet_data(data, buf, readfile_read); |
1404 | if(result) { |
1405 | keepon = FALSE; |
1406 | break; |
1407 | } |
1408 | } |
1409 | break; |
1410 | |
1411 | case WAIT_OBJECT_0: |
1412 | { |
1413 | events.lNetworkEvents = 0; |
1414 | if(WSAEnumNetworkEvents(sockfd, event_handle, &events) == SOCKET_ERROR) { |
1415 | err = SOCKERRNO; |
1416 | if(err != EINPROGRESS) { |
1417 | infof(data, "WSAEnumNetworkEvents failed (%d)" , err); |
1418 | keepon = FALSE; |
1419 | result = CURLE_READ_ERROR; |
1420 | } |
1421 | break; |
1422 | } |
1423 | if(events.lNetworkEvents & FD_READ) { |
1424 | /* read data from network */ |
1425 | result = Curl_read(data, sockfd, buf, data->set.buffer_size, &nread); |
1426 | /* read would've blocked. Loop again */ |
1427 | if(result == CURLE_AGAIN) |
1428 | break; |
1429 | /* returned not-zero, this an error */ |
1430 | else if(result) { |
1431 | keepon = FALSE; |
1432 | break; |
1433 | } |
1434 | /* returned zero but actually received 0 or less here, |
1435 | the server closed the connection and we bail out */ |
1436 | else if(nread <= 0) { |
1437 | keepon = FALSE; |
1438 | break; |
1439 | } |
1440 | |
1441 | result = telrcv(data, (unsigned char *) buf, nread); |
1442 | if(result) { |
1443 | keepon = FALSE; |
1444 | break; |
1445 | } |
1446 | |
1447 | /* Negotiate if the peer has started negotiating, |
1448 | otherwise don't. We don't want to speak telnet with |
1449 | non-telnet servers, like POP or SMTP. */ |
1450 | if(tn->please_negotiate && !tn->already_negotiated) { |
1451 | negotiate(data); |
1452 | tn->already_negotiated = 1; |
1453 | } |
1454 | } |
1455 | if(events.lNetworkEvents & FD_CLOSE) { |
1456 | keepon = FALSE; |
1457 | } |
1458 | } |
1459 | break; |
1460 | |
1461 | } |
1462 | |
1463 | if(data->set.timeout) { |
1464 | now = Curl_now(); |
1465 | if(Curl_timediff(now, conn->created) >= data->set.timeout) { |
1466 | failf(data, "Time-out" ); |
1467 | result = CURLE_OPERATION_TIMEDOUT; |
1468 | keepon = FALSE; |
1469 | } |
1470 | } |
1471 | } |
1472 | |
1473 | /* We called WSACreateEvent, so call WSACloseEvent */ |
1474 | if(!WSACloseEvent(event_handle)) { |
1475 | infof(data, "WSACloseEvent failed (%d)" , SOCKERRNO); |
1476 | } |
1477 | #else |
1478 | pfd[0].fd = sockfd; |
1479 | pfd[0].events = POLLIN; |
1480 | |
1481 | if(data->set.is_fread_set) { |
1482 | poll_cnt = 1; |
1483 | interval_ms = 100; /* poll user-supplied read function */ |
1484 | } |
1485 | else { |
1486 | /* really using fread, so infile is a FILE* */ |
1487 | pfd[1].fd = fileno((FILE *)data->state.in); |
1488 | pfd[1].events = POLLIN; |
1489 | poll_cnt = 2; |
1490 | interval_ms = 1 * 1000; |
1491 | } |
1492 | |
1493 | while(keepon) { |
1494 | switch(Curl_poll(pfd, poll_cnt, interval_ms)) { |
1495 | case -1: /* error, stop reading */ |
1496 | keepon = FALSE; |
1497 | continue; |
1498 | case 0: /* timeout */ |
1499 | pfd[0].revents = 0; |
1500 | pfd[1].revents = 0; |
1501 | /* FALLTHROUGH */ |
1502 | default: /* read! */ |
1503 | if(pfd[0].revents & POLLIN) { |
1504 | /* read data from network */ |
1505 | result = Curl_read(data, sockfd, buf, data->set.buffer_size, &nread); |
1506 | /* read would've blocked. Loop again */ |
1507 | if(result == CURLE_AGAIN) |
1508 | break; |
1509 | /* returned not-zero, this an error */ |
1510 | if(result) { |
1511 | keepon = FALSE; |
1512 | break; |
1513 | } |
1514 | /* returned zero but actually received 0 or less here, |
1515 | the server closed the connection and we bail out */ |
1516 | else if(nread <= 0) { |
1517 | keepon = FALSE; |
1518 | break; |
1519 | } |
1520 | |
1521 | total_dl += nread; |
1522 | Curl_pgrsSetDownloadCounter(data, total_dl); |
1523 | result = telrcv(data, (unsigned char *)buf, nread); |
1524 | if(result) { |
1525 | keepon = FALSE; |
1526 | break; |
1527 | } |
1528 | |
1529 | /* Negotiate if the peer has started negotiating, |
1530 | otherwise don't. We don't want to speak telnet with |
1531 | non-telnet servers, like POP or SMTP. */ |
1532 | if(tn->please_negotiate && !tn->already_negotiated) { |
1533 | negotiate(data); |
1534 | tn->already_negotiated = 1; |
1535 | } |
1536 | } |
1537 | |
1538 | nread = 0; |
1539 | if(poll_cnt == 2) { |
1540 | if(pfd[1].revents & POLLIN) { /* read from in file */ |
1541 | nread = read(pfd[1].fd, buf, data->set.buffer_size); |
1542 | } |
1543 | } |
1544 | else { |
1545 | /* read from user-supplied method */ |
1546 | nread = (int)data->state.fread_func(buf, 1, data->set.buffer_size, |
1547 | data->state.in); |
1548 | if(nread == CURL_READFUNC_ABORT) { |
1549 | keepon = FALSE; |
1550 | break; |
1551 | } |
1552 | if(nread == CURL_READFUNC_PAUSE) |
1553 | break; |
1554 | } |
1555 | |
1556 | if(nread > 0) { |
1557 | result = send_telnet_data(data, buf, nread); |
1558 | if(result) { |
1559 | keepon = FALSE; |
1560 | break; |
1561 | } |
1562 | total_ul += nread; |
1563 | Curl_pgrsSetUploadCounter(data, total_ul); |
1564 | } |
1565 | else if(nread < 0) |
1566 | keepon = FALSE; |
1567 | |
1568 | break; |
1569 | } /* poll switch statement */ |
1570 | |
1571 | if(data->set.timeout) { |
1572 | now = Curl_now(); |
1573 | if(Curl_timediff(now, conn->created) >= data->set.timeout) { |
1574 | failf(data, "Time-out" ); |
1575 | result = CURLE_OPERATION_TIMEDOUT; |
1576 | keepon = FALSE; |
1577 | } |
1578 | } |
1579 | |
1580 | if(Curl_pgrsUpdate(data)) { |
1581 | result = CURLE_ABORTED_BY_CALLBACK; |
1582 | break; |
1583 | } |
1584 | } |
1585 | #endif |
1586 | /* mark this as "no further transfer wanted" */ |
1587 | Curl_setup_transfer(data, -1, -1, FALSE, -1); |
1588 | |
1589 | return result; |
1590 | } |
1591 | #endif |
1592 | |