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