]> asedeno.scripts.mit.edu Git - PuTTY.git/blob - raw.c
The back ends now contain their own copies of the Config structure,
[PuTTY.git] / raw.c
1 #include <stdio.h>
2 #include <stdlib.h>
3
4 #include "putty.h"
5
6 #ifndef FALSE
7 #define FALSE 0
8 #endif
9 #ifndef TRUE
10 #define TRUE 1
11 #endif
12
13 #define RAW_MAX_BACKLOG 4096
14
15 typedef struct raw_backend_data {
16     const struct plug_function_table *fn;
17     /* the above field _must_ be first in the structure */
18
19     Socket s;
20     int bufsize;
21     void *frontend;
22 } *Raw;
23
24 static void raw_size(void *handle, int width, int height);
25
26 static void c_write(Raw raw, char *buf, int len)
27 {
28     int backlog = from_backend(raw->frontend, 0, buf, len);
29     sk_set_frozen(raw->s, backlog > RAW_MAX_BACKLOG);
30 }
31
32 static int raw_closing(Plug plug, char *error_msg, int error_code,
33                        int calling_back)
34 {
35     Raw raw = (Raw) plug;
36
37     if (raw->s) {
38         sk_close(raw->s);
39         raw->s = NULL;
40     }
41     if (error_msg) {
42         /* A socket error has occurred. */
43         logevent(raw->frontend, error_msg);
44         connection_fatal("%s", error_msg);
45     }                                  /* Otherwise, the remote side closed the connection normally. */
46     return 0;
47 }
48
49 static int raw_receive(Plug plug, int urgent, char *data, int len)
50 {
51     Raw raw = (Raw) plug;
52     c_write(raw, data, len);
53     return 1;
54 }
55
56 static void raw_sent(Plug plug, int bufsize)
57 {
58     Raw raw = (Raw) plug;
59     raw->bufsize = bufsize;
60 }
61
62 /*
63  * Called to set up the raw connection.
64  * 
65  * Returns an error message, or NULL on success.
66  *
67  * Also places the canonical host name into `realhost'. It must be
68  * freed by the caller.
69  */
70 static char *raw_init(void *frontend_handle, void **backend_handle,
71                       Config *cfg,
72                       char *host, int port, char **realhost, int nodelay)
73 {
74     static const struct plug_function_table fn_table = {
75         raw_closing,
76         raw_receive,
77         raw_sent
78     };
79     SockAddr addr;
80     char *err;
81     Raw raw;
82
83     raw = smalloc(sizeof(*raw));
84     raw->fn = &fn_table;
85     raw->s = NULL;
86     *backend_handle = raw;
87
88     raw->frontend = frontend_handle;
89
90     /*
91      * Try to find host.
92      */
93     {
94         char *buf;
95         buf = dupprintf("Looking up host \"%s\"", host);
96         logevent(raw->frontend, buf);
97         sfree(buf);
98     }
99     addr = name_lookup(host, port, realhost);
100     if ((err = sk_addr_error(addr)) != NULL)
101         return err;
102
103     if (port < 0)
104         port = 23;                     /* default telnet port */
105
106     /*
107      * Open socket.
108      */
109     {
110         char *buf, addrbuf[100];
111         sk_getaddr(addr, addrbuf, 100);
112         buf = dupprintf("Connecting to %s port %d", addrbuf, port);
113         logevent(raw->frontend, buf);
114         sfree(buf);
115     }
116     raw->s = new_connection(addr, *realhost, port, 0, 1, nodelay, (Plug) raw);
117     if ((err = sk_socket_error(raw->s)) != NULL)
118         return err;
119
120     sk_addr_free(addr);
121
122     return NULL;
123 }
124
125 /*
126  * Stub routine (we don't have any need to reconfigure this backend).
127  */
128 static void raw_reconfig(void *handle, Config *cfg)
129 {
130 }
131
132 /*
133  * Called to send data down the raw connection.
134  */
135 static int raw_send(void *handle, char *buf, int len)
136 {
137     Raw raw = (Raw) handle;
138
139     if (raw->s == NULL)
140         return 0;
141
142     raw->bufsize = sk_write(raw->s, buf, len);
143
144     return raw->bufsize;
145 }
146
147 /*
148  * Called to query the current socket sendability status.
149  */
150 static int raw_sendbuffer(void *handle)
151 {
152     Raw raw = (Raw) handle;
153     return raw->bufsize;
154 }
155
156 /*
157  * Called to set the size of the window
158  */
159 static void raw_size(void *handle, int width, int height)
160 {
161     /* Do nothing! */
162     return;
163 }
164
165 /*
166  * Send raw special codes.
167  */
168 static void raw_special(void *handle, Telnet_Special code)
169 {
170     /* Do nothing! */
171     return;
172 }
173
174 static Socket raw_socket(void *handle)
175 {
176     Raw raw = (Raw) handle;
177     return raw->s;
178 }
179
180 static int raw_sendok(void *handle)
181 {
182     return 1;
183 }
184
185 static void raw_unthrottle(void *handle, int backlog)
186 {
187     Raw raw = (Raw) handle;
188     sk_set_frozen(raw->s, backlog > RAW_MAX_BACKLOG);
189 }
190
191 static int raw_ldisc(void *handle, int option)
192 {
193     if (option == LD_EDIT || option == LD_ECHO)
194         return 1;
195     return 0;
196 }
197
198 static void raw_provide_ldisc(void *handle, void *ldisc)
199 {
200     /* This is a stub. */
201 }
202
203 static void raw_provide_logctx(void *handle, void *logctx)
204 {
205     /* This is a stub. */
206 }
207
208 static int raw_exitcode(void *handle)
209 {
210     /* Exit codes are a meaningless concept in the Raw protocol */
211     return 0;
212 }
213
214 Backend raw_backend = {
215     raw_init,
216     raw_reconfig,
217     raw_send,
218     raw_sendbuffer,
219     raw_size,
220     raw_special,
221     raw_socket,
222     raw_exitcode,
223     raw_sendok,
224     raw_ldisc,
225     raw_provide_ldisc,
226     raw_provide_logctx,
227     raw_unthrottle,
228     1
229 };