buffers.c 5.61 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
32
33
34
35
/* read from socket s, writing onto buf+buf_datalen. If at_most is >= 0 then
 * 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
39

  int read_result;

40
  assert(buf && *buf && buflen && buf_datalen && reached_eof && (s>=0));
Roger Dingledine's avatar
Roger Dingledine committed
41
42
43

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

44
  if(at_most < 0 || *buflen - *buf_datalen < at_most)
45
46
47
48
49
50
    at_most = *buflen - *buf_datalen; /* take the min of the two */
    /* (note that this only modifies at_most inside this function) */

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

51
  if(!options.LinkPadding && at_most > 10*sizeof(cell_t)) {
52
    /* if no linkpadding: do a rudimentary round-robin so one
53
54
     * connection can't hog a thickpipe
     */
55
56
    at_most = 10*(CELL_PAYLOAD_SIZE - RELAY_HEADER_SIZE);
    /* XXX this still isn't perfect. now we read 10 relay data payloads per read --
57
58
59
     * but if we're reading from a connection that speaks cells, we always
     * read a partial cell from the network and can't process it yet. Good
     * enough for now though. (And maybe best, to stress our code more.)
60
61
62
     */
  }

63
//  log_fn(LOG_DEBUG,"reading at most %d bytes.",at_most);
64
  read_result = read(s, *buf+*buf_datalen, at_most);
Roger Dingledine's avatar
Roger Dingledine committed
65
66
67
68
69
70
  if (read_result < 0) {
    if(errno!=EAGAIN) { /* it's a real error */
      return -1;
    }
    return 0;
  } else if (read_result == 0) {
71
    log_fn(LOG_DEBUG,"Encountered eof");
72
    *reached_eof = 1;
Roger Dingledine's avatar
Roger Dingledine committed
73
74
    return 0;
  } else { /* we read some bytes */
75
    *buf_datalen += read_result;
76
//    log_fn(LOG_DEBUG,"Read %d bytes. %d on inbuf.",read_result, *buf_datalen);
Roger Dingledine's avatar
Roger Dingledine committed
77
78
79
80
    return read_result;
  }
}

81
int flush_buf(int s, char **buf, int *buflen, int *buf_flushlen, int *buf_datalen) {
Roger Dingledine's avatar
Roger Dingledine committed
82
83
84

  /* push from buf onto s
   * then memmove to front of buf
85
   * return -1 or how many bytes remain to be flushed */
Roger Dingledine's avatar
Roger Dingledine committed
86
87
88

  int write_result;

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

91
  if(*buf_flushlen == 0) /* nothing to flush */
Roger Dingledine's avatar
Roger Dingledine committed
92
93
94
95
    return 0;

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

96
  write_result = write(s, *buf, *buf_flushlen);
Roger Dingledine's avatar
Roger Dingledine committed
97
98
99
100
  if (write_result < 0) {
    if(errno!=EAGAIN) { /* it's a real error */
      return -1;
    }
101
    log_fn(LOG_DEBUG,"write() would block, returning.");
Roger Dingledine's avatar
Roger Dingledine committed
102
103
    return 0;
  } else {
104
    *buf_datalen -= write_result;
105
    *buf_flushlen -= write_result;
106
    memmove(*buf, *buf+write_result, *buf_datalen);
107
//    log_fn(LOG_DEBUG,"flushed %d bytes, %d ready to flush, %d remain.",
108
//       write_result,*buf_flushlen,*buf_datalen);
109
    return *buf_flushlen;
Roger Dingledine's avatar
Roger Dingledine committed
110
111
112
  }
}

113
114
int write_to_buf(char *string, int string_len,
                 char **buf, int *buflen, int *buf_datalen) {
Roger Dingledine's avatar
Roger Dingledine committed
115
116
117
118
119

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

120
  assert(string && buf && *buf && buflen && buf_datalen);
Roger Dingledine's avatar
Roger Dingledine committed
121
122
123

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

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

129
130
  memcpy(*buf+*buf_datalen, string, string_len);
  *buf_datalen += string_len;
131
//  log_fn(LOG_DEBUG,"added %d bytes to buf (now %d total).",string_len, *buf_datalen);
132
  return *buf_datalen;
133
134
}

135
int fetch_from_buf(char *string, int string_len,
136
                   char **buf, int *buflen, int *buf_datalen) {
Roger Dingledine's avatar
Roger Dingledine committed
137

138
  /* if there are string_len bytes in buf, write them onto string,
139
140
141
142
143
   * then memmove buf back (that is, remove them from buf).
   *
   * If there are not enough bytes on the buffer to fill string, return -1.
   *
   * Return the number of bytes still on the buffer. */
Roger Dingledine's avatar
Roger Dingledine committed
144

145
  assert(string && buf && *buf && buflen && buf_datalen);
Roger Dingledine's avatar
Roger Dingledine committed
146
147
148

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

149
  if(string_len > *buf_datalen) /* we want too much. sorry. */
Roger Dingledine's avatar
Roger Dingledine committed
150
151
    return -1;
 
152
153
154
155
  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
156
157
}

158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
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;
}

180
181
182
183
184
185
186
/*
  Local Variables:
  mode:c
  indent-tabs-mode:nil
  c-basic-offset:2
  End:
*/