Annotation of embedaddon/curl/lib/telnet.c, revision 1.1.1.1
1.1 misho 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
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to telnet.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib