buffers.c 10.9 KB
Newer Older
1
2
3
/* Copyright 2001,2002 Roger Dingledine, Matej Pfajfar. */
/* See LICENSE for licensing information */
/* $Id$ */
Roger Dingledine's avatar
Roger Dingledine committed
4
5
6
7
8

/* buffers.c */

#include "or.h"

9
10
extern or_options_t options; /* command-line and config-file options */

11
12
/* Create a new buf of size MAX_BUF_SIZE. Write a pointer to it
 * into *buf, write MAX_BUF_SIZE into *buflen, and initialize
13
 * *buf_datalen to 0. Return 0.
14
 */
15
int buf_new(char **buf, int *buflen, int *buf_datalen) {
Roger Dingledine's avatar
Roger Dingledine committed
16

17
  assert(buf && buflen && buf_datalen);
Roger Dingledine's avatar
Roger Dingledine committed
18

19
  *buf = (char *)tor_malloc(MAX_BUF_SIZE);
20
//  memset(*buf,0,MAX_BUF_SIZE);
21
22
  *buflen = MAX_BUF_SIZE;
  *buf_datalen = 0;
Roger Dingledine's avatar
Roger Dingledine committed
23
24
25
26

  return 0;
}

27
void buf_free(char *buf) {
Roger Dingledine's avatar
Roger Dingledine committed
28
29
30
  free(buf);
}

31
/* read from socket s, writing onto buf+buf_datalen.
32
33
34
35
 * read at most 'at_most' bytes, and in any case don't read more than will fit based on buflen.
 * If read() returns 0, set *reached_eof to 1 and return 0. If you want to tear
 * down the connection return -1, else return the number of bytes read.
 */
36
int read_to_buf(int s, int at_most, char **buf, int *buflen, int *buf_datalen, int *reached_eof) {
Roger Dingledine's avatar
Roger Dingledine committed
37
38

  int read_result;
39
40
41
#ifdef MS_WINDOWS
  int e;
#endif
Roger Dingledine's avatar
Roger Dingledine committed
42

43
  assert(buf && *buf && buflen && buf_datalen && reached_eof && (s>=0));
Roger Dingledine's avatar
Roger Dingledine committed
44
45
46

  /* this is the point where you would grow the buffer, if you want to */

47
  if(at_most > *buflen - *buf_datalen)
48
49
50
51
52
    at_most = *buflen - *buf_datalen; /* take the min of the two */

  if(at_most == 0)
    return 0; /* we shouldn't read anything */

53
//  log_fn(LOG_DEBUG,"reading at most %d bytes.",at_most);
54
  read_result = read(s, *buf+*buf_datalen, at_most);
Roger Dingledine's avatar
Roger Dingledine committed
55
  if (read_result < 0) {
56
    if(!ERRNO_EAGAIN(errno)) { /* it's a real error */
Roger Dingledine's avatar
Roger Dingledine committed
57
58
      return -1;
    }
59
60
#ifdef MS_WINDOWS
    e = correct_socket_errno(s);
Roger Dingledine's avatar
Roger Dingledine committed
61
    if(!ERRNO_EAGAIN(e)) { /* no, it *is* a real error! */
62
63
64
      return -1;
    }
#endif
Roger Dingledine's avatar
Roger Dingledine committed
65
66
    return 0;
  } else if (read_result == 0) {
67
    log_fn(LOG_DEBUG,"Encountered eof");
68
    *reached_eof = 1;
Roger Dingledine's avatar
Roger Dingledine committed
69
70
    return 0;
  } else { /* we read some bytes */
71
    *buf_datalen += read_result;
72
//    log_fn(LOG_DEBUG,"Read %d bytes. %d on inbuf.",read_result, *buf_datalen);
Roger Dingledine's avatar
Roger Dingledine committed
73
74
75
76
    return read_result;
  }
}

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
int read_to_buf_tls(tor_tls *tls, int at_most, char **buf, int *buflen, int *buf_datalen) {
  int r;
  assert(tls && *buf && buflen && buf_datalen);
  
  if (at_most > *buflen - *buf_datalen)
    at_most = *buflen - *buf_datalen;

  if (at_most == 0)
    return 0;
  
  r = tor_tls_read(tls, *buf+*buf_datalen, at_most);
  if (r<0) 
    return r;
  *buf_datalen += r;
  return r;
} 

94
int flush_buf(int s, char **buf, int *buflen, int *buf_flushlen, int *buf_datalen) {
Roger Dingledine's avatar
Roger Dingledine committed
95
96
97

  /* push from buf onto s
   * then memmove to front of buf
98
   * return -1 or how many bytes remain to be flushed */
Roger Dingledine's avatar
Roger Dingledine committed
99
100

  int write_result;
101
102
103
#ifdef MS_WINDOWS
  int e;
#endif
Roger Dingledine's avatar
Roger Dingledine committed
104

105
  assert(buf && *buf && buflen && buf_flushlen && buf_datalen && (s>=0) && (*buf_flushlen <= *buf_datalen));
Roger Dingledine's avatar
Roger Dingledine committed
106

107
  if(*buf_flushlen == 0) /* nothing to flush */
Roger Dingledine's avatar
Roger Dingledine committed
108
109
110
111
    return 0;

  /* this is the point where you would grow the buffer, if you want to */

112
  write_result = write(s, *buf, *buf_flushlen);
Roger Dingledine's avatar
Roger Dingledine committed
113
  if (write_result < 0) {
114
115
116
117
118
    if(!ERRNO_EAGAIN(errno)) { /* it's a real error */
      return -1;
    }
#ifdef MS_WINDOWS
    e = correct_socket_errno(s);
Roger Dingledine's avatar
Roger Dingledine committed
119
    if(!ERRNO_EAGAIN(e)) { /* no, it *is* a real error! */
Roger Dingledine's avatar
Roger Dingledine committed
120
121
      return -1;
    }
122
#endif
123
    log_fn(LOG_DEBUG,"write() would block, returning.");
Roger Dingledine's avatar
Roger Dingledine committed
124
125
    return 0;
  } else {
126
    *buf_datalen -= write_result;
127
    *buf_flushlen -= write_result;
128
    memmove(*buf, *buf+write_result, *buf_datalen);
129
130
    log_fn(LOG_DEBUG,"%d: flushed %d bytes, %d ready to flush, %d remain.",
      s,write_result,*buf_flushlen,*buf_datalen);
131
    return *buf_flushlen;
Roger Dingledine's avatar
Roger Dingledine committed
132
    /* XXX USE_TLS should change to return write_result like any sane function would */
Roger Dingledine's avatar
Roger Dingledine committed
133
134
135
  }
}

136
137
138
139
int flush_buf_tls(tor_tls *tls, char **buf, int *buflen, int *buf_flushlen, int *buf_datalen)
{
  int r;
  assert(tls && *buf && buflen && buf_datalen);
Roger Dingledine's avatar
Roger Dingledine committed
140
141
142

  /* we want to let tls write even if flushlen is zero, because it might
   * have a partial record pending */
143
144
145
146
147
148
149
150
151
152
  r = tor_tls_write(tls, *buf, *buf_flushlen);
  if (r < 0) {
    return r;
  }
  *buf_datalen -= r;
  *buf_flushlen -= r;
  memmove(*buf, *buf+r, *buf_datalen);
  return r;
}

153
154
int write_to_buf(char *string, int string_len,
                 char **buf, int *buflen, int *buf_datalen) {
Roger Dingledine's avatar
Roger Dingledine committed
155
156
157
158
159

  /* append string to buf (growing as needed, return -1 if "too big")
   * return total number of bytes on the buf
   */

160
  assert(string && buf && *buf && buflen && buf_datalen);
Roger Dingledine's avatar
Roger Dingledine committed
161
162
163

  /* this is the point where you would grow the buffer, if you want to */

164
  if (string_len + *buf_datalen > *buflen) { /* we're out of luck */
165
    log_fn(LOG_DEBUG, "buflen too small. Time to implement growing dynamic bufs.");
Roger Dingledine's avatar
Roger Dingledine committed
166
167
168
    return -1;
  }

169
170
  memcpy(*buf+*buf_datalen, string, string_len);
  *buf_datalen += string_len;
171
//  log_fn(LOG_DEBUG,"added %d bytes to buf (now %d total).",string_len, *buf_datalen);
172
  return *buf_datalen;
173
174
}

175
int fetch_from_buf(char *string, int string_len,
176
                   char **buf, int *buflen, int *buf_datalen) {
Roger Dingledine's avatar
Roger Dingledine committed
177

178
  /* There must be string_len bytes in buf; write them onto string,
179
180
181
   * then memmove buf back (that is, remove them from buf).
   *
   * Return the number of bytes still on the buffer. */
Roger Dingledine's avatar
Roger Dingledine committed
182

183
  assert(string && buf && *buf && buflen && buf_datalen);
184
  assert(string_len <= *buf_datalen); /* make sure we don't ask for too much */
Roger Dingledine's avatar
Roger Dingledine committed
185

186
187
188
189
  memcpy(string,*buf,string_len);
  *buf_datalen -= string_len;
  memmove(*buf, *buf+string_len, *buf_datalen);
  return *buf_datalen;
Roger Dingledine's avatar
Roger Dingledine committed
190
191
}

192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
/* There is a (possibly incomplete) http statement on *buf, of the
 * form "%s\r\n\r\n%s", headers, body.
 * If a) the headers include a Content-Length field and all bytes in
 * the body are present, or b) there's no Content-Length field and
 * all headers are present, then:
 *   copy headers and body into the supplied args (and null terminate
 *   them), remove them from buf, and return 1.
 *   (If headers or body is NULL, discard that part of the buf.)
 *   If a headers or body doesn't fit in the arg, return -1.
 * 
 * Else, change nothing and return 0.
 */
int fetch_from_buf_http(char *buf, int *buf_datalen,
                        char *headers_out, int max_headerlen,
                        char *body_out, int max_bodylen) {
  char *headers, *body;
  int i;
  int headerlen, bodylen, contentlen;

  assert(buf && buf_datalen);

  headers = buf;
  i = find_on_inbuf("\r\n\r\n", 4, buf, *buf_datalen);
  if(i < 0) {
    log_fn(LOG_DEBUG,"headers not all here yet.");
    return 0;
  }
  body = buf+i;
  headerlen = body-headers; /* includes the CRLFCRLF */
  bodylen = *buf_datalen - headerlen;
  log_fn(LOG_DEBUG,"headerlen %d, bodylen %d.",headerlen,bodylen);

  if(headers_out && max_headerlen <= headerlen) {
    log_fn(LOG_DEBUG,"headerlen %d larger than %d. Failing.", headerlen, max_headerlen-1);
    return -1;
  }
  if(body_out && max_bodylen <= bodylen) {
    log_fn(LOG_DEBUG,"bodylen %d larger than %d. Failing.", bodylen, max_bodylen-1);
    return -1;
  }

233
#define CONTENT_LENGTH "\r\nContent-Length: "
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
  i = find_on_inbuf(CONTENT_LENGTH, strlen(CONTENT_LENGTH), headers, headerlen);
  if(i > 0) {
    contentlen = atoi(headers+i);
    if(bodylen < contentlen) {
      log_fn(LOG_DEBUG,"body not all here yet.");
      return 0; /* not all there yet */
    }
    bodylen = contentlen;
    log_fn(LOG_DEBUG,"bodylen reduced to %d.",bodylen);
  }
  /* all happy. copy into the appropriate places, and return 1 */
  if(headers_out) {
    memcpy(headers_out,buf,headerlen);
    headers_out[headerlen] = 0; /* null terminate it */
  }
  if(body_out) {
    memcpy(body_out,buf+headerlen,bodylen);
    body_out[bodylen] = 0; /* null terminate it */
  }
  *buf_datalen -= (headerlen+bodylen);
  memmove(buf, buf+headerlen+bodylen, *buf_datalen);

  return 1;
}

259
260
261
262
263
264
265
266
/* There is a (possibly incomplete) socks handshake on *buf, of the
 * forms
 *   socks4: "socksheader || username\0".
 *   socks4a: "socksheader || username\0 || destaddr\0".
 * If it's a complete and valid handshake, and destaddr fits in addr_out,
 *   then pull the handshake off the buf, assign to addr_out and port_out,
 *   and return 1.
 * If it's invalid or too big, return -1.
267
 * Else it's not all there yet, change nothing and return 0.
268
269
270
271
 */
int fetch_from_buf_socks(char *buf, int *buf_datalen,
                         char *addr_out, int max_addrlen,
                         uint16_t *port_out) {
272
273
  socks4_t socks4_info;
  char *tmpbuf=NULL;
274
275
276
277
278
279
280
  uint16_t port;
  enum {socks4, socks4a } socks_prot = socks4a;
  char *next, *startaddr;

  if(*buf_datalen < sizeof(socks4_t)) /* basic info available? */
    return 0; /* not yet */

281
282
283
284
285
  /* an inlined socks4_unpack() */
  socks4_info.version = *buf;
  socks4_info.command = *(buf+1);
  socks4_info.destport = *(uint16_t*)(buf+2); 
  socks4_info.destip = *(uint32_t*)(buf+4);
286

287
288
  if(socks4_info.version != 4) {
    log_fn(LOG_NOTICE,"Unrecognized version %d.",socks4_info.version);
289
290
291
    return -1;
  }

292
293
  if(socks4_info.command != 1) { /* not a connect? we don't support it. */
    log_fn(LOG_NOTICE,"command %d not '1'.",socks4_info.command);
294
295
296
    return -1;
  }

297
  port = ntohs(socks4_info.destport);
298
299
300
301
302
  if(!port) {
    log_fn(LOG_NOTICE,"Port is zero.");
    return -1;
  }

303
304
305
306
307
308
309
  if(!socks4_info.destip) {
    log_fn(LOG_NOTICE,"DestIP is zero.");
    return -1;
  }

  if(socks4_info.destip >> 8) {
    struct in_addr in;
310
    log_fn(LOG_NOTICE,"destip not in form 0.0.0.x.");
311
312
    in.s_addr = htonl(socks4_info.destip);
    tmpbuf = inet_ntoa(in);
313
    if(max_addrlen <= strlen(tmpbuf)) {
314
      log_fn(LOG_DEBUG,"socks4 addr too long.");
315
316
317
318
319
320
      return -1;
    }
    log_fn(LOG_DEBUG,"Successfully read destip (%s)", tmpbuf);
    socks_prot = socks4;
  }

321
  next = memchr(buf+SOCKS4_NETWORK_LEN, 0, *buf_datalen);
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
  if(!next) {
    log_fn(LOG_DEBUG,"Username not here yet.");
    return 0;
  }

  startaddr = next+1;
  if(socks_prot == socks4a) {
    next = memchr(startaddr, 0, buf+*buf_datalen-startaddr);
    if(!next) {
      log_fn(LOG_DEBUG,"Destaddr not here yet.");
      return 0;
    }
    if(max_addrlen <= next-startaddr) {
      log_fn(LOG_DEBUG,"Destaddr not here yet.");
      return -1;
    }
  }
  log_fn(LOG_DEBUG,"Everything is here. Success.");
  *port_out = port; 
  strcpy(addr_out, socks_prot == socks4 ? tmpbuf : startaddr);
  *buf_datalen -= (next-buf+1); /* next points to the final \0 on inbuf */
  memmove(buf, next+1, *buf_datalen);
//  log_fn(LOG_DEBUG,"buf_datalen is now %d:'%s'",*buf_datalen,buf);
  return 1;
}

348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
int find_on_inbuf(char *string, int string_len,
                  char *buf, int buf_datalen) {
  /* find first instance of needle 'string' on haystack 'buf'. return how
   * many bytes from the beginning of buf to the end of string.
   * If it's not there, return -1.
   */

  char *location;
  char *last_possible = buf + buf_datalen - string_len;

  assert(string && string_len > 0 && buf);

  if(buf_datalen < string_len)
    return -1;

  for(location = buf; location <= last_possible; location++)
    if((*location == *string) && !memcmp(location+1, string+1, string_len-1))
      return location-buf+string_len;

  return -1;
}

370
371
372
373
374
375
376
/*
  Local Variables:
  mode:c
  indent-tabs-mode:nil
  c-basic-offset:2
  End:
*/